@mastra/schema-compat 1.1.3 → 1.2.0

package/dist/index.cjs

@@ -1,12 +1,13 @@
 'use strict';
 
-var chunkDAVEUCUM_cjs = require('./chunk-DAVEUCUM.cjs');
-var chunkBOGGUXB5_cjs = require('./chunk-BOGGUXB5.cjs');
+var chunk3QMIGINL_cjs = require('./chunk-3QMIGINL.cjs');
+var chunkUFJG5KPA_cjs = require('./chunk-UFJG5KPA.cjs');
+var chunk3MLZICLP_cjs = require('./chunk-3MLZICLP.cjs');
 var chunkDZUJEN5N_cjs = require('./chunk-DZUJEN5N.cjs');
+var v3 = require('zod/v3');
 var zod = require('zod');
 var zodFromJsonSchema = require('zod-from-json-schema');
 var zodFromJsonSchemaV3 = require('zod-from-json-schema-v3');
-var v3 = require('zod/v3');
 var v4 = require('zod/v4');
 
 // ../_vendored/ai_v4/dist/chunk-OPIPXJLE.js
@@ -3571,7 +3572,7 @@ function trimStartOfStream() {
 
 // src/utils.ts
 function convertZodSchemaToAISDKSchema(zodSchema2, target = "jsonSchema7") {
-  const jsonSchemaToUse = chunkBOGGUXB5_cjs.zodToJsonSchema(zodSchema2, target);
+  const jsonSchemaToUse = chunkUFJG5KPA_cjs.zodToJsonSchema(zodSchema2, target);
   return jsonSchema(jsonSchemaToUse, {
     validate: (value) => {
       const result = zodSchema2.safeParse(value);
@@ -3606,20 +3607,29 @@ function applyCompatLayer({
   compatLayers,
   mode
 }) {
-  let zodSchema2;
-  if (!isZodType(schema)) {
-    zodSchema2 = convertSchemaToZod(schema);
-  } else {
-    zodSchema2 = schema;
-  }
-  for (const compat of compatLayers) {
-    if (compat.shouldApply()) {
-      return mode === "jsonSchema" ? compat.processToJSONSchema(zodSchema2) : compat.processToAISDKSchema(zodSchema2);
-    }
-  }
   if (mode === "jsonSchema") {
-    return chunkBOGGUXB5_cjs.zodToJsonSchema(zodSchema2, "jsonSchema7");
+    const standardSchema = chunk3QMIGINL_cjs.toStandardSchema(schema);
+    for (const compat of compatLayers) {
+      if (compat.shouldApply()) {
+        return compat.processToJSONSchema(standardSchema);
+      }
+    }
+    return chunk3QMIGINL_cjs.standardSchemaToJSONSchema(standardSchema);
   } else {
+    let zodSchema2;
+    if (isZodType(schema)) {
+      zodSchema2 = schema;
+    } else {
+      if (chunk3QMIGINL_cjs.isStandardSchemaWithJSON(schema)) {
+        throw new Error("StandardSchemaWithJSON is not supported for applyCompatLayer and aiSdkSchema mode");
+      }
+      zodSchema2 = convertSchemaToZod(schema);
+    }
+    for (const compat of compatLayers) {
+      if (compat.shouldApply()) {
+        return compat.processToAISDKSchema(zodSchema2);
+      }
+    }
     return convertZodSchemaToAISDKSchema(zodSchema2);
   }
 }
@@ -3634,12 +3644,12 @@ var ALL_NUMBER_CHECKS = [
   "multipleOf"
 ];
 var ALL_ARRAY_CHECKS = ["min", "max", "length"];
-var isOptional = (v) => v instanceof zod.ZodOptional;
-var isObj = (v) => v instanceof zod.ZodObject;
-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 isOptional = (v) => v instanceof v3.ZodOptional;
+var isObj = (v) => v instanceof v3.ZodObject;
+var isArr = (v) => v instanceof v3.ZodArray;
+var isUnion = (v) => v instanceof v3.ZodUnion;
+var isString = (v) => v instanceof v3.ZodString;
+var isNumber = (v) => v instanceof v3.ZodNumber;
 var UNSUPPORTED_ZOD_TYPES = ["ZodIntersection", "ZodNever", "ZodNull", "ZodTuple", "ZodUndefined"];
 var SUPPORTED_ZOD_TYPES = [
   "ZodObject",
@@ -3680,61 +3690,61 @@ var SchemaCompatLayer = class {
    * Type guard for optional Zod types
    */
   isOptional(v) {
-    return v instanceof zod.ZodOptional;
+    return v instanceof v3.ZodOptional;
   }
   /**
    * Type guard for object Zod types
    */
   isObj(v) {
-    return v instanceof zod.ZodObject;
+    return v instanceof v3.ZodObject;
   }
   /**
    * Type guard for null Zod types
    */
   isNull(v) {
-    return v instanceof zod.ZodNull;
+    return v instanceof v3.ZodNull;
   }
   /**
    * Type guard for nullable Zod types
    */
   isNullable(v) {
-    return v instanceof zod.ZodNullable;
+    return v instanceof v3.ZodNullable;
   }
   /**
    * Type guard for array Zod types
    */
   isArr(v) {
-    return v instanceof zod.ZodArray;
+    return v instanceof v3.ZodArray;
   }
   /**
    * Type guard for union Zod types
    */
   isUnion(v) {
-    return v instanceof zod.ZodUnion;
+    return v instanceof v3.ZodUnion;
   }
   /**
    * Type guard for string Zod types
    */
   isString(v) {
-    return v instanceof zod.ZodString;
+    return v instanceof v3.ZodString;
   }
   /**
    * Type guard for number Zod types
    */
   isNumber(v) {
-    return v instanceof zod.ZodNumber;
+    return v instanceof v3.ZodNumber;
   }
   /**
    * Type guard for date Zod types
    */
   isDate(v) {
-    return v instanceof zod.ZodDate;
+    return v instanceof v3.ZodDate;
   }
   /**
    * Type guard for default Zod types
    */
   isDefault(v) {
-    return v instanceof zod.ZodDefault;
+    return v instanceof v3.ZodDefault;
   }
   /**
    * Determines whether this compatibility layer should be applied for the current model.
@@ -3775,11 +3785,11 @@ var SchemaCompatLayer = class {
       acc[key] = this.processZodType(propValue);
       return acc;
     }, {});
-    let result = zod.z.object(processedShape);
+    let result = v3.z.object(processedShape);
     if (value._def.unknownKeys === "strict") {
       result = result.strict();
     }
-    if (value._def.catchall && !(value._def.catchall instanceof zod.z.ZodNever)) {
+    if (value._def.catchall && !(value._def.catchall instanceof v3.z.ZodNever)) {
       result = result.catchall(value._def.catchall);
     }
     if (value.description) {
@@ -3831,7 +3841,7 @@ var SchemaCompatLayer = class {
   defaultZodArrayHandler(value, handleChecks = ALL_ARRAY_CHECKS) {
     const zodArrayDef = value._def;
     const processedType = this.processZodType(zodArrayDef.type);
-    let result = zod.z.array(processedType);
+    let result = v3.z.array(processedType);
     const constraints = [];
     if (zodArrayDef.minLength?.value !== void 0) {
       if (handleChecks.includes("min")) {
@@ -3870,7 +3880,7 @@ var SchemaCompatLayer = class {
   defaultZodUnionHandler(value) {
     const processedOptions = value._def.options.map((option) => this.processZodType(option));
     if (processedOptions.length < 2) throw new Error("Union must have at least 2 options");
-    let result = zod.z.union(processedOptions);
+    let result = v3.z.union(processedOptions);
     if (value.description) {
       result = result.describe(value.description);
     }
@@ -3914,7 +3924,7 @@ var SchemaCompatLayer = class {
         }
       }
     }
-    let result = zod.z.string();
+    let result = v3.z.string();
     for (const check of newChecks) {
       result = result._addCheck(check);
     }
@@ -3963,7 +3973,7 @@ var SchemaCompatLayer = class {
         }
       }
     }
-    let result = zod.z.number();
+    let result = v3.z.number();
     for (const check of newChecks) {
       switch (check.kind) {
         case "int":
@@ -4010,7 +4020,7 @@ var SchemaCompatLayer = class {
       }
     }
     constraints.push(`Date format is date-time`);
-    let result = zod.z.string().describe("date-time");
+    let result = v3.z.string().describe("date-time");
     const description = this.mergeParameterDescription(value.description, constraints);
     if (description) {
       result = result.describe(description);
@@ -4519,7 +4529,7 @@ var SchemaCompatLayer2 = class {
 };
 
 // src/schema-compatibility.ts
-var import_json_schema_traverse = chunkDZUJEN5N_cjs.__toESM(chunkDAVEUCUM_cjs.require_json_schema_traverse(), 1);
+var import_json_schema_traverse = chunkDZUJEN5N_cjs.__toESM(chunk3MLZICLP_cjs.require_json_schema_traverse(), 1);
 
 // src/json-schema/utils.ts
 function hasType(schema, type) {
@@ -4546,7 +4556,10 @@ function isOneOfSchema(schema) {
   return Array.isArray(schema.oneOf) && schema.oneOf.length > 0;
 }
 function isUnionSchema(schema) {
-  return isAnyOfSchema(schema) || isOneOfSchema(schema);
+  return isAnyOfSchema(schema) || isOneOfSchema(schema) || Array.isArray(schema.type);
+}
+function isEnumSchema(schema) {
+  return Array.isArray(schema.enum) && schema.enum.length > 0;
 }
 function isOptionalSchema(propertyName, parentSchema) {
   if (!parentSchema.required || !Array.isArray(parentSchema.required)) {
@@ -4764,12 +4777,23 @@ var SchemaCompatLayer3 = class {
     return convertZodSchemaToAISDKSchema(processedSchema, this.getSchemaTarget());
   }
   processToJSONSchema(zodSchema2, io = "input") {
-    const standardSchema = chunkDAVEUCUM_cjs.toStandardSchema(zodSchema2);
-    return chunkDAVEUCUM_cjs.standardSchemaToJSONSchema(standardSchema, {
+    const standardSchema = chunk3QMIGINL_cjs.toStandardSchema(zodSchema2);
+    const jsonSchema2 = chunk3QMIGINL_cjs.standardSchemaToJSONSchema(standardSchema, {
       target: "draft-07",
       io
       // Use input mode so fields with defaults are optional
     });
+    (0, import_json_schema_traverse.default)(jsonSchema2, {
+      cb: {
+        pre: (schema) => {
+          this.preProcessJSONNode(schema);
+        },
+        post: (schema) => {
+          this.postProcessJSONNode(schema);
+        }
+      }
+    });
+    return jsonSchema2;
   }
   // ==========================================
   // JSON Schema Default Handlers
@@ -4825,22 +4849,23 @@ var SchemaCompatLayer3 = class {
       constraints.push(`maximum length ${schema.maxLength}`);
       delete schema.maxLength;
     }
-    if (schema.pattern !== void 0) {
-      delete schema.pattern;
+    switch (schema.format) {
+      case "email":
+      case "emoji":
+      case "uri":
+      case "uuid":
+      case "date-time":
+      case "date":
+      case "time": {
+        constraints.push(`a valid ${schema.format}`);
+        delete schema.pattern;
+        delete schema.format;
+        break;
+      }
     }
-    if (schema.format !== void 0) {
-      const formatMap = {
-        email: "a valid email",
-        uri: "a valid url",
-        url: "a valid url",
-        uuid: "a valid uuid",
-        "date-time": "a valid date-time",
-        date: "a valid date",
-        time: "a valid time"
-      };
-      const formatText = formatMap[schema.format] || `format: ${schema.format}`;
-      constraints.push(formatText);
-      delete schema.format;
+    if (constraints.length === 0 && schema.pattern !== void 0) {
+      constraints.push(`input must match this regex ${schema.pattern}`);
+      delete schema.pattern;
     }
     if (constraints.length) {
       schema.description = this.mergeParameterDescription(schema.description, constraints);
@@ -4887,16 +4912,17 @@ var SchemaCompatLayer3 = class {
    * Processes union schemas and can convert anyOf patterns to type arrays for simple primitives.
    */
   defaultUnionHandler(schema) {
-    if (schema.anyOf && Array.isArray(schema.anyOf)) {
-      const allSimplePrimitives = schema.anyOf.every((s) => {
-        if (typeof s !== "object" || s === null) return false;
-        const keys = Object.keys(s);
-        return keys.length === 1 && keys[0] === "type" && typeof s.type === "string";
-      });
-      if (allSimplePrimitives) {
-        const types = schema.anyOf.map((s) => s.type);
-        delete schema.anyOf;
-        schema.type = types;
+    if (Array.isArray(schema.anyOf)) {
+      schema.anyOf = schema.anyOf.map((subSchema) => {
+        if (typeof subSchema !== "object" || subSchema === null) {
+          return false;
+        }
+        this.preProcessJSONNode(subSchema);
+        this.postProcessJSONNode(subSchema);
+        return subSchema;
+      }).filter(Boolean);
+      if (schema.anyOf.length === 1) {
+        schema = schema.anyOf[0];
       }
     }
     return schema;
@@ -4976,26 +5002,81 @@ var SchemaCompatLayer3 = class {
    * Uses 'input' io mode so that fields with defaults are optional (appropriate for tool parameters).
    */
   toJSONSchema(zodSchema2) {
-    const target = "draft-07";
-    const standardSchema = chunkDAVEUCUM_cjs.toStandardSchema(zodSchema2);
-    const jsonSchema2 = chunkDAVEUCUM_cjs.standardSchemaToJSONSchema(standardSchema, {
+    const target = this.getSchemaTarget() === "jsonSchema7" ? "draft-07" : this.getSchemaTarget();
+    const standardSchema = chunk3QMIGINL_cjs.toStandardSchema(zodSchema2);
+    const jsonSchema2 = chunk3QMIGINL_cjs.standardSchemaToJSONSchema(standardSchema, {
       target,
       io: "input"
       // Use input mode so fields with defaults are optional
     });
     (0, import_json_schema_traverse.default)(jsonSchema2, {
       cb: {
-        pre: (schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema) => {
-          this.preProcessJSONNode(schema, parentSchema);
+        pre: (schema) => {
+          this.preProcessJSONNode(schema);
         },
-        post: (schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema) => {
-          this.postProcessJSONNode(schema, parentSchema);
+        post: (schema) => {
+          this.postProcessJSONNode(schema);
         }
       }
     });
     return jsonSchema2;
   }
 };
+
+// src/null-to-undefined.ts
+function transformNullToUndefined(value, jsonSchema2) {
+  if (value === null || value === void 0) {
+    return value;
+  }
+  if (typeof value !== "object" || Array.isArray(value)) {
+    if (Array.isArray(value) && jsonSchema2.items && typeof jsonSchema2.items === "object") {
+      return value.map((item) => transformNullToUndefined(item, jsonSchema2.items));
+    }
+    return value;
+  }
+  const properties = jsonSchema2.properties;
+  if (!properties) {
+    return value;
+  }
+  const required = jsonSchema2.required || [];
+  const result = {};
+  for (const [key, val] of Object.entries(value)) {
+    if (val === null && !required.includes(key)) {
+      result[key] = void 0;
+    } else if (val !== null && typeof val === "object" && properties[key]) {
+      result[key] = transformNullToUndefined(val, properties[key]);
+    } else {
+      result[key] = val;
+    }
+  }
+  return result;
+}
+function wrapSchemaWithNullTransform(schema) {
+  let jsonSchema2;
+  try {
+    jsonSchema2 = schema["~standard"].jsonSchema.input({ target: "draft-07" });
+  } catch {
+  }
+  if (!jsonSchema2) {
+    return schema;
+  }
+  const innerProps = schema["~standard"];
+  return {
+    "~standard": {
+      version: innerProps.version,
+      vendor: innerProps.vendor,
+      types: innerProps.types,
+      validate: (value, options) => {
+        const transformed = transformNullToUndefined(value, jsonSchema2);
+        return innerProps.validate(transformed, options);
+      },
+      jsonSchema: innerProps.jsonSchema
+    }
+  };
+}
+
+// src/provider-compats/openai.ts
+var import_json_schema_traverse2 = chunkDZUJEN5N_cjs.__toESM(chunk3MLZICLP_cjs.require_json_schema_traverse(), 1);
 function isOptional2(z11) {
   return (v) => v instanceof z11["ZodOptional"];
 }
@@ -5027,38 +5108,121 @@ function isNullable(z11) {
   return (v) => v instanceof z11["ZodNullable"];
 }
 
-// src/provider-compats/anthropic.ts
-var AnthropicSchemaCompatLayer = class extends SchemaCompatLayer3 {
+// src/provider-compats/openai.ts
+var OpenAISchemaCompatLayer = class extends SchemaCompatLayer3 {
   constructor(model) {
     super(model);
   }
   getSchemaTarget() {
-    return "jsonSchema7";
+    return `jsonSchema7`;
+  }
+  isReasoningModel() {
+    const modelId = this.getModel().modelId;
+    if (!modelId) return false;
+    return modelId.includes(`o3`) || modelId.includes(`o4`) || modelId.includes(`o1`);
   }
   shouldApply() {
-    return this.getModel().modelId.includes("claude");
+    const model = this.getModel();
+    if (!this.isReasoningModel() && (model.provider.includes(`openai`) || model.modelId?.includes(`openai`) || model.provider.includes(`groq`))) {
+      return true;
+    }
+    return false;
   }
   processZodType(value) {
-    if (this.isOptional(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 (this.isObj(value)) {
+    if (isOptional2(zod.z)(value)) {
+      const innerType = "_def" in value ? value._def.innerType : value._zod?.def?.innerType;
+      if (innerType) {
+        if (isNullable(zod.z)(innerType)) {
+          const processed = this.processZodType(innerType);
+          return processed.transform((val) => val === null ? void 0 : val);
+        }
+        const processedInner = this.processZodType(innerType);
+        return processedInner.nullable().transform((val) => val === null ? void 0 : val);
+      }
+      return value;
+    } else if (isNullable(zod.z)(value)) {
+      const innerType = "_def" in value ? value._def.innerType : value._zod?.def?.innerType;
+      if (innerType) {
+        if (isOptional2(zod.z)(innerType)) {
+          const innerInnerType = "_def" in innerType ? innerType._def.innerType : innerType._zod?.def?.innerType;
+          if (innerInnerType) {
+            const processedInnerInner = this.processZodType(innerInnerType);
+            return processedInnerInner.nullable().transform((val) => val === null ? void 0 : val);
+          }
+        }
+        const processedInner = this.processZodType(innerType);
+        return processedInner.nullable();
+      }
+      return value;
+    } else if (isDefault(zod.z)(value)) {
+      const innerType = "_def" in value ? value._def.innerType : value._zod?.def?.innerType;
+      const defaultValue = "_def" in value ? value._def.defaultValue : value._zod?.def?.defaultValue;
+      if (innerType) {
+        const processedInner = this.processZodType(innerType);
+        return processedInner.nullable().transform((val) => {
+          if (val === null) {
+            return typeof defaultValue === "function" ? defaultValue() : defaultValue;
+          }
+          return val;
+        });
+      }
+      return value;
+    } else if (isObj2(zod.z)(value)) {
       return this.defaultZodObjectHandler(value);
-    } else if (this.isArr(value)) {
-      return this.defaultZodArrayHandler(value, []);
-    } else if (this.isUnion(value)) {
+    } else if (isUnion2(zod.z)(value)) {
       return this.defaultZodUnionHandler(value);
-    } else if (this.isString(value)) {
-      if (this.getModel().modelId.includes("claude-3.5-haiku")) {
-        return this.defaultZodStringHandler(value, ["max", "min"]);
-      } else {
-        return value;
+    } else if (isArr2(zod.z)(value)) {
+      return this.defaultZodArrayHandler(value);
+    } else if (isString2(zod.z)(value)) {
+      const model = this.getModel();
+      const checks = ["emoji"];
+      if (model.modelId?.includes("gpt-4o-mini")) {
+        return this.defaultZodStringHandler(value, ["emoji", "regex"]);
       }
-    } else if (isNull(zod.z)(value)) {
-      return zod.z.any().refine((v) => v === null, { message: "must be null" }).describe(value.description || "must be null");
+      return this.defaultZodStringHandler(value, checks);
     }
-    return this.defaultUnsupportedZodTypeHandler(value);
+    return this.defaultUnsupportedZodTypeHandler(value, [
+      "ZodNever",
+      "ZodUndefined",
+      "ZodTuple"
+    ]);
+  }
+  /**
+   * Override to fix additionalProperties: {} which OpenAI doesn't support.
+   * Converts empty object {} to true to preserve passthrough intent.
+   */
+  processToJSONSchema(zodSchema2) {
+    const jsonSchema2 = super.processToJSONSchema(zodSchema2);
+    const fixedSchema = this.fixAdditionalProperties(jsonSchema2);
+    return chunkUFJG5KPA_cjs.ensureAllPropertiesRequired(fixedSchema);
+  }
+  /**
+   * 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(zodSchema2) {
+    const jsonSchemaResult = chunkUFJG5KPA_cjs.zodToJsonSchema(zodSchema2, this.getSchemaTarget());
+    const originalJsonSchema = JSON.parse(JSON.stringify(jsonSchemaResult));
+    (0, import_json_schema_traverse2.default)(jsonSchemaResult, {
+      cb: {
+        pre: (schema) => {
+          this.preProcessJSONNode(schema);
+        },
+        post: (schema) => {
+          this.postProcessJSONNode(schema);
+        }
+      }
+    });
+    const fixedSchema = this.fixAdditionalProperties(jsonSchemaResult);
+    const finalSchema = chunkUFJG5KPA_cjs.ensureAllPropertiesRequired(fixedSchema);
+    return jsonSchema(finalSchema, {
+      validate: (value) => {
+        const transformed = transformNullToUndefined(value, originalJsonSchema);
+        const result = zodSchema2.safeParse(transformed);
+        return result.success ? { success: true, value: result.data } : { success: false, error: result.error };
+      }
+    });
   }
   preProcessJSONNode(schema, _parentSchema) {
     if (isObjectSchema(schema)) {
@@ -5066,112 +5230,282 @@ var AnthropicSchemaCompatLayer = class extends SchemaCompatLayer3 {
     } else if (isArraySchema(schema)) {
       this.defaultArrayHandler(schema);
     } else if (isStringSchema(schema)) {
-      if (this.getModel().modelId.includes("claude-3.5-haiku")) {
-        this.defaultStringHandler(schema);
+      const model = this.getModel();
+      if (model.modelId?.includes("gpt-4o-mini")) {
+        if (schema.format === "emoji") {
+          delete schema.format;
+        }
+        if (schema.pattern) {
+          delete schema.pattern;
+        }
       }
+      this.defaultStringHandler(schema);
     }
   }
   postProcessJSONNode(schema) {
     if (isUnionSchema(schema)) {
       this.defaultUnionHandler(schema);
     }
+    if (schema.type === void 0 && !schema.anyOf) {
+      let subSchema = {};
+      for (const key of Object.keys(schema)) {
+        subSchema[key] = schema[key];
+        delete schema[key];
+      }
+      schema.anyOf = [
+        subSchema,
+        {
+          type: "null"
+        }
+      ];
+    }
+    if (schema.type === "object" && schema.additionalProperties === void 0) {
+      schema.additionalProperties = false;
+    }
     if (isObjectSchema(schema)) {
-      if (schema.additionalProperties !== void 0 && typeof schema.additionalProperties === "object" && schema.additionalProperties !== null && Object.keys(schema.additionalProperties).length === 0) {
-        schema.additionalProperties = true;
+      const keys = Object.keys(schema.properties || {});
+      if (keys.length) {
+        for (const key of keys) {
+          if (!schema.required?.includes(key) && schema.properties?.[key]?.type) {
+            const prop = schema.properties[key];
+            const subSchema = {};
+            for (const propKey of Object.keys(prop)) {
+              if (propKey !== "anyOf") {
+                subSchema[propKey] = prop[propKey];
+              }
+            }
+            prop.anyOf = [subSchema, { type: "null" }];
+            for (const propKey of Object.keys(subSchema)) {
+              delete prop[propKey];
+            }
+          }
+        }
+        schema.required = keys;
       }
       if ("propertyNames" in schema) {
         delete schema.propertyNames;
       }
     }
   }
-};
-var DeepSeekSchemaCompatLayer = class extends SchemaCompatLayer3 {
-  constructor(model) {
-    super(model);
-  }
-  getSchemaTarget() {
-    return "jsonSchema7";
-  }
-  shouldApply() {
-    return this.getModel().modelId.includes("deepseek") && !this.getModel().modelId.includes("r1");
-  }
-  processZodType(value) {
-    if (isOptional2(zod.z)(value)) {
-      return this.defaultZodOptionalHandler(value, ["ZodObject", "ZodArray", "ZodUnion", "ZodString", "ZodNumber"]);
-    } else if (isObj2(zod.z)(value)) {
-      return this.defaultZodObjectHandler(value);
-    } else if (isArr2(zod.z)(value)) {
-      return this.defaultZodArrayHandler(value, ["min", "max"]);
-    } else if (isUnion2(zod.z)(value)) {
-      return this.defaultZodUnionHandler(value);
-    } else if (isString2(zod.z)(value)) {
-      return this.defaultZodStringHandler(value);
+  /**
+   * Recursively fixes additionalProperties: {} to additionalProperties: true.
+   * OpenAI requires additionalProperties to be either:
+   * - false (no additional properties allowed)
+   * - true (any additional properties allowed)
+   * - an object with a "type" key (typed additional properties)
+   * An empty object {} is NOT valid.
+   */
+  fixAdditionalProperties(schema) {
+    if (typeof schema !== "object" || schema === null) {
+      return schema;
     }
-    return value;
-  }
-  preProcessJSONNode(schema, _parentSchema) {
-    if (isObjectSchema(schema)) {
-      this.defaultObjectHandler(schema);
-    } else if (isArraySchema(schema)) {
-      this.defaultArrayHandler(schema);
-    } else if (isStringSchema(schema)) {
-      this.defaultStringHandler(schema);
+    const result = { ...schema };
+    if (result.additionalProperties !== void 0 && typeof result.additionalProperties === "object" && result.additionalProperties !== null && !Array.isArray(result.additionalProperties) && Object.keys(result.additionalProperties).length === 0) {
+      result.additionalProperties = true;
     }
-  }
-  postProcessJSONNode(schema, _parentSchema) {
-    if (isUnionSchema(schema)) {
-      this.defaultUnionHandler(schema);
+    if (result.properties) {
+      result.properties = Object.fromEntries(
+        Object.entries(result.properties).map(([key, value]) => [
+          key,
+          this.fixAdditionalProperties(value)
+        ])
+      );
     }
-    if (isObjectSchema(schema)) {
-      if (schema.additionalProperties !== void 0 && typeof schema.additionalProperties === "object" && schema.additionalProperties !== null && Object.keys(schema.additionalProperties).length === 0) {
-        schema.additionalProperties = true;
-      }
-      if ("propertyNames" in schema) {
-        delete schema.propertyNames;
+    if (result.items) {
+      if (Array.isArray(result.items)) {
+        result.items = result.items.map((item) => this.fixAdditionalProperties(item));
+      } else {
+        result.items = this.fixAdditionalProperties(result.items);
       }
     }
+    if (result.additionalProperties && typeof result.additionalProperties === "object" && !Array.isArray(result.additionalProperties) && Object.keys(result.additionalProperties).length > 0) {
+      result.additionalProperties = this.fixAdditionalProperties(result.additionalProperties);
+    }
+    return result;
   }
 };
-var GoogleSchemaCompatLayer = class extends SchemaCompatLayer3 {
-  constructor(model) {
-    super(model);
-  }
+var OpenAIReasoningSchemaCompatLayer = class extends OpenAISchemaCompatLayer {
   getSchemaTarget() {
-    return "jsonSchema7";
+    return `openApi3`;
   }
   shouldApply() {
-    return this.getModel().provider.includes("google") || this.getModel().modelId.includes("google");
+    const model = this.getModel();
+    if (this.isReasoningModel() && (model.provider.includes(`openai`) || model.modelId?.includes(`openai`))) {
+      return true;
+    }
+    return false;
   }
   processZodType(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");
+      const innerType = "_def" in value ? value._def.innerType : value._zod?.def?.innerType;
+      if (innerType) {
+        if (isNullable(zod.z)(innerType)) {
+          const processed = this.processZodType(innerType);
+          return processed.transform((val) => val === null ? void 0 : val);
+        }
+        const processedInner = this.processZodType(innerType);
+        return processedInner.nullable().transform((val) => val === null ? void 0 : val);
+      }
+      return value;
+    } else if (isNullable(zod.z)(value)) {
+      const innerType = "_def" in value ? value._def.innerType : value._zod?.def?.innerType;
+      if (innerType && isOptional2(zod.z)(innerType)) {
+        const innerInnerType = "_def" in innerType ? innerType._def.innerType : innerType._zod?.def?.innerType;
+        if (innerInnerType) {
+          const processedInnerInner = this.processZodType(innerInnerType);
+          return processedInnerInner.nullable().transform((val) => val === null ? void 0 : val);
+        }
+      }
+      if (innerType) {
+        const processedInner = this.processZodType(innerType);
+        return processedInner.nullable();
+      }
+      return value;
     } else if (isObj2(zod.z)(value)) {
-      return this.defaultZodObjectHandler(value);
+      return this.defaultZodObjectHandler(value, { passthrough: false });
     } else if (isArr2(zod.z)(value)) {
-      return this.defaultZodArrayHandler(value, []);
+      return this.defaultZodArrayHandler(value);
     } else if (isUnion2(zod.z)(value)) {
       return this.defaultZodUnionHandler(value);
-    } else if (isString2(zod.z)(value)) {
-      return this.defaultZodStringHandler(value);
+    } else if (isDefault(zod.z)(value)) {
+      const defaultDef = value._def;
+      const innerType = defaultDef.innerType;
+      const defaultValue = typeof defaultDef.defaultValue === "function" ? defaultDef.defaultValue() : defaultDef.defaultValue;
+      const constraints = [];
+      if (defaultValue !== void 0) {
+        constraints.push(`the default value is ${defaultValue}`);
+      }
+      const description = this.mergeParameterDescription(value.description, constraints);
+      let result = this.processZodType(innerType);
+      if (description) {
+        result = result.describe(description);
+      }
+      return result;
     } else if (isNumber2(zod.z)(value)) {
       return this.defaultZodNumberHandler(value);
+    } else if (isString2(zod.z)(value)) {
+      return this.defaultZodStringHandler(value);
+    } else if (isDate(zod.z)(value)) {
+      return this.defaultZodDateHandler(value);
+    } 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 (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`
+      );
     }
     return this.defaultUnsupportedZodTypeHandler(value);
   }
+  processToJSONSchema(zodSchema2) {
+    const jsonSchema2 = super.processToJSONSchema(zodSchema2);
+    return chunkUFJG5KPA_cjs.ensureAllPropertiesRequired(jsonSchema2);
+  }
   preProcessJSONNode(schema, _parentSchema) {
     if (isObjectSchema(schema)) {
       this.defaultObjectHandler(schema);
     } else if (isArraySchema(schema)) {
       this.defaultArrayHandler(schema);
-    } else if (isStringSchema(schema)) {
-      this.defaultStringHandler(schema);
     } else if (isNumberSchema(schema)) {
       this.defaultNumberHandler(schema);
+    } else if (isStringSchema(schema)) {
+      this.defaultStringHandler(schema);
     }
   }
-  postProcessJSONNode(schema, _parentSchema) {
+  postProcessJSONNode(schema) {
+    super.postProcessJSONNode(schema);
+    if (schema.type === "object" && schema.properties !== void 0) {
+      schema.additionalProperties = false;
+    }
+  }
+};
+
+// src/standard-schema-compat.ts
+function extractZodSchema(schema) {
+  if (!isZodType(schema)) {
+    return null;
+  }
+  return schema;
+}
+function applyOpenAICompatTransforms(schema, modelInfo) {
+  const isOpenAI = modelInfo.provider?.includes("openai") || modelInfo.modelId?.includes("openai");
+  if (!isOpenAI) {
+    return schema;
+  }
+  const zodSchema2 = extractZodSchema(schema);
+  if (!zodSchema2) {
+    return schema;
+  }
+  const isReasoningModel = /^o[1-5]/.test(modelInfo.modelId);
+  const compatLayer = isReasoningModel ? new OpenAIReasoningSchemaCompatLayer(modelInfo) : new OpenAISchemaCompatLayer(modelInfo);
+  if (!compatLayer.shouldApply()) {
+    return schema;
+  }
+  const processedZodSchema = compatLayer.processZodType(zodSchema2);
+  return chunk3QMIGINL_cjs.toStandardSchema(processedZodSchema);
+}
+function applyOpenAICompatToTools(tools, modelInfo) {
+  if (!tools) {
+    return tools;
+  }
+  const transformedTools = {};
+  for (const [name17, tool] of Object.entries(tools)) {
+    if (tool.inputSchema) {
+      const processedSchema = applyOpenAICompatTransforms(tool.inputSchema, modelInfo);
+      transformedTools[name17] = {
+        ...tool,
+        inputSchema: processedSchema
+      };
+    } else {
+      transformedTools[name17] = tool;
+    }
+  }
+  return transformedTools;
+}
+var AnthropicSchemaCompatLayer = class extends SchemaCompatLayer3 {
+  constructor(model) {
+    super(model);
+  }
+  getSchemaTarget() {
+    return "jsonSchema7";
+  }
+  shouldApply() {
+    return this.getModel().modelId.includes("claude");
+  }
+  processZodType(value) {
+    if (this.isOptional(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 (this.isObj(value)) {
+      return this.defaultZodObjectHandler(value);
+    } else if (this.isArr(value)) {
+      return this.defaultZodArrayHandler(value, []);
+    } else if (this.isUnion(value)) {
+      return this.defaultZodUnionHandler(value);
+    } else if (this.isString(value)) {
+      if (this.getModel().modelId.includes("claude-3.5-haiku")) {
+        return this.defaultZodStringHandler(value, ["max", "min"]);
+      } else {
+        return value;
+      }
+    } else if (isNull(zod.z)(value)) {
+      return zod.z.any().refine((v) => v === null, { message: "must be null" }).describe(value.description || "must be null");
+    }
+    return this.defaultUnsupportedZodTypeHandler(value);
+  }
+  preProcessJSONNode(schema, _parentSchema) {
+    if (isObjectSchema(schema)) {
+      this.defaultObjectHandler(schema);
+    } else if (isArraySchema(schema)) {
+      this.defaultArrayHandler(schema);
+    } else if (isStringSchema(schema)) {
+      if (this.getModel().modelId.includes("claude-3.5-haiku")) {
+        this.defaultStringHandler(schema);
+      }
+    }
+  }
+  postProcessJSONNode(schema) {
     if (isUnionSchema(schema)) {
       this.defaultUnionHandler(schema);
     }
@@ -5185,7 +5519,7 @@ var GoogleSchemaCompatLayer = class extends SchemaCompatLayer3 {
     }
   }
 };
-var MetaSchemaCompatLayer = class extends SchemaCompatLayer3 {
+var DeepSeekSchemaCompatLayer = class extends SchemaCompatLayer3 {
   constructor(model) {
     super(model);
   }
@@ -5193,7 +5527,7 @@ var MetaSchemaCompatLayer = class extends SchemaCompatLayer3 {
     return "jsonSchema7";
   }
   shouldApply() {
-    return this.getModel().modelId.includes("meta");
+    return this.getModel().modelId.includes("deepseek") && !this.getModel().modelId.includes("r1");
   }
   processZodType(value) {
     if (isOptional2(zod.z)(value)) {
@@ -5204,8 +5538,6 @@ var MetaSchemaCompatLayer = class extends SchemaCompatLayer3 {
       return this.defaultZodArrayHandler(value, ["min", "max"]);
     } else if (isUnion2(zod.z)(value)) {
       return this.defaultZodUnionHandler(value);
-    } else if (isNumber2(zod.z)(value)) {
-      return this.defaultZodNumberHandler(value);
     } else if (isString2(zod.z)(value)) {
       return this.defaultZodStringHandler(value);
     }
@@ -5218,8 +5550,6 @@ var MetaSchemaCompatLayer = class extends SchemaCompatLayer3 {
       this.defaultArrayHandler(schema);
     } else if (isStringSchema(schema)) {
       this.defaultStringHandler(schema);
-    } else if (isNumberSchema(schema)) {
-      this.defaultNumberHandler(schema);
     }
   }
   postProcessJSONNode(schema, _parentSchema) {
@@ -5236,85 +5566,104 @@ var MetaSchemaCompatLayer = class extends SchemaCompatLayer3 {
     }
   }
 };
-var OpenAISchemaCompatLayer = class extends SchemaCompatLayer3 {
+function fixNullableUnionTypes(schema) {
+  if (typeof schema !== "object" || schema === null) {
+    return schema;
+  }
+  const result = { ...schema };
+  if (Array.isArray(result.type)) {
+    const nonNullTypes = result.type.filter((t) => t !== "null");
+    if (nonNullTypes.length < result.type.length) {
+      result.nullable = true;
+      if (nonNullTypes.length === 1) {
+        result.type = nonNullTypes[0];
+      } else if (nonNullTypes.length > 1) {
+        result.type = nonNullTypes;
+      } else {
+        delete result.type;
+      }
+    }
+  }
+  if (result.anyOf && Array.isArray(result.anyOf) && result.anyOf.length === 2) {
+    const nullSchema = result.anyOf.find((s) => typeof s === "object" && s !== null && s.type === "null");
+    const otherSchema = result.anyOf.find((s) => typeof s === "object" && s !== null && s.type !== "null");
+    if (nullSchema && otherSchema && typeof otherSchema === "object") {
+      const { anyOf: _, ...rest } = result;
+      const fixedOther = fixNullableUnionTypes(otherSchema);
+      return { ...rest, ...fixedOther, nullable: true };
+    }
+  }
+  if (result.properties && typeof result.properties === "object") {
+    result.properties = Object.fromEntries(
+      Object.entries(result.properties).map(([key, value]) => [key, fixNullableUnionTypes(value)])
+    );
+  }
+  if (result.items) {
+    if (Array.isArray(result.items)) {
+      result.items = result.items.map((item) => fixNullableUnionTypes(item));
+    } else {
+      result.items = fixNullableUnionTypes(result.items);
+    }
+  }
+  if (result.additionalProperties && typeof result.additionalProperties === "object") {
+    result.additionalProperties = fixNullableUnionTypes(result.additionalProperties);
+  }
+  if (result.anyOf && Array.isArray(result.anyOf)) {
+    result.anyOf = result.anyOf.map((s) => fixNullableUnionTypes(s));
+  }
+  if (result.oneOf && Array.isArray(result.oneOf)) {
+    result.oneOf = result.oneOf.map((s) => fixNullableUnionTypes(s));
+  }
+  if (result.allOf && Array.isArray(result.allOf)) {
+    result.allOf = result.allOf.map((s) => fixNullableUnionTypes(s));
+  }
+  return result;
+}
+var GoogleSchemaCompatLayer = class extends SchemaCompatLayer3 {
   constructor(model) {
     super(model);
   }
   getSchemaTarget() {
-    return `jsonSchema7`;
+    return "jsonSchema7";
   }
   shouldApply() {
-    if (!this.getModel().supportsStructuredOutputs && (this.getModel().provider.includes(`openai`) || this.getModel().modelId.includes(`openai`) || this.getModel().provider.includes(`groq`))) {
-      return true;
-    }
-    return false;
+    return this.getModel().provider.includes("google") || this.getModel().modelId.includes("google");
   }
   processZodType(value) {
     if (isOptional2(zod.z)(value)) {
-      const innerType = "_def" in value ? value._def.innerType : value._zod?.def?.innerType;
-      if (innerType) {
-        if (isNullable(zod.z)(innerType)) {
-          const processed = this.processZodType(innerType);
-          return processed.transform((val) => val === null ? void 0 : val);
-        }
-        const processedInner = this.processZodType(innerType);
-        return processedInner.nullable().transform((val) => val === null ? void 0 : val);
-      }
-      return value;
+      return this.defaultZodOptionalHandler(value, [
+        "ZodObject",
+        "ZodArray",
+        "ZodUnion",
+        "ZodString",
+        "ZodNumber",
+        "ZodNullable"
+      ]);
     } else if (isNullable(zod.z)(value)) {
-      const innerType = "_def" in value ? value._def.innerType : value._zod?.def?.innerType;
-      if (innerType) {
-        if (isOptional2(zod.z)(innerType)) {
-          const innerInnerType = "_def" in innerType ? innerType._def.innerType : innerType._zod?.def?.innerType;
-          if (innerInnerType) {
-            const processedInnerInner = this.processZodType(innerInnerType);
-            return processedInnerInner.nullable().transform((val) => val === null ? void 0 : val);
-          }
-        }
-        const processedInner = this.processZodType(innerType);
-        return processedInner.nullable();
-      }
-      return value;
-    } else if (isDefault(zod.z)(value)) {
-      const innerType = "_def" in value ? value._def.innerType : value._zod?.def?.innerType;
-      const defaultValue = "_def" in value ? value._def.defaultValue : value._zod?.def?.defaultValue;
-      if (innerType) {
-        const processedInner = this.processZodType(innerType);
-        return processedInner.nullable().transform((val) => {
-          if (val === null) {
-            return typeof defaultValue === "function" ? defaultValue() : defaultValue;
-          }
-          return val;
-        });
-      }
-      return value;
+      return this.defaultZodNullableHandler(value);
+    } 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 (isArr2(zod.z)(value)) {
+      return this.defaultZodArrayHandler(value, []);
     } else if (isUnion2(zod.z)(value)) {
       return this.defaultZodUnionHandler(value);
-    } else if (isArr2(zod.z)(value)) {
-      return this.defaultZodArrayHandler(value);
     } else if (isString2(zod.z)(value)) {
-      const model = this.getModel();
-      const checks = ["emoji"];
-      if (model.modelId.includes("gpt-4o-mini")) {
-        return this.defaultZodStringHandler(value, ["emoji", "regex"]);
-      }
-      return this.defaultZodStringHandler(value, checks);
+      return this.defaultZodStringHandler(value);
+    } else if (isNumber2(zod.z)(value)) {
+      return this.defaultZodNumberHandler(value);
     }
-    return this.defaultUnsupportedZodTypeHandler(value, [
-      "ZodNever",
-      "ZodUndefined",
-      "ZodTuple"
-    ]);
+    return this.defaultUnsupportedZodTypeHandler(value);
   }
-  /**
-   * Override to fix additionalProperties: {} which OpenAI doesn't support.
-   * Converts empty object {} to true to preserve passthrough intent.
-   */
-  processToJSONSchema(zodSchema2) {
-    const jsonSchema2 = super.processToJSONSchema(zodSchema2);
-    return this.fixAdditionalProperties(jsonSchema2);
+  processToJSONSchema(zodSchema2, io = "input") {
+    const result = super.processToJSONSchema(zodSchema2, io);
+    return fixNullableUnionTypes(result);
+  }
+  processToAISDKSchema(zodSchema2) {
+    const result = super.processToAISDKSchema(zodSchema2);
+    const fixedJsonSchema = fixNullableUnionTypes(result.jsonSchema);
+    return { ...result, jsonSchema: fixedJsonSchema };
   }
   preProcessJSONNode(schema, _parentSchema) {
     if (isObjectSchema(schema)) {
@@ -5322,22 +5671,14 @@ var OpenAISchemaCompatLayer = class extends SchemaCompatLayer3 {
     } else if (isArraySchema(schema)) {
       this.defaultArrayHandler(schema);
     } else if (isStringSchema(schema)) {
-      const model = this.getModel();
-      if (model.modelId.includes("gpt-4o-mini")) {
-        if (schema.format === "emoji") {
-          delete schema.format;
-        }
-        if (schema.pattern) {
-          delete schema.pattern;
-        }
-      } else {
-        if (schema.format === "emoji") {
-          delete schema.format;
-        }
-      }
+      this.defaultStringHandler(schema);
+    } else if (isNumberSchema(schema)) {
+      this.defaultNumberHandler(schema);
+    } else if (isEnumSchema(schema)) {
+      schema.type = "string";
     }
   }
-  postProcessJSONNode(schema) {
+  postProcessJSONNode(schema, _parentSchema) {
     if (isUnionSchema(schema)) {
       this.defaultUnionHandler(schema);
     }
@@ -5350,139 +5691,51 @@ var OpenAISchemaCompatLayer = class extends SchemaCompatLayer3 {
       }
     }
   }
-  /**
-   * Recursively fixes additionalProperties: {} to additionalProperties: true.
-   * OpenAI requires additionalProperties to be either:
-   * - false (no additional properties allowed)
-   * - true (any additional properties allowed)
-   * - an object with a "type" key (typed additional properties)
-   * An empty object {} is NOT valid.
-   */
-  fixAdditionalProperties(schema) {
-    if (typeof schema !== "object" || schema === null) {
-      return schema;
-    }
-    const result = { ...schema };
-    if (result.additionalProperties !== void 0 && typeof result.additionalProperties === "object" && result.additionalProperties !== null && !Array.isArray(result.additionalProperties) && Object.keys(result.additionalProperties).length === 0) {
-      result.additionalProperties = true;
-    }
-    if (result.properties) {
-      result.properties = Object.fromEntries(
-        Object.entries(result.properties).map(([key, value]) => [
-          key,
-          this.fixAdditionalProperties(value)
-        ])
-      );
-    }
-    if (result.items) {
-      if (Array.isArray(result.items)) {
-        result.items = result.items.map((item) => this.fixAdditionalProperties(item));
-      } else {
-        result.items = this.fixAdditionalProperties(result.items);
-      }
-    }
-    if (result.additionalProperties && typeof result.additionalProperties === "object" && !Array.isArray(result.additionalProperties) && Object.keys(result.additionalProperties).length > 0) {
-      result.additionalProperties = this.fixAdditionalProperties(result.additionalProperties);
-    }
-    return result;
-  }
 };
-var OpenAIReasoningSchemaCompatLayer = class extends SchemaCompatLayer3 {
+var MetaSchemaCompatLayer = class extends SchemaCompatLayer3 {
   constructor(model) {
     super(model);
   }
   getSchemaTarget() {
-    return `openApi3`;
-  }
-  isReasoningModel() {
-    return this.getModel().modelId.includes(`o3`) || this.getModel().modelId.includes(`o4`) || this.getModel().modelId.includes(`o1`);
+    return "jsonSchema7";
   }
   shouldApply() {
-    if (this.isReasoningModel() && (this.getModel().provider.includes(`openai`) || this.getModel().modelId.includes(`openai`))) {
-      return true;
-    }
-    return false;
+    return this.getModel().modelId.includes("meta");
   }
   processZodType(value) {
     if (isOptional2(zod.z)(value)) {
-      const innerType = "_def" in value ? value._def.innerType : value._zod?.def?.innerType;
-      if (innerType) {
-        if (isNullable(zod.z)(innerType)) {
-          const processed = this.processZodType(innerType);
-          return processed.transform((val) => val === null ? void 0 : val);
-        }
-        const processedInner = this.processZodType(innerType);
-        return processedInner.nullable().transform((val) => val === null ? void 0 : val);
-      }
-      return value;
-    } else if (isNullable(zod.z)(value)) {
-      const innerType = "_def" in value ? value._def.innerType : value._zod?.def?.innerType;
-      if (innerType && isOptional2(zod.z)(innerType)) {
-        const innerInnerType = "_def" in innerType ? innerType._def.innerType : innerType._zod?.def?.innerType;
-        if (innerInnerType) {
-          const processedInnerInner = this.processZodType(innerInnerType);
-          return processedInnerInner.nullable().transform((val) => val === null ? void 0 : val);
-        }
-      }
-      if (innerType) {
-        const processedInner = this.processZodType(innerType);
-        return processedInner.nullable();
-      }
-      return value;
+      return this.defaultZodOptionalHandler(value, ["ZodObject", "ZodArray", "ZodUnion", "ZodString", "ZodNumber"]);
     } else if (isObj2(zod.z)(value)) {
-      return this.defaultZodObjectHandler(value, { passthrough: false });
+      return this.defaultZodObjectHandler(value);
     } else if (isArr2(zod.z)(value)) {
-      return this.defaultZodArrayHandler(value);
+      return this.defaultZodArrayHandler(value, ["min", "max"]);
     } else if (isUnion2(zod.z)(value)) {
       return this.defaultZodUnionHandler(value);
-    } else if (isDefault(zod.z)(value)) {
-      const defaultDef = value._def;
-      const innerType = defaultDef.innerType;
-      const defaultValue = typeof defaultDef.defaultValue === "function" ? defaultDef.defaultValue() : defaultDef.defaultValue;
-      const constraints = [];
-      if (defaultValue !== void 0) {
-        constraints.push(`the default value is ${defaultValue}`);
-      }
-      const description = this.mergeParameterDescription(value.description, constraints);
-      let result = this.processZodType(innerType);
-      if (description) {
-        result = result.describe(description);
-      }
-      return result;
     } else if (isNumber2(zod.z)(value)) {
       return this.defaultZodNumberHandler(value);
     } else if (isString2(zod.z)(value)) {
       return this.defaultZodStringHandler(value);
-    } else if (isDate(zod.z)(value)) {
-      return this.defaultZodDateHandler(value);
-    } 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 (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`
-      );
     }
-    return this.defaultUnsupportedZodTypeHandler(value);
+    return value;
   }
   preProcessJSONNode(schema, _parentSchema) {
     if (isObjectSchema(schema)) {
       this.defaultObjectHandler(schema);
     } else if (isArraySchema(schema)) {
       this.defaultArrayHandler(schema);
-    } else if (isNumberSchema(schema)) {
-      this.defaultNumberHandler(schema);
     } else if (isStringSchema(schema)) {
       this.defaultStringHandler(schema);
+    } else if (isNumberSchema(schema)) {
+      this.defaultNumberHandler(schema);
     }
   }
-  postProcessJSONNode(schema) {
+  postProcessJSONNode(schema, _parentSchema) {
     if (isUnionSchema(schema)) {
       this.defaultUnionHandler(schema);
     }
     if (isObjectSchema(schema)) {
       if (schema.additionalProperties !== void 0 && typeof schema.additionalProperties === "object" && schema.additionalProperties !== null && Object.keys(schema.additionalProperties).length === 0) {
-        schema.additionalProperties = false;
+        schema.additionalProperties = true;
       }
       if ("propertyNames" in schema) {
         delete schema.propertyNames;
@@ -5491,6 +5744,38 @@ Argument was an "any" type, but you (the LLM) do not support "any", so it was ca
   }
 };
 
+Object.defineProperty(exports, "JSON_SCHEMA_LIBRARY_OPTIONS", {
+  enumerable: true,
+  get: function () { return chunk3QMIGINL_cjs.JSON_SCHEMA_LIBRARY_OPTIONS; }
+});
+Object.defineProperty(exports, "isStandardJSONSchema", {
+  enumerable: true,
+  get: function () { return chunk3QMIGINL_cjs.isStandardJSONSchema; }
+});
+Object.defineProperty(exports, "isStandardSchema", {
+  enumerable: true,
+  get: function () { return chunk3QMIGINL_cjs.isStandardSchema; }
+});
+Object.defineProperty(exports, "isStandardSchemaWithJSON", {
+  enumerable: true,
+  get: function () { return chunk3QMIGINL_cjs.isStandardSchemaWithJSON; }
+});
+Object.defineProperty(exports, "standardSchemaToJSONSchema", {
+  enumerable: true,
+  get: function () { return chunk3QMIGINL_cjs.standardSchemaToJSONSchema; }
+});
+Object.defineProperty(exports, "toStandardSchema", {
+  enumerable: true,
+  get: function () { return chunk3QMIGINL_cjs.toStandardSchema; }
+});
+Object.defineProperty(exports, "ensureAllPropertiesRequired", {
+  enumerable: true,
+  get: function () { return chunkUFJG5KPA_cjs.ensureAllPropertiesRequired; }
+});
+Object.defineProperty(exports, "prepareJsonSchemaForOpenAIStrictMode", {
+  enumerable: true,
+  get: function () { return chunkUFJG5KPA_cjs.prepareJsonSchemaForOpenAIStrictMode; }
+});
 exports.ALL_ARRAY_CHECKS = ALL_ARRAY_CHECKS;
 exports.ALL_NUMBER_CHECKS = ALL_NUMBER_CHECKS;
 exports.ALL_STRING_CHECKS = ALL_STRING_CHECKS;
@@ -5507,8 +5792,11 @@ exports.SchemaCompatLayerV3 = SchemaCompatLayer;
 exports.SchemaCompatLayerV4 = SchemaCompatLayer2;
 exports.UNSUPPORTED_ZOD_TYPES = UNSUPPORTED_ZOD_TYPES;
 exports.applyCompatLayer = applyCompatLayer;
+exports.applyOpenAICompatToTools = applyOpenAICompatToTools;
+exports.applyOpenAICompatTransforms = applyOpenAICompatTransforms;
 exports.convertSchemaToZod = convertSchemaToZod;
 exports.convertZodSchemaToAISDKSchema = convertZodSchemaToAISDKSchema;
+exports.extractZodSchema = extractZodSchema;
 exports.isArr = isArr;
 exports.isNumber = isNumber;
 exports.isObj = isObj;
@@ -5517,5 +5805,6 @@ exports.isString = isString;
 exports.isUnion = isUnion;
 exports.isZodType = isZodType;
 exports.jsonSchema = jsonSchema;
+exports.wrapSchemaWithNullTransform = wrapSchemaWithNullTransform;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map