@mastra/schema-compat 1.0.0-beta.8 → 1.1.0-alpha.0

package/dist/index.cjs

@@ -1,6 +1,8 @@
 'use strict';
 
-var chunkZXNJQOPF_cjs = require('./chunk-ZXNJQOPF.cjs');
+var chunkDAVEUCUM_cjs = require('./chunk-DAVEUCUM.cjs');
+var chunkVC7YNDY2_cjs = require('./chunk-VC7YNDY2.cjs');
+var chunkDZUJEN5N_cjs = require('./chunk-DZUJEN5N.cjs');
 var zod = require('zod');
 var zodFromJsonSchema = require('zod-from-json-schema');
 var zodFromJsonSchemaV3 = require('zod-from-json-schema-v3');
@@ -24,7 +26,7 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
   // If the importer is in node compatibility mode or this is not an ESM
   // file that has been converted to a CommonJS file using a Babel-
   // compatible transform (i.e. "__esModule" has not been set), then set
@@ -33,7 +35,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var require_secure_json_parse = __commonJS({
-  "../../../node_modules/.pnpm/secure-json-parse@2.7.0/node_modules/secure-json-parse/index.js"(exports, module) {
+  "../../../node_modules/.pnpm/secure-json-parse@2.7.0/node_modules/secure-json-parse/index.js"(exports$1, module) {
     var hasBuffer = typeof Buffer !== "undefined";
     var suspectProtoRx = /"(?:_|\\u005[Ff])(?:_|\\u005[Ff])(?:p|\\u0070)(?:r|\\u0072)(?:o|\\u006[Ff])(?:t|\\u0074)(?:o|\\u006[Ff])(?:_|\\u005[Ff])(?:_|\\u005[Ff])"\s*:/;
     var suspectConstructorRx = /"(?:c|\\u0063)(?:o|\\u006[Ff])(?:n|\\u006[Ee])(?:s|\\u0073)(?:t|\\u0074)(?:r|\\u0072)(?:u|\\u0075)(?:c|\\u0063)(?:t|\\u0074)(?:o|\\u006[Ff])(?:r|\\u0072)"\s*:/;
@@ -268,7 +270,7 @@ var customAlphabet = (alphabet, defaultSize = 21) => {
     return id;
   };
 };
-var import_secure_json_parse = __toESM(require_secure_json_parse());
+var import_secure_json_parse = __toESM2(require_secure_json_parse());
 function convertAsyncIteratorToReadableStream(iterator) {
   return new ReadableStream({
     /**
@@ -3568,7 +3570,7 @@ function trimStartOfStream() {
 
 // src/utils.ts
 function convertZodSchemaToAISDKSchema(zodSchema2, target = "jsonSchema7") {
-  const jsonSchemaToUse = chunkZXNJQOPF_cjs.zodToJsonSchema(zodSchema2, target);
+  const jsonSchemaToUse = chunkVC7YNDY2_cjs.zodToJsonSchema(zodSchema2, target);
   return jsonSchema(jsonSchemaToUse, {
     validate: (value) => {
       const result = zodSchema2.safeParse(value);
@@ -3615,7 +3617,7 @@ function applyCompatLayer({
     }
   }
   if (mode === "jsonSchema") {
-    return chunkZXNJQOPF_cjs.zodToJsonSchema(zodSchema2, "jsonSchema7");
+    return chunkVC7YNDY2_cjs.zodToJsonSchema(zodSchema2, "jsonSchema7");
   } else {
     return convertZodSchemaToAISDKSchema(zodSchema2);
   }
@@ -3691,6 +3693,12 @@ var SchemaCompatLayer = class {
   isNull(v) {
     return v instanceof zod.ZodNull;
   }
+  /**
+   * Type guard for nullable Zod types
+   */
+  isNullable(v) {
+    return v instanceof zod.ZodNullable;
+  }
   /**
    * Type guard for array Zod types
    */
@@ -4022,6 +4030,20 @@ var SchemaCompatLayer = class {
       return value;
     }
   }
+  /**
+   * Default handler for Zod nullable types. Processes the inner type and maintains nullability.
+   *
+   * @param value - The Zod nullable to process
+   * @param handleTypes - Types that should be processed vs passed through
+   * @returns The processed Zod nullable
+   */
+  defaultZodNullableHandler(value, handleTypes = SUPPORTED_ZOD_TYPES) {
+    if (handleTypes.includes(value._def.innerType._def.typeName)) {
+      return this.processZodType(value._def.innerType).nullable();
+    } else {
+      return value;
+    }
+  }
   /**
    * Processes a Zod object schema and converts it to an AI SDK Schema.
    *
@@ -4192,16 +4214,16 @@ var SchemaCompatLayer2 = class {
     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)) {
+    } else if (value._zod.def.catchall instanceof v4.z.ZodUnknown) {
+      if (options.passthrough) {
+        result = v4.z.looseObject(processedShape);
+      }
+    } else if (value._zod.def.catchall) {
       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;
   }
   /**
@@ -4460,6 +4482,20 @@ var SchemaCompatLayer2 = class {
       return value;
     }
   }
+  /**
+   * Default handler for Zod nullable types. Processes the inner type and maintains nullability.
+   *
+   * @param value - The Zod nullable to process
+   * @param handleTypes - Types that should be processed vs passed through
+   * @returns The processed Zod nullable
+   */
+  defaultZodNullableHandler(value, handleTypes = SUPPORTED_ZOD_TYPES2) {
+    if (handleTypes.includes(value.constructor.name)) {
+      return this.processZodType(value._zod.def.innerType).nullable();
+    } else {
+      return value;
+    }
+  }
   /**
    * Processes a Zod object schema and converts it to an AI SDK Schema.
    *
@@ -4481,6 +4517,43 @@ var SchemaCompatLayer2 = class {
   }
 };
 
+// src/schema-compatibility.ts
+var import_json_schema_traverse = chunkDZUJEN5N_cjs.__toESM(chunkDAVEUCUM_cjs.require_json_schema_traverse(), 1);
+
+// src/json-schema/utils.ts
+function hasType(schema, type) {
+  if (schema.type === type) return true;
+  if (Array.isArray(schema.type) && schema.type.includes(type)) return true;
+  return false;
+}
+function isObjectSchema(schema) {
+  return hasType(schema, "object") || schema.properties !== void 0;
+}
+function isArraySchema(schema) {
+  return hasType(schema, "array") || schema.items !== void 0;
+}
+function isStringSchema(schema) {
+  return hasType(schema, "string");
+}
+function isNumberSchema(schema) {
+  return hasType(schema, "number") || hasType(schema, "integer");
+}
+function isAnyOfSchema(schema) {
+  return Array.isArray(schema.anyOf) && schema.anyOf.length > 0;
+}
+function isOneOfSchema(schema) {
+  return Array.isArray(schema.oneOf) && schema.oneOf.length > 0;
+}
+function isUnionSchema(schema) {
+  return isAnyOfSchema(schema) || isOneOfSchema(schema);
+}
+function isOptionalSchema(propertyName, parentSchema) {
+  if (!parentSchema.required || !Array.isArray(parentSchema.required)) {
+    return true;
+  }
+  return !parentSchema.required.includes(propertyName);
+}
+
 // src/schema-compatibility.ts
 var SchemaCompatLayer3 = class {
   model;
@@ -4504,8 +4577,8 @@ var SchemaCompatLayer3 = class {
   getModel() {
     return this.model;
   }
-  getUnsupportedZodTypes(v) {
-    if ("_zod" in v) {
+  getUnsupportedZodTypes(value) {
+    if ("_zod" in value) {
       return this.v4Layer.getUnsupportedZodTypes();
     } else {
       return this.v3Layer.getUnsupportedZodTypes();
@@ -4532,6 +4605,13 @@ var SchemaCompatLayer3 = class {
       return this.v3Layer.isNull(v);
     }
   }
+  isNullable(v) {
+    if ("_zod" in v) {
+      return this.v4Layer.isNullable(v);
+    } else {
+      return this.v3Layer.isNullable(v);
+    }
+  }
   isArr(v) {
     if ("_zod" in v) {
       return this.v4Layer.isArr(v);
@@ -4574,6 +4654,10 @@ var SchemaCompatLayer3 = class {
       return this.v3Layer.isDefault(v);
     }
   }
+  preProcessJSONNode(_schema, _parentSchema) {
+  }
+  postProcessJSONNode(_schema, _parentSchema) {
+  }
   defaultZodObjectHandler(value, options = { passthrough: true }) {
     if ("_zod" in value) {
       return this.v4Layer.defaultZodObjectHandler(value, options);
@@ -4581,31 +4665,12 @@ var SchemaCompatLayer3 = class {
       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
       );
@@ -4652,65 +4717,285 @@ var SchemaCompatLayer3 = class {
     }
   }
   defaultZodOptionalHandler(value, handleTypes) {
+    if (!handleTypes) {
+      handleTypes = ["ZodObject", "ZodArray", "ZodUnion", "ZodString", "ZodNumber"];
+    }
+    let innerTypeName;
     if ("_zod" in value) {
-      return this.v4Layer.defaultZodOptionalHandler(value, handleTypes ?? SUPPORTED_ZOD_TYPES2);
+      const innerType = value._zod?.def?.innerType;
+      const v4Type = innerType?._zod?.def?.type;
+      if (!v4Type) {
+        return value;
+      }
+      innerTypeName = "Zod" + v4Type.charAt(0).toUpperCase() + v4Type.slice(1);
+    } else {
+      innerTypeName = value._def.innerType._def.typeName;
+    }
+    if (handleTypes.includes(innerTypeName)) {
+      if ("_zod" in value) {
+        const innerType = value._zod?.def?.innerType;
+        if (!innerType) {
+          return value;
+        }
+        return this.processZodType(innerType).optional();
+      } else {
+        return this.processZodType(value._def.innerType).optional();
+      }
     } else {
-      return this.v3Layer.defaultZodOptionalHandler(value, handleTypes ?? SUPPORTED_ZOD_TYPES);
+      return value;
+    }
+  }
+  defaultZodNullableHandler(value, handleTypes) {
+    if ("_zod" in value) {
+      return this.v4Layer.defaultZodNullableHandler(
+        value,
+        handleTypes ?? SUPPORTED_ZOD_TYPES2
+      );
+    } else {
+      return this.v3Layer.defaultZodNullableHandler(
+        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(zodSchema2) {
     const processedSchema = this.processZodType(zodSchema2);
     return convertZodSchemaToAISDKSchema(processedSchema, this.getSchemaTarget());
   }
+  processToJSONSchema(zodSchema2, io = "input") {
+    const standardSchema = chunkDAVEUCUM_cjs.toStandardSchema(zodSchema2);
+    return chunkDAVEUCUM_cjs.standardSchemaToJSONSchema(standardSchema, {
+      target: "draft-07",
+      io
+      // Use input mode so fields with defaults are optional
+    });
+  }
+  // ==========================================
+  // JSON Schema Default Handlers
+  // ==========================================
   /**
-   * Processes a Zod object schema and converts it to a JSON Schema.
+   * Default handler for JSON Schema objects.
+   * Processes object schemas with properties and required fields.
+   */
+  defaultObjectHandler(schema) {
+    if (schema.properties && schema.additionalProperties === void 0) {
+      schema.additionalProperties = false;
+    }
+    return schema;
+  }
+  /**
+   * Default handler for JSON Schema arrays.
+   * Converts array constraints (minItems, maxItems) to description text.
+   */
+  defaultArrayHandler(schema) {
+    let constraints = [];
+    const minItems = schema.minItems;
+    const maxItems = schema.maxItems;
+    if (minItems !== void 0 && maxItems !== void 0 && minItems === maxItems) {
+      constraints = [`exact length ${minItems}`];
+      delete schema.minItems;
+      delete schema.maxItems;
+    } else {
+      if (minItems !== void 0) {
+        constraints.push(`minimum length ${minItems}`);
+        delete schema.minItems;
+      }
+      if (maxItems !== void 0) {
+        constraints.push(`maximum length ${maxItems}`);
+        delete schema.maxItems;
+      }
+    }
+    if (constraints.length) {
+      schema.description = this.mergeParameterDescription(schema.description, constraints);
+    }
+    return schema;
+  }
+  /**
+   * Default handler for JSON Schema strings.
+   * Converts string constraints (minLength, maxLength, pattern, format) to description text.
+   */
+  defaultStringHandler(schema) {
+    const constraints = [];
+    if (schema.minLength !== void 0) {
+      constraints.push(`minimum length ${schema.minLength}`);
+      delete schema.minLength;
+    }
+    if (schema.maxLength !== void 0) {
+      constraints.push(`maximum length ${schema.maxLength}`);
+      delete schema.maxLength;
+    }
+    if (schema.pattern !== void 0) {
+      delete schema.pattern;
+    }
+    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) {
+      schema.description = this.mergeParameterDescription(schema.description, constraints);
+    }
+    return schema;
+  }
+  /**
+   * Default handler for JSON Schema numbers/integers.
+   * Converts number constraints (minimum, maximum, multipleOf, exclusiveMinimum, exclusiveMaximum) to description text.
+   */
+  defaultNumberHandler(schema) {
+    const constraints = [];
+    if (schema.minimum !== void 0) {
+      if (schema.minimum !== Number.MIN_SAFE_INTEGER) {
+        constraints.push(`greater than or equal to ${schema.minimum}`);
+      }
+      delete schema.minimum;
+    }
+    if (schema.maximum !== void 0) {
+      if (schema.maximum !== Number.MAX_SAFE_INTEGER) {
+        constraints.push(`lower than or equal to ${schema.maximum}`);
+      }
+      delete schema.maximum;
+    }
+    if (schema.exclusiveMinimum !== void 0) {
+      constraints.push(`greater than ${schema.exclusiveMinimum}`);
+      delete schema.exclusiveMinimum;
+    }
+    if (schema.exclusiveMaximum !== void 0) {
+      constraints.push(`lower than ${schema.exclusiveMaximum}`);
+      delete schema.exclusiveMaximum;
+    }
+    if (schema.multipleOf !== void 0) {
+      constraints.push(`multiple of ${schema.multipleOf}`);
+      delete schema.multipleOf;
+    }
+    if (constraints.length) {
+      schema.description = this.mergeParameterDescription(schema.description, constraints);
+    }
+    return schema;
+  }
+  /**
+   * Default handler for JSON Schema unions (anyOf/oneOf).
+   * 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;
+      }
+    }
+    return schema;
+  }
+  /**
+   * Default handler for JSON Schema nullable types.
+   * Ensures nullable types are represented correctly.
+   */
+  defaultNullableHandler(schema) {
+    return this.defaultUnionHandler(schema);
+  }
+  /**
+   * Default handler for JSON Schema dates (string with date/date-time format).
+   * Converts date formats to string type with format constraint in description.
+   */
+  defaultDateHandler(schema) {
+    if (schema.format === "date" || schema.format === "date-time") {
+      const format = schema.format;
+      delete schema.format;
+      schema.description = this.mergeParameterDescription(schema.description, [`format: ${format}`]);
+    }
+    return schema;
+  }
+  /**
+   * Default handler for empty JSON schemas.
+   * Converts empty {} schemas to a union of primitive types.
+   */
+  defaultEmptySchemaHandler(schema) {
+    if (Object.keys(schema).length === 0) {
+      schema.type = ["string", "number", "boolean", "null"];
+    }
+    return schema;
+  }
+  /**
+   * Default handler for unsupported JSON Schema features.
+   * Can be used to strip or convert unsupported keywords.
+   */
+  defaultUnsupportedHandler(schema, unsupportedKeywords = []) {
+    for (const keyword of unsupportedKeywords) {
+      if (keyword in schema) {
+        delete schema[keyword];
+      }
+    }
+    return schema;
+  }
+  // ==========================================
+  // JSON Schema Type Checkers (delegating to json-schema/utils)
+  // ==========================================
+  isObjectSchema(schema) {
+    return isObjectSchema(schema);
+  }
+  isArraySchema(schema) {
+    return isArraySchema(schema);
+  }
+  isStringSchema(schema) {
+    return isStringSchema(schema);
+  }
+  isNumberSchema(schema) {
+    return isNumberSchema(schema);
+  }
+  isUnionSchema(schema) {
+    return isUnionSchema(schema);
+  }
+  /**
+   * Checks if a property is optional within a parent object schema.
+   * A property is optional if it's not in the parent's `required` array.
+   * @param propertyName - The name of the property to check
+   * @param parentSchema - The parent object schema containing the property
+   */
+  isOptionalProperty(propertyName, parentSchema) {
+    return isOptionalSchema(propertyName, parentSchema);
+  }
+  /**
+   * Converts a Zod schema to JSON Schema using the standard-schema interface
+   * and applies pre/post processing via traverse.
    *
-   * @param zodSchema - The Zod object schema to process
-   * @returns A JSONSchema7 object with provider-specific compatibility applied
+   * Uses 'input' io mode so that fields with defaults are optional (appropriate for tool parameters).
    */
-  processToJSONSchema(zodSchema2) {
-    return this.processToAISDKSchema(zodSchema2).jsonSchema;
+  toJSONSchema(zodSchema2) {
+    const target = "draft-07";
+    const standardSchema = chunkDAVEUCUM_cjs.toStandardSchema(zodSchema2);
+    const jsonSchema2 = chunkDAVEUCUM_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);
+        },
+        post: (schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema) => {
+          this.postProcessJSONNode(schema, parentSchema);
+        }
+      }
+    });
+    return jsonSchema2;
   }
 };
 
