@mastra/server 1.36.1-alpha.0 → 1.37.0-alpha.2

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

@@ -0,0 +1,119 @@
+/** The Standard Typed interface. This is a base type extended by other specs. */
+interface StandardTypedV1<Input = unknown, Output = Input> {
+    /** The Standard properties. */
+    readonly "~standard": StandardTypedV1.Props<Input, Output>;
+}
+declare namespace StandardTypedV1 {
+    /** The Standard Typed properties interface. */
+    interface Props<Input = unknown, Output = Input> {
+        /** The version number of the standard. */
+        readonly version: 1;
+        /** The vendor name of the schema library. */
+        readonly vendor: string;
+        /** Inferred types associated with the schema. */
+        readonly types?: Types<Input, Output> | undefined;
+    }
+    /** The Standard Typed types interface. */
+    interface Types<Input = unknown, Output = Input> {
+        /** The input type of the schema. */
+        readonly input: Input;
+        /** The output type of the schema. */
+        readonly output: Output;
+    }
+    /** Infers the input type of a Standard Typed. */
+    type InferInput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["input"];
+    /** Infers the output type of a Standard Typed. */
+    type InferOutput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["output"];
+}
+/** The Standard Schema interface. */
+interface StandardSchemaV1<Input = unknown, Output = Input> {
+    /** The Standard Schema properties. */
+    readonly "~standard": StandardSchemaV1.Props<Input, Output>;
+}
+declare namespace StandardSchemaV1 {
+    /** The Standard Schema properties interface. */
+    interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
+        /** Validates unknown input values. */
+        readonly validate: (value: unknown, options?: StandardSchemaV1.Options | undefined) => Result<Output> | Promise<Result<Output>>;
+    }
+    /** The result interface of the validate function. */
+    type Result<Output> = SuccessResult<Output> | FailureResult;
+    /** The result interface if validation succeeds. */
+    interface SuccessResult<Output> {
+        /** The typed output value. */
+        readonly value: Output;
+        /** A falsy value for `issues` indicates success. */
+        readonly issues?: undefined;
+    }
+    interface Options {
+        /** Explicit support for additional vendor-specific parameters, if needed. */
+        readonly libraryOptions?: Record<string, unknown> | undefined;
+    }
+    /** The result interface if validation fails. */
+    interface FailureResult {
+        /** The issues of failed validation. */
+        readonly issues: ReadonlyArray<Issue>;
+    }
+    /** The issue interface of the failure output. */
+    interface Issue {
+        /** The error message of the issue. */
+        readonly message: string;
+        /** The path of the issue, if any. */
+        readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+    }
+    /** The path segment interface of the issue. */
+    interface PathSegment {
+        /** The key representing a path segment. */
+        readonly key: PropertyKey;
+    }
+    /** The Standard types interface. */
+    interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {
+    }
+    /** Infers the input type of a Standard. */
+    type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
+    /** Infers the output type of a Standard. */
+    type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
+}
+/** The Standard JSON Schema interface. */
+interface StandardJSONSchemaV1<Input = unknown, Output = Input> {
+    /** The Standard JSON Schema properties. */
+    readonly "~standard": StandardJSONSchemaV1.Props<Input, Output>;
+}
+declare namespace StandardJSONSchemaV1 {
+    /** The Standard JSON Schema properties interface. */
+    interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
+        /** Methods for generating the input/output JSON Schema. */
+        readonly jsonSchema: StandardJSONSchemaV1.Converter;
+    }
+    /** The Standard JSON Schema converter interface. */
+    interface Converter {
+        /** Converts the input type to JSON Schema. May throw if conversion is not supported. */
+        readonly input: (options: StandardJSONSchemaV1.Options) => Record<string, unknown>;
+        /** Converts the output type to JSON Schema. May throw if conversion is not supported. */
+        readonly output: (options: StandardJSONSchemaV1.Options) => Record<string, unknown>;
+    }
+    /**
+     * The target version of the generated JSON Schema.
+     *
+     * It is *strongly recommended* that implementers support `"draft-2020-12"` and `"draft-07"`, as they are both in wide use. All other targets can be implemented on a best-effort basis. Libraries should throw if they don't support a specified target.
+     *
+     * The `"openapi-3.0"` target is intended as a standardized specifier for OpenAPI 3.0 which is a superset of JSON Schema `"draft-04"`.
+     */
+    type Target = "draft-2020-12" | "draft-07" | "openapi-3.0" | ({} & string);
+    /** The options for the input/output methods. */
+    interface Options {
+        /** Specifies the target version of the generated JSON Schema. Support for all versions is on a best-effort basis. If a given version is not supported, the library should throw. */
+        readonly target: Target;
+        /** Explicit support for additional vendor-specific parameters, if needed. */
+        readonly libraryOptions?: Record<string, unknown> | undefined;
+    }
+    /** The Standard types interface. */
+    interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {
+    }
+    /** Infers the input type of a Standard. */
+    type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
+    /** Infers the output type of a Standard. */
+    type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
+}
+
+export { StandardJSONSchemaV1, StandardSchemaV1, StandardTypedV1 };

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

