@mastra/schema-compat 0.11.2-alpha.1 → 0.11.2-alpha.3

package/src/utils-test-suite.ts

@@ -1,467 +0,0 @@
-import { jsonSchema } 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 { ZodType as ZodTypeV3 } from 'zod/v3';
-import type { ZodType as ZodTypeV4 } from 'zod/v4';
-import { SchemaCompatLayer } from './schema-compatibility';
-import type { ModelInformation } from './types';
-import { convertZodSchemaToAISDKSchema, convertSchemaToZod, applyCompatLayer, isZodType } from './utils';
-
-type ZodType = ZodTypeV3 | ZodTypeV4;
-
-const mockModel = new MockLanguageModelV1({
-  modelId: 'test-model',
-  defaultObjectGenerationMode: 'json',
-});
-
-class MockSchemaCompatibility extends SchemaCompatLayer {
-  constructor(
-    model: ModelInformation,
-    private shouldApplyValue: boolean = true,
-  ) {
-    super(model);
-  }
-
-  shouldApply(): boolean {
-    return this.shouldApplyValue;
-  }
-
-  getSchemaTarget() {
-    return 'jsonSchema7' as const;
-  }
-
-  processZodType(value: ZodType): any {
-    if (value.constructor.name === 'ZodString') {
-      return z.string().describe('processed string');
-    }
-    if (value instanceof z.ZodObject) {
-      return this.defaultZodObjectHandler(value);
-    }
-    if (value instanceof z.ZodArray) {
-      return this.defaultZodArrayHandler(value);
-    }
-    return value;
-  }
-}
-
-export function runTestSuite() {
-  describe('Builder Functions', () => {
-    describe('convertZodSchemaToAISDKSchema', () => {
-      it('should convert simple Zod schema to AI SDK schema', () => {
-        const zodSchema = z.object({
-          name: z.string(),
-          age: z.number(),
-        });
-
-        const result = convertZodSchemaToAISDKSchema(zodSchema);
-
-        expect(result).toHaveProperty('jsonSchema');
-        expect(result).toHaveProperty('validate');
-        expect(typeof result.validate).toBe('function');
-      });
-
-      it('should create schema with validation function', () => {
-        const zodSchema = z.object({
-          email: z.string().email(),
-        });
-
-        const result = convertZodSchemaToAISDKSchema(zodSchema);
-
-        expect(result.validate).toBeDefined();
-
-        const validResult = result.validate!({ email: 'test@example.com' });
-        expect(validResult.success).toBe(true);
-        if (validResult.success) {
-          expect(validResult.value).toEqual({ email: 'test@example.com' });
-        }
-
-        const invalidResult = result.validate!({ email: 'invalid-email' });
-        expect(invalidResult.success).toBe(false);
-      });
-
-      it('should handle custom targets', () => {
-        const zodSchema = z.object({
-          name: z.string(),
-        });
-
-        const result = convertZodSchemaToAISDKSchema(zodSchema, 'openApi3');
-
-        expect(result).toHaveProperty('jsonSchema');
-        expect(result).toHaveProperty('validate');
-      });
-
-      it('should handle complex nested schemas', () => {
-        const zodSchema = z.object({
-          user: z.object({
-            name: z.string(),
-            preferences: z.object({
-              theme: z.enum(['light', 'dark']),
-              notifications: z.boolean(),
-            }),
-          }),
-          tags: z.array(z.string()),
-        });
-
-        const result = convertZodSchemaToAISDKSchema(zodSchema);
-
-        expect(result).toHaveProperty('jsonSchema');
-        expect(result.jsonSchema).toHaveProperty('properties');
-      });
-
-      it('should handle array schemas', () => {
-        const zodSchema = z.array(z.string());
-        const result = convertZodSchemaToAISDKSchema(zodSchema);
-        expect(result.jsonSchema.type).toBe('array');
-        expect((result.jsonSchema.items as any)?.type).toBe('string');
-      });
-    });
-
-    describe('convertSchemaToZod', () => {
-      it('should return Zod schema unchanged', () => {
-        const zodSchema = z.object({
-          name: z.string(),
-        });
-
-        const result = convertSchemaToZod(zodSchema);
-
-        expect(result).toBe(zodSchema);
-      });
-
-      it('should convert AI SDK schema to Zod', () => {
-        const aiSchema: Schema = jsonSchema({
-          type: 'object',
-          properties: {
-            name: { type: 'string' },
-            age: { type: 'number' },
-          },
-          required: ['name'],
-        });
-
-        const result = convertSchemaToZod(aiSchema);
-
-        expect(isZodType(result)).toBe(true);
-        const parseResult = result.safeParse({ name: 'John', age: 30 });
-        expect(parseResult.success).toBe(true);
-      });
-
-      it('should handle complex JSON schema conversion', () => {
-        const complexSchema: Schema = jsonSchema({
-          type: 'object',
-          properties: {
-            user: {
-              type: 'object',
-              properties: {
-                name: { type: 'string' },
-                email: { type: 'string', format: 'email' },
-              },
-              required: ['name'],
-            },
-            tags: {
-              type: 'array',
-              items: { type: 'string' },
-            },
-          },
-          required: ['user'],
-        });
-
-        const result = convertSchemaToZod(complexSchema);
-
-        expect(isZodType(result)).toBe(true);
-
-        const validData = {
-          user: { name: 'John', email: 'john@example.com' },
-          tags: ['tag1', 'tag2'],
-        };
-        const parseResult = result.safeParse(validData);
-        expect(parseResult.success).toBe(true);
-      });
-
-      it('should convert AI SDK array schema to Zod', () => {
-        const aiSchema: Schema = jsonSchema({
-          type: 'array',
-          items: {
-            type: 'string',
-          },
-        });
-
-        const result = convertSchemaToZod(aiSchema);
-
-        expect(result.constructor.name).toBe('ZodArray');
-        // @ts-expect-error - this is a test so we can ignore the type error
-        expect(result.element.constructor.name).toBe('ZodString');
-      });
-    });
-
-    describe('applyCompatLayer', () => {
-      let mockCompatibility: MockSchemaCompatibility;
-
-      beforeEach(() => {
-        mockCompatibility = new MockSchemaCompatibility({
-          modelId: mockModel.modelId,
-          supportsStructuredOutputs: mockModel.supportsStructuredOutputs ?? false,
-          provider: mockModel.provider,
-        });
-      });
-
-      it('should process Zod object schema with compatibility', () => {
-        const zodSchema = z.object({
-          name: z.string(),
-          age: z.number(),
-        });
-
-        const result = applyCompatLayer({
-          schema: zodSchema,
-          compatLayers: [mockCompatibility],
-          mode: 'aiSdkSchema',
-        });
-
-        expect(result).toHaveProperty('jsonSchema');
-        expect(result).toHaveProperty('validate');
-      });
-
-      it('should process AI SDK schema with compatibility', () => {
-        const aiSchema: Schema = jsonSchema({
-          type: 'object',
-          properties: {
-            name: { type: 'string' },
-          },
-        });
-
-        const result = applyCompatLayer({
-          schema: aiSchema,
-          compatLayers: [mockCompatibility],
-          mode: 'jsonSchema',
-        });
-
-        expect(typeof result).toBe('object');
-        expect(result).toHaveProperty('type');
-      });
-
-      it('should handle object schema with string property', () => {
-        const stringSchema = z.object({ value: z.string() });
-
-        const result = applyCompatLayer({
-          schema: stringSchema,
-          compatLayers: [mockCompatibility],
-          mode: 'aiSdkSchema',
-        });
-
-        expect(result).toHaveProperty('jsonSchema');
-        expect(result).toHaveProperty('validate');
-      });
-
-      it('should return processed schema when compatibility applies', () => {
-        const zodSchema = z.object({
-          name: z.string(),
-        });
-
-        const result = applyCompatLayer({
-          schema: zodSchema,
-          compatLayers: [mockCompatibility],
-          mode: 'aiSdkSchema',
-        });
-
-        expect(result).toHaveProperty('jsonSchema');
-        expect(result).toHaveProperty('validate');
-      });
-
-      it('should return fallback when no compatibility applies', () => {
-        const nonApplyingCompatibility = new MockSchemaCompatibility(
-          {
-            modelId: mockModel.modelId,
-            supportsStructuredOutputs: mockModel.supportsStructuredOutputs ?? false,
-            provider: mockModel.provider,
-          },
-          false,
-        );
-        const zodSchema = z.object({
-          name: z.string(),
-        });
-
-        const result = applyCompatLayer({
-          schema: zodSchema,
-          compatLayers: [nonApplyingCompatibility],
-          mode: 'aiSdkSchema',
-        });
-
-        expect(result).toHaveProperty('jsonSchema');
-        expect(result).toHaveProperty('validate');
-      });
-
-      it('should handle jsonSchema mode', () => {
-        const zodSchema = z.object({
-          name: z.string(),
-        });
-
-        const result = applyCompatLayer({
-          schema: zodSchema,
-          compatLayers: [mockCompatibility],
-          mode: 'jsonSchema',
-        });
-
-        expect(typeof result).toBe('object');
-        expect(result).toHaveProperty('type');
-      });
-
-      it('should handle empty compatLayers array', () => {
-        const zodSchema = z.object({
-          name: z.string(),
-        });
-
-        const result = applyCompatLayer({
-          schema: zodSchema,
-          compatLayers: [],
-          mode: 'aiSdkSchema',
-        });
-
-        expect(result).toHaveProperty('jsonSchema');
-        expect(result).toHaveProperty('validate');
-      });
-
-      it('should handle complex schema with multiple compatLayers', () => {
-        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');
-
-        const zodSchema = z.object({
-          name: z.string(),
-          settings: z.object({
-            theme: z.string(),
-            notifications: z.boolean(),
-          }),
-        });
-
-        const result = applyCompatLayer({
-          schema: zodSchema,
-          compatLayers: [compat1, compat2],
-          mode: 'aiSdkSchema',
-        });
-
-        expect(result).toHaveProperty('jsonSchema');
-        expect(result).toHaveProperty('validate');
-        expect(compat1.processZodType).not.toHaveBeenCalled();
-        expect(compat2.processZodType).toHaveBeenCalled();
-      });
-
-      it('should process Zod array schema with compatibility', () => {
-        const arraySchema = z.array(z.string());
-
-        const result = applyCompatLayer({
-          schema: arraySchema,
-          compatLayers: [mockCompatibility],
-          mode: 'aiSdkSchema',
-        });
-
-        expect(result.jsonSchema.type).toBe('array');
-        if (
-          result.jsonSchema.items &&
-          !Array.isArray(result.jsonSchema.items) &&
-          typeof result.jsonSchema.items === 'object'
-        ) {
-          expect(result.jsonSchema.items.type).toBe('string');
-          expect(result.jsonSchema.items.description).toBe('processed string');
-        } else {
-          expect.fail('items is not a single schema object');
-        }
-      });
-
-      it('should process AI SDK array schema with compatibility', () => {
-        const aiSchema: Schema = jsonSchema({
-          type: 'array',
-          items: {
-            type: 'string',
-          },
-        });
-
-        const result = applyCompatLayer({
-          schema: aiSchema,
-          compatLayers: [mockCompatibility],
-          mode: 'aiSdkSchema',
-        });
-
-        expect(result.jsonSchema.type).toBe('array');
-        if (
-          result.jsonSchema.items &&
-          !Array.isArray(result.jsonSchema.items) &&
-          typeof result.jsonSchema.items === 'object'
-        ) {
-          expect(result.jsonSchema.items.type).toBe('string');
-          expect(result.jsonSchema.items.description).toBe('processed string');
-        } else {
-          expect.fail('items is not a single schema object');
-        }
-      });
-
-      it('should handle a complex array of objects schema', () => {
-        const complexArraySchema = z.array(
-          z.object({
-            id: z.string(),
-            user: z.object({
-              name: z.string(),
-            }),
-          }),
-        );
-
-        const result = applyCompatLayer({
-          schema: complexArraySchema,
-          compatLayers: [mockCompatibility],
-          mode: 'aiSdkSchema',
-        });
-
-        const { jsonSchema } = result;
-        expect(jsonSchema.type).toBe('array');
-
-        const items = jsonSchema.items;
-        if (items && !Array.isArray(items) && typeof items === 'object') {
-          expect(items.type).toBe('object');
-          expect(items.properties).toHaveProperty('id');
-          expect(items.properties).toHaveProperty('user');
-
-          const idProperty = items.properties!.id as any;
-          expect(idProperty.description).toBe('processed string');
-
-          const userProperty = items.properties!.user as any;
-          expect(userProperty.type).toBe('object');
-          expect(userProperty.properties).toHaveProperty('name');
-
-          const nameProperty = userProperty.properties.name as any;
-          expect(nameProperty.description).toBe('processed string');
-        } else {
-          expect.fail('items is not a single schema object');
-        }
-      });
-
-      it('should handle a scalar zod schema', () => {
-        const scalarSchema = z.string().email();
-
-        const result = applyCompatLayer({
-          schema: scalarSchema,
-          compatLayers: [mockCompatibility],
-          mode: 'aiSdkSchema',
-        });
-
-        const { jsonSchema } = result;
-        expect(jsonSchema.type).toBe('string');
-        expect(jsonSchema.description).toBe('processed string');
-      });
-    });
-  });
-}

