@ai-sdk/provider-utils 4.0.8 → 4.0.10

package/src/types/tool.test-d.ts

@@ -1,228 +0,0 @@
-import { LanguageModelV3ToolResultPart } from '@ai-sdk/provider';
-import { describe, expectTypeOf, it } from 'vitest';
-import { z } from 'zod/v4';
-import { FlexibleSchema } from '../schema';
-import { ModelMessage } from './model-message';
-import { Tool, tool, ToolExecuteFunction } from './tool';
-import { ToolResultOutput } from './content-part';
-
-describe('tool type', () => {
-  describe('input type', () => {
-    it('should work with fixed inputSchema', () => {
-      const aTool = tool({
-        inputSchema: z.object({ number: z.number() }),
-      });
-
-      expectTypeOf(aTool).toEqualTypeOf<Tool<{ number: number }, never>>();
-      expectTypeOf(aTool.execute).toEqualTypeOf<undefined>();
-      expectTypeOf(aTool.execute).not.toEqualTypeOf<Function>();
-      expectTypeOf(aTool.inputSchema).toEqualTypeOf<
-        FlexibleSchema<{ number: number }>
-      >();
-    });
-
-    it('should work with flexible inputSchema', <T>() => {
-      const aTool = tool({
-        inputSchema: null as unknown as FlexibleSchema<T>,
-      });
-
-      expectTypeOf(aTool).toEqualTypeOf<Tool<T, never>>();
-      expectTypeOf(aTool.execute).toEqualTypeOf<undefined>();
-      expectTypeOf(aTool.execute).not.toEqualTypeOf<Function>();
-      expectTypeOf(aTool.inputSchema).toEqualTypeOf<FlexibleSchema<T>>();
-    });
-
-    it('should infer input type correctly when inputExamples are present with optional/default zod schema', () => {
-      const inputSchema = z.object({
-        location: z.string(),
-        unit: z.enum(['celsius', 'fahrenheit']).optional().default('celsius'),
-      });
-
-      tool({
-        description: 'Get the weather for a location',
-        inputSchema,
-        inputExamples: [
-          { input: { location: 'San Francisco', unit: 'celsius' } },
-        ],
-        execute: async input => {
-          expectTypeOf(input).toEqualTypeOf<z.infer<typeof inputSchema>>();
-          return { temperature: 20, unit: input.unit };
-        },
-      });
-    });
-
-    it('should infer input type correctly when inputExamples are present with refine zod schema', () => {
-      const inputSchema = z.object({
-        code: z.string().refine(val => val.length === 3),
-      });
-
-      tool({
-        description: 'Get code details',
-        inputSchema,
-        inputExamples: [{ input: { code: 'ABC' } }],
-        execute: async input => {
-          expectTypeOf(input).toEqualTypeOf<z.infer<typeof inputSchema>>();
-          return { valid: true };
-        },
-      });
-    });
-  });
-
-  describe('output type', () => {
-    it('should derive output type from execute function', () => {
-      const aTool = tool({
-        inputSchema: z.object({ number: z.number() }),
-        execute: async input => {
-          expectTypeOf(input).toEqualTypeOf<{ number: number }>();
-          return 'test' as const;
-        },
-      });
-
-      expectTypeOf(aTool).toEqualTypeOf<Tool<{ number: number }, 'test'>>();
-      expectTypeOf(aTool.execute).toMatchTypeOf<
-        ToolExecuteFunction<{ number: number }, 'test'> | undefined
-      >();
-      expectTypeOf(aTool.execute).not.toEqualTypeOf<undefined>();
-      expectTypeOf(aTool.inputSchema).toEqualTypeOf<
-        FlexibleSchema<{ number: number }>
-      >();
-    });
-
-    it('should derive const schema from async generator execute function', () => {
-      const aTool = tool({
-        inputSchema: z.object({ number: z.number() }),
-        execute: async function* () {
-          yield 'test' as const;
-        },
-      });
-
-      expectTypeOf(aTool).toEqualTypeOf<Tool<{ number: number }, 'test'>>();
-      expectTypeOf(aTool.execute).toEqualTypeOf<
-        ToolExecuteFunction<{ number: number }, 'test'> | undefined
-      >();
-      expectTypeOf(aTool.inputSchema).toEqualTypeOf<
-        FlexibleSchema<{ number: number }>
-      >();
-    });
-  });
-
-  describe('toModelOutput', () => {
-    it('should infer toModelOutput argument when there is only an input schema', () => {
-      const aTool = tool({
-        inputSchema: z.object({ number: z.number() }),
-        toModelOutput: ({ output }) => {
-          expectTypeOf(output).toEqualTypeOf<any>();
-          return { type: 'text', value: 'test' };
-        },
-      });
-
-      expectTypeOf(aTool.toModelOutput).toMatchTypeOf<
-        | ((options: {
-            toolCallId: string;
-            input: { number: number };
-            output: any;
-          }) => ToolResultOutput | PromiseLike<ToolResultOutput>)
-        | undefined
-      >();
-    });
-
-    it('should infer toModelOutput argument when there is an execute function', () => {
-      const aTool = tool({
-        inputSchema: z.object({ number: z.number() }),
-        execute: async () => 'test' as const,
-        toModelOutput: ({ output }) => {
-          expectTypeOf(output).toEqualTypeOf<'test'>();
-          return { type: 'text', value: 'test' };
-        },
-      });
-
-      expectTypeOf(aTool.toModelOutput).toMatchTypeOf<
-        | ((options: {
-            toolCallId: string;
-            input: { number: number };
-            output: 'test';
-          }) => ToolResultOutput | PromiseLike<ToolResultOutput>)
-        | undefined
-      >();
-    });
-
-    it('should infer toModelOutput argument when there is an output schema', () => {
-      const aTool = tool({
-        inputSchema: z.object({ number: z.number() }),
-        outputSchema: z.literal('test'),
-        toModelOutput: ({ output }) => {
-          expectTypeOf(output).toEqualTypeOf<'test'>();
-          return { type: 'text', value: 'test' };
-        },
-      });
-
-      expectTypeOf(aTool.toModelOutput).toMatchTypeOf<
-        | ((options: {
-            toolCallId: string;
-            input: { number: number };
-            output: 'test';
-          }) => ToolResultOutput | PromiseLike<ToolResultOutput>)
-        | undefined
-      >();
-    });
-  });
-
-  describe('needsApproval (function)', () => {
-    it('should infer needsApproval argument when there is only an input schema', () => {
-      const aTool = tool({
-        inputSchema: z.object({ number: z.number() }),
-        needsApproval: (input, options) => {
-          expectTypeOf(input).toEqualTypeOf<{ number: number }>();
-          expectTypeOf(options).toEqualTypeOf<{
-            toolCallId: string;
-            messages: ModelMessage[];
-            experimental_context?: unknown;
-          }>();
-          return true;
-        },
-      });
-
-      expectTypeOf(aTool.needsApproval).toMatchTypeOf<
-        | boolean
-        | ((
-            input: { number: number },
-            options: {
-              toolCallId: string;
-              messages: ModelMessage[];
-              experimental_context: unknown;
-            },
-          ) => boolean | PromiseLike<boolean>)
-        | undefined
-      >();
-    });
-
-    it('should infer needsApproval argument when there is an execute function', () => {
-      const aTool = tool({
-        inputSchema: z.object({ number: z.number() }),
-        execute: async () => 'test' as const,
-        needsApproval: (input, options) => {
-          expectTypeOf(input).toEqualTypeOf<{ number: number }>();
-          expectTypeOf(options).toEqualTypeOf<{
-            toolCallId: string;
-            messages: ModelMessage[];
-            experimental_context?: unknown;
-          }>();
-          return true;
-        },
-      });
-
-      expectTypeOf(aTool.needsApproval).toMatchTypeOf<
-        | boolean
-        | ((
-            input: { number: number },
-            options: {
-              toolCallId: string;
-              messages: ModelMessage[];
-              experimental_context: unknown;
-            },
-          ) => boolean | PromiseLike<boolean>)
-        | undefined
-      >();
-    });
-  });
-});