@@ -0,0 +1,19 @@
+export { SchemaCompatLayer as SchemaCompatLayerV3, ALL_STRING_CHECKS, ALL_NUMBER_CHECKS, ALL_ARRAY_CHECKS, UNSUPPORTED_ZOD_TYPES, SUPPORTED_ZOD_TYPES, ALL_ZOD_TYPES, type StringCheckType, type NumberCheckType, type ArrayCheckType, type UnsupportedZodType, type SupportedZodType, type AllZodType, type ZodShape, type ShapeKey, type ShapeValue, isOptional, isObj, isArr, isUnion, isString, isNumber, } from './schema-compatibility-v3.js';
+export { SchemaCompatLayer as SchemaCompatLayerV4 } from './schema-compatibility-v4.js';
+export { SchemaCompatLayer } from './schema-compatibility.js';
+export { convertZodSchemaToAISDKSchema, applyCompatLayer, convertSchemaToZod, isZodType } from './utils.js';
+export { wrapSchemaWithNullTransform } from './null-to-undefined.js';
+export { ensureAllPropertiesRequired, prepareJsonSchemaForOpenAIStrictMode } from './zod-to-json.js';
+export { extractZodSchema, applyOpenAICompatTransforms, applyOpenAICompatToTools } from './standard-schema-compat.js';
+export { AnthropicSchemaCompatLayer } from './provider-compats/anthropic.js';
+export { DeepSeekSchemaCompatLayer } from './provider-compats/deepseek.js';
+export { GoogleSchemaCompatLayer } from './provider-compats/google.js';
+export { MetaSchemaCompatLayer } from './provider-compats/meta.js';
+export { OpenAISchemaCompatLayer } from './provider-compats/openai.js';
+export { OpenAIReasoningSchemaCompatLayer } from './provider-compats/openai-reasoning.js';
+export { type ModelInformation } from './types.js';
+export { type JSONSchema7, type Schema, jsonSchema } from './json-schema/index.js';
+export type { PublicSchema, InferPublicSchema } from './schema.types.js';
+export type { StandardSchemaWithJSON, StandardSchemaWithJSONProps, InferInput, InferOutput, StandardSchemaIssue, } from './standard-schema/standard-schema.types.js';
+export { toStandardSchema, isStandardSchema, isStandardJSONSchema, isStandardSchemaWithJSON, standardSchemaToJSONSchema, JSON_SCHEMA_LIBRARY_OPTIONS, } from './standard-schema/standard-schema.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/_types/@mastra_schema-compat/dist/null-to-undefined.d.ts

@@ -0,0 +1,24 @@
+import type { StandardSchemaWithJSON } from './standard-schema/standard-schema.types.js';
+/**
+ * Recursively converts null values to undefined in an object based on which
+ * properties are optional in the JSON Schema. This is needed because OpenAI
+ * strict mode sends null for optional fields, but schemas like Zod's .optional()
+ * reject null.
+ *
+ * Only converts null→undefined for properties that are NOT in the schema's
+ * `required` array, preserving null for explicitly .nullable() fields.
+ */
+export declare function transformNullToUndefined(value: unknown, jsonSchema: Record<string, unknown>): unknown;
+/**
+ * Wraps a StandardSchemaWithJSON to transform null values to undefined for
+ * optional fields before validation. This is a schema-agnostic solution for
+ * OpenAI strict mode, which sends null for optional fields.
+ *
+ * The wrapper:
+ * 1. Extracts the JSON Schema from the inner schema to determine optional fields
+ * 2. Before validation, transforms null→undefined for non-required properties
+ * 3. Delegates validation to the inner schema with the transformed value
+ * 4. Delegates JSON Schema conversion to the inner schema unchanged
+ */
+export declare function wrapSchemaWithNullTransform<Input = unknown, Output = Input>(schema: StandardSchemaWithJSON<Input, Output>): StandardSchemaWithJSON<Input, Output>;
+//# sourceMappingURL=null-to-undefined.d.ts.map

