@mastra/schema-compat 0.0.0-ai-v5-20250801192614 → 0.0.0-consolidate-changesets-20250904042643

package/src/provider-compats/anthropic.ts

@@ -1,43 +0,0 @@
-import type { ZodTypeAny } from 'zod';
-import type { Targets } from 'zod-to-json-schema';
-import { SchemaCompatLayer, isArr, isObj, isOptional, isString, isUnion } from '../schema-compatibility';
-import type { AllZodType, SchemaCompatModel } from '../schema-compatibility';
-
-export class AnthropicSchemaCompatLayer extends SchemaCompatLayer {
-  constructor(model: SchemaCompatModel) {
-    super(model);
-  }
-
-  getSchemaTarget(): Targets | undefined {
-    return 'jsonSchema7';
-  }
-
-  shouldApply(): boolean {
-    return this.getModel().modelId.includes('claude');
-  }
-
-  processZodType(value: ZodTypeAny): ZodTypeAny {
-    if (isOptional(value)) {
-      const handleTypes: AllZodType[] = ['ZodObject', 'ZodArray', 'ZodUnion', 'ZodNever', 'ZodUndefined', 'ZodTuple'];
-      if (this.getModel().modelId.includes('claude-3.5-haiku')) handleTypes.push('ZodString');
-      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
-
-      if (this.getModel().modelId.includes('claude-3.5-haiku')) {
-        return this.defaultZodStringHandler(value, ['max', 'min']);
-      } else {
-        return value;
-      }
-    }
-
-    return this.defaultUnsupportedZodTypeHandler(value, ['ZodNever', 'ZodTuple', 'ZodUndefined']);
-  }
-}

package/src/provider-compats/deepseek.ts

@@ -1,35 +0,0 @@
-import type { ZodTypeAny } from 'zod';
-import type { Targets } from 'zod-to-json-schema';
-import { SchemaCompatLayer, isArr, isObj, isOptional, isString, isUnion } from '../schema-compatibility';
-import type { SchemaCompatModel } from '../schema-compatibility';
-
-export class DeepSeekSchemaCompatLayer extends SchemaCompatLayer {
-  constructor(model: SchemaCompatModel) {
-    super(model);
-  }
-
-  getSchemaTarget(): Targets | undefined {
-    return 'jsonSchema7';
-  }
-
-  shouldApply(): boolean {
-    // Deepseek R1 performs perfectly without this compat layer
-    return this.getModel().modelId.includes('deepseek') && !this.getModel().modelId.includes('r1');
-  }
-
-  processZodType(value: ZodTypeAny): ZodTypeAny {
-    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;
-  }
-}

package/src/provider-compats/google.ts

@@ -1,63 +0,0 @@
-import type { ZodTypeAny } from 'zod';
-import { z } from 'zod';
-import type { Targets } from 'zod-to-json-schema';
-import {
-  SchemaCompatLayer,
-  UNSUPPORTED_ZOD_TYPES,
-  isArr,
-  isNull,
-  isNumber,
-  isObj,
-  isOptional,
-  isString,
-  isUnion,
-} from '../schema-compatibility';
-import type { SchemaCompatModel } from '../schema-compatibility';
-
-export class GoogleSchemaCompatLayer extends SchemaCompatLayer {
-  constructor(model: SchemaCompatModel) {
-    super(model);
-  }
-
-  getSchemaTarget(): Targets | undefined {
-    return 'jsonSchema7';
-  }
-
-  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)) {
-      // 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)) {
-      return this.defaultZodObjectHandler(value);
-    } else if (isArr(value)) {
-      return this.defaultZodArrayHandler(value, []);
-    } else if (isUnion(value)) {
-      return this.defaultZodUnionHandler(value);
-    } else if (isString(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)) {
-      // 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);
-  }
-}

package/src/provider-compats/meta.ts

@@ -1,36 +0,0 @@
-import type { ZodTypeAny } from 'zod';
-import type { Targets } from 'zod-to-json-schema';
-import { SchemaCompatLayer, isArr, isNumber, isObj, isOptional, isString, isUnion } from '../schema-compatibility';
-import type { SchemaCompatModel } from '../schema-compatibility';
-
-export class MetaSchemaCompatLayer extends SchemaCompatLayer {
-  constructor(model: SchemaCompatModel) {
-    super(model);
-  }
-
-  getSchemaTarget(): Targets | undefined {
-    return 'jsonSchema7';
-  }
-
-  shouldApply(): boolean {
-    return this.getModel().modelId.includes('meta');
-  }
-
-  processZodType(value: ZodTypeAny): ZodTypeAny {
-    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;
-  }
-}

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

