@mastra/server 1.37.0-alpha.1 → 1.37.0-alpha.3

package/dist/_types/@mastra_schema-compat/dist/schema-compatibility-v4.d.ts

@@ -0,0 +1,304 @@
+import { z, ZodOptional, ZodObject, ZodArray, ZodUnion, ZodString, ZodNumber, ZodDate, ZodDefault, ZodNull, ZodNullable, ZodIntersection } from 'zod/v4';
+import type { ZodAny, ZodType } from 'zod/v4';
+import type { Targets } from 'zod-to-json-schema';
+import type { JSONSchema7, Schema } from './json-schema/index.js';
+import type { SchemaCompatLayer as ParentSchemaCompatLayer } from './schema-compatibility.js';
+import type { ModelInformation } from './types.js';
+/**
+ * All supported string validation check types that can be processed or converted to descriptions.
+ * @constant
+ */
+export declare const ALL_STRING_CHECKS: readonly ["regex", "emoji", "email", "url", "uuid", "cuid", "min_length", "max_length", "string_format"];
+/**
+ * All supported number validation check types that can be processed or converted to descriptions.
+ * @constant
+ */
+export declare const ALL_NUMBER_CHECKS: readonly ["greater_than", "less_than", "multiple_of"];
+/**
+ * All supported array validation check types that can be processed or converted to descriptions.
+ * @constant
+ */
+export declare const ALL_ARRAY_CHECKS: readonly ["min", "max", "length"];
+/**
+ * Zod types that are not supported by most AI model providers and should be avoided.
+ * @constant
+ */
+export declare const UNSUPPORTED_ZOD_TYPES: readonly ["ZodIntersection", "ZodNever", "ZodNull", "ZodTuple", "ZodUndefined"];
+/**
+ * Zod types that are generally supported by AI model providers.
+ * @constant
+ */
+export declare const SUPPORTED_ZOD_TYPES: readonly ["ZodObject", "ZodArray", "ZodUnion", "ZodString", "ZodNumber", "ZodDate", "ZodAny", "ZodDefault", "ZodNullable"];
+/**
+ * All Zod types (both supported and unsupported).
+ * @constant
+ */
+export declare const ALL_ZOD_TYPES: readonly ["ZodObject", "ZodArray", "ZodUnion", "ZodString", "ZodNumber", "ZodDate", "ZodAny", "ZodDefault", "ZodNullable", "ZodIntersection", "ZodNever", "ZodNull", "ZodTuple", "ZodUndefined"];
+/**
+ * Type representing string validation checks.
+ */
+export type StringCheckType = (typeof ALL_STRING_CHECKS)[number];
+/**
+ * Type representing number validation checks.
+ */
+export type NumberCheckType = (typeof ALL_NUMBER_CHECKS)[number];
+/**
+ * Type representing array validation checks.
+ */
+export type ArrayCheckType = (typeof ALL_ARRAY_CHECKS)[number];
+/**
+ * Type representing unsupported Zod schema types.
+ */
+export type UnsupportedZodType = (typeof UNSUPPORTED_ZOD_TYPES)[number];
+/**
+ * Type representing supported Zod schema types.
+ */
+export type SupportedZodType = (typeof SUPPORTED_ZOD_TYPES)[number];
+/**
+ * Type representing all Zod schema types (supported and unsupported).
+ */
+export type AllZodType = (typeof ALL_ZOD_TYPES)[number];
+/**
+ * Utility type to extract the shape of a Zod object schema.
+ */
+export type ZodShape<T extends z.ZodObject<any, any>> = T['shape'];
+/**
+ * Utility type to extract the keys from a Zod object shape.
+ */
+export type ShapeKey<T extends z.ZodObject<any, any>> = keyof ZodShape<T>;
+/**
+ * Utility type to extract the value types from a Zod object shape.
+ */
+export type ShapeValue<T extends z.ZodObject<any, any>> = ZodShape<T>[ShapeKey<T>];
+type ConstraintHelperText = string[];
+/**
+ * Abstract base class for creating schema compatibility layers for different AI model providers.
+ *
+ * This class provides a framework for transforming Zod schemas to work with specific AI model
+ * provider requirements and limitations. Each provider may have different support levels for
+ * JSON Schema features, validation constraints, and data types.
+ *
+ *
+ * @example
+ * ```typescript
+ * import { SchemaCompatLayer } from '@mastra/schema-compat';
+ * import type { LanguageModelV1 } from 'ai';
+ *
+ * class CustomProviderCompat extends SchemaCompatLayer {
+ *   constructor(model: LanguageModelV1) {
+ *     super(model);
+ *   }
+ *
+ *   shouldApply(): boolean {
+ *     return this.getModel().provider === 'custom-provider';
+ *   }
+ *
+ *   getSchemaTarget() {
+ *     return 'jsonSchema7';
+ *   }
+ *
+ *   processZodType<T extends z.AnyZodObject>(value: z.ZodAny): ShapeValue<T> {
+ *     // Custom processing logic for this provider
+ *     switch (value._def.typeName) {
+ *       case 'ZodString':
+ *         return this.defaultZodStringHandler(value, ['email', 'url']);
+ *       default:
+ *         return this.defaultUnsupportedZodTypeHandler(value);
+ *     }
+ *   }
+ * }
+ * ```
+ */
+export declare class SchemaCompatLayer {
+    private model;
+    private parent;
+    /**
+     * Creates a new schema compatibility instance.
+     *
+     * @param model - The language model this compatibility layer applies to
+     */
+    constructor(model: ModelInformation, parent: ParentSchemaCompatLayer);
+    /**
+     * Gets the language model associated with this compatibility layer.
+     *
+     * @returns The language model instance
+     */
+    getModel(): ModelInformation;
+    getUnsupportedZodTypes(): readonly string[];
+    /**
+     * Type guard for optional Zod types
+     */
+    isOptional(v: ZodAny | ZodOptional<any>): v is ZodOptional<any>;
+    /**
+     * Type guard for object Zod types
+     */
+    isObj(v: ZodAny | ZodObject<any, any>): v is ZodObject<any, any>;
+    /**
+     * Type guard for null Zod types
+     */
+    isNull(v: ZodAny | ZodNull): v is ZodNull;
+    /**
+     * Type guard for nullable Zod types
+     */
+    isNullable(v: ZodAny | ZodNullable<any>): v is ZodNullable<any>;
+    /**
+     * Type guard for array Zod types
+     */
+    isArr(v: ZodAny | ZodArray<any>): v is ZodArray<any>;
+    /**
+     * Type guard for union Zod types
+     */
+    isUnion(v: ZodAny | ZodUnion<[ZodAny, ...ZodAny[]]>): v is ZodUnion<[ZodAny, ...ZodAny[]]>;
+    /**
+     * Type guard for string Zod types
+     */
+    isString(v: ZodAny | ZodString): v is ZodString;
+    /**
+     * Type guard for number Zod types
+     */
+    isNumber(v: ZodAny | ZodNumber): v is ZodNumber;
+    /**
+     * Type guard for date Zod types
+     */
+    isDate(v: ZodAny | ZodDate): v is ZodDate;
+    /**
+     * Type guard for default Zod types
+     */
+    isDefault(v: ZodAny | ZodDefault<any>): v is ZodDefault<any>;
+    /**
+     * Type guard for intersection Zod types
+     */
+    isIntersection(v: ZodAny | ZodIntersection<any, any>): v is ZodIntersection<any, any>;
+    /**
+     * Determines whether this compatibility layer should be applied for the current model.
+     *
+     * @returns True if this compatibility layer should be used, false otherwise
+     * @abstract
+     */
+    shouldApply(): boolean;
+    /**
+     * Returns the JSON Schema target format for this provider.
+     *
+     * @returns The schema target format, or undefined to use the default 'jsonSchema7'
+     * @abstract
+     */
+    getSchemaTarget(): Targets | undefined;
+    /**
+     * Processes a specific Zod type according to the provider's requirements.
+     *
+     * @param value - The Zod type to process
+     * @returns The processed Zod type
+     * @abstract
+     */
+    processZodType(value: ZodType): ZodType;
+    /**
+     * Default handler for Zod object types. Recursively processes all properties in the object.
+     *
+     * @param value - The Zod object to process
+     * @returns The processed Zod object
+     */
+    defaultZodObjectHandler(value: ZodObject<any, any>, options?: {
+        passthrough?: boolean;
+    }): ZodObject<any, any>;
+    /**
+     * Merges validation constraints into a parameter description.
+     *
+     * This helper method converts validation constraints that may not be supported
+     * by a provider into human-readable descriptions.
+     *
+     * @param description - The existing parameter description
+     * @param constraints - The validation constraints to merge
+     * @returns The updated description with constraints, or undefined if no constraints
+     */
+    mergeParameterDescription(description: string | undefined, constraints: ConstraintHelperText): string | undefined;
+    /**
+     * Default handler for unsupported Zod types. Throws an error for specified unsupported types.
+     *
+     * @param value - The Zod type to check
+     * @param throwOnTypes - Array of type names to throw errors for
+     * @returns The original value if not in the throw list
+     * @throws Error if the type is in the unsupported list
+     */
+    defaultUnsupportedZodTypeHandler<T extends z.ZodObject<any, any>>(value: z.ZodAny, throwOnTypes?: readonly UnsupportedZodType[]): ShapeValue<T>;
+    /**
+     * Default handler for Zod array types. Processes array constraints according to provider support.
+     *
+     * @param value - The Zod array to process
+     * @param handleChecks - Array constraints to convert to descriptions vs keep as validation
+     * @returns The processed Zod array
+     */
+    defaultZodArrayHandler(value: ZodArray<any>, handleChecks?: readonly ArrayCheckType[]): ZodArray<any>;
+    /**
+     * Default handler for Zod union types. Processes all union options.
+     *
+     * @param value - The Zod union to process
+     * @returns The processed Zod union
+     * @throws Error if union has fewer than 2 options
+     */
+    defaultZodUnionHandler(value: ZodUnion<[ZodAny, ...ZodAny[]]>): ZodAny;
+    /**
+     * Default handler for Zod string types. Processes string validation constraints.
+     *
+     * @param value - The Zod string to process
+     * @param handleChecks - String constraints to convert to descriptions vs keep as validation
+     * @returns The processed Zod string
+     */
+    defaultZodStringHandler(value: ZodString, handleChecks?: readonly StringCheckType[]): ZodString;
+    /**
+     * Default handler for Zod number types. Processes number validation constraints.
+     *
+     * @param value - The Zod number to process
+     * @param handleChecks - Number constraints to convert to descriptions vs keep as validation
+     * @returns The processed Zod number
+     */
+    defaultZodNumberHandler(value: ZodNumber, handleChecks?: readonly NumberCheckType[]): ZodNumber;
+    /**
+     * Default handler for Zod date types. Converts dates to ISO strings with constraint descriptions.
+     *
+     * @param value - The Zod date to process
+     * @returns A Zod string schema representing the date in ISO format
+     */
+    defaultZodDateHandler(value: ZodDate): ZodString;
+    /**
+     * Default handler for Zod optional types. Processes the inner type and maintains optionality.
+     *
+     * @param value - The Zod optional to process
+     * @param handleTypes - Types that should be processed vs passed through
+     * @returns The processed Zod optional
+     */
+    defaultZodOptionalHandler(value: ZodOptional<any>, handleTypes?: readonly AllZodType[]): ZodType;
+    /**
+     * Default handler for Zod nullable types. Processes the inner type and maintains nullability.
+     *
+     * @param value - The Zod nullable to process
+     * @param handleTypes - Types that should be processed vs passed through
+     * @returns The processed Zod nullable
+     */
+    defaultZodNullableHandler(value: ZodNullable<any>, handleTypes?: readonly AllZodType[]): ZodType;
+    /**
+     * Recursively collects leaf types from a ZodIntersection tree.
+     */
+    private collectIntersectionLeaves;
+    /**
+     * Default handler for Zod intersection types.
+     * Flattens the intersection tree and merges object shapes into a single z.object().
+     * Falls back to z.any() for non-object intersections.
+     */
+    defaultZodIntersectionHandler(value: ZodIntersection<any, any>): ZodType;
+    /**
+     * Processes a Zod object schema and converts it to an AI SDK Schema.
+     *
+     * @param zodSchema - The Zod object schema to process
+     * @returns An AI SDK Schema with provider-specific compatibility applied
+     */
+    processToAISDKSchema(zodSchema: ZodType): Schema;
+    /**
+     * Processes a Zod object schema and converts it to a JSON Schema.
+     *
+     * @param zodSchema - The Zod object schema to process
+     * @returns A JSONSchema7 object with provider-specific compatibility applied
+     */
+    processToJSONSchema(zodSchema: ZodType): JSONSchema7;
+}
+export {};
+//# sourceMappingURL=schema-compatibility-v4.d.ts.map