package/dist/_types/@mastra_schema-compat/dist/provider-compats/anthropic.d.ts

@@ -0,0 +1,20 @@
+import type { JSONSchema7 } from 'json-schema';
+import type { ZodType as ZodTypeV3 } from 'zod/v3';
+import type { ZodType as ZodTypeV4 } from 'zod/v4';
+import type { Targets } from 'zod-to-json-schema';
+import { SchemaCompatLayer } from '../schema-compatibility.js';
+import type { PublicSchema, ZodType } from '../schema.types.js';
+import type { StandardSchemaWithJSON } from '../standard-schema/standard-schema.types.js';
+import type { ModelInformation } from '../types.js';
+export declare class AnthropicSchemaCompatLayer extends SchemaCompatLayer {
+    #private;
+    constructor(model: ModelInformation);
+    getSchemaTarget(): Targets | undefined;
+    shouldApply(): boolean;
+    processZodType(value: ZodType): ZodType;
+    processToAISDKSchema(zodSchema: ZodTypeV3 | ZodTypeV4): import("../_types/@internal_ai-sdk-v4/dist/index.d.ts").Schema<any>;
+    processToCompatSchema<T>(schema: PublicSchema<T>): StandardSchemaWithJSON<T>;
+    preProcessJSONNode(schema: JSONSchema7): void;
+    postProcessJSONNode(schema: JSONSchema7): void;
+}
+//# sourceMappingURL=anthropic.d.ts.map

package/dist/_types/@mastra_schema-compat/dist/provider-compats/deepseek.d.ts

@@ -0,0 +1,21 @@
+import type { JSONSchema7 } from 'json-schema';
+import type { ZodType as ZodTypeV3 } from 'zod/v3';
+import type { ZodType as ZodTypeV4 } from 'zod/v4';
+import type { Targets } from 'zod-to-json-schema';
+import { SchemaCompatLayer } from '../schema-compatibility.js';
+import type { PublicSchema } from '../schema.types.js';
+import type { StandardSchemaWithJSON } from '../standard-schema/standard-schema.types.js';
+import type { ModelInformation } from '../types.js';
+export declare class DeepSeekSchemaCompatLayer extends SchemaCompatLayer {
+    #private;
+    constructor(model: ModelInformation);
+    getSchemaTarget(): Targets | undefined;
+    shouldApply(): boolean;
+    processZodType(value: ZodTypeV3): ZodTypeV3;
+    processZodType(value: ZodTypeV4): ZodTypeV4;
+    processToAISDKSchema(zodSchema: ZodTypeV3 | ZodTypeV4): import("../_types/@internal_ai-sdk-v4/dist/index.d.ts").Schema<any>;
+    processToCompatSchema<T>(schema: PublicSchema<T>): StandardSchemaWithJSON<T>;
+    preProcessJSONNode(schema: JSONSchema7): void;
+    postProcessJSONNode(schema: JSONSchema7): void;
+}
+//# sourceMappingURL=deepseek.d.ts.map

package/dist/_types/@mastra_schema-compat/dist/provider-compats/google.d.ts

@@ -0,0 +1,23 @@
+import type { JSONSchema7 } from 'json-schema';
+import type { ZodType as ZodTypeV3 } from 'zod/v3';
+import type { ZodType as ZodTypeV4 } from 'zod/v4';
+import type { Targets } from 'zod-to-json-schema';
+import type { Schema } from '../json-schema/index.js';
+import { SchemaCompatLayer } from '../schema-compatibility.js';
+import type { PublicSchema } from '../schema.types.js';
+import type { StandardSchemaWithJSON } from '../standard-schema/standard-schema.types.js';
+import type { ModelInformation } from '../types.js';
+export declare class GoogleSchemaCompatLayer extends SchemaCompatLayer {
+    #private;
+    constructor(model: ModelInformation);
+    getSchemaTarget(): Targets | undefined;
+    shouldApply(): boolean;
+    processZodType(value: ZodTypeV3): ZodTypeV3;
+    processZodType(value: ZodTypeV4): ZodTypeV4;
+    processToJSONSchema(schema: PublicSchema<any>, io?: 'input' | 'output'): JSONSchema7;
+    processToAISDKSchema(zodSchema: ZodTypeV3 | ZodTypeV4): Schema;
+    processToCompatSchema<T>(schema: PublicSchema<T>): StandardSchemaWithJSON<T>;
+    preProcessJSONNode(schema: JSONSchema7): void;
+    postProcessJSONNode(schema: JSONSchema7): void;
+}
+//# sourceMappingURL=google.d.ts.map