@@ -1,88 +0,0 @@
-import { z } from 'zod';
-import type { ZodTypeAny } from 'zod';
-import type { Targets } from 'zod-to-json-schema';
-import {
-  SchemaCompatLayer,
-  isArr,
-  isDate,
-  isDefault,
-  isNumber,
-  isObj,
-  isOptional,
-  isString,
-  isUnion,
-} from '../schema-compatibility';
-import type { SchemaCompatModel } from '../schema-compatibility';
-
-export class OpenAIReasoningSchemaCompatLayer extends SchemaCompatLayer {
-  constructor(model: SchemaCompatModel) {
-    super(model);
-  }
-
-  getSchemaTarget(): Targets | undefined {
-    return `openApi3`;
-  }
-
-  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`);
-  }
-
-  shouldApply(): boolean {
-    if (
-      // (this.getModel().supportsStructuredOutputs || this.isReasoningModel()) && // <- supportsStructuredOutputs no longer exists
-      this.isReasoningModel() &&
-      (this.getModel().provider.includes(`openai`) || this.getModel().modelId.includes(`openai`))
-    ) {
-      return true;
-    }
-
-    return false;
-  }
-
-  processZodType(value: ZodTypeAny): ZodTypeAny {
-    if (isOptional(value)) {
-      const innerZodType = this.processZodType(value._def.innerType);
-      return innerZodType.nullable();
-    } else if (isObj(value)) {
-      return this.defaultZodObjectHandler(value, { passthrough: false });
-    } 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: { defaultValue?: unknown } = {};
-      if (defaultValue !== undefined) {
-        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') {
-      // 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
-        .string()
-        .describe(
-          (value.description ?? '') +
-            `\nArgument was an "any" type, but you (the LLM) do not support "any", so it was cast to a "string" type`,
-        );
-    }
-
-    return this.defaultUnsupportedZodTypeHandler(value);
-  }
-}

package/src/provider-compats/openai.ts

@@ -1,56 +0,0 @@
-import type { ZodTypeAny } from 'zod';
-import type { Targets } from 'zod-to-json-schema';
-import { SchemaCompatLayer, isArr, isObj, isOptional, isString, isUnion } from '../schema-compatibility';
-import type { SchemaCompatModel, StringCheckType } from '../schema-compatibility';
-
-export class OpenAISchemaCompatLayer extends SchemaCompatLayer {
-  constructor(model: SchemaCompatModel) {
-    super(model);
-  }
-
-  getSchemaTarget(): Targets | undefined {
-    return `jsonSchema7`;
-  }
-
-  shouldApply(): boolean {
-    if (
-      // !this.getModel().supportsStructuredOutputs && // <- TODO: this no longer exists, do we need it?
-      this.getModel().provider.includes(`openai`) ||
-      this.getModel().modelId.includes(`openai`)
-    ) {
-      return true;
-    }
-
-    return false;
-  }
-
-  processZodType(value: ZodTypeAny): ZodTypeAny {
-    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: StringCheckType[] = ['emoji'];
-
-      if (model.modelId.includes('gpt-4o-mini')) {
-        checks.push('regex');
-      }
-      return this.defaultZodStringHandler(value, checks);
-    }
-
-    return this.defaultUnsupportedZodTypeHandler(value, ['ZodNever', 'ZodUndefined', 'ZodTuple']);
-  }
-}

package/src/provider-compats.test.ts

@@ -1,312 +0,0 @@
-import { MockLanguageModelV2 } from 'ai/test';
-import { describe, it, expect } from 'vitest';
-import { z } from 'zod';
-import {
-  AnthropicSchemaCompatLayer,
-  OpenAISchemaCompatLayer,
-  OpenAIReasoningSchemaCompatLayer,
-  GoogleSchemaCompatLayer,
-  DeepSeekSchemaCompatLayer,
-  MetaSchemaCompatLayer,
-} from './index';
-
-describe('Provider Compatibility Classes', () => {
-  const mockModels = {
-    anthropic: new MockLanguageModelV2({
-      modelId: 'claude-3-sonnet-20240229',
-      doGenerate: async () => ({ response: { id: 'test' } }) as any,
-    }),
-    openai: new MockLanguageModelV2({
-      modelId: 'openai/gpt-4',
-      doGenerate: async () => ({ response: { id: 'test' } }) as any,
-    }),
-    openaiReasoning: new MockLanguageModelV2({
-      modelId: 'openai/o3-mini',
-      doGenerate: async () => ({ response: { id: 'test' } }) as any,
-    }),
-    google: new MockLanguageModelV2({
-      modelId: 'gemini-pro',
-      doGenerate: async () => ({ response: { id: 'test' } }) as any,
-    }),
-    deepseek: new MockLanguageModelV2({
-      modelId: 'deepseek-chat',
-      doGenerate: async () => ({ response: { id: 'test' } }) as any,
-    }),
-    meta: new MockLanguageModelV2({
-      modelId: 'llama-3.1-405b-instruct',
-      doGenerate: async () => ({ response: { id: 'test' } }) as any,
-    }),
-  };
-
-  describe('AnthropicSchemaCompatLayer', () => {
-    it('should apply for Anthropic models', () => {
-      const compat = new AnthropicSchemaCompatLayer(mockModels.anthropic);
-      expect(compat.shouldApply()).toBe(true);
-    });
-
-    it('should not apply for non-Anthropic models', () => {
-      const compat = new AnthropicSchemaCompatLayer(mockModels.openai);
-      expect(compat.shouldApply()).toBe(false);
-    });
-
-    it('should return correct schema target', () => {
-      const compat = new AnthropicSchemaCompatLayer(mockModels.anthropic);
-      expect(compat.getSchemaTarget()).toBe('jsonSchema7');
-    });
-
-    it('should process schemas correctly', () => {
-      const compat = new AnthropicSchemaCompatLayer(mockModels.anthropic);
-      const schema = z.object({
-        text: z.string().min(1).max(100),
-        count: z.number().min(1),
-      });
-
-      const result = compat.processToAISDKSchema(schema);
-
-      expect(result).toHaveProperty('jsonSchema');
-      expect(result).toHaveProperty('validate');
-
-      const validData = {
-        text: 'Hello, world!',
-        count: 10,
-      };
-
-      const validationResult = result.validate!(validData);
-      expect(typeof validationResult).toBe('object');
-      expect(validationResult).toHaveProperty('success');
-    });
-  });
-
-  describe('OpenAISchemaCompatLayer', () => {
-    it('should apply for OpenAI models without structured outputs support', () => {
-      const compat = new OpenAISchemaCompatLayer(mockModels.openai);
-      expect(compat.shouldApply()).toBe(true);
-    });
-
-    it('should return correct schema target', () => {
-      const compat = new OpenAISchemaCompatLayer(mockModels.openai);
-      expect(compat.getSchemaTarget()).toBe('jsonSchema7');
-    });
-
-    it('should process complex schemas', () => {
-      const compat = new OpenAISchemaCompatLayer(mockModels.openai);
-      const schema = z.object({
-        user: z.object({
-          name: z.string().email(),
-          preferences: z.array(z.enum(['dark', 'light'])),
-        }),
-        settings: z.record(z.boolean()),
-      });
-
-      const result = compat.processToAISDKSchema(schema);
-
-      const validData = {
-        user: {
-          name: 'John Doe',
-          preferences: ['dark'],
-        },
-        settings: {
-          public: true,
-          featured: false,
-        },
-      };
-
-      expect(result).toHaveProperty('jsonSchema');
-      expect(result).toHaveProperty('validate');
-
-      const validationResult = result.validate!(validData);
-      expect(typeof validationResult).toBe('object');
-      expect(validationResult).toHaveProperty('success');
-    });
-  });
-
-  describe('OpenAIReasoningSchemaCompatLayer', () => {
-    it('should have consistent behavior', () => {
-      const compat = new OpenAIReasoningSchemaCompatLayer(mockModels.openaiReasoning);
-      expect(compat.shouldApply()).toBe(true);
-    });
-
-    it('should return correct schema target', () => {
-      const compat = new OpenAIReasoningSchemaCompatLayer(mockModels.openaiReasoning);
-      expect(compat.getSchemaTarget()).toBe('openApi3');
-    });
-  });
-
-  describe('GoogleSchemaCompatLayer', () => {
-    it('should have consistent behavior', () => {
-      const compat = new GoogleSchemaCompatLayer(mockModels.google);
-      expect(typeof compat.shouldApply()).toBe('boolean');
-    });
-
-    it('should return correct schema target', () => {
-      const compat = new GoogleSchemaCompatLayer(mockModels.google);
-      expect(compat.getSchemaTarget()).toBe('jsonSchema7');
-    });
-
-    it('should handle date types correctly', () => {
-      const compat = new GoogleSchemaCompatLayer(mockModels.google);
-      const schema = z.object({
-        startDate: z.date(),
-        endDate: z.date().optional(),
-        title: z.string(),
-      });
-
-      const result = compat.processToAISDKSchema(schema);
-
-      expect(result).toHaveProperty('jsonSchema');
-      expect(result).toHaveProperty('validate');
-
-      const validData = {
-        startDate: new Date(),
-        title: 'Hello, world!',
-      };
-
-      const validationResult = result.validate!(validData);
-      expect(typeof validationResult).toBe('object');
-      expect(validationResult).toHaveProperty('success');
-    });
-  });
-
-  describe('DeepSeekSchemaCompatLayer', () => {
-    it('should apply for DeepSeek models', () => {
-      const compat = new DeepSeekSchemaCompatLayer(mockModels.deepseek);
-      expect(compat.shouldApply()).toBe(true);
-    });
-
-    it('should not apply for non-DeepSeek models', () => {
-      const compat = new DeepSeekSchemaCompatLayer(mockModels.openai);
-      expect(compat.shouldApply()).toBe(false);
-    });
-
-    it('should return correct schema target', () => {
-      const compat = new DeepSeekSchemaCompatLayer(mockModels.deepseek);
-      expect(compat.getSchemaTarget()).toBe('jsonSchema7');
-    });
-
-    it('should handle string constraints', () => {
-      const compat = new DeepSeekSchemaCompatLayer(mockModels.deepseek);
-      const schema = z.object({
-        email: z.string().email(),
-        url: z.string().url(),
-        uuid: z.string().uuid(),
-        text: z.string().min(10).max(1000),
-      });
-
-      const result = compat.processToAISDKSchema(schema);
-
-      expect(result).toHaveProperty('jsonSchema');
-      expect(result).toHaveProperty('validate');
-
-      const validData = {
-        email: 'john@example.com',
-        url: 'https://example.com',
-        uuid: '123e4567-e89b-12d3-a456-426614174000',
-        text: 'Hello, world!',
-      };
-
-      const validationResult = result.validate!(validData);
-      expect(typeof validationResult).toBe('object');
-      expect(validationResult).toHaveProperty('success');
-    });
-  });
-
-  describe('MetaSchemaCompatLayer', () => {
-    it('should have consistent behavior', () => {
-      const compat = new MetaSchemaCompatLayer(mockModels.meta);
-      expect(typeof compat.shouldApply()).toBe('boolean');
-    });
-
-    it('should return correct schema target', () => {
-      const compat = new MetaSchemaCompatLayer(mockModels.meta);
-      expect(compat.getSchemaTarget()).toBe('jsonSchema7');
-    });
-
-    it('should handle array and union types', () => {
-      const compat = new MetaSchemaCompatLayer(mockModels.meta);
-      const schema = z.object({
-        tags: z.array(z.string()).min(1).max(10),
-        status: z.union([z.literal('active'), z.literal('inactive')]),
-        priority: z.enum(['low', 'medium', 'high']),
-      });
-
-      const result = compat.processToAISDKSchema(schema);
-
-      expect(result).toHaveProperty('jsonSchema');
-      expect(result).toHaveProperty('validate');
-
-      const validData = {
-        tags: ['tag1'],
-        status: 'active',
-        priority: 'high',
-      };
-
-      const validationResult = result.validate!(validData);
-      expect(typeof validationResult).toBe('object');
-      expect(validationResult).toHaveProperty('success');
-    });
-  });
-
-  describe('Integration tests', () => {
-    it('should handle schema processing across providers', () => {
-      const complexSchema = z.object({
-        user: z.object({
-          name: z.string().min(1).max(100),
-          email: z.string().email(),
-          age: z.number().min(0).max(120).optional(),
-        }),
-        preferences: z.object({
-          theme: z.enum(['light', 'dark']),
-          notifications: z.boolean(),
-          language: z.string().regex(/^[a-z]{2}$/),
-        }),
-        tags: z.array(z.string()).min(1).max(5),
-        metadata: z.record(z.union([z.string(), z.number(), z.boolean()])),
-        createdAt: z.date(),
-        settings: z
-          .object({
-            public: z.boolean(),
-            featured: z.boolean().optional(),
-          })
-          .optional(),
-      });
-
-      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),
-      ];
-
-      providers.forEach(provider => {
-        const result = provider.processToAISDKSchema(complexSchema);
-
-        expect(result).toHaveProperty('jsonSchema');
-        expect(result).toHaveProperty('validate');
-        expect(typeof result.validate).toBe('function');
-
-        const validData = {
-          user: {
-            name: 'John Doe',
-            email: 'john@example.com',
-          },
-          preferences: {
-            theme: 'dark' as const,
-            notifications: true,
-            language: 'en',
-          },
-          tags: ['tag1'],
-          metadata: {
-            key1: 'value1',
-          },
-          createdAt: new Date(),
-        };
-
-        const validationResult = result.validate!(validData);
-        expect(typeof validationResult).toBe('object');
-        expect(validationResult).toHaveProperty('success');
-      });
-    });
-  });
-});