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

package/dist/index.js

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import { ZodOptional, ZodObject, ZodArray, ZodUnion, ZodString, ZodNumber, z, ZodDefault, ZodDate } from 'zod';
 import { jsonSchema } from 'ai';
 import { convertJsonSchemaToZod } from 'zod-from-json-schema';
 import { zodToJsonSchema } from 'zod-to-json-schema';
@@ -43,18 +43,9 @@ function applyCompatLayer({
 }) {
   let zodSchema;
   if (!isZodType(schema)) {
-    const convertedSchema = convertSchemaToZod(schema);
-    if (convertedSchema instanceof z.ZodObject) {
-      zodSchema = convertedSchema;
-    } else {
-      zodSchema = z.object({ value: convertedSchema });
-    }
+    zodSchema = convertSchemaToZod(schema);
   } else {
-    if (schema instanceof z.ZodObject) {
-      zodSchema = schema;
-    } else {
-      zodSchema = z.object({ value: schema });
-    }
+    zodSchema = schema;
   }
   for (const compat of compatLayers) {
     if (compat.shouldApply()) {
@@ -78,6 +69,14 @@ var ALL_NUMBER_CHECKS = [
   "multipleOf"
 ];
 var ALL_ARRAY_CHECKS = ["min", "max", "length"];
+var isOptional = (v) => v instanceof ZodOptional;
+var isObj = (v) => v instanceof ZodObject;
+var isArr = (v) => v instanceof ZodArray;
+var isUnion = (v) => v instanceof ZodUnion;
+var isString = (v) => v instanceof ZodString;
+var isNumber = (v) => v instanceof ZodNumber;
+var isDate = (v) => v instanceof ZodDate;
+var isDefault = (v) => v instanceof ZodDefault;
 var UNSUPPORTED_ZOD_TYPES = ["ZodIntersection", "ZodNever", "ZodNull", "ZodTuple", "ZodUndefined"];
 var SUPPORTED_ZOD_TYPES = [
   "ZodObject",
@@ -108,25 +107,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 = 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.
    *
@@ -134,17 +114,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 = z.object(processedShape);
+    if (value._def.unknownKeys === "strict") {
+      result = result.strict();
+    }
+    if (value._def.catchall && !(value._def.catchall instanceof z.ZodNever)) {
+      result = result.catchall(value._def.catchall);
+    }
     if (value.description) {
       result = result.describe(value.description);
     }
@@ -189,28 +169,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 = 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) {
@@ -226,8 +208,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 = z.union(processedOptions);
     if (value.description) {
@@ -243,9 +224,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) {
@@ -310,9 +290,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) {
@@ -368,9 +347,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) {
@@ -418,8 +396,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.
@@ -444,36 +422,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"]);
     }
   }
 };
@@ -490,24 +460,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;
   }
 };
 
@@ -523,36 +487,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);
   }
 };
 
@@ -568,27 +523,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;
   }
 };
 
@@ -607,37 +555,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 {
@@ -657,53 +599,43 @@ 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 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 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);
   }
 };
 
-export { ALL_ARRAY_CHECKS, ALL_NUMBER_CHECKS, ALL_STRING_CHECKS, ALL_ZOD_TYPES, AnthropicSchemaCompatLayer, DeepSeekSchemaCompatLayer, GoogleSchemaCompatLayer, MetaSchemaCompatLayer, OpenAIReasoningSchemaCompatLayer, OpenAISchemaCompatLayer, SUPPORTED_ZOD_TYPES, SchemaCompatLayer, UNSUPPORTED_ZOD_TYPES, applyCompatLayer, convertSchemaToZod, convertZodSchemaToAISDKSchema };
+export { ALL_ARRAY_CHECKS, ALL_NUMBER_CHECKS, ALL_STRING_CHECKS, ALL_ZOD_TYPES, AnthropicSchemaCompatLayer, DeepSeekSchemaCompatLayer, GoogleSchemaCompatLayer, MetaSchemaCompatLayer, OpenAIReasoningSchemaCompatLayer, OpenAISchemaCompatLayer, SUPPORTED_ZOD_TYPES, SchemaCompatLayer, UNSUPPORTED_ZOD_TYPES, applyCompatLayer, convertSchemaToZod, convertZodSchemaToAISDKSchema, isArr, isNumber, isObj, isOptional, isString, isUnion };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/schema-compat",
-  "version": "0.10.2-alpha.2",
+  "version": "0.10.2",
   "description": "Tool schema compatibility layer for Mastra.ai",
   "type": "module",
   "main": "dist/index.js",
@@ -42,10 +42,10 @@
     "eslint": "^9.28.0",
     "tsup": "^8.5.0",
     "typescript": "^5.8.2",
-    "vitest": "^3.1.2",
-    "zod": "^3.24.3",
+    "vitest": "^3.2.2",
+    "zod": "^3.25.56",
     "ai": "4.3.16",
-    "@internal/lint": "0.0.10"
+    "@internal/lint": "0.0.11"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm,cjs --experimental-dts --clean --treeshake=smallest --splitting",

package/src/index.ts

@@ -18,6 +18,13 @@ export {
   type ZodShape,
   type ShapeKey,
   type ShapeValue,
+  // Re-usable type predicates
+  isOptional,
+  isObj,
+  isArr,
+  isUnion,
+  isString,
+  isNumber,
 } from './schema-compatibility';
 
 // Utility functions

package/src/provider-compats/anthropic.ts

@@ -1,8 +1,8 @@
 import type { LanguageModelV1 } from 'ai';
-import type { z } from 'zod';
+import type { ZodTypeAny } from 'zod';
 import type { Targets } from 'zod-to-json-schema';
-import { SchemaCompatLayer } from '../schema-compatibility';
-import type { ShapeValue, AllZodType } from '../schema-compatibility';
+import { SchemaCompatLayer, isArr, isObj, isOptional, isString, isUnion } from '../schema-compatibility';
+import type { AllZodType } from '../schema-compatibility';
 
 export class AnthropicSchemaCompatLayer extends SchemaCompatLayer {
   constructor(model: LanguageModelV1) {
@@ -17,38 +17,33 @@ export class AnthropicSchemaCompatLayer extends SchemaCompatLayer {
     return this.getModel().modelId.includes('claude');
   }
 
-  processZodType<T extends z.AnyZodObject>(value: z.ZodTypeAny): ShapeValue<T> {
-    switch (value._def.typeName) {
-      case 'ZodOptional':
-        const handleTypes: AllZodType[] = ['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);
-      }
+  processZodType(value: ZodTypeAny): ZodTypeAny {
+    if (isOptional(value)) {
+      const handleTypes: AllZodType[] = ['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)) {
       // 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 as ShapeValue<T>;
-        }
+
+      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']);
     }
   }
 }