@mastra/schema-compat 0.0.0-fix-message-list-args-missing-20250807205055 → 0.0.0-vector-query-tool-provider-options-20250828222356

package/src/types.ts

@@ -0,0 +1,5 @@
+export type ModelInformation = {
+  modelId: string;
+  provider: string;
+  supportsStructuredOutputs: boolean;
+};

package/src/utils-test-suite.ts

@@ -0,0 +1,467 @@
+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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,9 @@
+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,12 +1,18 @@
 import { jsonSchema } from 'ai';
 import type { Schema } from 'ai';
 import type { JSONSchema7 } from 'json-schema';
-import type { z, ZodSchema } from 'zod';
+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 type { JSONSchema as ZodFromJSONSchema_JSONSchema } 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 { zodToJsonSchema } 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.
@@ -33,18 +39,14 @@ import type { SchemaCompatLayer } from './schema-compatibility';
  */
 // 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 };
-      },
+  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 };
     },
-  );
+  });
 }
 
 /**
@@ -54,7 +56,7 @@ export function convertZodSchemaToAISDKSchema(zodSchema: ZodSchema, target: Targ
  * @returns True if the value is a Zod type, false otherwise
  * @internal
  */
-function isZodType(value: unknown): value is z.ZodType {
+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' &&
@@ -92,13 +94,18 @@ function isZodType(value: unknown): value is z.ZodType {
  * const zodSchema = convertSchemaToZod(aiSchema);
  * ```
  */
-export function convertSchemaToZod(schema: Schema | z.ZodSchema): z.ZodType {
+export function convertSchemaToZod(schema: Schema | ZodSchema): ZodType {
   if (isZodType(schema)) {
     return schema;
   } else {
-    const jsonSchemaToConvert = ('jsonSchema' in schema ? schema.jsonSchema : schema) as ZodFromJSONSchema_JSONSchema;
+    const jsonSchemaToConvert = ('jsonSchema' in schema ? schema.jsonSchema : schema) as JSONSchema;
     try {
-      return convertJsonSchemaToZod(jsonSchemaToConvert);
+      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);
@@ -117,7 +124,7 @@ export function convertSchemaToZod(schema: Schema | z.ZodSchema): z.ZodType {
  * @returns Processed schema as an AI SDK Schema
  */
 export function applyCompatLayer(options: {
-  schema: Schema | z.ZodSchema;
+  schema: Schema | ZodSchema;
   compatLayers: SchemaCompatLayer[];
   mode: 'aiSdkSchema';
 }): Schema;
@@ -132,7 +139,7 @@ export function applyCompatLayer(options: {
  * @returns Processed schema as a JSONSchema7
  */
 export function applyCompatLayer(options: {
-  schema: Schema | z.ZodSchema;
+  schema: Schema | ZodSchema;
   compatLayers: SchemaCompatLayer[];
   mode: 'jsonSchema';
 }): JSONSchema7;
@@ -177,11 +184,11 @@ export function applyCompatLayer({
   compatLayers,
   mode,
 }: {
-  schema: Schema | z.ZodSchema;
+  schema: Schema | ZodSchema;
   compatLayers: SchemaCompatLayer[];
   mode: 'jsonSchema' | 'aiSdkSchema';
 }): JSONSchema7 | Schema {
-  let zodSchema: z.ZodSchema;
+  let zodSchema: ZodSchema;
 
   if (!isZodType(schema)) {
     // Convert non-zod schema to Zod
@@ -195,10 +202,9 @@ export function applyCompatLayer({
       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;
+    return zodToJsonSchema(zodSchema, 'jsonSchema7') as JSONSchema7;
   } else {
     return convertZodSchemaToAISDKSchema(zodSchema);
   }

package/src/zod-to-json.ts

@@ -0,0 +1,28 @@
+import type { JSONSchema7 } from 'json-schema';
+import { z } from 'zod';
+import type { ZodSchema as ZodSchemaV3 } from 'zod/v3';
+import type { ZodType as ZodSchemaV4 } from 'zod/v4';
+import type { Targets } from 'zod-to-json-schema';
+import zodToJsonSchemaOriginal from 'zod-to-json-schema';
+
+export function zodToJsonSchema(zodSchema: ZodSchemaV3 | ZodSchemaV4, target: Targets = 'jsonSchema7') {
+  if ('toJSONSchema' in z) {
+    // Use dynamic property access to avoid import errors in Zod v3
+    return (z as any)['toJSONSchema'](zodSchema, {
+      unrepresentable: 'any',
+      override: (ctx: any) => {
+        // Safe access to handle cases where _zod might be undefined
+        const def = ctx.zodSchema?._zod?.def;
+        if (def && def.type === 'date') {
+          ctx.jsonSchema.type = 'string';
+          ctx.jsonSchema.format = 'date-time';
+        }
+      },
+    }) as JSONSchema7;
+  } else {
+    return zodToJsonSchemaOriginal(zodSchema as ZodSchemaV3, {
+      $refStrategy: 'none',
+      target,
+    }) as JSONSchema7;
+  }
+}