@mastra/schema-compat 0.10.2-alpha.2 → 0.10.2

package/dist/index.cjs

@@ -45,18 +45,9 @@ function applyCompatLayer({
 }) {
   let zodSchema;
   if (!isZodType(schema)) {
-    const convertedSchema = convertSchemaToZod(schema);
-    if (convertedSchema instanceof zod.z.ZodObject) {
-      zodSchema = convertedSchema;
-    } else {
-      zodSchema = zod.z.object({ value: convertedSchema });
-    }
+    zodSchema = convertSchemaToZod(schema);
   } else {
-    if (schema instanceof zod.z.ZodObject) {
-      zodSchema = schema;
-    } else {
-      zodSchema = zod.z.object({ value: schema });
-    }
+    zodSchema = schema;
   }
   for (const compat of compatLayers) {
     if (compat.shouldApply()) {
@@ -80,6 +71,14 @@ 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 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",
@@ -110,25 +109,6 @@ var SchemaCompatLayer = class {
   getModel() {
     return this.model;
   }
-  /**
-   * Applies compatibility transformations to a Zod object schema.
-   *
-   * @param zodSchema - The Zod object schema to transform
-   * @returns Object containing the transformed schema
-   * @private
-   */
-  applyZodSchemaCompatibility(zodSchema) {
-    const newSchema = zod.z.object(
-      Object.entries(zodSchema.shape || {}).reduce(
-        (acc, [key, value]) => ({
-          ...acc,
-          [key]: this.processZodType(value)
-        }),
-        {}
-      )
-    );
-    return { schema: newSchema };
-  }
   /**
    * Default handler for Zod object types. Recursively processes all properties in the object.
    *
@@ -136,17 +116,17 @@ var SchemaCompatLayer = class {
    * @returns The processed Zod object
    */
   defaultZodObjectHandler(value) {
-    const zodObject = value;
-    const processedShape = Object.entries(zodObject.shape || {}).reduce(
-      (acc, [key, propValue]) => {
-        const typedPropValue = propValue;
-        const processedValue = this.processZodType(typedPropValue);
-        acc[key] = processedValue;
-        return acc;
-      },
-      {}
-    );
+    const processedShape = Object.entries(value.shape).reduce((acc, [key, propValue]) => {
+      acc[key] = this.processZodType(propValue);
+      return acc;
+    }, {});
     let result = zod.z.object(processedShape);
+    if (value._def.unknownKeys === "strict") {
+      result = result.strict();
+    }
+    if (value._def.catchall && !(value._def.catchall instanceof zod.z.ZodNever)) {
+      result = result.catchall(value._def.catchall);
+    }
     if (value.description) {
       result = result.describe(value.description);
     }
@@ -191,28 +171,30 @@ var SchemaCompatLayer = class {
    * @returns The processed Zod array
    */
   defaultZodArrayHandler(value, handleChecks = ALL_ARRAY_CHECKS) {
-    const zodArray = value._def;
-    const arrayType = zodArray.type;
-    const constraints = {};
-    if (zodArray.minLength?.value !== void 0 && handleChecks.includes("min")) {
-      constraints.minLength = zodArray.minLength.value;
-    }
-    if (zodArray.maxLength?.value !== void 0 && handleChecks.includes("max")) {
-      constraints.maxLength = zodArray.maxLength.value;
-    }
-    if (zodArray.exactLength?.value !== void 0 && handleChecks.includes("length")) {
-      constraints.exactLength = zodArray.exactLength.value;
-    }
-    const processedType = arrayType._def.typeName === "ZodObject" ? this.processZodType(arrayType) : arrayType;
+    const zodArrayDef = value._def;
+    const processedType = this.processZodType(zodArrayDef.type);
     let result = zod.z.array(processedType);
-    if (zodArray.minLength?.value !== void 0 && !handleChecks.includes("min")) {
-      result = result.min(zodArray.minLength.value);
+    const constraints = {};
+    if (zodArrayDef.minLength?.value !== void 0) {
+      if (handleChecks.includes("min")) {
+        constraints.minLength = zodArrayDef.minLength.value;
+      } else {
+        result = result.min(zodArrayDef.minLength.value);
+      }
     }
-    if (zodArray.maxLength?.value !== void 0 && !handleChecks.includes("max")) {
-      result = result.max(zodArray.maxLength.value);
+    if (zodArrayDef.maxLength?.value !== void 0) {
+      if (handleChecks.includes("max")) {
+        constraints.maxLength = zodArrayDef.maxLength.value;
+      } else {
+        result = result.max(zodArrayDef.maxLength.value);
+      }
     }
-    if (zodArray.exactLength?.value !== void 0 && !handleChecks.includes("length")) {
-      result = result.length(zodArray.exactLength.value);
+    if (zodArrayDef.exactLength?.value !== void 0) {
+      if (handleChecks.includes("length")) {
+        constraints.exactLength = zodArrayDef.exactLength.value;
+      } else {
+        result = result.length(zodArrayDef.exactLength.value);
+      }
     }
     const description = this.mergeParameterDescription(value.description, constraints);
     if (description) {
@@ -228,8 +210,7 @@ var SchemaCompatLayer = class {
    * @throws Error if union has fewer than 2 options
    */
   defaultZodUnionHandler(value) {
-    const zodUnion = value;
-    const processedOptions = zodUnion._def.options.map((option) => this.processZodType(option));
+    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);
     if (value.description) {
@@ -245,9 +226,8 @@ var SchemaCompatLayer = class {
    * @returns The processed Zod string
    */
   defaultZodStringHandler(value, handleChecks = ALL_STRING_CHECKS) {
-    const zodString = value;
     const constraints = {};
-    const checks = zodString._def.checks || [];
+    const checks = value._def.checks || [];
     const newChecks = [];
     for (const check of checks) {
       if ("kind" in check) {
@@ -312,9 +292,8 @@ var SchemaCompatLayer = class {
    * @returns The processed Zod number
    */
   defaultZodNumberHandler(value, handleChecks = ALL_NUMBER_CHECKS) {
-    const zodNumber = value;
     const constraints = {};
-    const checks = zodNumber._def.checks || [];
+    const checks = value._def.checks || [];
     const newChecks = [];
     for (const check of checks) {
       if ("kind" in check) {
@@ -370,9 +349,8 @@ var SchemaCompatLayer = class {
    * @returns A Zod string schema representing the date in ISO format
    */
   defaultZodDateHandler(value) {
-    const zodDate = value;
     const constraints = {};
-    const checks = zodDate._def.checks || [];
+    const checks = value._def.checks || [];
     for (const check of checks) {
       if ("kind" in check) {
         switch (check.kind) {
@@ -420,8 +398,8 @@ var SchemaCompatLayer = class {
    * @returns An AI SDK Schema with provider-specific compatibility applied
    */
   processToAISDKSchema(zodSchema) {
-    const { schema } = this.applyZodSchemaCompatibility(zodSchema);
-    return convertZodSchemaToAISDKSchema(schema, this.getSchemaTarget());
+    const processedSchema = this.processZodType(zodSchema);
+    return convertZodSchemaToAISDKSchema(processedSchema, this.getSchemaTarget());
   }
   /**
    * Processes a Zod object schema and converts it to a JSON Schema.
@@ -446,36 +424,28 @@ var AnthropicSchemaCompatLayer = class extends SchemaCompatLayer {
     return this.getModel().modelId.includes("claude");
   }
   processZodType(value) {
-    switch (value._def.typeName) {
-      case "ZodOptional":
-        const handleTypes = ["ZodObject", "ZodArray", "ZodUnion", "ZodNever", "ZodUndefined"];
-        if (this.getModel().modelId.includes("claude-3.5-haiku")) handleTypes.push("ZodString");
-        if (this.getModel().modelId.includes("claude-3.7")) handleTypes.push("ZodTuple");
-        return this.defaultZodOptionalHandler(value, handleTypes);
-      case "ZodObject": {
-        return this.defaultZodObjectHandler(value);
-      }
-      case "ZodArray": {
-        return this.defaultZodArrayHandler(value, []);
-      }
-      case "ZodUnion": {
-        return this.defaultZodUnionHandler(value);
-      }
-      // the claude-3.5-haiku model support these properties but the model doesn't respect them, but it respects them when they're
-      // added to the tool description
-      case "ZodString": {
-        if (this.getModel().modelId.includes("claude-3.5-haiku")) {
-          return this.defaultZodStringHandler(value, ["max", "min"]);
-        } else {
-          return value;
-        }
+    if (isOptional(value)) {
+      const handleTypes = ["ZodObject", "ZodArray", "ZodUnion", "ZodNever", "ZodUndefined"];
+      if (this.getModel().modelId.includes("claude-3.5-haiku")) handleTypes.push("ZodString");
+      if (this.getModel().modelId.includes("claude-3.7")) handleTypes.push("ZodTuple");
+      return this.defaultZodOptionalHandler(value, handleTypes);
+    } else if (isObj(value)) {
+      return this.defaultZodObjectHandler(value);
+    } else if (isArr(value)) {
+      return this.defaultZodArrayHandler(value, []);
+    } else if (isUnion(value)) {
+      return this.defaultZodUnionHandler(value);
+    } else if (isString(value)) {
+      if (this.getModel().modelId.includes("claude-3.5-haiku")) {
+        return this.defaultZodStringHandler(value, ["max", "min"]);
+      } else {
+        return value;
       }
-      default:
-        if (this.getModel().modelId.includes("claude-3.7")) {
-          return this.defaultUnsupportedZodTypeHandler(value, ["ZodNever", "ZodTuple", "ZodUndefined"]);
-        } else {
-          return this.defaultUnsupportedZodTypeHandler(value, ["ZodNever", "ZodUndefined"]);
-        }
+    }
+    if (this.getModel().modelId.includes("claude-3.7")) {
+      return this.defaultUnsupportedZodTypeHandler(value, ["ZodNever", "ZodTuple", "ZodUndefined"]);
+    } else {
+      return this.defaultUnsupportedZodTypeHandler(value, ["ZodNever", "ZodUndefined"]);
     }
   }
 };
@@ -492,24 +462,18 @@ var DeepSeekSchemaCompatLayer = class extends SchemaCompatLayer {
     return this.getModel().modelId.includes("deepseek") && !this.getModel().modelId.includes("r1");
   }
   processZodType(value) {
-    switch (value._def.typeName) {
-      case "ZodOptional":
-        return this.defaultZodOptionalHandler(value, ["ZodObject", "ZodArray", "ZodUnion", "ZodString", "ZodNumber"]);
-      case "ZodObject": {
-        return this.defaultZodObjectHandler(value);
-      }
-      case "ZodArray": {
-        return this.defaultZodArrayHandler(value, ["min", "max"]);
-      }
-      case "ZodUnion": {
-        return this.defaultZodUnionHandler(value);
-      }
-      case "ZodString": {
-        return this.defaultZodStringHandler(value);
-      }
-      default:
-        return value;
+    if (isOptional(value)) {
+      return this.defaultZodOptionalHandler(value, ["ZodObject", "ZodArray", "ZodUnion", "ZodString", "ZodNumber"]);
+    } else if (isObj(value)) {
+      return this.defaultZodObjectHandler(value);
+    } else if (isArr(value)) {
+      return this.defaultZodArrayHandler(value, ["min", "max"]);
+    } else if (isUnion(value)) {
+      return this.defaultZodUnionHandler(value);
+    } else if (isString(value)) {
+      return this.defaultZodStringHandler(value);
     }
+    return value;
   }
 };
 
@@ -525,36 +489,27 @@ var GoogleSchemaCompatLayer = class extends SchemaCompatLayer {
     return this.getModel().provider.includes("google") || this.getModel().modelId.includes("google");
   }
   processZodType(value) {
-    switch (value._def.typeName) {
-      case "ZodOptional":
-        return this.defaultZodOptionalHandler(value, [
-          "ZodObject",
-          "ZodArray",
-          "ZodUnion",
-          "ZodString",
-          "ZodNumber",
-          ...UNSUPPORTED_ZOD_TYPES
-        ]);
-      case "ZodObject": {
-        return this.defaultZodObjectHandler(value);
-      }
-      case "ZodArray": {
-        return this.defaultZodArrayHandler(value, []);
-      }
-      case "ZodUnion": {
-        return this.defaultZodUnionHandler(value);
-      }
-      // Google models support these properties but the model doesn't respect them, but it respects them when they're
-      // added to the tool description
-      case "ZodString": {
-        return this.defaultZodStringHandler(value);
-      }
-      case "ZodNumber": {
-        return this.defaultZodNumberHandler(value);
-      }
-      default:
-        return this.defaultUnsupportedZodTypeHandler(value);
-    }
+    if (isOptional(value)) {
+      return this.defaultZodOptionalHandler(value, [
+        "ZodObject",
+        "ZodArray",
+        "ZodUnion",
+        "ZodString",
+        "ZodNumber",
+        ...UNSUPPORTED_ZOD_TYPES
+      ]);
+    } else if (isObj(value)) {
+      return this.defaultZodObjectHandler(value);
+    } else if (isArr(value)) {
+      return this.defaultZodArrayHandler(value, []);
+    } else if (isUnion(value)) {
+      return this.defaultZodUnionHandler(value);
+    } else if (isString(value)) {
+      return this.defaultZodStringHandler(value);
+    } else if (isNumber(value)) {
+      return this.defaultZodNumberHandler(value);
+    }
+    return this.defaultUnsupportedZodTypeHandler(value);
   }
 };
 
@@ -570,27 +525,20 @@ var MetaSchemaCompatLayer = class extends SchemaCompatLayer {
     return this.getModel().modelId.includes("meta");
   }
   processZodType(value) {
-    switch (value._def.typeName) {
-      case "ZodOptional":
-        return this.defaultZodOptionalHandler(value, ["ZodObject", "ZodArray", "ZodUnion", "ZodString", "ZodNumber"]);
-      case "ZodObject": {
-        return this.defaultZodObjectHandler(value);
-      }
-      case "ZodArray": {
-        return this.defaultZodArrayHandler(value, ["min", "max"]);
-      }
-      case "ZodUnion": {
-        return this.defaultZodUnionHandler(value);
-      }
-      case "ZodNumber": {
-        return this.defaultZodNumberHandler(value);
-      }
-      case "ZodString": {
-        return this.defaultZodStringHandler(value);
-      }
-      default:
-        return value;
+    if (isOptional(value)) {
+      return this.defaultZodOptionalHandler(value, ["ZodObject", "ZodArray", "ZodUnion", "ZodString", "ZodNumber"]);
+    } else if (isObj(value)) {
+      return this.defaultZodObjectHandler(value);
+    } else if (isArr(value)) {
+      return this.defaultZodArrayHandler(value, ["min", "max"]);
+    } else if (isUnion(value)) {
+      return this.defaultZodUnionHandler(value);
+    } else if (isNumber(value)) {
+      return this.defaultZodNumberHandler(value);
+    } else if (isString(value)) {
+      return this.defaultZodStringHandler(value);
     }
+    return value;
   }
 };
 
@@ -609,37 +557,31 @@ var OpenAISchemaCompatLayer = class extends SchemaCompatLayer {
     return false;
   }
   processZodType(value) {
-    switch (value._def.typeName) {
-      case "ZodOptional":
-        return this.defaultZodOptionalHandler(value, [
-          "ZodObject",
-          "ZodArray",
-          "ZodUnion",
-          "ZodString",
-          "ZodNever",
-          "ZodUndefined",
-          "ZodTuple"
-        ]);
-      case "ZodObject": {
-        return this.defaultZodObjectHandler(value);
-      }
-      case "ZodUnion": {
-        return this.defaultZodUnionHandler(value);
-      }
-      case "ZodArray": {
-        return this.defaultZodArrayHandler(value);
-      }
-      case "ZodString": {
-        const model = this.getModel();
-        const checks = ["emoji"];
-        if (model.modelId.includes("gpt-4o-mini")) {
-          checks.push("regex");
-        }
-        return this.defaultZodStringHandler(value, checks);
-      }
-      default:
-        return this.defaultUnsupportedZodTypeHandler(value, ["ZodNever", "ZodUndefined", "ZodTuple"]);
-    }
+    if (isOptional(value)) {
+      return this.defaultZodOptionalHandler(value, [
+        "ZodObject",
+        "ZodArray",
+        "ZodUnion",
+        "ZodString",
+        "ZodNever",
+        "ZodUndefined",
+        "ZodTuple"
+      ]);
+    } else if (isObj(value)) {
+      return this.defaultZodObjectHandler(value);
+    } else if (isUnion(value)) {
+      return this.defaultZodUnionHandler(value);
+    } else if (isArr(value)) {
+      return this.defaultZodArrayHandler(value);
+    } else if (isString(value)) {
+      const model = this.getModel();
+      const checks = ["emoji"];
+      if (model.modelId.includes("gpt-4o-mini")) {
+        checks.push("regex");
+      }
+      return this.defaultZodStringHandler(value, checks);
+    }
+    return this.defaultUnsupportedZodTypeHandler(value, ["ZodNever", "ZodUndefined", "ZodTuple"]);
   }
 };
 var OpenAIReasoningSchemaCompatLayer = class extends SchemaCompatLayer {
@@ -659,52 +601,42 @@ var OpenAIReasoningSchemaCompatLayer = class extends SchemaCompatLayer {
     return false;
   }
   processZodType(value) {
-    switch (value._def.typeName) {
-      case "ZodOptional":
-        const innerZodType = this.processZodType(value._def.innerType);
-        return innerZodType.nullable();
-      case "ZodObject": {
-        return this.defaultZodObjectHandler(value);
-      }
-      case "ZodArray": {
-        return this.defaultZodArrayHandler(value);
-      }
-      case "ZodUnion": {
-        return this.defaultZodUnionHandler(value);
-      }
-      case "ZodDefault": {
-        const defaultDef = value._def;
-        const innerType = defaultDef.innerType;
-        const defaultValue = defaultDef.defaultValue();
-        const constraints = {};
-        if (defaultValue !== void 0) {
-          constraints.defaultValue = defaultValue;
-        }
-        const description = this.mergeParameterDescription(value.description, constraints);
-        let result = this.processZodType(innerType);
-        if (description) {
-          result = result.describe(description);
-        }
-        return result;
-      }
-      case "ZodNumber": {
-        return this.defaultZodNumberHandler(value);
-      }
-      case "ZodString": {
-        return this.defaultZodStringHandler(value);
-      }
-      case "ZodDate": {
-        return this.defaultZodDateHandler(value);
-      }
-      case "ZodAny": {
-        return zod.z.string().describe(
-          (value.description ?? "") + `
+    if (isOptional(value)) {
+      const innerZodType = this.processZodType(value._def.innerType);
+      return innerZodType.nullable();
+    } else if (isObj(value)) {
+      return this.defaultZodObjectHandler(value);
+    } else if (isArr(value)) {
+      return this.defaultZodArrayHandler(value);
+    } else if (isUnion(value)) {
+      return this.defaultZodUnionHandler(value);
+    } else if (isDefault(value)) {
+      const defaultDef = value._def;
+      const innerType = defaultDef.innerType;
+      const defaultValue = defaultDef.defaultValue();
+      const constraints = {};
+      if (defaultValue !== void 0) {
+        constraints.defaultValue = defaultValue;
+      }
+      const description = this.mergeParameterDescription(value.description, constraints);
+      let result = this.processZodType(innerType);
+      if (description) {
+        result = result.describe(description);
+      }
+      return result;
+    } else if (isNumber(value)) {
+      return this.defaultZodNumberHandler(value);
+    } else if (isString(value)) {
+      return this.defaultZodStringHandler(value);
+    } else if (isDate(value)) {
+      return this.defaultZodDateHandler(value);
+    } else if (value._def.typeName === "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`
-        );
-      }
-      default:
-        return this.defaultUnsupportedZodTypeHandler(value);
+      );
     }
+    return this.defaultUnsupportedZodTypeHandler(value);
   }
 };
 
@@ -724,3 +656,9 @@ exports.UNSUPPORTED_ZOD_TYPES = UNSUPPORTED_ZOD_TYPES;
 exports.applyCompatLayer = applyCompatLayer;
 exports.convertSchemaToZod = convertSchemaToZod;
 exports.convertZodSchemaToAISDKSchema = convertZodSchemaToAISDKSchema;
+exports.isArr = isArr;
+exports.isNumber = isNumber;
+exports.isObj = isObj;
+exports.isOptional = isOptional;
+exports.isString = isString;
+exports.isUnion = isUnion;

package/dist/index.d.cts

@@ -14,6 +14,12 @@ export { AllZodType } from './_tsup-dts-rollup.cjs';
 export { ZodShape } from './_tsup-dts-rollup.cjs';
 export { ShapeKey } from './_tsup-dts-rollup.cjs';
 export { ShapeValue } from './_tsup-dts-rollup.cjs';
+export { isOptional } from './_tsup-dts-rollup.cjs';
+export { isObj } from './_tsup-dts-rollup.cjs';
+export { isArr } from './_tsup-dts-rollup.cjs';
+export { isUnion } from './_tsup-dts-rollup.cjs';
+export { isString } from './_tsup-dts-rollup.cjs';
+export { isNumber } from './_tsup-dts-rollup.cjs';
 export { convertZodSchemaToAISDKSchema } from './_tsup-dts-rollup.cjs';
 export { applyCompatLayer } from './_tsup-dts-rollup.cjs';
 export { convertSchemaToZod } from './_tsup-dts-rollup.cjs';

package/dist/index.d.ts

@@ -14,6 +14,12 @@ export { AllZodType } from './_tsup-dts-rollup.js';
 export { ZodShape } from './_tsup-dts-rollup.js';
 export { ShapeKey } from './_tsup-dts-rollup.js';
 export { ShapeValue } from './_tsup-dts-rollup.js';
+export { isOptional } from './_tsup-dts-rollup.js';
+export { isObj } from './_tsup-dts-rollup.js';
+export { isArr } from './_tsup-dts-rollup.js';
+export { isUnion } from './_tsup-dts-rollup.js';
+export { isString } from './_tsup-dts-rollup.js';
+export { isNumber } from './_tsup-dts-rollup.js';
 export { convertZodSchemaToAISDKSchema } from './_tsup-dts-rollup.js';
 export { applyCompatLayer } from './_tsup-dts-rollup.js';
 export { convertSchemaToZod } from './_tsup-dts-rollup.js';