package/src/utils-v3.test.ts

@@ -1,9 +0,0 @@
-import { vi } from 'vitest';
-import { z as zV3 } from 'zod/v3';
-import { runTestSuite } from './utils-test-suite';
-
-vi.mock('zod', () => ({
-  z: zV3,
-}));
-
-runTestSuite();

package/src/utils-v4.test.ts

@@ -1,9 +0,0 @@
-import { vi } from 'vitest';
-import { z as zV4 } from 'zod/v4';
-import { runTestSuite } from './utils-test-suite';
-
-vi.mock('zod', () => ({
-  z: zV4,
-}));
-
-runTestSuite();

package/src/utils.ts

@@ -1,211 +0,0 @@
-import { jsonSchema } from 'ai';
-import type { Schema } from 'ai';
-import type { JSONSchema7 } from 'json-schema';
-import { z } from 'zod';
-import type { ZodSchema as ZodSchemaV3, ZodType as ZodTypeV3 } from 'zod/v3';
-import type { ZodType as ZodSchemaV4, ZodType as ZodTypeV4 } from 'zod/v4';
-import { convertJsonSchemaToZod } from 'zod-from-json-schema';
-import { convertJsonSchemaToZod as convertJsonSchemaToZodV3 } from 'zod-from-json-schema-v3';
-import type { JSONSchema } from 'zod-from-json-schema-v3';
-import type { Targets } from 'zod-to-json-schema';
-import type { SchemaCompatLayer } from './schema-compatibility';
-import { zodToJsonSchema } from './zod-to-json';
-
-type ZodSchema = ZodSchemaV3 | ZodSchemaV4;
-type ZodType = ZodTypeV3 | ZodTypeV4;
-
-/**
- * Converts a Zod schema to an AI SDK Schema with validation support.
- *
- * This function mirrors the behavior of Vercel's AI SDK zod-schema utility but allows
- * customization of the JSON Schema target format.
- *
- * @param zodSchema - The Zod schema to convert
- * @param target - The JSON Schema target format (defaults to 'jsonSchema7')
- * @returns An AI SDK Schema object with built-in validation
- *
- * @example
- * ```typescript
- * import { z } from 'zod';
- * import { convertZodSchemaToAISDKSchema } from '@mastra/schema-compat';
- *
- * const userSchema = z.object({
- *   name: z.string(),
- *   age: z.number().min(0)
- * });
- *
- * const aiSchema = convertZodSchemaToAISDKSchema(userSchema);
- * ```
- */
-// mirrors https://github.com/vercel/ai/blob/main/packages/ui-utils/src/zod-schema.ts#L21 but with a custom target
-export function convertZodSchemaToAISDKSchema(zodSchema: ZodSchema, target: Targets = 'jsonSchema7') {
-  const jsonSchemaToUse = zodToJsonSchema(zodSchema, target) as JSONSchema7;
-
-  return jsonSchema(jsonSchemaToUse, {
-    validate: value => {
-      const result = zodSchema.safeParse(value);
-      return result.success ? { success: true, value: result.data } : { success: false, error: result.error };
-    },
-  });
-}
-
-/**
- * Checks if a value is a Zod type by examining its properties and methods.
- *
- * @param value - The value to check
- * @returns True if the value is a Zod type, false otherwise
- * @internal
- */
-export function isZodType(value: unknown): value is ZodType {
-  // Check if it's a Zod schema by looking for common Zod properties and methods
-  return (
-    typeof value === 'object' &&
-    value !== null &&
-    '_def' in value &&
-    'parse' in value &&
-    typeof (value as any).parse === 'function' &&
-    'safeParse' in value &&
-    typeof (value as any).safeParse === 'function'
-  );
-}
-
-/**
- * Converts an AI SDK Schema or Zod schema to a Zod schema.
- *
- * If the input is already a Zod schema, it returns it unchanged.
- * If the input is an AI SDK Schema, it extracts the JSON schema and converts it to Zod.
- *
- * @param schema - The schema to convert (AI SDK Schema or Zod schema)
- * @returns A Zod schema equivalent of the input
- * @throws Error if the conversion fails
- *
- * @example
- * ```typescript
- * import { jsonSchema } from 'ai';
- * import { convertSchemaToZod } from '@mastra/schema-compat';
- *
- * const aiSchema = jsonSchema({
- *   type: 'object',
- *   properties: {
- *     name: { type: 'string' }
- *   }
- * });
- *
- * const zodSchema = convertSchemaToZod(aiSchema);
- * ```
- */
-export function convertSchemaToZod(schema: Schema | ZodSchema): ZodType {
-  if (isZodType(schema)) {
-    return schema;
-  } else {
-    const jsonSchemaToConvert = ('jsonSchema' in schema ? schema.jsonSchema : schema) as JSONSchema;
-    try {
-      if ('toJSONSchema' in z) {
-        // @ts-expect-error - zod type issue
-        return convertJsonSchemaToZod(jsonSchemaToConvert);
-      } else {
-        return convertJsonSchemaToZodV3(jsonSchemaToConvert);
-      }
-    } catch (e: unknown) {
-      const errorMessage = `[Schema Builder] Failed to convert schema parameters to Zod. Original schema: ${JSON.stringify(jsonSchemaToConvert)}`;
-      console.error(errorMessage, e);
-      throw new Error(errorMessage + (e instanceof Error ? `\n${e.stack}` : '\nUnknown error object'));
-    }
-  }
-}
-
-/**
- * Processes a schema using provider compatibility layers and converts it to an AI SDK Schema.
- *
- * @param options - Configuration object for schema processing
- * @param options.schema - The schema to process (AI SDK Schema or Zod object schema)
- * @param options.compatLayers - Array of compatibility layers to try
- * @param options.mode - Must be 'aiSdkSchema'
- * @returns Processed schema as an AI SDK Schema
- */
-export function applyCompatLayer(options: {
-  schema: Schema | ZodSchema;
-  compatLayers: SchemaCompatLayer[];
-  mode: 'aiSdkSchema';
-}): Schema;
-
-/**
- * Processes a schema using provider compatibility layers and converts it to a JSON Schema.
- *
- * @param options - Configuration object for schema processing
- * @param options.schema - The schema to process (AI SDK Schema or Zod object schema)
- * @param options.compatLayers - Array of compatibility layers to try
- * @param options.mode - Must be 'jsonSchema'
- * @returns Processed schema as a JSONSchema7
- */
-export function applyCompatLayer(options: {
-  schema: Schema | ZodSchema;
-  compatLayers: SchemaCompatLayer[];
-  mode: 'jsonSchema';
-}): JSONSchema7;
-
-/**
- * Processes a schema using provider compatibility layers and converts it to the specified format.
- *
- * This function automatically applies the first matching compatibility layer from the provided
- * list based on the model configuration. If no compatibility applies, it falls back to
- * standard conversion.
- *
- * @param options - Configuration object for schema processing
- * @param options.schema - The schema to process (AI SDK Schema or Zod object schema)
- * @param options.compatLayers - Array of compatibility layers to try
- * @param options.mode - Output format: 'jsonSchema' for JSONSchema7 or 'aiSdkSchema' for AI SDK Schema
- * @returns Processed schema in the requested format
- *
- * @example
- * ```typescript
- * import { z } from 'zod';
- * import { applyCompatLayer, OpenAISchemaCompatLayer, AnthropicSchemaCompatLayer } from '@mastra/schema-compat';
- *
- * const schema = z.object({
- *   query: z.string().email(),
- *   limit: z.number().min(1).max(100)
- * });
- *
- * const compatLayers = [
- *   new OpenAISchemaCompatLayer(model),
- *   new AnthropicSchemaCompatLayer(model)
- * ];
- *
- * const result = applyCompatLayer({
- *   schema,
- *   compatLayers,
- *   mode: 'aiSdkSchema'
- * });
- * ```
- */
-export function applyCompatLayer({
-  schema,
-  compatLayers,
-  mode,
-}: {
-  schema: Schema | ZodSchema;
-  compatLayers: SchemaCompatLayer[];
-  mode: 'jsonSchema' | 'aiSdkSchema';
-}): JSONSchema7 | Schema {
-  let zodSchema: ZodSchema;
-
-  if (!isZodType(schema)) {
-    // Convert non-zod schema to Zod
-    zodSchema = convertSchemaToZod(schema);
-  } else {
-    zodSchema = schema;
-  }
-
-  for (const compat of compatLayers) {
-    if (compat.shouldApply()) {
-      return mode === 'jsonSchema' ? compat.processToJSONSchema(zodSchema) : compat.processToAISDKSchema(zodSchema);
-    }
-  }
-  // If no compatibility applied, convert back to appropriate format
-  if (mode === 'jsonSchema') {
-    return zodToJsonSchema(zodSchema, 'jsonSchema7') as JSONSchema7;
-  } else {
-    return convertZodSchemaToAISDKSchema(zodSchema);
-  }
-}