-// src/zodTypes.ts
-function isOptional2(z11) {
-  return (v) => v instanceof z11["ZodOptional"];
-}
-function isObj2(z11) {
-  return (v) => v instanceof z11["ZodObject"];
-}
-function isNull(z11) {
-  return (v) => v instanceof z11["ZodNull"];
-}
-function isArr2(z11) {
-  return (v) => v instanceof z11["ZodArray"];
-}
-function isUnion2(z11) {
-  return (v) => v instanceof z11["ZodUnion"];
-}
-function isString2(z11) {
-  return (v) => v instanceof z11["ZodString"];
-}
-function isNumber2(z11) {
-  return (v) => v instanceof z11["ZodNumber"];
-}
-function isDate(z11) {
-  return (v) => v instanceof z11["ZodDate"];
-}
-function isDefault(z11) {
-  return (v) => v instanceof z11["ZodDefault"];
-}
-function isNullable(z11) {
-  return (v) => v instanceof z11["ZodNullable"];
-}
-
 // src/provider-compats/anthropic.ts
 var AnthropicSchemaCompatLayer = class extends SchemaCompatLayer3 {
   constructor(model) {
@@ -4723,37 +5008,82 @@ var AnthropicSchemaCompatLayer = class extends SchemaCompatLayer3 {
     return this.getModel().modelId.includes("claude");
   }
   processZodType(value) {
-    if (isOptional2(zod.z)(value)) {
-      const handleTypes = [
-        "ZodObject",
-        "ZodArray",
-        "ZodUnion",
-        "ZodNever",
-        "ZodUndefined",
-        "ZodTuple"
-      ];
+    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 (isObj2(zod.z)(value)) {
+    } else if (this.isObj(value)) {
       return this.defaultZodObjectHandler(value);
-    } else if (isArr2(zod.z)(value)) {
+    } else if (this.isArr(value)) {
       return this.defaultZodArrayHandler(value, []);
-    } else if (isUnion2(zod.z)(value)) {
+    } else if (this.isUnion(value)) {
       return this.defaultZodUnionHandler(value);
-    } else if (isString2(zod.z)(value)) {
+    } else if (this.isString(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);
+  }
+  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);
+    }
+    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;
+      }
+    }
   }
 };