package/src/validate-types.test.ts

@@ -1,105 +0,0 @@
-import { TypeValidationError } from '@ai-sdk/provider';
-import { describe, expect, it } from 'vitest';
-import { safeValidateTypes, validateTypes } from './validate-types';
-import { StandardSchema } from './schema';
-
-const customSchema: StandardSchema<{ name: string; age: number }> = {
-  '~standard': {
-    version: 1,
-    vendor: 'custom',
-    validate: async (value: any) => {
-      return typeof value === 'object' &&
-        value !== null &&
-        'name' in value &&
-        typeof value.name === 'string' &&
-        'age' in value &&
-        typeof value.age === 'number'
-        ? { value }
-        : { issues: [new Error('Invalid input')] };
-    },
-    jsonSchema: {
-      input: () => ({
-        type: 'object',
-        properties: {
-          name: { type: 'string' },
-          age: { type: 'number' },
-        },
-      }),
-      output: () => ({
-        type: 'object',
-        properties: {
-          name: { type: 'string' },
-          age: { type: 'number' },
-        },
-      }),
-    },
-  },
-};
-
-describe('validateTypes', () => {
-  it('should return validated object for valid input', async () => {
-    const input = { name: 'John', age: 30 };
-    expect(await validateTypes({ value: input, schema: customSchema })).toEqual(
-      input,
-    );
-  });
-
-  it('should throw TypeValidationError for invalid input', async () => {
-    const input = { name: 'John', age: '30' };
-
-    try {
-      await validateTypes({
-        value: input,
-        schema: customSchema,
-      });
-      expect.fail('Expected TypeValidationError to be thrown');
-    } catch (error) {
-      expect(error).toBeInstanceOf(TypeValidationError);
-
-      const typedError = error as TypeValidationError;
-
-      expect({
-        name: typedError.name,
-        value: typedError.value,
-        cause: typedError.cause,
-        message: typedError.message,
-      }).toStrictEqual({
-        name: 'AI_TypeValidationError',
-        value: input,
-        cause: [expect.any(Error)],
-        message: expect.stringContaining('Type validation failed'),
-      });
-    }
-  });
-});
-
-describe('safeValidateTypes', () => {
-  it('should return validated object for valid input', async () => {
-    const input = { name: 'John', age: 30 };
-    const result = await safeValidateTypes({
-      value: input,
-      schema: customSchema,
-    });
-    expect(result).toEqual({ success: true, value: input, rawValue: input });
-  });
-
-  it('should return error object for invalid input', async () => {
-    const input = { name: 'John', age: '30' };
-    const result = await safeValidateTypes({
-      value: input,
-      schema: customSchema,
-    });
-
-    expect(result).toEqual({
-      success: false,
-      error: expect.any(TypeValidationError),
-      rawValue: input,
-    });
-
-    if (!result.success) {
-      expect(result.error).toBeInstanceOf(TypeValidationError);
-      expect(result.error.value).toEqual(input);
-      expect(result.error.message).toContain('Type validation failed');
-    }
-  });
-});