package/dist/_types/@mastra_schema-compat/dist/provider-compats/meta.d.ts

@@ -0,0 +1,21 @@
+import type { JSONSchema7 } from 'json-schema';
+import type { ZodType as ZodTypeV3 } from 'zod/v3';
+import type { ZodType as ZodTypeV4 } from 'zod/v4';
+import type { Targets } from 'zod-to-json-schema';
+import { SchemaCompatLayer } from '../schema-compatibility.js';
+import type { PublicSchema } from '../schema.types.js';
+import type { StandardSchemaWithJSON } from '../standard-schema/standard-schema.types.js';
+import type { ModelInformation } from '../types.js';
+export declare class MetaSchemaCompatLayer extends SchemaCompatLayer {
+    #private;
+    constructor(model: ModelInformation);
+    getSchemaTarget(): Targets | undefined;
+    shouldApply(): boolean;
+    processZodType(value: ZodTypeV3): ZodTypeV3;
+    processZodType(value: ZodTypeV4): ZodTypeV4;
+    processToAISDKSchema(zodSchema: ZodTypeV3 | ZodTypeV4): import("../_types/@internal_ai-sdk-v4/dist/index.d.ts").Schema<any>;
+    processToCompatSchema<T>(schema: PublicSchema<T>): StandardSchemaWithJSON<T>;
+    preProcessJSONNode(schema: JSONSchema7): void;
+    postProcessJSONNode(schema: JSONSchema7): void;
+}
+//# sourceMappingURL=meta.d.ts.map

package/dist/_types/@mastra_schema-compat/dist/provider-compats/openai-reasoning.d.ts

@@ -0,0 +1,10 @@
+import type { Targets } from 'zod-to-json-schema';
+import type { ZodType } from '../schema.types.js';
+import { OpenAISchemaCompatLayer } from './openai.js';
+export declare class OpenAIReasoningSchemaCompatLayer extends OpenAISchemaCompatLayer {
+    getSchemaTarget(): Targets | undefined;
+    isReasoningModel(): boolean;
+    shouldApply(): boolean;
+    processZodType(value: ZodType): ZodType;
+}
+//# sourceMappingURL=openai-reasoning.d.ts.map

package/dist/_types/@mastra_schema-compat/dist/provider-compats/openai.d.ts

@@ -0,0 +1,25 @@
+import type { JSONSchema7 } from 'json-schema';
+import type { ZodType as ZodTypeV3 } from 'zod/v3';
+import type { ZodType as ZodTypeV4 } from 'zod/v4';
+import type { Targets } from 'zod-to-json-schema';
+import type { Schema } from '../json-schema/index.js';
+import { SchemaCompatLayer } from '../schema-compatibility.js';
+import type { PublicSchema, ZodType } from '../schema.types.js';
+import type { StandardSchemaWithJSON } from '../standard-schema/standard-schema.types.js';
+export declare class OpenAISchemaCompatLayer extends SchemaCompatLayer {
+    #private;
+    getSchemaTarget(): Targets | undefined;
+    isReasoningModel(): boolean;
+    shouldApply(): boolean;
+    processZodType(value: ZodType): ZodType;
+    /**
+     * Override to apply the same JSON Schema fixes (additionalProperties, required fields)
+     * that processToJSONSchema applies. The base implementation skips JSON Schema traversal,
+     * which causes OpenAI strict mode to reject tool schemas missing additionalProperties: false.
+     */
+    processToAISDKSchema(zodSchema: ZodTypeV3 | ZodTypeV4): Schema;
+    processToCompatSchema<T>(schema: PublicSchema<T>): StandardSchemaWithJSON<T>;
+    preProcessJSONNode(schema: JSONSchema7, _parentSchema?: JSONSchema7): void;
+    postProcessJSONNode(schema: JSONSchema7): void;
+}
+//# sourceMappingURL=openai.d.ts.map

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