+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"];
+}
+function isNullable(z10) {
+  return (v) => v instanceof z10["ZodNullable"];
+}
+
+// src/provider-compats/deepseek.ts
 var DeepSeekSchemaCompatLayer = class extends SchemaCompatLayer3 {
   constructor(model) {
     super(model);
@@ -4778,6 +5108,28 @@ var DeepSeekSchemaCompatLayer = class extends SchemaCompatLayer3 {
     }
     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);
+    }
+  }
+  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 = true;
+      }
+      if ("propertyNames" in schema) {
+        delete schema.propertyNames;
+      }
+    }
+  }
 };
 var GoogleSchemaCompatLayer = class extends SchemaCompatLayer3 {
   constructor(model) {
@@ -4807,6 +5159,30 @@ var GoogleSchemaCompatLayer = class extends SchemaCompatLayer3 {
     }
     return this.defaultUnsupportedZodTypeHandler(value);
   }
+  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);
+    }
+  }
+  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 = true;
+      }
+      if ("propertyNames" in schema) {
+        delete schema.propertyNames;
+      }
+    }
+  }
 };
 var MetaSchemaCompatLayer = class extends SchemaCompatLayer3 {
   constructor(model) {
@@ -4834,6 +5210,30 @@ var MetaSchemaCompatLayer = class extends SchemaCompatLayer3 {
     }
     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);
+    } else if (isNumberSchema(schema)) {
+      this.defaultNumberHandler(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 = true;
+      }
+      if ("propertyNames" in schema) {
+        delete schema.propertyNames;
+      }
+    }
+  }
 };
 var OpenAISchemaCompatLayer = class extends SchemaCompatLayer3 {
   constructor(model) {
@@ -4915,6 +5315,40 @@ var OpenAISchemaCompatLayer = class extends SchemaCompatLayer3 {
     const jsonSchema2 = super.processToJSONSchema(zodSchema2);
     return this.fixAdditionalProperties(jsonSchema2);
   }
+  preProcessJSONNode(schema, _parentSchema) {
+    if (isObjectSchema(schema)) {
+      this.defaultObjectHandler(schema);
+    } 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;
+        }
+      }
+    }
+  }
+  postProcessJSONNode(schema) {
+    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 = true;
+      }
+      if ("propertyNames" in schema) {
+        delete schema.propertyNames;
+      }
+    }
+  }
   /**
    * Recursively fixes additionalProperties: {} to additionalProperties: true.
    * OpenAI requires additionalProperties to be either:
@@ -5028,6 +5462,30 @@ Argument was an "any" type, but you (the LLM) do not support "any", so it was ca
     }
     return this.defaultUnsupportedZodTypeHandler(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);
+    }
+  }
+  postProcessJSONNode(schema) {
+    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;
+      }
+      if ("propertyNames" in schema) {
+        delete schema.propertyNames;
+      }
+    }
+  }
 };
 
 exports.ALL_ARRAY_CHECKS = ALL_ARRAY_CHECKS;