package/dist/_types/@mastra_schema-compat/dist/schema-compatibility.d.ts

@@ -0,0 +1,147 @@
+import type { z as zV3 } from 'zod/v3';
+import type { z as zV4 } from 'zod/v4';
+import type { Targets } from 'zod-to-json-schema';
+import type { JSONSchema7, Schema } from './json-schema/index.js';
+import type { PublicSchema, StandardSchemaWithJSON } from './schema.js';
+import * as v3 from './schema-compatibility-v3.js';
+import * as v4 from './schema-compatibility-v4.js';
+import type { ZodType, ZodUnion } from './schema.types.js';
+import type { ModelInformation } from './types.js';
+export { ALL_STRING_CHECKS, ALL_NUMBER_CHECKS, ALL_ARRAY_CHECKS, UNSUPPORTED_ZOD_TYPES as UNSUPPORTED_ZOD_TYPES_V3, SUPPORTED_ZOD_TYPES as SUPPORTED_ZOD_TYPES_V3, } from './schema-compatibility-v3.js';
+export type { UnsupportedZodType as UnsupportedZodTypeV3, ShapeValue as ShapeValueV3, StringCheckType, NumberCheckType, ArrayCheckType, AllZodType as AllZodTypeV3, } from './schema-compatibility-v3.js';
+export { UNSUPPORTED_ZOD_TYPES as UNSUPPORTED_ZOD_TYPES_V4, SUPPORTED_ZOD_TYPES as SUPPORTED_ZOD_TYPES_V4, } from './schema-compatibility-v4.js';
+export type { UnsupportedZodType as UnsupportedZodTypeV4, ShapeValue as ShapeValueV4, AllZodType as AllZodTypeV4, } from './schema-compatibility-v4.js';
+type ConstraintHelperText = string[];
+export declare abstract class SchemaCompatLayer {
+    private model;
+    private v3Layer;
+    private v4Layer;
+    /**
+     * Creates a new schema compatibility instance.
+     *
+     * @param model - The language model this compatibility layer applies to
+     */
+    constructor(model: ModelInformation);
+    preProcessJSONNode(_schema: JSONSchema7, _parentSchema?: JSONSchema7): void;
+    postProcessJSONNode(_schema: JSONSchema7, _parentSchema?: JSONSchema7): void;
+    /**
+     * Gets the language model associated with this compatibility layer.
+     *
+     * @returns The language model instance
+     */
+    getModel(): ModelInformation;
+    getUnsupportedZodTypes(value: ZodType): readonly string[];
+    isOptional(v: zV3.ZodType | zV4.ZodType): v is zV3.ZodOptional<any> | zV4.ZodOptional<any>;
+    isObj(v: zV3.ZodType | zV4.ZodType): v is zV3.ZodObject<any, any, any, any, any> | zV4.ZodObject<any, any>;
+    isNull(v: zV3.ZodType | zV4.ZodType): v is zV3.ZodNull | zV4.ZodNull;
+    isNullable(v: zV3.ZodType | zV4.ZodType): v is zV3.ZodNullable<any> | zV4.ZodNullable<any>;
+    isArr(v: zV3.ZodType | zV4.ZodType): v is zV3.ZodArray<any, any> | zV4.ZodArray<any>;
+    isUnion(v: zV3.ZodType | zV4.ZodType): v is zV3.ZodUnion<[zV3.ZodType, ...zV3.ZodType[]]> | zV4.ZodUnion<[zV4.ZodType, ...zV4.ZodType[]]>;
+    isString(v: zV3.ZodType | zV4.ZodType): v is zV3.ZodString | zV4.ZodString;
+    isNumber(v: zV3.ZodType | zV4.ZodType): v is zV3.ZodNumber | zV4.ZodNumber;
+    isDate(v: zV3.ZodType | zV4.ZodType): v is zV3.ZodDate | zV4.ZodDate;
+    isDefault(v: zV3.ZodType | zV4.ZodType): v is zV3.ZodDefault<any> | zV4.ZodDefault<any>;
+    isIntersection(v: zV3.ZodType | zV4.ZodType): v is zV3.ZodIntersection<any, any> | zV4.ZodIntersection<any, any>;
+    abstract shouldApply(): boolean;
+    abstract getSchemaTarget(): Targets | undefined;
+    abstract processZodType(value: ZodType): ZodType;
+    defaultZodObjectHandler(value: zV3.ZodObject<any, any, any, any, any> | zV4.ZodObject<any, any>, options?: {
+        passthrough?: boolean;
+    }): zV3.ZodObject<any, any, any, any, any> | zV4.ZodObject<any, any>;
+    mergeParameterDescription(description: string | undefined, constraints: ConstraintHelperText): string | undefined;
+    defaultUnsupportedZodTypeHandler(value: zV3.ZodType | zV4.ZodType, throwOnTypes?: readonly (v3.UnsupportedZodType | v4.UnsupportedZodType)[]): zV3.ZodType | zV4.ZodType;
+    defaultZodArrayHandler(value: zV3.ZodArray<any, any> | zV4.ZodArray<any>, handleChecks?: readonly v3.ArrayCheckType[]): zV3.ZodArray<any, any> | zV4.ZodArray<any>;
+    defaultZodUnionHandler(value: ZodUnion): zV3.ZodType | zV4.ZodType;
+    defaultZodStringHandler(value: zV3.ZodString | zV4.ZodString, handleChecks?: readonly v3.StringCheckType[]): zV3.ZodString | zV4.ZodString;
+    defaultZodNumberHandler(value: zV3.ZodNumber | zV4.ZodNumber, handleChecks?: readonly v3.NumberCheckType[]): zV3.ZodNumber | zV4.ZodNumber;
+    defaultZodDateHandler(value: zV3.ZodDate | zV4.ZodDate): zV3.ZodString | zV4.ZodString;
+    defaultZodOptionalHandler(value: zV3.ZodOptional<any> | zV4.ZodOptional<any>, handleTypes?: readonly string[]): zV3.ZodType | zV4.ZodType;
+    defaultZodNullableHandler(value: zV3.ZodNullable<any> | zV4.ZodNullable<any>, handleTypes?: readonly string[]): zV3.ZodType | zV4.ZodType;
+    defaultZodIntersectionHandler(value: zV3.ZodIntersection<any, any> | zV4.ZodIntersection<any, any>): zV3.ZodType | zV4.ZodType;
+    /**
+     * @deprecated please use processToCompatSchema to usse StandardSchemaWithJSON
+     * @param zodSchema
+     * @returns
+     */
+    processToAISDKSchema(zodSchema: zV3.ZodSchema | zV4.ZodType): Schema;
+    /**
+     * @param schema
+     * @returns
+     */
+    processToJSONSchema(schema: PublicSchema<any>, io?: 'input' | 'output'): JSONSchema7;
+    processToCompatSchema<T>(schema: PublicSchema<T>): StandardSchemaWithJSON<T>;
+    /**
+     * Default handler for JSON Schema objects.
+     * Processes object schemas with properties and required fields.
+     */
+    protected defaultObjectHandler(schema: JSONSchema7): JSONSchema7;
+    /**
+     * Default handler for JSON Schema arrays.
+     * Converts array constraints (minItems, maxItems) to description text.
+     */
+    protected defaultArrayHandler(schema: JSONSchema7): JSONSchema7;
+    /**
+     * Default handler for JSON Schema strings.
+     * Converts string constraints (minLength, maxLength, pattern, format) to description text.
+     */
+    protected defaultStringHandler(schema: JSONSchema7): JSONSchema7;
+    /**
+     * Default handler for JSON Schema numbers/integers.
+     * Converts number constraints (minimum, maximum, multipleOf, exclusiveMinimum, exclusiveMaximum) to description text.
+     */
+    protected defaultNumberHandler(schema: JSONSchema7): JSONSchema7;
+    /**
+     * Default handler for JSON Schema unions (anyOf/oneOf).
+     * Processes union schemas and can convert anyOf patterns to type arrays for simple primitives.
+     */
+    protected defaultUnionHandler(schema: JSONSchema7): JSONSchema7;
+    /**
+     * Default handler for JSON Schema allOf (intersection) types.
+     * Flattens allOf sub-schemas by merging properties and required arrays into a single object schema.
+     */
+    protected defaultAllOfHandler(schema: JSONSchema7): JSONSchema7;
+    /**
+     * Default handler for JSON Schema nullable types.
+     * Ensures nullable types are represented correctly.
+     */
+    protected defaultNullableHandler(schema: JSONSchema7): JSONSchema7;
+    /**
+     * Default handler for JSON Schema dates (string with date/date-time format).
+     * Converts date formats to string type with format constraint in description.
+     */
+    protected defaultDateHandler(schema: JSONSchema7): JSONSchema7;
+    /**
+     * Default handler for empty JSON schemas.
+     * Converts empty {} schemas to a union of primitive types.
+     */
+    protected defaultEmptySchemaHandler(schema: JSONSchema7): JSONSchema7;
+    /**
+     * Default handler for unsupported JSON Schema features.
+     * Can be used to strip or convert unsupported keywords.
+     */
+    protected defaultUnsupportedHandler(schema: JSONSchema7, unsupportedKeywords?: string[]): JSONSchema7;
+    protected isObjectSchema(schema: JSONSchema7): boolean;
+    protected isArraySchema(schema: JSONSchema7): boolean;
+    protected isStringSchema(schema: JSONSchema7): boolean;
+    protected isNumberSchema(schema: JSONSchema7): boolean;
+    protected isUnionSchema(schema: JSONSchema7): boolean;
+    protected isAllOfSchema(schema: JSONSchema7): schema is JSONSchema7 & {
+        allOf: JSONSchema7[];
+    };
+    /**
+     * Checks if a property is optional within a parent object schema.
+     * A property is optional if it's not in the parent's `required` array.
+     * @param propertyName - The name of the property to check
+     * @param parentSchema - The parent object schema containing the property
+     */
+    protected isOptionalProperty(propertyName: string, parentSchema: JSONSchema7): boolean;
+    /**
+     * Converts a Zod schema to JSON Schema using the standard-schema interface
+     * and applies pre/post processing via traverse.
+     *
+     * Uses 'input' io mode so that fields with defaults are optional (appropriate for tool parameters).
+     * @deprecated please use processToCompatSchema
+     */
+    toJSONSchema(zodSchema: ZodType): JSONSchema7;
+}
+//# sourceMappingURL=schema-compatibility.d.ts.map

