@mastra/schema-compat 0.0.0-fix-fetching-workflow-snapshots-20250625000954 → 0.0.0-fix-message-list-args-missing-20250807205055

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 => {

package/src/schema-compatibility.test.ts

@@ -1,11 +1,11 @@
-import type { LanguageModelV1 } from 'ai';
 import { MockLanguageModelV1 } from 'ai/test';
 import { describe, it, expect, beforeEach } from 'vitest';
 import { z } from 'zod';
+import type { ModelInformation } from './schema-compatibility';
 import { isArr, isObj, isOptional, isString, isUnion, SchemaCompatLayer } from './schema-compatibility';
 
 class MockSchemaCompatibility extends SchemaCompatLayer {
-  constructor(model: LanguageModelV1) {
+  constructor(model: ModelInformation) {
     super(model);
   }
 
@@ -45,12 +45,20 @@ describe('SchemaCompatLayer', () => {
   let compatibility: MockSchemaCompatibility;
 
   beforeEach(() => {
-    compatibility = new MockSchemaCompatibility(mockModel);
+    compatibility = new MockSchemaCompatibility({
+      modelId: mockModel.modelId,
+      supportsStructuredOutputs: mockModel.supportsStructuredOutputs ?? false,
+      provider: mockModel.provider,
+    });
   });
 
   describe('constructor and getModel', () => {
     it('should store and return the model', () => {
-      expect(compatibility.getModel()).toBe(mockModel);
+      expect(compatibility.getModel()).toEqual({
+        modelId: mockModel.modelId,
+        supportsStructuredOutputs: mockModel.supportsStructuredOutputs ?? false,
+        provider: mockModel.provider,
+      });
     });
   });
 
@@ -351,7 +359,11 @@ describe('SchemaCompatLayer', () => {
         }
       }
 
-      const testCompat = new TestCompatibility(mockModel);
+      const testCompat = new TestCompatibility({
+        modelId: mockModel.modelId,
+        supportsStructuredOutputs: mockModel.supportsStructuredOutputs ?? false,
+        provider: mockModel.provider,
+      });
       const result = testCompat.defaultZodOptionalHandler(optionalSchema);
 
       expect(result._def.typeName).toBe('ZodOptional');
@@ -400,7 +412,11 @@ describe('SchemaCompatLayer', () => {
           return super.processZodType(value);
         }
       }
-      const preservingCompat = new PreservingMock(mockModel);
+      const preservingCompat = new PreservingMock({
+        modelId: mockModel.modelId,
+        supportsStructuredOutputs: mockModel.supportsStructuredOutputs ?? false,
+        provider: mockModel.provider,
+      });
       const preservingResult = preservingCompat.processToAISDKSchema(arraySchema);
       expect(preservingResult.jsonSchema.description).toBeUndefined();
       expect(

package/src/schema-compatibility.ts

@@ -1,6 +1,6 @@
-import type { Schema, LanguageModelV1 } from 'ai';
+import type { Schema } from 'ai';
 import type { JSONSchema7 } from 'json-schema';
-import { z, ZodOptional, ZodObject, ZodArray, ZodUnion, ZodString, ZodNumber, ZodDate, ZodDefault } from 'zod';
+import { z, ZodOptional, ZodObject, ZodArray, ZodUnion, ZodString, ZodNumber, ZodDate, ZodDefault, ZodNull } from 'zod';
 import type { ZodTypeAny } from 'zod';
 import type { Targets } from 'zod-to-json-schema';
 import { convertZodSchemaToAISDKSchema } from './utils';
@@ -29,6 +29,7 @@ export const ALL_ARRAY_CHECKS = ['min', 'max', 'length'] as const;
 
 export const isOptional = (v: ZodTypeAny): v is ZodOptional<any> => v instanceof ZodOptional;
 export const isObj = (v: ZodTypeAny): v is ZodObject<any, any, any> => v instanceof ZodObject;
+export const isNull = (v: ZodTypeAny): v is ZodNull => v instanceof ZodNull;
 export const isArr = (v: ZodTypeAny): v is ZodArray<any, any> => v instanceof ZodArray;
 export const isUnion = (v: ZodTypeAny): v is ZodUnion<[ZodTypeAny, ...ZodTypeAny[]]> => v instanceof ZodUnion;
 export const isString = (v: ZodTypeAny): v is ZodString => v instanceof ZodString;
@@ -141,6 +142,12 @@ type DateConstraints = {
   dateFormat?: string;
 };
 
+export type ModelInformation = {
+  modelId: string;
+  provider: string;
+  supportsStructuredOutputs: boolean;
+};
+
 /**
  * Abstract base class for creating schema compatibility layers for different AI model providers.
  *
@@ -181,14 +188,14 @@ type DateConstraints = {
  * ```
  */
 export abstract class SchemaCompatLayer {
-  private model: LanguageModelV1;
+  private model: ModelInformation;
 
   /**
    * Creates a new schema compatibility instance.
    *
    * @param model - The language model this compatibility layer applies to
    */
-  constructor(model: LanguageModelV1) {
+  constructor(model: ModelInformation) {
     this.model = model;
   }
 
@@ -197,7 +204,7 @@ export abstract class SchemaCompatLayer {
    *
    * @returns The language model instance
    */
-  getModel(): LanguageModelV1 {
+  getModel(): ModelInformation {
     return this.model;
   }
 
@@ -299,8 +306,8 @@ export abstract class SchemaCompatLayer {
     value: z.ZodTypeAny,
     throwOnTypes: readonly UnsupportedZodType[] = UNSUPPORTED_ZOD_TYPES,
   ): ShapeValue<T> {
-    if (throwOnTypes.includes(value._def.typeName as UnsupportedZodType)) {
-      throw new Error(`${this.model.modelId} does not support zod type: ${value._def.typeName}`);
+    if (throwOnTypes.includes(value._def?.typeName as UnsupportedZodType)) {
+      throw new Error(`${this.model.modelId} does not support zod type: ${value._def?.typeName}`);
     }
     return value as ShapeValue<T>;
   }

package/src/utils.test.ts

@@ -1,8 +1,9 @@
 import { jsonSchema } from 'ai';
-import type { LanguageModelV1, Schema } from 'ai';
+import type { Schema } from 'ai';
 import { MockLanguageModelV1 } from 'ai/test';
 import { describe, it, expect, beforeEach, vi } from 'vitest';
 import { z } from 'zod';
+import type { ModelInformation } from './schema-compatibility';
 import { SchemaCompatLayer } from './schema-compatibility';
 import { convertZodSchemaToAISDKSchema, convertSchemaToZod, applyCompatLayer } from './utils';
 
@@ -13,7 +14,7 @@ const mockModel = new MockLanguageModelV1({
 
 class MockSchemaCompatibility extends SchemaCompatLayer {
   constructor(
-    model: LanguageModelV1,
+    model: ModelInformation,
     private shouldApplyValue: boolean = true,
   ) {
     super(model);
@@ -191,7 +192,11 @@ describe('Builder Functions', () => {
     let mockCompatibility: MockSchemaCompatibility;
 
     beforeEach(() => {
-      mockCompatibility = new MockSchemaCompatibility(mockModel);
+      mockCompatibility = new MockSchemaCompatibility({
+        modelId: mockModel.modelId,
+        supportsStructuredOutputs: mockModel.supportsStructuredOutputs ?? false,
+        provider: mockModel.provider,
+      });
     });
 
     it('should process Zod object schema with compatibility', () => {
@@ -257,7 +262,14 @@ describe('Builder Functions', () => {
     });
 
     it('should return fallback when no compatibility applies', () => {
-      const nonApplyingCompatibility = new MockSchemaCompatibility(mockModel, false);
+      const nonApplyingCompatibility = new MockSchemaCompatibility(
+        {
+          modelId: mockModel.modelId,
+          supportsStructuredOutputs: mockModel.supportsStructuredOutputs ?? false,
+          provider: mockModel.provider,
+        },
+        false,
+      );
       const zodSchema = z.object({
         name: z.string(),
       });
@@ -303,8 +315,22 @@ describe('Builder Functions', () => {
     });
 
     it('should handle complex schema with multiple compatLayers', () => {
-      const compat1 = new MockSchemaCompatibility(mockModel, false);
-      const compat2 = new MockSchemaCompatibility(mockModel, true);
+      const compat1 = new MockSchemaCompatibility(
+        {
+          modelId: mockModel.modelId,
+          supportsStructuredOutputs: mockModel.supportsStructuredOutputs ?? true,
+          provider: mockModel.provider,
+        },
+        false,
+      );
+      const compat2 = new MockSchemaCompatibility(
+        {
+          modelId: mockModel.modelId,
+          supportsStructuredOutputs: mockModel.supportsStructuredOutputs ?? false,
+          provider: mockModel.provider,
+        },
+        true,
+      );
 
       vi.spyOn(compat1, 'processZodType');
       vi.spyOn(compat2, 'processZodType');

package/tsconfig.build.json

@@ -0,0 +1,9 @@
+{
+  "extends": ["./tsconfig.json", "../../tsconfig.build.json"],
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "**/*.test.ts", "src/**/*.mock.ts"]
+}

package/tsconfig.json

@@ -1,5 +1,5 @@
 {
   "extends": "../../tsconfig.node.json",
-  "include": ["src/**/*"],
+  "include": ["src/**/*", "tsup.config.ts"],
   "exclude": ["node_modules", "**/*.test.ts"]
 }

package/tsup.config.ts

@@ -0,0 +1,17 @@
+import { generateTypes } from '@internal/types-builder';
+import { defineConfig } from 'tsup';
+
+export default defineConfig({
+  entry: ['src/index.ts'],
+  format: ['esm', 'cjs'],
+  clean: true,
+  dts: false,
+  splitting: true,
+  treeshake: {
+    preset: 'smallest',
+  },
+  sourcemap: true,
+  onSuccess: async () => {
+    await generateTypes(process.cwd());
+  },
+});