package/src/with-user-agent-suffix.test.ts

@@ -1,84 +0,0 @@
-import { describe, it, expect } from 'vitest';
-
-import { withUserAgentSuffix } from './with-user-agent-suffix';
-
-describe('withUserAgentSuffix', () => {
-  it('should create a new user-agent header when no existing user-agent exists', () => {
-    const headers = {
-      'content-type': 'application/json',
-      authorization: 'Bearer token123',
-    };
-
-    const result = withUserAgentSuffix(
-      headers,
-      'ai-sdk/0.0.0-test',
-      'provider/test-openai',
-    );
-
-    expect(result['user-agent']).toBe('ai-sdk/0.0.0-test provider/test-openai');
-    expect(result['content-type']).toBe('application/json');
-    expect(result['authorization']).toBe('Bearer token123');
-  });
-
-  it('should append suffix parts to existing user-agent header', () => {
-    const headers = {
-      'user-agent': 'TestApp/0.0.0-test',
-      accept: 'application/json',
-    };
-
-    const result = withUserAgentSuffix(
-      headers,
-      'ai-sdk/0.0.0-test',
-      'provider/test-anthropic',
-    );
-
-    expect(result['user-agent']).toBe(
-      'TestApp/0.0.0-test ai-sdk/0.0.0-test provider/test-anthropic',
-    );
-    expect(result['accept']).toBe('application/json');
-  });
-
-  it('should automatically remove undefined entries from headers', () => {
-    const headers = {
-      'content-type': 'application/json',
-      authorization: undefined,
-      'user-agent': 'TestApp/0.0.0-test',
-      accept: 'application/json',
-      'cache-control': null,
-    };
-
-    const result = withUserAgentSuffix(headers as any, 'ai-sdk/0.0.0-test');
-
-    expect(result['user-agent']).toBe('TestApp/0.0.0-test ai-sdk/0.0.0-test');
-    expect(result['content-type']).toBe('application/json');
-    expect(result['accept']).toBe('application/json');
-    expect(result['authorization']).toBeUndefined();
-    expect(result['cache-control']).toBeUndefined();
-  });
-
-  it('should preserve headers when given a Headers instance', () => {
-    const headers = new Headers({
-      Authorization: 'Bearer token123',
-      'X-Custom': 'value',
-    });
-
-    const result = withUserAgentSuffix(headers, 'ai-sdk/0.0.0-test');
-
-    expect(result['authorization']).toBe('Bearer token123');
-    expect(result['x-custom']).toBe('value');
-    expect(result['user-agent']).toBe('ai-sdk/0.0.0-test');
-  });
-
-  it('should handle array header entries', () => {
-    const headers: HeadersInit = [
-      ['Authorization', 'Bearer token123'],
-      ['X-Feature', 'alpha'],
-    ];
-
-    const result = withUserAgentSuffix(headers, 'ai-sdk/0.0.0-test');
-
-    expect(result['authorization']).toBe('Bearer token123');
-    expect(result['x-feature']).toBe('alpha');
-    expect(result['user-agent']).toBe('ai-sdk/0.0.0-test');
-  });
-});