@mastra/schema-compat 0.0.0-ai-v5-20250729181825 → 0.0.0-ai-v5-20250813235735

package/src/provider-compats.test.ts

@@ -40,22 +40,34 @@ 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,
+        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,
+        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,
+        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,
+        provider: mockModels.anthropic.provider,
+      });
       const schema = z.object({
         text: z.string().min(1).max(100),
         count: z.number().min(1),
@@ -79,17 +91,26 @@ 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,
+        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,
+        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,
+        provider: mockModels.openai.provider,
+      });
       const schema = z.object({
         user: z.object({
           name: z.string().email(),
@@ -122,29 +143,44 @@ 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,
+        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,
+        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,
+        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,
+        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,
+        provider: mockModels.google.provider,
+      });
       const schema = z.object({
         startDate: z.date(),
         endDate: z.date().optional(),
@@ -169,22 +205,34 @@ 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,
+        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,
+        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,
+        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,
+        provider: mockModels.deepseek.provider,
+      });
       const schema = z.object({
         email: z.string().email(),
         url: z.string().url(),
@@ -212,17 +260,26 @@ 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,
+        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,
+        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,
+        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 +328,26 @@ 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,
+          provider: mockModels.anthropic.provider,
+        }),
+        new OpenAISchemaCompatLayer({
+          modelId: mockModels.openai.modelId,
+          provider: mockModels.openai.provider,
+        }),
+        new OpenAIReasoningSchemaCompatLayer({
+          modelId: mockModels.openaiReasoning.modelId,
+          provider: mockModels.openaiReasoning.provider,
+        }),
+        new GoogleSchemaCompatLayer({
+          modelId: mockModels.google.modelId,
+          provider: mockModels.google.provider,
+        }),
+        new MetaSchemaCompatLayer({
+          modelId: mockModels.meta.modelId,
+          provider: mockModels.meta.provider,
+        }),
       ];
 
       providers.forEach(provider => {

package/src/schema-compatibility.test.ts

@@ -1,11 +1,11 @@
 import { MockLanguageModelV2 } from 'ai/test';
 import { describe, it, expect, beforeEach } from 'vitest';
 import { z } from 'zod';
-import type { SchemaCompatModel } from './schema-compatibility';
+import type { ModelInformation } from './schema-compatibility';
 import { isArr, isObj, isOptional, isString, isUnion, SchemaCompatLayer } from './schema-compatibility';
 
 class MockSchemaCompatibility extends SchemaCompatLayer {
-  constructor(model: SchemaCompatModel) {
+  constructor(model: ModelInformation) {
     super(model);
   }
 
@@ -44,12 +44,18 @@ describe('SchemaCompatLayer', () => {
   let compatibility: MockSchemaCompatibility;
 
   beforeEach(() => {
-    compatibility = new MockSchemaCompatibility(mockModel);
+    compatibility = new MockSchemaCompatibility({
+      modelId: mockModel.modelId,
+      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,
+        provider: mockModel.provider,
+      });
     });
   });
 
@@ -350,7 +356,10 @@ describe('SchemaCompatLayer', () => {
         }
       }
 
-      const testCompat = new TestCompatibility(mockModel);
+      const testCompat = new TestCompatibility({
+        modelId: mockModel.modelId,
+        provider: mockModel.provider,
+      });
       const result = testCompat.defaultZodOptionalHandler(optionalSchema);
 
       expect(result._def.typeName).toBe('ZodOptional');
@@ -401,7 +410,10 @@ describe('SchemaCompatLayer', () => {
           return super.processZodType(value);
         }
       }
-      const preservingCompat = new PreservingMock(mockModel);
+      const preservingCompat = new PreservingMock({
+        modelId: mockModel.modelId,
+        provider: mockModel.provider,
+      });
       const preservingResult = preservingCompat.processToAISDKSchema(arraySchema);
       expect(preservingResult.jsonSchema.description).toBeUndefined();
       expect(

package/src/schema-compatibility.ts

@@ -121,7 +121,7 @@ type StringConstraints = {
   uuid?: boolean;
   cuid?: boolean;
   emoji?: boolean;
-  regex?: { pattern: string; flags?: string };
+  regex?: string;
 };
 
 type NumberConstraints = {
@@ -144,6 +144,11 @@ type DateConstraints = {
   dateFormat?: string;
 };
 
+export type ModelInformation = {
+  modelId: string;
+  provider: string;
+};
+
 /**
  * Abstract base class for creating schema compatibility layers for different AI model providers.
  *
@@ -184,14 +189,14 @@ type DateConstraints = {
  * ```
  */
 export abstract class SchemaCompatLayer {
-  private model: SchemaCompatModel;
+  private model: ModelInformation;
 
   /**
    * Creates a new schema compatibility instance.
    *
    * @param model - The language model this compatibility layer applies to
    */
-  constructor(model: SchemaCompatModel) {
+  constructor(model: ModelInformation) {
     this.model = model;
   }
 
@@ -200,7 +205,7 @@ export abstract class SchemaCompatLayer {
    *
    * @returns The language model instance
    */
-  getModel(): SchemaCompatModel {
+  getModel(): ModelInformation {
     return this.model;
   }
 
@@ -394,10 +399,7 @@ export abstract class SchemaCompatLayer {
         if (handleChecks.includes(check.kind as StringCheckType)) {
           switch (check.kind) {
             case 'regex': {
-              constraints.regex = {
-                pattern: check.regex.source,
-                flags: check.regex.flags,
-              };
+              constraints.regex = `A string that must match the regex pattern: ${check.regex.source}, with flags: ${check.regex.flags}`;
               break;
             }
             case 'emoji': {

package/src/utils.test.ts

@@ -3,7 +3,7 @@ import type { Schema } from 'ai';
 import { MockLanguageModelV2 } from 'ai/test';
 import { describe, it, expect, beforeEach, vi } from 'vitest';
 import { z } from 'zod';
-import type { SchemaCompatModel } from './schema-compatibility';
+import type { ModelInformation } from './schema-compatibility';
 import { SchemaCompatLayer } from './schema-compatibility';
 import { convertZodSchemaToAISDKSchema, convertSchemaToZod, applyCompatLayer } from './utils';
 
@@ -13,7 +13,7 @@ const mockModel = new MockLanguageModelV2({
 
 class MockSchemaCompatibility extends SchemaCompatLayer {
   constructor(
-    model: SchemaCompatModel,
+    model: ModelInformation,
     private shouldApplyValue: boolean = true,
   ) {
     super(model);
@@ -199,7 +199,10 @@ describe('Builder Functions', () => {
     let mockCompatibility: MockSchemaCompatibility;
 
     beforeEach(() => {
-      mockCompatibility = new MockSchemaCompatibility(mockModel);
+      mockCompatibility = new MockSchemaCompatibility({
+        modelId: mockModel.modelId,
+        provider: mockModel.provider,
+      });
     });
 
     it('should process Zod object schema with compatibility', () => {
@@ -265,7 +268,13 @@ describe('Builder Functions', () => {
     });
 
     it('should return fallback when no compatibility applies', () => {
-      const nonApplyingCompatibility = new MockSchemaCompatibility(mockModel, false);
+      const nonApplyingCompatibility = new MockSchemaCompatibility(
+        {
+          modelId: mockModel.modelId,
+          provider: mockModel.provider,
+        },
+        false,
+      );
       const zodSchema = z.object({
         name: z.string(),
       });
@@ -311,8 +320,20 @@ 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,
+          provider: mockModel.provider,
+        },
+        false,
+      );
+      const compat2 = new MockSchemaCompatibility(
+        {
+          modelId: mockModel.modelId,
+          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());
+  },
+});