@mastra/schema-compat 0.10.7 → 0.11.1

package/src/provider-compats/deepseek.ts

@@ -1,7 +1,10 @@
-import type { ZodTypeAny } from 'zod';
+import { z } from 'zod';
+import type { ZodType as ZodTypeV3 } from 'zod/v3';
+import type { ZodType as ZodTypeV4 } from 'zod/v4';
 import type { Targets } from 'zod-to-json-schema';
-import { SchemaCompatLayer, isArr, isObj, isOptional, isString, isUnion } from '../schema-compatibility';
-import type { ModelInformation } from '../schema-compatibility';
+import { SchemaCompatLayer } from '../schema-compatibility';
+import type { ModelInformation } from '../types';
+import { isOptional, isObj, isArr, isUnion, isString } from '../zodTypes';
 
 export class DeepSeekSchemaCompatLayer extends SchemaCompatLayer {
   constructor(model: ModelInformation) {
@@ -17,16 +20,18 @@ export class DeepSeekSchemaCompatLayer extends SchemaCompatLayer {
     return this.getModel().modelId.includes('deepseek') && !this.getModel().modelId.includes('r1');
   }
 
-  processZodType(value: ZodTypeAny): ZodTypeAny {
-    if (isOptional(value)) {
+  processZodType(value: ZodTypeV3): ZodTypeV3;
+  processZodType(value: ZodTypeV4): ZodTypeV4;
+  processZodType(value: ZodTypeV3 | ZodTypeV4): ZodTypeV3 | ZodTypeV4 {
+    if (isOptional(z)(value)) {
       return this.defaultZodOptionalHandler(value, ['ZodObject', 'ZodArray', 'ZodUnion', 'ZodString', 'ZodNumber']);
-    } else if (isObj(value)) {
+    } else if (isObj(z)(value)) {
       return this.defaultZodObjectHandler(value);
-    } else if (isArr(value)) {
+    } else if (isArr(z)(value)) {
       return this.defaultZodArrayHandler(value, ['min', 'max']);
-    } else if (isUnion(value)) {
+    } else if (isUnion(z)(value)) {
       return this.defaultZodUnionHandler(value);
-    } else if (isString(value)) {
+    } else if (isString(z)(value)) {
       return this.defaultZodStringHandler(value);
     }
 

package/src/provider-compats/google.ts

@@ -1,18 +1,10 @@
-import type { ZodTypeAny } from 'zod';
 import { z } from 'zod';
+import type { ZodType as ZodTypeV3, ZodObject as ZodObjectV3 } from 'zod/v3';
+import type { ZodType as ZodTypeV4, ZodObject as ZodObjectV4 } from 'zod/v4';
 import type { Targets } from 'zod-to-json-schema';
-import type { ModelInformation } from '../schema-compatibility';
-import {
-  SchemaCompatLayer,
-  UNSUPPORTED_ZOD_TYPES,
-  isArr,
-  isNull,
-  isNumber,
-  isObj,
-  isOptional,
-  isString,
-  isUnion,
-} from '../schema-compatibility';
+import { SchemaCompatLayer } from '../schema-compatibility';
+import type { ModelInformation } from '../types';
+import { isOptional, isNull, isObj, isArr, isUnion, isString, isNumber } from '../zodTypes';
 
 export class GoogleSchemaCompatLayer extends SchemaCompatLayer {
   constructor(model: ModelInformation) {
@@ -26,38 +18,32 @@ export class GoogleSchemaCompatLayer extends SchemaCompatLayer {
   shouldApply(): boolean {
     return this.getModel().provider.includes('google') || this.getModel().modelId.includes('google');
   }
-
-  processZodType(value: ZodTypeAny): ZodTypeAny {
-    if (isOptional(value)) {
-      return this.defaultZodOptionalHandler(value, [
-        'ZodObject',
-        'ZodArray',
-        'ZodUnion',
-        'ZodString',
-        'ZodNumber',
-        ...UNSUPPORTED_ZOD_TYPES,
-      ]);
-    } else if (isNull(value)) {
+  processZodType(value: ZodTypeV3): ZodTypeV3;
+  processZodType(value: ZodTypeV4): ZodTypeV4;
+  processZodType(value: ZodTypeV3 | ZodTypeV4): ZodTypeV3 | ZodTypeV4 {
+    if (isOptional(z)(value)) {
+      return this.defaultZodOptionalHandler(value, ['ZodObject', 'ZodArray', 'ZodUnion', 'ZodString', 'ZodNumber']);
+    } else if (isNull(z)(value)) {
       // Google models don't support null, so we need to convert it to any and then refine it to null
       return z
         .any()
         .refine(v => v === null, { message: 'must be null' })
-        .describe(value._def.description || 'must be null');
-    } else if (isObj(value)) {
+        .describe(value.description || 'must be null');
+    } else if (isObj(z)(value)) {
       return this.defaultZodObjectHandler(value);
-    } else if (isArr(value)) {
+    } else if (isArr(z)(value)) {
       return this.defaultZodArrayHandler(value, []);
-    } else if (isUnion(value)) {
+    } else if (isUnion(z)(value)) {
       return this.defaultZodUnionHandler(value);
-    } else if (isString(value)) {
+    } else if (isString(z)(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
       return this.defaultZodStringHandler(value);
-    } else if (isNumber(value)) {
+    } else if (isNumber(z)(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
       return this.defaultZodNumberHandler(value);
     }
-    return this.defaultUnsupportedZodTypeHandler(value);
+    return this.defaultUnsupportedZodTypeHandler(value as ZodObjectV4<any> | ZodObjectV3<any>);
   }
 }

package/src/provider-compats/meta.ts

@@ -1,7 +1,10 @@
-import type { ZodTypeAny } from 'zod';
+import { z } from 'zod';
+import type { ZodType as ZodTypeV3 } from 'zod/v3';
+import type { ZodType as ZodTypeV4 } from 'zod/v4';
 import type { Targets } from 'zod-to-json-schema';
-import { SchemaCompatLayer, isArr, isNumber, isObj, isOptional, isString, isUnion } from '../schema-compatibility';
-import type { ModelInformation } from '../schema-compatibility';
+import { SchemaCompatLayer } from '../schema-compatibility';
+import type { ModelInformation } from '../types';
+import { isOptional, isObj, isArr, isUnion, isNumber, isString } from '../zodTypes';
 
 export class MetaSchemaCompatLayer extends SchemaCompatLayer {
   constructor(model: ModelInformation) {
@@ -16,18 +19,20 @@ export class MetaSchemaCompatLayer extends SchemaCompatLayer {
     return this.getModel().modelId.includes('meta');
   }
 
-  processZodType(value: ZodTypeAny): ZodTypeAny {
-    if (isOptional(value)) {
+  processZodType(value: ZodTypeV3): ZodTypeV3;
+  processZodType(value: ZodTypeV4): ZodTypeV4;
+  processZodType(value: ZodTypeV3 | ZodTypeV4): ZodTypeV3 | ZodTypeV4 {
+    if (isOptional(z)(value)) {
       return this.defaultZodOptionalHandler(value, ['ZodObject', 'ZodArray', 'ZodUnion', 'ZodString', 'ZodNumber']);
-    } else if (isObj(value)) {
+    } else if (isObj(z)(value)) {
       return this.defaultZodObjectHandler(value);
-    } else if (isArr(value)) {
+    } else if (isArr(z)(value)) {
       return this.defaultZodArrayHandler(value, ['min', 'max']);
-    } else if (isUnion(value)) {
+    } else if (isUnion(z)(value)) {
       return this.defaultZodUnionHandler(value);
-    } else if (isNumber(value)) {
+    } else if (isNumber(z)(value)) {
       return this.defaultZodNumberHandler(value);
-    } else if (isString(value)) {
+    } else if (isString(z)(value)) {
       return this.defaultZodStringHandler(value);
     }
 

package/src/provider-compats/openai-reasoning.ts

@@ -1,18 +1,10 @@
 import { z } from 'zod';
-import type { ZodTypeAny } from 'zod';
+import type { ZodType as ZodTypeV3, ZodObject as ZodObjectV3 } from 'zod/v3';
+import type { ZodType as ZodTypeV4, ZodObject as ZodObjectV4 } from 'zod/v4';
 import type { Targets } from 'zod-to-json-schema';
-import type { ModelInformation } from '../schema-compatibility';
-import {
-  SchemaCompatLayer,
-  isArr,
-  isDate,
-  isDefault,
-  isNumber,
-  isObj,
-  isOptional,
-  isString,
-  isUnion,
-} from '../schema-compatibility';
+import { SchemaCompatLayer } from '../schema-compatibility';
+import type { ModelInformation } from '../types';
+import { isOptional, isObj, isArr, isUnion, isDefault, isNumber, isString, isDate } from '../zodTypes';
 
 export class OpenAIReasoningSchemaCompatLayer extends SchemaCompatLayer {
   constructor(model: ModelInformation) {
@@ -44,17 +36,19 @@ export class OpenAIReasoningSchemaCompatLayer extends SchemaCompatLayer {
     return false;
   }
 
-  processZodType(value: ZodTypeAny): ZodTypeAny {
-    if (isOptional(value)) {
+  processZodType(value: ZodTypeV3): ZodTypeV3;
+  processZodType(value: ZodTypeV4): ZodTypeV4;
+  processZodType(value: ZodTypeV3 | ZodTypeV4): ZodTypeV3 | ZodTypeV4 {
+    if (isOptional(z)(value)) {
       const innerZodType = this.processZodType(value._def.innerType);
       return innerZodType.nullable();
-    } else if (isObj(value)) {
+    } else if (isObj(z)(value)) {
       return this.defaultZodObjectHandler(value, { passthrough: false });
-    } else if (isArr(value)) {
+    } else if (isArr(z)(value)) {
       return this.defaultZodArrayHandler(value);
-    } else if (isUnion(value)) {
+    } else if (isUnion(z)(value)) {
       return this.defaultZodUnionHandler(value);
-    } else if (isDefault(value)) {
+    } else if (isDefault(z)(value)) {
       const defaultDef = value._def;
       const innerType = defaultDef.innerType;
       const defaultValue = defaultDef.defaultValue();
@@ -69,13 +63,13 @@ export class OpenAIReasoningSchemaCompatLayer extends SchemaCompatLayer {
         result = result.describe(description);
       }
       return result;
-    } else if (isNumber(value)) {
+    } else if (isNumber(z)(value)) {
       return this.defaultZodNumberHandler(value);
-    } else if (isString(value)) {
+    } else if (isString(z)(value)) {
       return this.defaultZodStringHandler(value);
-    } else if (isDate(value)) {
+    } else if (isDate(z)(value)) {
       return this.defaultZodDateHandler(value);
-    } else if (value._def.typeName === 'ZodAny') {
+    } else if (value.constructor.name === 'ZodAny') {
       // It's bad practice in the tool to use any, it's not reasonable for models that don't support that OOTB, to cast every single possible type
       // in the schema. Usually when it's "any" it could be a json object or a union of specific types.
       return z
@@ -86,6 +80,6 @@ export class OpenAIReasoningSchemaCompatLayer extends SchemaCompatLayer {
         );
     }
 
-    return this.defaultUnsupportedZodTypeHandler(value);
+    return this.defaultUnsupportedZodTypeHandler(value as ZodObjectV4<any> | ZodObjectV3<any>);
   }
 }

package/src/provider-compats/openai.ts

@@ -1,7 +1,10 @@
-import type { ZodTypeAny } from 'zod';
+import { z } from 'zod';
+import type { ZodType as ZodTypeV3, ZodObject as ZodObjectV3 } from 'zod/v3';
+import type { ZodType as ZodTypeV4, ZodObject as ZodObjectV4 } from 'zod/v4';
 import type { Targets } from 'zod-to-json-schema';
-import { SchemaCompatLayer, isArr, isObj, isOptional, isString, isUnion } from '../schema-compatibility';
-import type { ModelInformation, StringCheckType } from '../schema-compatibility';
+import { SchemaCompatLayer } from '../schema-compatibility';
+import type { ModelInformation } from '../types';
+import { isOptional, isObj, isUnion, isArr, isString } from '../zodTypes';
 
 export class OpenAISchemaCompatLayer extends SchemaCompatLayer {
   constructor(model: ModelInformation) {
@@ -23,8 +26,10 @@ export class OpenAISchemaCompatLayer extends SchemaCompatLayer {
     return false;
   }
 
-  processZodType(value: ZodTypeAny): ZodTypeAny {
-    if (isOptional(value)) {
+  processZodType(value: ZodTypeV3): ZodTypeV3;
+  processZodType(value: ZodTypeV4): ZodTypeV4;
+  processZodType(value: ZodTypeV3 | ZodTypeV4): ZodTypeV3 | ZodTypeV4 {
+    if (isOptional(z)(value)) {
       return this.defaultZodOptionalHandler(value, [
         'ZodObject',
         'ZodArray',
@@ -34,22 +39,27 @@ export class OpenAISchemaCompatLayer extends SchemaCompatLayer {
         'ZodUndefined',
         'ZodTuple',
       ]);
-    } else if (isObj(value)) {
+    } else if (isObj(z)(value)) {
       return this.defaultZodObjectHandler(value);
-    } else if (isUnion(value)) {
+    } else if (isUnion(z)(value)) {
       return this.defaultZodUnionHandler(value);
-    } else if (isArr(value)) {
+    } else if (isArr(z)(value)) {
       return this.defaultZodArrayHandler(value);
-    } else if (isString(value)) {
+    } else if (isString(z)(value)) {
       const model = this.getModel();
-      const checks: StringCheckType[] = ['emoji'];
+      const checks = ['emoji'] as const;
 
       if (model.modelId.includes('gpt-4o-mini')) {
-        checks.push('regex');
+        return this.defaultZodStringHandler(value, ['emoji', 'regex']);
       }
+
       return this.defaultZodStringHandler(value, checks);
     }
 
-    return this.defaultUnsupportedZodTypeHandler(value, ['ZodNever', 'ZodUndefined', 'ZodTuple']);
+    return this.defaultUnsupportedZodTypeHandler(value as ZodObjectV4<any> | ZodObjectV3<any>, [
+      'ZodNever',
+      'ZodUndefined',
+      'ZodTuple',
+    ]);
   }
 }