@@ -0,0 +1,315 @@
+import { z, ZodOptional, ZodObject, ZodArray, ZodUnion, ZodString, ZodNumber, ZodDate, ZodDefault, ZodNull, ZodNullable, ZodIntersection } from 'zod/v3';
+import type { ZodTypeAny } from 'zod/v3';
+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", "max"];
+/**
+ * All supported number validation check types that can be processed or converted to descriptions.
+ * @constant
+ */
+export declare const ALL_NUMBER_CHECKS: readonly ["min", "max", "multipleOf"];
+/**
+ * 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"];
+export declare const isOptional: (v: ZodTypeAny) => v is ZodOptional<any>;
+export declare const isObj: (v: ZodTypeAny) => v is ZodObject<any, any, any>;
+export declare const isNull: (v: ZodTypeAny) => v is ZodNull;
+export declare const isNullable: (v: ZodTypeAny) => v is ZodNullable<any>;
+export declare const isArr: (v: ZodTypeAny) => v is ZodArray<any, any>;
+export declare const isUnion: (v: ZodTypeAny) => v is ZodUnion<[ZodTypeAny, ...ZodTypeAny[]]>;
+export declare const isString: (v: ZodTypeAny) => v is ZodString;
+export declare const isNumber: (v: ZodTypeAny) => v is ZodNumber;
+export declare const isDate: (v: ZodTypeAny) => v is ZodDate;
+export declare const isDefault: (v: ZodTypeAny) => v is ZodDefault<any>;
+export declare const isIntersection: (v: ZodTypeAny) => v is ZodIntersection<any, any>;
+/**
+ * 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.AnyZodObject> = T['shape'];
+/**
+ * Utility type to extract the keys from a Zod object shape.
+ */
+export type ShapeKey<T extends z.AnyZodObject> = keyof ZodShape<T>;
+/**
+ * Utility type to extract the value types from a Zod object shape.
+ */
+export type ShapeValue<T extends z.AnyZodObject> = 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: ModelInformation) {
+ *     super(model);
+ *   }
+ *
+ *   shouldApply(): boolean {
+ *     return this.getModel().provider === 'custom-provider';
+ *   }
+ *
+ *   getSchemaTarget() {
+ *     return 'jsonSchema7';
+ *   }
+ *
+ *   processZodType<T extends z.AnyZodObject>(value: z.ZodTypeAny): 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: ZodTypeAny): v is ZodOptional<any>;
+    /**
+     * Type guard for object Zod types
+     */
+    isObj(v: ZodTypeAny): v is ZodObject<any, any, any>;
+    /**
+     * Type guard for null Zod types
+     */
+    isNull(v: ZodTypeAny): v is ZodNull;
+    /**
+     * Type guard for nullable Zod types
+     */
+    isNullable(v: ZodTypeAny): v is ZodNullable<any>;
+    /**
+     * Type guard for array Zod types
+     */
+    isArr(v: ZodTypeAny): v is ZodArray<any, any>;
+    /**
+     * Type guard for union Zod types
+     */
+    isUnion(v: ZodTypeAny): v is ZodUnion<[ZodTypeAny, ...ZodTypeAny[]]>;
+    /**
+     * Type guard for string Zod types
+     */
+    isString(v: ZodTypeAny): v is ZodString;
+    /**
+     * Type guard for number Zod types
+     */
+    isNumber(v: ZodTypeAny): v is ZodNumber;
+    /**
+     * Type guard for date Zod types
+     */
+    isDate(v: ZodTypeAny): v is ZodDate;
+    /**
+     * Type guard for default Zod types
+     */
+    isDefault(v: ZodTypeAny): v is ZodDefault<any>;
+    /**
+     * Type guard for intersection Zod types
+     */
+    isIntersection(v: ZodTypeAny): 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: ZodTypeAny): ZodTypeAny;
+    /**
+     * 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, any>, options?: {
+        passthrough?: boolean;
+    }): ZodObject<any, 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.AnyZodObject>(value: z.ZodTypeAny, 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, any>, handleChecks?: readonly ArrayCheckType[]): ZodArray<any, 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<[ZodTypeAny, ...ZodTypeAny[]]>): ZodTypeAny;
+    /**
+     * 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[]): ZodTypeAny;
+    /**
+     * 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[]): ZodTypeAny;
+    /**
+     * 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>): ZodTypeAny;
+    /**
+     * 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: z.ZodSchema): 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: z.ZodSchema): JSONSchema7;
+}
+export {};
+//# sourceMappingURL=schema-compatibility-v3.d.ts.map