@mastra/schema-compat 0.10.6-alpha.0 → 0.10.6-alpha.1

package/src/provider-compats/deepseek.ts

@@ -1,10 +1,13 @@
-import type { LanguageModelV1 } from 'ai';
-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 { SchemaCompatLayer } from '../schema-compatibility';
+import type { ModelInformation } from '../types';
+import { isOptional, isObj, isArr, isUnion, isString } from '../zodTypes';
 
 export class DeepSeekSchemaCompatLayer extends SchemaCompatLayer {
-  constructor(model: LanguageModelV1) {
+  constructor(model: ModelInformation) {
     super(model);
   }
 
@@ -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,21 +1,13 @@
-import type { LanguageModelV1 } from 'ai';
-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,
-  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: LanguageModelV1) {
+  constructor(model: ModelInformation) {
     super(model);
   }
 
@@ -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,10 +1,13 @@
-import type { LanguageModelV1 } from 'ai';
-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 { 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: LanguageModelV1) {
+  constructor(model: ModelInformation) {
     super(model);
   }
 
@@ -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,21 +1,13 @@
-import type { LanguageModelV1 } from 'ai';
 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 {
-  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: LanguageModelV1) {
+  constructor(model: ModelInformation) {
     super(model);
   }
 
@@ -26,7 +18,11 @@ export class OpenAIReasoningSchemaCompatLayer extends SchemaCompatLayer {
   isReasoningModel(): boolean {
     // there isn't a good way to automatically detect reasoning models besides doing this.
     // in the future when o5 is released this compat wont apply and we'll want to come back and update this class + our tests
-    return this.getModel().modelId.includes(`o3`) || this.getModel().modelId.includes(`o4`);
+    return (
+      this.getModel().modelId.includes(`o3`) ||
+      this.getModel().modelId.includes(`o4`) ||
+      this.getModel().modelId.includes(`o1`)
+    );
   }
 
   shouldApply(): boolean {
@@ -40,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();
@@ -65,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
@@ -82,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,11 +1,13 @@
-import type { LanguageModelV1 } from 'ai';
-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 { 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: LanguageModelV1) {
+  constructor(model: ModelInformation) {
     super(model);
   }
 
@@ -24,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',
@@ -35,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',
+    ]);
   }
 }

package/src/provider-compats.test.ts

@@ -40,22 +40,38 @@ describe('Provider Compatibility Classes', () => {
 
   describe('AnthropicSchemaCompatLayer', () => {
     it('should apply for Anthropic models', () => {
-      const compat = new AnthropicSchemaCompatLayer(mockModels.anthropic);
+      const compat = new AnthropicSchemaCompatLayer({
+        modelId: mockModels.anthropic.modelId,
+        supportsStructuredOutputs: mockModels.anthropic.supportsStructuredOutputs ?? false,
+        provider: mockModels.anthropic.provider,
+      });
       expect(compat.shouldApply()).toBe(true);
     });
 
     it('should not apply for non-Anthropic models', () => {
-      const compat = new AnthropicSchemaCompatLayer(mockModels.openai);
+      const compat = new AnthropicSchemaCompatLayer({
+        modelId: mockModels.openai.modelId,
+        supportsStructuredOutputs: mockModels.openai.supportsStructuredOutputs ?? false,
+        provider: mockModels.openai.provider,
+      });
       expect(compat.shouldApply()).toBe(false);
     });
 
     it('should return correct schema target', () => {
-      const compat = new AnthropicSchemaCompatLayer(mockModels.anthropic);
+      const compat = new AnthropicSchemaCompatLayer({
+        modelId: mockModels.anthropic.modelId,
+        supportsStructuredOutputs: mockModels.anthropic.supportsStructuredOutputs ?? false,
+        provider: mockModels.anthropic.provider,
+      });
       expect(compat.getSchemaTarget()).toBe('jsonSchema7');
     });
 
     it('should process schemas correctly', () => {
-      const compat = new AnthropicSchemaCompatLayer(mockModels.anthropic);
+      const compat = new AnthropicSchemaCompatLayer({
+        modelId: mockModels.anthropic.modelId,
+        supportsStructuredOutputs: mockModels.anthropic.supportsStructuredOutputs ?? false,
+        provider: mockModels.anthropic.provider,
+      });
       const schema = z.object({
         text: z.string().min(1).max(100),
         count: z.number().min(1),
@@ -79,17 +95,29 @@ describe('Provider Compatibility Classes', () => {
 
   describe('OpenAISchemaCompatLayer', () => {
     it('should apply for OpenAI models without structured outputs support', () => {
-      const compat = new OpenAISchemaCompatLayer(mockModels.openai);
+      const compat = new OpenAISchemaCompatLayer({
+        modelId: mockModels.openai.modelId,
+        supportsStructuredOutputs: mockModels.openai.supportsStructuredOutputs ?? false,
+        provider: mockModels.openai.provider,
+      });
       expect(compat.shouldApply()).toBe(true);
     });
 
     it('should return correct schema target', () => {
-      const compat = new OpenAISchemaCompatLayer(mockModels.openai);
+      const compat = new OpenAISchemaCompatLayer({
+        modelId: mockModels.openai.modelId,
+        supportsStructuredOutputs: mockModels.openai.supportsStructuredOutputs ?? false,
+        provider: mockModels.openai.provider,
+      });
       expect(compat.getSchemaTarget()).toBe('jsonSchema7');
     });
 
     it('should process complex schemas', () => {
-      const compat = new OpenAISchemaCompatLayer(mockModels.openai);
+      const compat = new OpenAISchemaCompatLayer({
+        modelId: mockModels.openai.modelId,
+        supportsStructuredOutputs: mockModels.openai.supportsStructuredOutputs ?? false,
+        provider: mockModels.openai.provider,
+      });
       const schema = z.object({
         user: z.object({
           name: z.string().email(),
@@ -122,29 +150,49 @@ describe('Provider Compatibility Classes', () => {
 
   describe('OpenAIReasoningSchemaCompatLayer', () => {
     it('should have consistent behavior', () => {
-      const compat = new OpenAIReasoningSchemaCompatLayer(mockModels.openaiReasoning);
+      const compat = new OpenAIReasoningSchemaCompatLayer({
+        modelId: mockModels.openaiReasoning.modelId,
+        supportsStructuredOutputs: mockModels.openaiReasoning.supportsStructuredOutputs ?? false,
+        provider: mockModels.openaiReasoning.provider,
+      });
       expect(compat.shouldApply()).toBe(true);
     });
 
     it('should return correct schema target', () => {
-      const compat = new OpenAIReasoningSchemaCompatLayer(mockModels.openaiReasoning);
+      const compat = new OpenAIReasoningSchemaCompatLayer({
+        modelId: mockModels.openaiReasoning.modelId,
+        supportsStructuredOutputs: mockModels.openaiReasoning.supportsStructuredOutputs ?? false,
+        provider: mockModels.openaiReasoning.provider,
+      });
       expect(compat.getSchemaTarget()).toBe('openApi3');
     });
   });
 
   describe('GoogleSchemaCompatLayer', () => {
     it('should have consistent behavior', () => {
-      const compat = new GoogleSchemaCompatLayer(mockModels.google);
+      const compat = new GoogleSchemaCompatLayer({
+        modelId: mockModels.google.modelId,
+        supportsStructuredOutputs: mockModels.google.supportsStructuredOutputs ?? false,
+        provider: mockModels.google.provider,
+      });
       expect(typeof compat.shouldApply()).toBe('boolean');
     });
 
     it('should return correct schema target', () => {
-      const compat = new GoogleSchemaCompatLayer(mockModels.google);
+      const compat = new GoogleSchemaCompatLayer({
+        modelId: mockModels.google.modelId,
+        supportsStructuredOutputs: mockModels.google.supportsStructuredOutputs ?? false,
+        provider: mockModels.google.provider,
+      });
       expect(compat.getSchemaTarget()).toBe('jsonSchema7');
     });
 
     it('should handle date types correctly', () => {
-      const compat = new GoogleSchemaCompatLayer(mockModels.google);
+      const compat = new GoogleSchemaCompatLayer({
+        modelId: mockModels.google.modelId,
+        supportsStructuredOutputs: mockModels.google.supportsStructuredOutputs ?? false,
+        provider: mockModels.google.provider,
+      });
       const schema = z.object({
         startDate: z.date(),
         endDate: z.date().optional(),
@@ -169,22 +217,38 @@ describe('Provider Compatibility Classes', () => {
 
   describe('DeepSeekSchemaCompatLayer', () => {
     it('should apply for DeepSeek models', () => {
-      const compat = new DeepSeekSchemaCompatLayer(mockModels.deepseek);
+      const compat = new DeepSeekSchemaCompatLayer({
+        modelId: mockModels.deepseek.modelId,
+        supportsStructuredOutputs: mockModels.deepseek.supportsStructuredOutputs ?? false,
+        provider: mockModels.deepseek.provider,
+      });
       expect(compat.shouldApply()).toBe(true);
     });
 
     it('should not apply for non-DeepSeek models', () => {
-      const compat = new DeepSeekSchemaCompatLayer(mockModels.openai);
+      const compat = new DeepSeekSchemaCompatLayer({
+        modelId: mockModels.openai.modelId,
+        supportsStructuredOutputs: mockModels.openai.supportsStructuredOutputs ?? false,
+        provider: mockModels.openai.provider,
+      });
       expect(compat.shouldApply()).toBe(false);
     });
 
     it('should return correct schema target', () => {
-      const compat = new DeepSeekSchemaCompatLayer(mockModels.deepseek);
+      const compat = new DeepSeekSchemaCompatLayer({
+        modelId: mockModels.deepseek.modelId,
+        supportsStructuredOutputs: mockModels.deepseek.supportsStructuredOutputs ?? false,
+        provider: mockModels.deepseek.provider,
+      });
       expect(compat.getSchemaTarget()).toBe('jsonSchema7');
     });
 
     it('should handle string constraints', () => {
-      const compat = new DeepSeekSchemaCompatLayer(mockModels.deepseek);
+      const compat = new DeepSeekSchemaCompatLayer({
+        modelId: mockModels.deepseek.modelId,
+        supportsStructuredOutputs: mockModels.deepseek.supportsStructuredOutputs ?? false,
+        provider: mockModels.deepseek.provider,
+      });
       const schema = z.object({
         email: z.string().email(),
         url: z.string().url(),
@@ -212,17 +276,29 @@ describe('Provider Compatibility Classes', () => {
 
   describe('MetaSchemaCompatLayer', () => {
     it('should have consistent behavior', () => {
-      const compat = new MetaSchemaCompatLayer(mockModels.meta);
+      const compat = new MetaSchemaCompatLayer({
+        modelId: mockModels.meta.modelId,
+        supportsStructuredOutputs: mockModels.meta.supportsStructuredOutputs ?? false,
+        provider: mockModels.meta.provider,
+      });
       expect(typeof compat.shouldApply()).toBe('boolean');
     });
 
     it('should return correct schema target', () => {
-      const compat = new MetaSchemaCompatLayer(mockModels.meta);
+      const compat = new MetaSchemaCompatLayer({
+        modelId: mockModels.meta.modelId,
+        supportsStructuredOutputs: mockModels.meta.supportsStructuredOutputs ?? false,
+        provider: mockModels.meta.provider,
+      });
       expect(compat.getSchemaTarget()).toBe('jsonSchema7');
     });
 
     it('should handle array and union types', () => {
-      const compat = new MetaSchemaCompatLayer(mockModels.meta);
+      const compat = new MetaSchemaCompatLayer({
+        modelId: mockModels.meta.modelId,
+        supportsStructuredOutputs: mockModels.meta.supportsStructuredOutputs ?? false,
+        provider: mockModels.meta.provider,
+      });
       const schema = z.object({
         tags: z.array(z.string()).min(1).max(10),
         status: z.union([z.literal('active'), z.literal('inactive')]),
@@ -271,12 +347,31 @@ describe('Provider Compatibility Classes', () => {
       });
 
       const providers = [
-        new AnthropicSchemaCompatLayer(mockModels.anthropic),
-        new OpenAISchemaCompatLayer(mockModels.openai),
-        new OpenAIReasoningSchemaCompatLayer(mockModels.openaiReasoning),
-        new GoogleSchemaCompatLayer(mockModels.google),
-        new DeepSeekSchemaCompatLayer(mockModels.deepseek),
-        new MetaSchemaCompatLayer(mockModels.meta),
+        new AnthropicSchemaCompatLayer({
+          modelId: mockModels.anthropic.modelId,
+          supportsStructuredOutputs: mockModels.anthropic.supportsStructuredOutputs ?? false,
+          provider: mockModels.anthropic.provider,
+        }),
+        new OpenAISchemaCompatLayer({
+          modelId: mockModels.openai.modelId,
+          supportsStructuredOutputs: mockModels.openai.supportsStructuredOutputs ?? false,
+          provider: mockModels.openai.provider,
+        }),
+        new OpenAIReasoningSchemaCompatLayer({
+          modelId: mockModels.openaiReasoning.modelId,
+          supportsStructuredOutputs: mockModels.openaiReasoning.supportsStructuredOutputs ?? false,
+          provider: mockModels.openaiReasoning.provider,
+        }),
+        new GoogleSchemaCompatLayer({
+          modelId: mockModels.google.modelId,
+          supportsStructuredOutputs: mockModels.google.supportsStructuredOutputs ?? false,
+          provider: mockModels.google.provider,
+        }),
+        new MetaSchemaCompatLayer({
+          modelId: mockModels.meta.modelId,
+          supportsStructuredOutputs: mockModels.meta.supportsStructuredOutputs ?? false,
+          provider: mockModels.meta.provider,
+        }),
       ];
 
       providers.forEach(provider => {