@mastra/schema-compat 0.0.0-ai-v5-20250801192614 → 0.0.0-bundle-recursion-20251030002519

package/dist/index.cjs

@@ -1,24 +1,20 @@
 'use strict';
 
+var chunk5WM4A32G_cjs = require('./chunk-5WM4A32G.cjs');
 var zod = require('zod');
 var ai = require('ai');
 var zodFromJsonSchema = require('zod-from-json-schema');
-var zodToJsonSchema = require('zod-to-json-schema');
+var zodFromJsonSchemaV3 = require('zod-from-json-schema-v3');
+var v4 = require('zod/v4');
 
-// src/schema-compatibility.ts
 function convertZodSchemaToAISDKSchema(zodSchema, target = "jsonSchema7") {
-  return ai.jsonSchema(
-    zodToJsonSchema.zodToJsonSchema(zodSchema, {
-      $refStrategy: "none",
-      target
-    }),
-    {
-      validate: (value) => {
-        const result = zodSchema.safeParse(value);
-        return result.success ? { success: true, value: result.data } : { success: false, error: result.error };
-      }
+  const jsonSchemaToUse = chunk5WM4A32G_cjs.zodToJsonSchema(zodSchema, target);
+  return ai.jsonSchema(jsonSchemaToUse, {
+    validate: (value) => {
+      const result = zodSchema.safeParse(value);
+      return result.success ? { success: true, value: result.data } : { success: false, error: result.error };
     }
-  );
+  });
 }
 function isZodType(value) {
   return typeof value === "object" && value !== null && "_def" in value && "parse" in value && typeof value.parse === "function" && "safeParse" in value && typeof value.safeParse === "function";
@@ -29,7 +25,11 @@ function convertSchemaToZod(schema) {
   } else {
     const jsonSchemaToConvert = "jsonSchema" in schema ? schema.jsonSchema : schema;
     try {
-      return zodFromJsonSchema.convertJsonSchemaToZod(jsonSchemaToConvert);
+      if ("toJSONSchema" in zod.z) {
+        return zodFromJsonSchema.convertJsonSchemaToZod(jsonSchemaToConvert);
+      } else {
+        return zodFromJsonSchemaV3.convertJsonSchemaToZod(jsonSchemaToConvert);
+      }
     } catch (e) {
       const errorMessage = `[Schema Builder] Failed to convert schema parameters to Zod. Original schema: ${JSON.stringify(jsonSchemaToConvert)}`;
       console.error(errorMessage, e);
@@ -55,13 +55,13 @@ function applyCompatLayer({
     }
   }
   if (mode === "jsonSchema") {
-    return zodToJsonSchema.zodToJsonSchema(zodSchema, { $refStrategy: "none", target: "jsonSchema7" });
+    return chunk5WM4A32G_cjs.zodToJsonSchema(zodSchema, "jsonSchema7");
   } else {
     return convertZodSchemaToAISDKSchema(zodSchema);
   }
 }
 
-// src/schema-compatibility.ts
+// src/schema-compatibility-v3.ts
 var ALL_STRING_CHECKS = ["regex", "emoji", "email", "url", "uuid", "cuid", "min", "max"];
 var ALL_NUMBER_CHECKS = [
   "min",
@@ -73,13 +73,10 @@ var ALL_NUMBER_CHECKS = [
 var ALL_ARRAY_CHECKS = ["min", "max", "length"];
 var isOptional = (v) => v instanceof zod.ZodOptional;
 var isObj = (v) => v instanceof zod.ZodObject;
-var isNull = (v) => v instanceof zod.ZodNull;
 var isArr = (v) => v instanceof zod.ZodArray;
 var isUnion = (v) => v instanceof zod.ZodUnion;
 var isString = (v) => v instanceof zod.ZodString;
 var isNumber = (v) => v instanceof zod.ZodNumber;
-var isDate = (v) => v instanceof zod.ZodDate;
-var isDefault = (v) => v instanceof zod.ZodDefault;
 var UNSUPPORTED_ZOD_TYPES = ["ZodIntersection", "ZodNever", "ZodNull", "ZodTuple", "ZodUndefined"];
 var SUPPORTED_ZOD_TYPES = [
   "ZodObject",
@@ -94,13 +91,15 @@ var SUPPORTED_ZOD_TYPES = [
 var ALL_ZOD_TYPES = [...SUPPORTED_ZOD_TYPES, ...UNSUPPORTED_ZOD_TYPES];
 var SchemaCompatLayer = class {
   model;
+  parent;
   /**
    * Creates a new schema compatibility instance.
    *
    * @param model - The language model this compatibility layer applies to
    */
-  constructor(model) {
+  constructor(model, parent) {
     this.model = model;
+    this.parent = parent;
   }
   /**
    * Gets the language model associated with this compatibility layer.
@@ -110,6 +109,91 @@ var SchemaCompatLayer = class {
   getModel() {
     return this.model;
   }
+  getUnsupportedZodTypes() {
+    return UNSUPPORTED_ZOD_TYPES;
+  }
+  /**
+   * Type guard for optional Zod types
+   */
+  isOptional(v) {
+    return v instanceof zod.ZodOptional;
+  }
+  /**
+   * Type guard for object Zod types
+   */
+  isObj(v) {
+    return v instanceof zod.ZodObject;
+  }
+  /**
+   * Type guard for null Zod types
+   */
+  isNull(v) {
+    return v instanceof zod.ZodNull;
+  }
+  /**
+   * Type guard for array Zod types
+   */
+  isArr(v) {
+    return v instanceof zod.ZodArray;
+  }
+  /**
+   * Type guard for union Zod types
+   */
+  isUnion(v) {
+    return v instanceof zod.ZodUnion;
+  }
+  /**
+   * Type guard for string Zod types
+   */
+  isString(v) {
+    return v instanceof zod.ZodString;
+  }
+  /**
+   * Type guard for number Zod types
+   */
+  isNumber(v) {
+    return v instanceof zod.ZodNumber;
+  }
+  /**
+   * Type guard for date Zod types
+   */
+  isDate(v) {
+    return v instanceof zod.ZodDate;
+  }
+  /**
+   * Type guard for default Zod types
+   */
+  isDefault(v) {
+    return v instanceof zod.ZodDefault;
+  }
+  /**
+   * 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() {
+    return this.parent.shouldApply();
+  }
+  /**
+   * Returns the JSON Schema target format for this provider.
+   *
+   * @returns The schema target format, or undefined to use the default 'jsonSchema7'
+   * @abstract
+   */
+  getSchemaTarget() {
+    return this.parent.getSchemaTarget();
+  }
+  /**
+   * 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) {
+    return this.parent.processZodType(value);
+  }
   /**
    * Default handler for Zod object types. Recursively processes all properties in the object.
    *
@@ -147,8 +231,8 @@ var SchemaCompatLayer = class {
    * @returns The updated description with constraints, or undefined if no constraints
    */
   mergeParameterDescription(description, constraints) {
-    if (Object.keys(constraints).length > 0) {
-      return (description ? description + "\n" : "") + JSON.stringify(constraints);
+    if (constraints.length > 0) {
+      return (description ? description + "\n" : "") + `constraints: ${constraints.join(`, `)}`;
     } else {
       return description;
     }
@@ -178,24 +262,24 @@ var SchemaCompatLayer = class {
     const zodArrayDef = value._def;
     const processedType = this.processZodType(zodArrayDef.type);
     let result = zod.z.array(processedType);
-    const constraints = {};
+    const constraints = [];
     if (zodArrayDef.minLength?.value !== void 0) {
       if (handleChecks.includes("min")) {
-        constraints.minLength = zodArrayDef.minLength.value;
+        constraints.push(`minimum length ${zodArrayDef.minLength.value}`);
       } else {
         result = result.min(zodArrayDef.minLength.value);
       }
     }
     if (zodArrayDef.maxLength?.value !== void 0) {
       if (handleChecks.includes("max")) {
-        constraints.maxLength = zodArrayDef.maxLength.value;
+        constraints.push(`maximum length ${zodArrayDef.maxLength.value}`);
       } else {
         result = result.max(zodArrayDef.maxLength.value);
       }
     }
     if (zodArrayDef.exactLength?.value !== void 0) {
       if (handleChecks.includes("length")) {
-        constraints.exactLength = zodArrayDef.exactLength.value;
+        constraints.push(`exact length ${zodArrayDef.exactLength.value}`);
       } else {
         result = result.length(zodArrayDef.exactLength.value);
       }
@@ -230,7 +314,7 @@ var SchemaCompatLayer = class {
    * @returns The processed Zod string
    */
   defaultZodStringHandler(value, handleChecks = ALL_STRING_CHECKS) {
-    const constraints = {};
+    const constraints = [];
     const checks = value._def.checks || [];
     const newChecks = [];
     for (const check of checks) {
@@ -238,38 +322,20 @@ var SchemaCompatLayer = class {
         if (handleChecks.includes(check.kind)) {
           switch (check.kind) {
             case "regex": {
-              constraints.regex = {
-                pattern: check.regex.source,
-                flags: check.regex.flags
-              };
-              break;
-            }
-            case "emoji": {
-              constraints.emoji = true;
-              break;
-            }
-            case "email": {
-              constraints.email = true;
-              break;
-            }
-            case "url": {
-              constraints.url = true;
-              break;
-            }
-            case "uuid": {
-              constraints.uuid = true;
+              constraints.push(`input must match this regex ${check.regex.source}`);
               break;
             }
+            case "emoji":
+            case "email":
+            case "url":
+            case "uuid":
             case "cuid": {
-              constraints.cuid = true;
-              break;
-            }
-            case "min": {
-              constraints.minLength = check.value;
+              constraints.push(`a valid ${check.kind}`);
               break;
             }
+            case "min":
             case "max": {
-              constraints.maxLength = check.value;
+              constraints.push(`${check.kind}imum length ${check.value}`);
               break;
             }
           }
@@ -296,7 +362,7 @@ var SchemaCompatLayer = class {
    * @returns The processed Zod number
    */
   defaultZodNumberHandler(value, handleChecks = ALL_NUMBER_CHECKS) {
-    const constraints = {};
+    const constraints = [];
     const checks = value._def.checks || [];
     const newChecks = [];
     for (const check of checks) {
@@ -305,20 +371,20 @@ var SchemaCompatLayer = class {
           switch (check.kind) {
             case "min":
               if (check.inclusive) {
-                constraints.gte = check.value;
+                constraints.push(`greater than or equal to ${check.value}`);
               } else {
-                constraints.gt = check.value;
+                constraints.push(`greater than ${check.value}`);
               }
               break;
             case "max":
               if (check.inclusive) {
-                constraints.lte = check.value;
+                constraints.push(`lower than or equal to ${check.value}`);
               } else {
-                constraints.lt = check.value;
+                constraints.push(`lower than ${check.value}`);
               }
               break;
             case "multipleOf": {
-              constraints.multipleOf = check.value;
+              constraints.push(`multiple of ${check.value}`);
               break;
             }
           }
@@ -353,7 +419,7 @@ var SchemaCompatLayer = class {
    * @returns A Zod string schema representing the date in ISO format
    */
   defaultZodDateHandler(value) {
-    const constraints = {};
+    const constraints = [];
     const checks = value._def.checks || [];
     for (const check of checks) {
       if ("kind" in check) {
@@ -361,19 +427,19 @@ var SchemaCompatLayer = class {
           case "min":
             const minDate = new Date(check.value);
             if (!isNaN(minDate.getTime())) {
-              constraints.minDate = minDate.toISOString();
+              constraints.push(`Date must be newer than ${minDate.toISOString()} (ISO)`);
             }
             break;
           case "max":
             const maxDate = new Date(check.value);
             if (!isNaN(maxDate.getTime())) {
-              constraints.maxDate = maxDate.toISOString();
+              constraints.push(`Date must be older than ${maxDate.toISOString()} (ISO)`);
             }
             break;
         }
       }
     }
-    constraints.dateFormat = "date-time";
+    constraints.push(`Date format is date-time`);
     let result = zod.z.string().describe("date-time");
     const description = this.mergeParameterDescription(value.description, constraints);
     if (description) {
@@ -415,9 +481,667 @@ var SchemaCompatLayer = class {
     return this.processToAISDKSchema(zodSchema).jsonSchema;
   }
 };
+var ALL_STRING_CHECKS2 = [
+  "regex",
+  "emoji",
+  "email",
+  "url",
+  "uuid",
+  "cuid",
+  "min_length",
+  "max_length",
+  "string_format"
+];
+var ALL_NUMBER_CHECKS2 = ["greater_than", "less_than", "multiple_of"];
+var ALL_ARRAY_CHECKS2 = ["min", "max", "length"];
+var UNSUPPORTED_ZOD_TYPES2 = ["ZodIntersection", "ZodNever", "ZodNull", "ZodTuple", "ZodUndefined"];
+var SUPPORTED_ZOD_TYPES2 = [
+  "ZodObject",
+  "ZodArray",
+  "ZodUnion",
+  "ZodString",
+  "ZodNumber",
+  "ZodDate",
+  "ZodAny",
+  "ZodDefault"
+];
+var SchemaCompatLayer2 = class {
+  model;
+  parent;
+  /**
+   * Creates a new schema compatibility instance.
+   *
+   * @param model - The language model this compatibility layer applies to
+   */
+  constructor(model, parent) {
+    this.model = model;
+    this.parent = parent;
+  }
+  /**
+   * Gets the language model associated with this compatibility layer.
+   *
+   * @returns The language model instance
+   */
+  getModel() {
+    return this.model;
+  }
+  getUnsupportedZodTypes() {
+    return UNSUPPORTED_ZOD_TYPES2;
+  }
+  /**
+   * Type guard for optional Zod types
+   */
+  isOptional(v) {
+    return v instanceof v4.ZodOptional;
+  }
+  /**
+   * Type guard for object Zod types
+   */
+  isObj(v) {
+    return v instanceof v4.ZodObject;
+  }
+  /**
+   * Type guard for null Zod types
+   */
+  isNull(v) {
+    return v instanceof v4.ZodNull;
+  }
+  /**
+   * Type guard for array Zod types
+   */
+  isArr(v) {
+    return v instanceof v4.ZodArray;
+  }
+  /**
+   * Type guard for union Zod types
+   */
+  isUnion(v) {
+    return v instanceof v4.ZodUnion;
+  }
+  /**
+   * Type guard for string Zod types
+   */
+  isString(v) {
+    return v instanceof v4.ZodString;
+  }
+  /**
+   * Type guard for number Zod types
+   */
+  isNumber(v) {
+    return v instanceof v4.ZodNumber;
+  }
+  /**
+   * Type guard for date Zod types
+   */
+  isDate(v) {
+    return v instanceof v4.ZodDate;
+  }
+  /**
+   * Type guard for default Zod types
+   */
+  isDefault(v) {
+    return v instanceof v4.ZodDefault;
+  }
+  /**
+   * 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() {
+    return this.parent.shouldApply();
+  }
+  /**
+   * Returns the JSON Schema target format for this provider.
+   *
+   * @returns The schema target format, or undefined to use the default 'jsonSchema7'
+   * @abstract
+   */
+  getSchemaTarget() {
+    return this.parent.getSchemaTarget();
+  }
+  /**
+   * 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) {
+    return this.parent.processZodType(value);
+  }
+  /**
+   * 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, options = { passthrough: true }) {
+    const processedShape = Object.entries(value.shape).reduce((acc, [key, propValue]) => {
+      acc[key] = this.processZodType(propValue);
+      return acc;
+    }, {});
+    let result = v4.z.object(processedShape);
+    if (value._zod.def.catchall instanceof v4.z.ZodNever) {
+      result = v4.z.strictObject(processedShape);
+    }
+    if (value._zod.def.catchall && !(value._zod.def.catchall instanceof v4.z.ZodNever)) {
+      result = result.catchall(value._zod.def.catchall);
+    }
+    if (value.description) {
+      result = result.describe(value.description);
+    }
+    if (options.passthrough && value._zod.def.catchall instanceof v4.z.ZodUnknown) {
+      result = v4.z.looseObject(processedShape);
+    }
+    return result;
+  }
+  /**
+   * 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, constraints) {
+    if (constraints.length > 0) {
+      return (description ? description + "\n" : "") + `constraints: ${constraints.join(`, `)}`;
+    } else {
+      return description;
+    }
+  }
+  /**
+   * 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(value, throwOnTypes = UNSUPPORTED_ZOD_TYPES2) {
+    if (throwOnTypes.includes(value.constructor.name)) {
+      throw new Error(`${this.model.modelId} does not support zod type: ${value.constructor.name}`);
+    }
+    return value;
+  }
+  /**
+   * 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, handleChecks = ALL_ARRAY_CHECKS2) {
+    const zodArrayDef = value._zod.def;
+    const processedType = this.processZodType(zodArrayDef.element);
+    let result = v4.z.array(processedType);
+    const constraints = [];
+    if (zodArrayDef.checks) {
+      for (const check of zodArrayDef.checks) {
+        if (check._zod.def.check === "min_length") {
+          if (handleChecks.includes("min")) {
+            constraints.push(`minimum length ${check._zod.def.minimum}`);
+          } else {
+            result = result.min(check._zod.def.minimum);
+          }
+        }
+        if (check._zod.def.check === "max_length") {
+          if (handleChecks.includes("max")) {
+            constraints.push(`maximum length ${check._zod.def.maximum}`);
+          } else {
+            result = result.max(check._zod.def.maximum);
+          }
+        }
+        if (check._zod.def.check === "length_equals") {
+          if (handleChecks.includes("length")) {
+            constraints.push(`exact length ${check._zod.def.length}`);
+          } else {
+            result = result.length(check._zod.def.length);
+          }
+        }
+      }
+    }
+    const metaDescription = value.meta()?.description;
+    const legacyDescription = value.description;
+    const description = this.mergeParameterDescription(metaDescription || legacyDescription, constraints);
+    if (description) {
+      result = result.describe(description);
+    }
+    return result;
+  }
+  /**
+   * 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) {
+    const processedOptions = value._zod.def.options.map((option) => this.processZodType(option));
+    if (processedOptions.length < 2) throw new Error("Union must have at least 2 options");
+    let result = v4.z.union(processedOptions);
+    if (value.description) {
+      result = result.describe(value.description);
+    }
+    return result;
+  }
+  /**
+   * 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, handleChecks = ALL_STRING_CHECKS2) {
+    const constraints = [];
+    const checks = value._zod.def.checks || [];
+    const newChecks = [];
+    if (checks) {
+      for (const check of checks) {
+        if (handleChecks.includes(check._zod.def.check)) {
+          switch (check._zod.def.check) {
+            case "min_length":
+              constraints.push(`minimum length ${check._zod.def.minimum}`);
+              break;
+            case "max_length":
+              constraints.push(`maximum length ${check._zod.def.maximum}`);
+              break;
+            case "string_format":
+              {
+                switch (check._zod.def.format) {
+                  case "email":
+                  case "url":
+                  case "emoji":
+                  case "uuid":
+                  case "cuid":
+                    constraints.push(`a valid ${check._zod.def.format}`);
+                    break;
+                  case "regex":
+                    constraints.push(`input must match this regex ${check._zod.def.pattern}`);
+                    break;
+                }
+              }
+              break;
+          }
+        } else {
+          newChecks.push(check);
+        }
+      }
+    }
+    let result = v4.z.string();
+    for (const check of newChecks) {
+      result = result.check(check);
+    }
+    const metaDescription = value.meta()?.description;
+    const legacyDescription = value.description;
+    const description = this.mergeParameterDescription(metaDescription || legacyDescription, constraints);
+    if (description) {
+      result = result.describe(description);
+    }
+    return result;
+  }
+  /**
+   * 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, handleChecks = ALL_NUMBER_CHECKS2) {
+    const constraints = [];
+    const checks = value._zod.def.checks || [];
+    const newChecks = [];
+    if (checks) {
+      for (const check of checks) {
+        if (handleChecks.includes(check._zod.def.check)) {
+          switch (check._zod.def.check) {
+            case "greater_than":
+              if (check._zod.def.inclusive) {
+                constraints.push(`greater than or equal to ${check._zod.def.value}`);
+              } else {
+                constraints.push(`greater than ${check._zod.def.value}`);
+              }
+              break;
+            case "less_than":
+              if (check._zod.def.inclusive) {
+                constraints.push(`lower than or equal to ${check._zod.def.value}`);
+              } else {
+                constraints.push(`lower than ${check._zod.def.value}`);
+              }
+              break;
+            case "multiple_of": {
+              constraints.push(`multiple of ${check._zod.def.value}`);
+              break;
+            }
+          }
+        } else {
+          newChecks.push(check);
+        }
+      }
+    }
+    let result = v4.z.number();
+    for (const check of newChecks) {
+      switch (check._zod.def.check) {
+        case "number_format": {
+          switch (check._zod.def.format) {
+            case "safeint":
+              result = result.int();
+              break;
+          }
+          break;
+        }
+        default:
+          result = result.check(check);
+      }
+    }
+    const description = this.mergeParameterDescription(value.description, constraints);
+    if (description) {
+      result = result.describe(description);
+    }
+    return result;
+  }
+  /**
+   * 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) {
+    const constraints = [];
+    const checks = value._zod.def.checks || [];
+    if (checks) {
+      for (const check of checks) {
+        switch (check._zod.def.check) {
+          case "less_than":
+            const minDate = new Date(check._zod.def.value);
+            if (!isNaN(minDate.getTime())) {
+              constraints.push(`Date must be newer than ${minDate.toISOString()} (ISO)`);
+            }
+            break;
+          case "greater_than":
+            const maxDate = new Date(check._zod.def.value);
+            if (!isNaN(maxDate.getTime())) {
+              constraints.push(`Date must be older than ${maxDate.toISOString()} (ISO)`);
+            }
+            break;
+        }
+      }
+    }
+    constraints.push(`Date format is date-time`);
+    let result = v4.z.string().describe("date-time");
+    const description = this.mergeParameterDescription(value.description, constraints);
+    if (description) {
+      result = result.describe(description);
+    }
+    return result;
+  }
+  /**
+   * 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, handleTypes = SUPPORTED_ZOD_TYPES2) {
+    if (handleTypes.includes(value.constructor.name)) {
+      return this.processZodType(value._zod.def.innerType).optional();
+    } else {
+      return value;
+    }
+  }
+  /**
+   * 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) {
+    const processedSchema = this.processZodType(zodSchema);
+    return convertZodSchemaToAISDKSchema(processedSchema, this.getSchemaTarget());
+  }
+  /**
+   * 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) {
+    return this.processToAISDKSchema(zodSchema).jsonSchema;
+  }
+};
+
+// src/schema-compatibility.ts
+var SchemaCompatLayer3 = class {
+  model;
+  v3Layer;
+  v4Layer;
+  /**
+   * Creates a new schema compatibility instance.
+   *
+   * @param model - The language model this compatibility layer applies to
+   */
+  constructor(model) {
+    this.model = model;
+    this.v3Layer = new SchemaCompatLayer(model, this);
+    this.v4Layer = new SchemaCompatLayer2(model, this);
+  }
+  /**
+   * Gets the language model associated with this compatibility layer.
+   *
+   * @returns The language model instance
+   */
+  getModel() {
+    return this.model;
+  }
+  getUnsupportedZodTypes(v) {
+    if ("_zod" in v) {
+      return this.v4Layer.getUnsupportedZodTypes();
+    } else {
+      return this.v3Layer.getUnsupportedZodTypes();
+    }
+  }
+  isOptional(v) {
+    if ("_zod" in v) {
+      return this.v4Layer.isOptional(v);
+    } else {
+      return this.v3Layer.isOptional(v);
+    }
+  }
+  isObj(v) {
+    if ("_zod" in v) {
+      return this.v4Layer.isObj(v);
+    } else {
+      return this.v3Layer.isObj(v);
+    }
+  }
+  isNull(v) {
+    if ("_zod" in v) {
+      return this.v4Layer.isNull(v);
+    } else {
+      return this.v3Layer.isNull(v);
+    }
+  }
+  isArr(v) {
+    if ("_zod" in v) {
+      return this.v4Layer.isArr(v);
+    } else {
+      return this.v3Layer.isArr(v);
+    }
+  }
+  isUnion(v) {
+    if ("_zod" in v) {
+      return this.v4Layer.isUnion(v);
+    } else {
+      return this.v3Layer.isUnion(v);
+    }
+  }
+  isString(v) {
+    if ("_zod" in v) {
+      return this.v4Layer.isString(v);
+    } else {
+      return this.v3Layer.isString(v);
+    }
+  }
+  isNumber(v) {
+    if ("_zod" in v) {
+      return this.v4Layer.isNumber(v);
+    } else {
+      return this.v3Layer.isNumber(v);
+    }
+  }
+  isDate(v) {
+    if ("_zod" in v) {
+      return this.v4Layer.isDate(v);
+    } else {
+      return this.v3Layer.isDate(v);
+    }
+  }
+  isDefault(v) {
+    if ("_zod" in v) {
+      return this.v4Layer.isDefault(v);
+    } else {
+      return this.v3Layer.isDefault(v);
+    }
+  }
+  defaultZodObjectHandler(value, options = { passthrough: true }) {
+    if ("_zod" in value) {
+      return this.v4Layer.defaultZodObjectHandler(value, options);
+    } else {
+      return this.v3Layer.defaultZodObjectHandler(value, options);
+    }
+  }
+  /**
+   * 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, constraints) {
+    return this.v3Layer.mergeParameterDescription(description, constraints);
+  }
+  /**
+   * 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(value, throwOnTypes) {
+    if ("_zod" in value) {
+      return this.v4Layer.defaultUnsupportedZodTypeHandler(
+        // @ts-expect-error - fix later
+        value,
+        throwOnTypes ?? UNSUPPORTED_ZOD_TYPES2
+      );
+    } else {
+      return this.v3Layer.defaultUnsupportedZodTypeHandler(
+        value,
+        throwOnTypes ?? UNSUPPORTED_ZOD_TYPES
+      );
+    }
+  }
+  defaultZodArrayHandler(value, handleChecks = ALL_ARRAY_CHECKS) {
+    if ("_zod" in value) {
+      return this.v4Layer.defaultZodArrayHandler(value, handleChecks);
+    } else {
+      return this.v3Layer.defaultZodArrayHandler(value, handleChecks);
+    }
+  }
+  defaultZodUnionHandler(value) {
+    if ("_zod" in value) {
+      return this.v4Layer.defaultZodUnionHandler(value);
+    } else {
+      return this.v3Layer.defaultZodUnionHandler(value);
+    }
+  }
+  defaultZodStringHandler(value, handleChecks = ALL_STRING_CHECKS) {
+    if ("_zod" in value) {
+      return this.v4Layer.defaultZodStringHandler(value);
+    } else {
+      return this.v3Layer.defaultZodStringHandler(value, handleChecks);
+    }
+  }
+  defaultZodNumberHandler(value, handleChecks = ALL_NUMBER_CHECKS) {
+    if ("_zod" in value) {
+      return this.v4Layer.defaultZodNumberHandler(value);
+    } else {
+      return this.v3Layer.defaultZodNumberHandler(value, handleChecks);
+    }
+  }
+  defaultZodDateHandler(value) {
+    if ("_zod" in value) {
+      return this.v4Layer.defaultZodDateHandler(value);
+    } else {
+      return this.v3Layer.defaultZodDateHandler(value);
+    }
+  }
+  defaultZodOptionalHandler(value, handleTypes) {
+    if ("_zod" in value) {
+      return this.v4Layer.defaultZodOptionalHandler(value, handleTypes ?? SUPPORTED_ZOD_TYPES2);
+    } else {
+      return this.v3Layer.defaultZodOptionalHandler(value, handleTypes ?? SUPPORTED_ZOD_TYPES);
+    }
+  }
+  /**
+   * 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) {
+    const processedSchema = this.processZodType(zodSchema);
+    return convertZodSchemaToAISDKSchema(processedSchema, this.getSchemaTarget());
+  }
+  /**
+   * 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) {
+    return this.processToAISDKSchema(zodSchema).jsonSchema;
+  }
+};
+
+// src/zodTypes.ts
+function isOptional2(z10) {
+  return (v) => v instanceof z10["ZodOptional"];
+}
+function isObj2(z10) {
+  return (v) => v instanceof z10["ZodObject"];
+}
+function isNull(z10) {
+  return (v) => v instanceof z10["ZodNull"];
+}
+function isArr2(z10) {
+  return (v) => v instanceof z10["ZodArray"];
+}
+function isUnion2(z10) {
+  return (v) => v instanceof z10["ZodUnion"];
+}
+function isString2(z10) {
+  return (v) => v instanceof z10["ZodString"];
+}
+function isNumber2(z10) {
+  return (v) => v instanceof z10["ZodNumber"];
+}
+function isDate(z10) {
+  return (v) => v instanceof z10["ZodDate"];
+}
+function isDefault(z10) {
+  return (v) => v instanceof z10["ZodDefault"];
+}
 
 // src/provider-compats/anthropic.ts
-var AnthropicSchemaCompatLayer = class extends SchemaCompatLayer {
+var AnthropicSchemaCompatLayer = class extends SchemaCompatLayer3 {
   constructor(model) {
     super(model);
   }
@@ -428,29 +1152,38 @@ var AnthropicSchemaCompatLayer = class extends SchemaCompatLayer {
     return this.getModel().modelId.includes("claude");
   }
   processZodType(value) {
-    if (isOptional(value)) {
-      const handleTypes = ["ZodObject", "ZodArray", "ZodUnion", "ZodNever", "ZodUndefined", "ZodTuple"];
+    if (isOptional2(zod.z)(value)) {
+      const handleTypes = [
+        "ZodObject",
+        "ZodArray",
+        "ZodUnion",
+        "ZodNever",
+        "ZodUndefined",
+        "ZodTuple"
+      ];
       if (this.getModel().modelId.includes("claude-3.5-haiku")) handleTypes.push("ZodString");
       return this.defaultZodOptionalHandler(value, handleTypes);
-    } else if (isObj(value)) {
+    } else if (isObj2(zod.z)(value)) {
       return this.defaultZodObjectHandler(value);
-    } else if (isArr(value)) {
+    } else if (isArr2(zod.z)(value)) {
       return this.defaultZodArrayHandler(value, []);
-    } else if (isUnion(value)) {
+    } else if (isUnion2(zod.z)(value)) {
       return this.defaultZodUnionHandler(value);
-    } else if (isString(value)) {
+    } else if (isString2(zod.z)(value)) {
       if (this.getModel().modelId.includes("claude-3.5-haiku")) {
         return this.defaultZodStringHandler(value, ["max", "min"]);
       } else {
         return value;
       }
     }
-    return this.defaultUnsupportedZodTypeHandler(value, ["ZodNever", "ZodTuple", "ZodUndefined"]);
+    return this.defaultUnsupportedZodTypeHandler(value, [
+      "ZodNever",
+      "ZodTuple",
+      "ZodUndefined"
+    ]);
   }
 };
-
-// src/provider-compats/deepseek.ts
-var DeepSeekSchemaCompatLayer = class extends SchemaCompatLayer {
+var DeepSeekSchemaCompatLayer = class extends SchemaCompatLayer3 {
   constructor(model) {
     super(model);
   }
@@ -461,21 +1194,21 @@ var DeepSeekSchemaCompatLayer = class extends SchemaCompatLayer {
     return this.getModel().modelId.includes("deepseek") && !this.getModel().modelId.includes("r1");
   }
   processZodType(value) {
-    if (isOptional(value)) {
+    if (isOptional2(zod.z)(value)) {
       return this.defaultZodOptionalHandler(value, ["ZodObject", "ZodArray", "ZodUnion", "ZodString", "ZodNumber"]);
-    } else if (isObj(value)) {
+    } else if (isObj2(zod.z)(value)) {
       return this.defaultZodObjectHandler(value);
-    } else if (isArr(value)) {
+    } else if (isArr2(zod.z)(value)) {
       return this.defaultZodArrayHandler(value, ["min", "max"]);
-    } else if (isUnion(value)) {
+    } else if (isUnion2(zod.z)(value)) {
       return this.defaultZodUnionHandler(value);
-    } else if (isString(value)) {
+    } else if (isString2(zod.z)(value)) {
       return this.defaultZodStringHandler(value);
     }
     return value;
   }
 };
-var GoogleSchemaCompatLayer = class extends SchemaCompatLayer {
+var GoogleSchemaCompatLayer = class extends SchemaCompatLayer3 {
   constructor(model) {
     super(model);
   }
@@ -486,34 +1219,25 @@ var GoogleSchemaCompatLayer = class extends SchemaCompatLayer {
     return this.getModel().provider.includes("google") || this.getModel().modelId.includes("google");
   }
   processZodType(value) {
-    if (isOptional(value)) {
-      return this.defaultZodOptionalHandler(value, [
-        "ZodObject",
-        "ZodArray",
-        "ZodUnion",
-        "ZodString",
-        "ZodNumber",
-        ...UNSUPPORTED_ZOD_TYPES
-      ]);
-    } else if (isNull(value)) {
-      return zod.z.any().refine((v) => v === null, { message: "must be null" }).describe(value._def.description || "must be null");
-    } else if (isObj(value)) {
+    if (isOptional2(zod.z)(value)) {
+      return this.defaultZodOptionalHandler(value, ["ZodObject", "ZodArray", "ZodUnion", "ZodString", "ZodNumber"]);
+    } else if (isNull(zod.z)(value)) {
+      return zod.z.any().refine((v) => v === null, { message: "must be null" }).describe(value.description || "must be null");
+    } else if (isObj2(zod.z)(value)) {
       return this.defaultZodObjectHandler(value);
-    } else if (isArr(value)) {
+    } else if (isArr2(zod.z)(value)) {
       return this.defaultZodArrayHandler(value, []);
-    } else if (isUnion(value)) {
+    } else if (isUnion2(zod.z)(value)) {
       return this.defaultZodUnionHandler(value);
-    } else if (isString(value)) {
+    } else if (isString2(zod.z)(value)) {
       return this.defaultZodStringHandler(value);
-    } else if (isNumber(value)) {
+    } else if (isNumber2(zod.z)(value)) {
       return this.defaultZodNumberHandler(value);
     }
     return this.defaultUnsupportedZodTypeHandler(value);
   }
 };
-
-// src/provider-compats/meta.ts
-var MetaSchemaCompatLayer = class extends SchemaCompatLayer {
+var MetaSchemaCompatLayer = class extends SchemaCompatLayer3 {
   constructor(model) {
     super(model);
   }
@@ -524,25 +1248,23 @@ var MetaSchemaCompatLayer = class extends SchemaCompatLayer {
     return this.getModel().modelId.includes("meta");
   }
   processZodType(value) {
-    if (isOptional(value)) {
+    if (isOptional2(zod.z)(value)) {
       return this.defaultZodOptionalHandler(value, ["ZodObject", "ZodArray", "ZodUnion", "ZodString", "ZodNumber"]);
-    } else if (isObj(value)) {
+    } else if (isObj2(zod.z)(value)) {
       return this.defaultZodObjectHandler(value);
-    } else if (isArr(value)) {
+    } else if (isArr2(zod.z)(value)) {
       return this.defaultZodArrayHandler(value, ["min", "max"]);
-    } else if (isUnion(value)) {
+    } else if (isUnion2(zod.z)(value)) {
       return this.defaultZodUnionHandler(value);
-    } else if (isNumber(value)) {
+    } else if (isNumber2(zod.z)(value)) {
       return this.defaultZodNumberHandler(value);
-    } else if (isString(value)) {
+    } else if (isString2(zod.z)(value)) {
       return this.defaultZodStringHandler(value);
     }
     return value;
   }
 };
-
-// src/provider-compats/openai.ts
-var OpenAISchemaCompatLayer = class extends SchemaCompatLayer {
+var OpenAISchemaCompatLayer = class extends SchemaCompatLayer3 {
   constructor(model) {
     super(model);
   }
@@ -550,16 +1272,13 @@ var OpenAISchemaCompatLayer = class extends SchemaCompatLayer {
     return `jsonSchema7`;
   }
   shouldApply() {
-    if (
-      // !this.getModel().supportsStructuredOutputs && // <- TODO: this no longer exists, do we need it?
-      this.getModel().provider.includes(`openai`) || this.getModel().modelId.includes(`openai`)
-    ) {
+    if (!this.getModel().supportsStructuredOutputs && (this.getModel().provider.includes(`openai`) || this.getModel().modelId.includes(`openai`))) {
       return true;
     }
     return false;
   }
   processZodType(value) {
-    if (isOptional(value)) {
+    if (isOptional2(zod.z)(value)) {
       return this.defaultZodOptionalHandler(value, [
         "ZodObject",
         "ZodArray",
@@ -569,24 +1288,28 @@ var OpenAISchemaCompatLayer = class extends SchemaCompatLayer {
         "ZodUndefined",
         "ZodTuple"
       ]);
-    } else if (isObj(value)) {
+    } else if (isObj2(zod.z)(value)) {
       return this.defaultZodObjectHandler(value);
-    } else if (isUnion(value)) {
+    } else if (isUnion2(zod.z)(value)) {
       return this.defaultZodUnionHandler(value);
-    } else if (isArr(value)) {
+    } else if (isArr2(zod.z)(value)) {
       return this.defaultZodArrayHandler(value);
-    } else if (isString(value)) {
+    } else if (isString2(zod.z)(value)) {
       const model = this.getModel();
       const checks = ["emoji"];
       if (model.modelId.includes("gpt-4o-mini")) {
-        checks.push("regex");
+        return this.defaultZodStringHandler(value, ["emoji", "regex"]);
       }
       return this.defaultZodStringHandler(value, checks);
     }
-    return this.defaultUnsupportedZodTypeHandler(value, ["ZodNever", "ZodUndefined", "ZodTuple"]);
+    return this.defaultUnsupportedZodTypeHandler(value, [
+      "ZodNever",
+      "ZodUndefined",
+      "ZodTuple"
+    ]);
   }
 };
-var OpenAIReasoningSchemaCompatLayer = class extends SchemaCompatLayer {
+var OpenAIReasoningSchemaCompatLayer = class extends SchemaCompatLayer3 {
   constructor(model) {
     super(model);
   }
@@ -594,34 +1317,31 @@ var OpenAIReasoningSchemaCompatLayer = class extends SchemaCompatLayer {
     return `openApi3`;
   }
   isReasoningModel() {
-    return this.getModel().modelId.includes(`o3`) || this.getModel().modelId.includes(`o4`);
+    return this.getModel().modelId.includes(`o3`) || this.getModel().modelId.includes(`o4`) || this.getModel().modelId.includes(`o1`);
   }
   shouldApply() {
-    if (
-      // (this.getModel().supportsStructuredOutputs || this.isReasoningModel()) && // <- supportsStructuredOutputs no longer exists
-      this.isReasoningModel() && (this.getModel().provider.includes(`openai`) || this.getModel().modelId.includes(`openai`))
-    ) {
+    if ((this.getModel().supportsStructuredOutputs || this.isReasoningModel()) && (this.getModel().provider.includes(`openai`) || this.getModel().modelId.includes(`openai`))) {
       return true;
     }
     return false;
   }
   processZodType(value) {
-    if (isOptional(value)) {
+    if (isOptional2(zod.z)(value)) {
       const innerZodType = this.processZodType(value._def.innerType);
       return innerZodType.nullable();
-    } else if (isObj(value)) {
+    } else if (isObj2(zod.z)(value)) {
       return this.defaultZodObjectHandler(value, { passthrough: false });
-    } else if (isArr(value)) {
+    } else if (isArr2(zod.z)(value)) {
       return this.defaultZodArrayHandler(value);
-    } else if (isUnion(value)) {
+    } else if (isUnion2(zod.z)(value)) {
       return this.defaultZodUnionHandler(value);
-    } else if (isDefault(value)) {
+    } else if (isDefault(zod.z)(value)) {
       const defaultDef = value._def;
       const innerType = defaultDef.innerType;
-      const defaultValue = defaultDef.defaultValue();
-      const constraints = {};
+      const defaultValue = typeof defaultDef.defaultValue === "function" ? defaultDef.defaultValue() : defaultDef.defaultValue;
+      const constraints = [];
       if (defaultValue !== void 0) {
-        constraints.defaultValue = defaultValue;
+        constraints.push(`the default value is ${defaultValue}`);
       }
       const description = this.mergeParameterDescription(value.description, constraints);
       let result = this.processZodType(innerType);
@@ -629,13 +1349,13 @@ var OpenAIReasoningSchemaCompatLayer = class extends SchemaCompatLayer {
         result = result.describe(description);
       }
       return result;
-    } else if (isNumber(value)) {
+    } else if (isNumber2(zod.z)(value)) {
       return this.defaultZodNumberHandler(value);
-    } else if (isString(value)) {
+    } else if (isString2(zod.z)(value)) {
       return this.defaultZodStringHandler(value);
-    } else if (isDate(value)) {
+    } else if (isDate(zod.z)(value)) {
       return this.defaultZodDateHandler(value);
-    } else if (value._def.typeName === "ZodAny") {
+    } else if (value.constructor.name === "ZodAny") {
       return zod.z.string().describe(
         (value.description ?? "") + `
 Argument was an "any" type, but you (the LLM) do not support "any", so it was cast to a "string" type`
@@ -656,7 +1376,9 @@ exports.MetaSchemaCompatLayer = MetaSchemaCompatLayer;
 exports.OpenAIReasoningSchemaCompatLayer = OpenAIReasoningSchemaCompatLayer;
 exports.OpenAISchemaCompatLayer = OpenAISchemaCompatLayer;
 exports.SUPPORTED_ZOD_TYPES = SUPPORTED_ZOD_TYPES;
-exports.SchemaCompatLayer = SchemaCompatLayer;
+exports.SchemaCompatLayer = SchemaCompatLayer3;
+exports.SchemaCompatLayerV3 = SchemaCompatLayer;
+exports.SchemaCompatLayerV4 = SchemaCompatLayer2;
 exports.UNSUPPORTED_ZOD_TYPES = UNSUPPORTED_ZOD_TYPES;
 exports.applyCompatLayer = applyCompatLayer;
 exports.convertSchemaToZod = convertSchemaToZod;