@mastra/schema-compat 0.0.0-taofeeq-fix-tool-call-showing-after-message-20250806184630 → 0.0.0-vnext-20251104230439

package/src/utils.test.ts

@@ -1,434 +0,0 @@
-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');
-    }
-    if (value instanceof z.ZodObject) {
-      return this.defaultZodObjectHandler(value);
-    }
-    if (value instanceof z.ZodArray) {
-      return this.defaultZodArrayHandler(value);
-    }
-    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');
-    });
-
-    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(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);
-    });
-
-    it('should convert AI SDK array schema to Zod', () => {
-      const aiSchema: Schema = jsonSchema({
-        type: 'array',
-        items: {
-          type: 'string',
-        },
-      });
-
-      const result = convertSchemaToZod(aiSchema);
-
-      expect(result).toBeInstanceOf(z.ZodArray);
-      expect((result as z.ZodArray<any>).element).toBeInstanceOf(z.ZodString);
-    });
-  });
-
-  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 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();
-    });
-
-    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.ts

@@ -1,205 +0,0 @@
-import { jsonSchema } from 'ai';
-import type { Schema } from 'ai';
-import type { JSONSchema7 } from 'json-schema';
-import type { z, ZodSchema } 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.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 | z.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 | z.ZodSchema;
-  compatLayers: SchemaCompatLayer[];
-  mode: 'jsonSchema' | 'aiSdkSchema';
-}): JSONSchema7 | Schema {
-  let zodSchema: z.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, { $refStrategy: 'none', target: 'jsonSchema7' }) as JSONSchema7;
-  } else {
-    return convertZodSchemaToAISDKSchema(zodSchema);
-  }
-}

package/tsconfig.build.json

@@ -1,9 +0,0 @@
-{
-  "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 +0,0 @@
-{
-  "extends": "../../tsconfig.node.json",
-  "include": ["src/**/*", "tsup.config.ts"],
-  "exclude": ["node_modules", "**/*.test.ts"]
-}

package/tsup.config.ts

@@ -1,17 +0,0 @@
-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());
-  },
-});

package/vitest.config.ts

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