package/dist/_types/@mastra_schema-compat/dist/schema.d.ts

@@ -0,0 +1,4 @@
+export type { StandardSchemaWithJSON, InferOutput as InferStandardSchemaOutput, InferInput as InferStandardSchemaInput, StandardSchemaIssue, StandardSchemaWithJSONProps, } from './standard-schema/standard-schema.types.js';
+export type { PublicSchema, InferPublicSchema, ZodType } from './schema.types.js';
+export { toStandardSchema, isStandardSchema, isStandardJSONSchema, isStandardSchemaWithJSON, standardSchemaToJSONSchema, JSON_SCHEMA_LIBRARY_OPTIONS, } from './standard-schema/standard-schema.js';
+//# sourceMappingURL=schema.d.ts.map

package/dist/_types/@mastra_schema-compat/dist/schema.types.d.ts

@@ -0,0 +1,19 @@
+import type { Schema as SchemaV4 } from './_types/@internal_ai-sdk-v4/dist/index.d.ts';
+import type { Schema as SchemaV5 } from './_types/@internal_ai-sdk-v5/dist/index.d.ts';
+import type { Schema as SchemaV6 } from './_types/@internal_ai-v6/dist/index.d.ts';
+import type { JSONSchema7 } from 'json-schema';
+import type z3 from 'zod/v3';
+import type z4 from 'zod/v4';
+import type { StandardSchemaWithJSON } from './standard-schema/standard-schema.types.js';
+export type ZodType = z4.ZodType<any, any> | z3.Schema<any, z3.ZodTypeDef, any>;
+export type ZodOptional = z4.ZodOptional<any> | z3.ZodOptional<any>;
+export type ZodObject = z4.ZodObject<any, any> | z3.ZodObject<any, any, any, any, any>;
+export type ZodArray = z4.ZodArray<any> | z3.ZodArray<any, any>;
+export type ZodUnion = z4.ZodUnion<any> | z3.ZodUnion<any>;
+export type ZodString = z4.ZodString | z3.ZodString;
+export type ZodNumber = z4.ZodNumber | z3.ZodNumber;
+export type ZodDate = z4.ZodDate | z3.ZodDate;
+export type ZodDefault = z4.ZodDefault<any> | z3.ZodDefault<any>;
+export type PublicSchema<Output = unknown, Input = Output> = z4.ZodType<Output, Input> | z3.Schema<Output, z3.ZodTypeDef, Input> | SchemaV4<Output> | SchemaV5<Output> | SchemaV6<Output> | JSONSchema7 | StandardSchemaWithJSON<Input, Output>;
+export type InferPublicSchema<T extends PublicSchema> = T extends PublicSchema<infer Output> ? Output : never;
+//# sourceMappingURL=schema.types.d.ts.map

