@mastra/schema-compat 0.10.2-alpha.2

package/src/utils.test.ts

@@ -0,0 +1,328 @@
+import { jsonSchema } from 'ai';
+import type { LanguageModelV1, Schema } from 'ai';
+import { MockLanguageModelV1 } from 'ai/test';
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { z } from 'zod';
+import { SchemaCompatLayer } from './schema-compatibility';
+import { convertZodSchemaToAISDKSchema, convertSchemaToZod, applyCompatLayer } from './utils';
+
+const mockModel = new MockLanguageModelV1({
+  modelId: 'test-model',
+  defaultObjectGenerationMode: 'json',
+});
+
+class MockSchemaCompatibility extends SchemaCompatLayer {
+  constructor(
+    model: LanguageModelV1,
+    private shouldApplyValue: boolean = true,
+  ) {
+    super(model);
+  }
+
+  shouldApply(): boolean {
+    return this.shouldApplyValue;
+  }
+
+  getSchemaTarget() {
+    return 'jsonSchema7' as const;
+  }
+
+  processZodType(value: z.ZodTypeAny): any {
+    if (value._def.typeName === 'ZodString') {
+      return z.string().describe('processed string');
+    }
+    return value;
+  }
+}
+
+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');
+    });
+  });
+
+  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(result).toBeInstanceOf(z.ZodType);
+      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(result).toBeInstanceOf(z.ZodType);
+
+      const validData = {
+        user: { name: 'John', email: 'john@example.com' },
+        tags: ['tag1', 'tag2'],
+      };
+      const parseResult = result.safeParse(validData);
+      expect(parseResult.success).toBe(true);
+    });
+  });
+
+  describe('applyCompatLayer', () => {
+    let mockCompatibility: MockSchemaCompatibility;
+
+    beforeEach(() => {
+      mockCompatibility = new MockSchemaCompatibility(mockModel);
+    });
+
+    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(mockModel, 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 convert non-object AI SDK schema correctly', () => {
+      const stringSchema: Schema = jsonSchema({ type: 'string' });
+
+      const result = applyCompatLayer({
+        schema: stringSchema,
+        compatLayers: [mockCompatibility],
+        mode: 'aiSdkSchema',
+      });
+
+      expect(result).toHaveProperty('jsonSchema');
+      expect(result).toHaveProperty('validate');
+
+      // Verify the schema structure shows the string was wrapped in a 'value' property
+      const resultSchema = (result as Schema).jsonSchema;
+      expect(resultSchema).toHaveProperty('type', 'object');
+      expect(resultSchema).toHaveProperty('properties');
+      expect(resultSchema.properties).toHaveProperty('value');
+
+      // Verify the string property has the description added by the mock compatibility layer
+      const valueProperty = resultSchema.properties!.value as any;
+      expect(valueProperty).toHaveProperty('description', 'processed string');
+    });
+
+    it('should handle complex schema with multiple compatLayers', () => {
+      const compat1 = new MockSchemaCompatibility(mockModel, false);
+      const compat2 = new MockSchemaCompatibility(mockModel, 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();
+    });
+  });
+});

package/src/utils.ts

@@ -0,0 +1,218 @@
+import { jsonSchema } from 'ai';
+import type { Schema } from 'ai';
+import type { JSONSchema7 } from 'json-schema';
+import type { ZodSchema } from 'zod';
+import { z } from 'zod';
+import { convertJsonSchemaToZod } from 'zod-from-json-schema';
+import type { JSONSchema as ZodFromJSONSchema_JSONSchema } from 'zod-from-json-schema';
+import type { Targets } from 'zod-to-json-schema';
+import { zodToJsonSchema } from 'zod-to-json-schema';
+import type { SchemaCompatLayer } from './schema-compatibility';
+
+/**
+ * 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') {
+  return jsonSchema(
+    zodToJsonSchema(zodSchema, {
+      $refStrategy: 'none',
+      target,
+    }) as JSONSchema7,
+    {
+      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
+ */
+function isZodType(value: unknown): value is z.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 | z.ZodSchema): z.ZodType {
+  if (isZodType(schema)) {
+    return schema;
+  } else {
+    const jsonSchemaToConvert = ('jsonSchema' in schema ? schema.jsonSchema : schema) as ZodFromJSONSchema_JSONSchema;
+    try {
+      return convertJsonSchemaToZod(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 | z.AnyZodObject;
+  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 | z.AnyZodObject;
+  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 | z.AnyZodObject;
+  compatLayers: SchemaCompatLayer[];
+  mode: 'jsonSchema' | 'aiSdkSchema';
+}): JSONSchema7 | Schema {
+  let zodSchema: z.AnyZodObject;
+
+  if (!isZodType(schema)) {
+    // Convert Schema to ZodObject
+    const convertedSchema = convertSchemaToZod(schema);
+    if (convertedSchema instanceof z.ZodObject) {
+      zodSchema = convertedSchema;
+    } else {
+      // If it's not an object schema, wrap it in an object
+      zodSchema = z.object({ value: convertedSchema });
+    }
+  } else {
+    // Ensure it's a ZodObject
+    if (schema instanceof z.ZodObject) {
+      zodSchema = schema;
+    } else {
+      // Wrap non-object schemas in an object
+      zodSchema = z.object({ value: 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, { $refStrategy: 'none', target: 'jsonSchema7' }) as JSONSchema7;
+  } else {
+    return convertZodSchemaToAISDKSchema(zodSchema);
+  }
+}

package/tsconfig.json

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

package/vitest.config.ts

@@ -0,0 +1,7 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    environment: 'node',
+  },
+});