package/dist/_types/@mastra_schema-compat/dist/standard-schema/standard-schema.d.ts

@@ -0,0 +1,107 @@
+import type { StandardJSONSchemaV1, StandardSchemaV1 } from '../_types/@standard-schema_spec/dist/index.d.ts';
+import type { JSONSchema7 } from 'json-schema';
+import type { PublicSchema } from '../schema.types.js';
+import type { StandardSchemaWithJSON } from './standard-schema.types.js';
+/**
+ * Override function for JSON Schema conversion.
+ * Handles types that Zod v4 cannot natively represent in JSON Schema:
+ * - z.date() -> { type: 'string', format: 'date-time' }
+ */
+declare function jsonSchemaOverride(ctx: {
+    zodSchema: unknown;
+    jsonSchema: Record<string, unknown>;
+}): undefined;
+/**
+ * Library options for JSON Schema conversion.
+ * - unrepresentable: 'any' allows z.custom() and other unrepresentable types to be converted to {}
+ *   instead of throwing "Custom types cannot be represented in JSON Schema"
+ * - override: converts z.date() to { type: 'string', format: 'date-time' }
+ */
+export declare const JSON_SCHEMA_LIBRARY_OPTIONS: {
+    unrepresentable: "any";
+    override: typeof jsonSchemaOverride;
+};
+export type { StandardSchemaWithJSON, StandardSchemaWithJSONProps, InferInput, InferOutput, StandardSchemaIssue, } from './standard-schema.types.js';
+export declare function toStandardSchema<T = unknown>(schema: PublicSchema<T>): StandardSchemaWithJSON<T>;
+/**
+ * Type guard to check if a value implements the StandardSchemaV1 interface.
+ *
+ * @param value - The value to check
+ * @returns True if the value implements StandardSchemaV1
+ *
+ * @example
+ * ```typescript
+ * import { isStandardSchema } from '@mastra/schema-compat';
+ *
+ * if (isStandardSchema(someValue)) {
+ *   const result = someValue['~standard'].validate(input);
+ * }
+ * ```
+ */
+export declare function isStandardSchema(value: unknown): value is StandardSchemaV1;
+/**
+ * Type guard to check if a value implements the StandardJSONSchemaV1 interface.
+ *
+ * @param value - The value to check
+ * @returns True if the value implements StandardJSONSchemaV1
+ *
+ * @example
+ * ```typescript
+ * import { isStandardJSONSchema } from '@mastra/schema-compat';
+ *
+ * if (isStandardJSONSchema(someValue)) {
+ *   const jsonSchema = someValue['~standard'].jsonSchema.output({ target: 'draft-07' });
+ * }
+ * ```
+ */
+export declare function isStandardJSONSchema(value: unknown): value is StandardJSONSchemaV1;
+/**
+ * Type guard to check if a value implements both StandardSchemaV1 and StandardJSONSchemaV1.
+ *
+ * @param value - The value to check
+ * @returns True if the value implements both interfaces
+ *
+ * @example
+ * ```typescript
+ * import { isStandardSchemaWithJSON } from '@mastra/schema-compat';
+ *
+ * if (isStandardSchemaWithJSON(someValue)) {
+ *   // Can use both validation and JSON Schema conversion
+ *   const result = someValue['~standard'].validate(input);
+ *   const jsonSchema = someValue['~standard'].jsonSchema.output({ target: 'draft-07' });
+ * }
+ * ```
+ */
+export declare function isStandardSchemaWithJSON(value: unknown): value is StandardSchemaWithJSON;
+/**
+ * Converts a StandardSchemaWithJSON to a JSON Schema.
+ *
+ * @param schema - The StandardSchemaWithJSON schema to convert
+ * @param options - Conversion options
+ * @param options.target - The JSON Schema target version (default: 'draft-07')
+ * @param options.io - Whether to use input or output schema (default: 'output')
+ *   - 'input': Use for tool parameters, function arguments, request bodies
+ *   - 'output': Use for return types, response bodies
+ * @returns The JSON Schema representation
+ *
+ * @example
+ * ```typescript
+ * import { standardSchemaToJSONSchema, toStandardSchema } from '@mastra/schema-compat';
+ * import { z } from 'zod';
+ *
+ * const zodSchema = z.object({ name: z.string() });
+ * const standardSchema = toStandardSchema(zodSchema);
+ *
+ * // For output types (default)
+ * const outputSchema = standardSchemaToJSONSchema(standardSchema);
+ *
+ * // For input types (tool parameters)
+ * const inputSchema = standardSchemaToJSONSchema(standardSchema, { io: 'input' });
+ * ```
+ */
+export declare function standardSchemaToJSONSchema(schema: StandardSchemaWithJSON, options?: {
+    target?: StandardJSONSchemaV1.Target;
+    io?: 'input' | 'output';
+    override?: (typeof JSON_SCHEMA_LIBRARY_OPTIONS)['override'];
+}): JSONSchema7;
+//# sourceMappingURL=standard-schema.d.ts.map

package/dist/_types/@mastra_schema-compat/dist/standard-schema/standard-schema.types.d.ts

@@ -0,0 +1,24 @@
+import type { StandardJSONSchemaV1, StandardSchemaV1, StandardTypedV1 } from '../_types/@standard-schema_spec/dist/index.d.ts';
+/**
+ * Type for schemas that implement both StandardSchemaV1 and StandardJSONSchemaV1.
+ * This combined type provides both validation and JSON Schema conversion capabilities.
+ */
+export type StandardSchemaWithJSON<Input = unknown, Output = Input> = StandardSchemaV1<Input, Output> & StandardJSONSchemaV1<Input, Output>;
+/**
+ * Props type for the combined standard schema interface.
+ */
+export type StandardSchemaWithJSONProps<Input = unknown, Output = Input> = StandardSchemaV1.Props<Input, Output> & StandardJSONSchemaV1.Props<Input, Output>;
+/**
+ * Utility type to infer the input type from a StandardSchemaV1 or StandardJSONSchemaV1.
+ */
+export type InferInput<T extends StandardTypedV1> = StandardTypedV1.InferInput<T>;
+/**
+ * Utility type to infer the output type from a StandardSchemaV1 or StandardJSONSchemaV1.
+ */
+export type InferOutput<T extends StandardTypedV1> = StandardTypedV1.InferOutput<T>;
+/**
+ * Supported targets for zod-to-json-schema conversion.
+ */
+export type ZodToJsonSchemaTarget = 'jsonSchema7' | 'openApi3' | 'jsonSchema2019-09';
+export type StandardSchemaIssue = StandardSchemaV1.Issue;
+//# sourceMappingURL=standard-schema.types.d.ts.map