@ai-sdk/provider-utils 4.0.8 → 4.0.10

package/src/media-type-to-extension.test.ts

@@ -1,26 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { mediaTypeToExtension } from './media-type-to-extension';
-
-describe('mediaTypeToExtension()', () => {
-  it.each([
-    // most common
-    ['audio/mpeg', 'mp3'],
-    ['audio/mp3', 'mp3'],
-    ['audio/wav', 'wav'],
-    ['audio/x-wav', 'wav'],
-    ['audio/webm', 'webm'],
-    ['audio/ogg', 'ogg'],
-    ['audio/opus', 'ogg'],
-    ['audio/mp4', 'm4a'],
-    ['audio/x-m4a', 'm4a'],
-    ['audio/flac', 'flac'],
-    ['audio/aac', 'aac'],
-    // upper case
-    ['AUDIO/MPEG', 'mp3'],
-    ['AUDIO/MP3', 'mp3'],
-    // invalid
-    ['nope', ''],
-  ])('should map %s to %s', (mediaType, expectedExtension) => {
-    expect(mediaTypeToExtension(mediaType)).toBe(expectedExtension);
-  });
-});

package/src/normalize-headers.test.ts

@@ -1,64 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { normalizeHeaders } from './normalize-headers';
-
-describe('normalizeHeaders', () => {
-  it('returns empty object for undefined', () => {
-    expect(normalizeHeaders(undefined)).toEqual({});
-  });
-
-  it('converts Headers instance to record', () => {
-    const headers = new Headers({
-      Authorization: 'Bearer token',
-      'X-Feature': 'beta',
-    });
-
-    expect(normalizeHeaders(headers)).toEqual({
-      authorization: 'Bearer token',
-      'x-feature': 'beta',
-    });
-  });
-
-  it('converts tuple array', () => {
-    const headers: HeadersInit = [
-      ['Authorization', 'Bearer token'],
-      ['X-Feature', 'beta'],
-      ['X-Ignore', undefined as unknown as string],
-    ];
-
-    expect(normalizeHeaders(headers)).toEqual({
-      authorization: 'Bearer token',
-      'x-feature': 'beta',
-    });
-  });
-
-  it('converts plain record and filters nullish values', () => {
-    expect(
-      normalizeHeaders({
-        Authorization: 'Bearer token',
-        'X-Feature': undefined,
-        'Content-Type': 'application/json',
-      }),
-    ).toEqual({
-      authorization: 'Bearer token',
-      'content-type': 'application/json',
-    });
-  });
-
-  it('handles empty Headers instance', () => {
-    const headers = new Headers();
-    expect(normalizeHeaders(headers)).toEqual({});
-  });
-
-  it('converts uppercase keys to lowercase', () => {
-    expect(
-      normalizeHeaders({
-        'CONTENT-TYPE': 'application/json',
-        'X-CUSTOM-HEADER': 'test-value',
-      }),
-    ).toEqual({
-      'content-type': 'application/json',
-      'x-custom-header': 'test-value',
-    });
-  });
-});

package/src/parse-json.test.ts

@@ -1,191 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { parseJSON, safeParseJSON, isParsableJson } from './parse-json';
-import { z } from 'zod/v4';
-import { JSONParseError, TypeValidationError } from '@ai-sdk/provider';
-
-describe('parseJSON', () => {
-  it('should parse basic JSON without schema', async () => {
-    const result = await parseJSON({ text: '{"foo": "bar"}' });
-    expect(result).toEqual({ foo: 'bar' });
-  });
-
-  it('should parse JSON with schema validation', async () => {
-    const schema = z.object({ foo: z.string() });
-    const result = await parseJSON({ text: '{"foo": "bar"}', schema });
-    expect(result).toEqual({ foo: 'bar' });
-  });
-
-  it('should throw JSONParseError for invalid JSON', async () => {
-    await expect(() => parseJSON({ text: 'invalid json' })).rejects.toThrow(
-      JSONParseError,
-    );
-  });
-
-  it('should throw TypeValidationError for schema validation failures', async () => {
-    const schema = z.object({ foo: z.number() });
-    await expect(() =>
-      parseJSON({ text: '{"foo": "bar"}', schema }),
-    ).rejects.toThrow(TypeValidationError);
-  });
-});
-
-describe('safeParseJSON', () => {
-  it('should safely parse basic JSON without schema and include rawValue', async () => {
-    const result = await safeParseJSON({ text: '{"foo": "bar"}' });
-    expect(result).toEqual({
-      success: true,
-      value: { foo: 'bar' },
-      rawValue: { foo: 'bar' },
-    });
-  });
-
-  it('should preserve rawValue even after schema transformation', async () => {
-    const schema = z.object({
-      count: z.coerce.number(),
-    });
-    const result = await safeParseJSON({
-      text: '{"count": "42"}',
-      schema,
-    });
-
-    expect(result).toEqual({
-      success: true,
-      value: { count: 42 },
-      rawValue: { count: '42' },
-    });
-  });
-
-  it('should handle failed parsing with error details', async () => {
-    const result = await safeParseJSON({ text: 'invalid json' });
-    expect(result).toEqual({
-      success: false,
-      error: expect.any(JSONParseError),
-    });
-  });
-
-  it('should handle schema validation failures', async () => {
-    const schema = z.object({ age: z.number() });
-    const result = await safeParseJSON({
-      text: '{"age": "twenty"}',
-      schema,
-    });
-
-    expect(result).toEqual({
-      success: false,
-      error: expect.any(TypeValidationError),
-      rawValue: { age: 'twenty' },
-    });
-  });
-
-  it('should handle nested objects and preserve raw values', async () => {
-    const schema = z.object({
-      user: z.object({
-        id: z.string().transform(val => parseInt(val, 10)),
-        name: z.string(),
-      }),
-    });
-
-    const result = await safeParseJSON({
-      text: '{"user": {"id": "123", "name": "John"}}',
-      schema: schema as any,
-    });
-
-    expect(result).toEqual({
-      success: true,
-      value: { user: { id: 123, name: 'John' } },
-      rawValue: { user: { id: '123', name: 'John' } },
-    });
-  });
-
-  it('should handle arrays and preserve raw values', async () => {
-    const schema = z.array(z.string().transform(val => val.toUpperCase()));
-    const result = await safeParseJSON({
-      text: '["hello", "world"]',
-      schema,
-    });
-
-    expect(result).toEqual({
-      success: true,
-      value: ['HELLO', 'WORLD'],
-      rawValue: ['hello', 'world'],
-    });
-  });
-
-  it('should handle discriminated unions in schema', async () => {
-    const schema = z.discriminatedUnion('type', [
-      z.object({ type: z.literal('text'), content: z.string() }),
-      z.object({ type: z.literal('number'), value: z.number() }),
-    ]);
-
-    const result = await safeParseJSON({
-      text: '{"type": "text", "content": "hello"}',
-      schema,
-    });
-
-    expect(result).toEqual({
-      success: true,
-      value: { type: 'text', content: 'hello' },
-      rawValue: { type: 'text', content: 'hello' },
-    });
-  });
-
-  it('should handle nullable fields in schema', async () => {
-    const schema = z.object({
-      id: z.string().nullish(),
-      data: z.string(),
-    });
-
-    const result = await safeParseJSON({
-      text: '{"id": null, "data": "test"}',
-      schema,
-    });
-
-    expect(result).toEqual({
-      success: true,
-      value: { id: null, data: 'test' },
-      rawValue: { id: null, data: 'test' },
-    });
-  });
-
-  it('should handle union types in schema', async () => {
-    const schema = z.object({
-      value: z.union([z.string(), z.number()]),
-    });
-
-    const result1 = await safeParseJSON({
-      text: '{"value": "test"}',
-      schema,
-    });
-
-    const result2 = await safeParseJSON({
-      text: '{"value": 123}',
-      schema,
-    });
-
-    expect(result1).toEqual({
-      success: true,
-      value: { value: 'test' },
-      rawValue: { value: 'test' },
-    });
-
-    expect(result2).toEqual({
-      success: true,
-      value: { value: 123 },
-      rawValue: { value: 123 },
-    });
-  });
-});
-
-describe('isParsableJson', () => {
-  it('should return true for valid JSON', () => {
-    expect(isParsableJson('{"foo": "bar"}')).toBe(true);
-    expect(isParsableJson('[1, 2, 3]')).toBe(true);
-    expect(isParsableJson('"hello"')).toBe(true);
-  });
-
-  it('should return false for invalid JSON', () => {
-    expect(isParsableJson('invalid')).toBe(false);
-    expect(isParsableJson('{foo: "bar"}')).toBe(false);
-    expect(isParsableJson('{"foo": }')).toBe(false);
-  });
-});

package/src/remove-undefined-entries.test.ts

@@ -1,57 +0,0 @@
-import { expect, it } from 'vitest';
-import { removeUndefinedEntries } from './remove-undefined-entries';
-
-it('should remove undefined entries from record', () => {
-  const input = {
-    a: 1,
-    b: undefined,
-    c: 'test',
-    d: undefined,
-  };
-
-  expect(removeUndefinedEntries(input)).toEqual({
-    a: 1,
-    c: 'test',
-  });
-});
-
-it('should handle empty object', () => {
-  const input = {};
-  expect(removeUndefinedEntries(input)).toEqual({});
-});
-
-it('should handle object with all undefined values', () => {
-  const input = {
-    a: undefined,
-    b: undefined,
-  };
-  expect(removeUndefinedEntries(input)).toEqual({});
-});
-
-it('should remove null values', () => {
-  // Both null and undefined will be removed.
-  const input = {
-    a: null,
-    b: undefined,
-    c: 'test',
-  };
-  expect(removeUndefinedEntries(input)).toEqual({
-    c: 'test',
-  });
-});
-
-it('should preserve falsy values except null and undefined', () => {
-  // Only false, 0, and '' are preserved.
-  const input = {
-    a: false,
-    b: 0,
-    c: '',
-    d: undefined,
-    e: null,
-  };
-  expect(removeUndefinedEntries(input)).toEqual({
-    a: false,
-    b: 0,
-    c: '',
-  });
-});

package/src/resolve.test.ts

@@ -1,125 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { resolve, Resolvable } from './resolve';
-
-describe('resolve', () => {
-  // Test raw values
-  it('should resolve raw values', async () => {
-    const value: Resolvable<number> = 42;
-    expect(await resolve(value)).toBe(42);
-  });
-
-  it('should resolve raw objects', async () => {
-    const value: Resolvable<object> = { foo: 'bar' };
-    expect(await resolve(value)).toEqual({ foo: 'bar' });
-  });
-
-  // Test promises
-  it('should resolve promises', async () => {
-    const value: Resolvable<string> = Promise.resolve('hello');
-    expect(await resolve(value)).toBe('hello');
-  });
-
-  it('should resolve rejected promises', async () => {
-    const value: Resolvable<string> = Promise.reject(new Error('test error'));
-    await expect(resolve(value)).rejects.toThrow('test error');
-  });
-
-  // Test synchronous functions
-  it('should resolve synchronous functions', async () => {
-    const value: Resolvable<number> = () => 42;
-    expect(await resolve(value)).toBe(42);
-  });
-
-  it('should resolve synchronous functions returning objects', async () => {
-    const value: Resolvable<object> = () => ({ foo: 'bar' });
-    expect(await resolve(value)).toEqual({ foo: 'bar' });
-  });
-
-  // Test async functions
-  it('should resolve async functions', async () => {
-    const value: Resolvable<string> = async () => 'hello';
-    expect(await resolve(value)).toBe('hello');
-  });
-
-  it('should resolve async functions returning promises', async () => {
-    const value: Resolvable<number> = () => Promise.resolve(42);
-    expect(await resolve(value)).toBe(42);
-  });
-
-  it('should handle async function rejections', async () => {
-    const value: Resolvable<string> = async () => {
-      throw new Error('async error');
-    };
-    await expect(resolve(value)).rejects.toThrow('async error');
-  });
-
-  // Test edge cases
-  it('should handle null', async () => {
-    const value: Resolvable<null> = null;
-    expect(await resolve(value)).toBe(null);
-  });
-
-  it('should handle undefined', async () => {
-    const value: Resolvable<undefined> = undefined;
-    expect(await resolve(value)).toBe(undefined);
-  });
-
-  // Test with complex objects
-  it('should resolve nested objects', async () => {
-    const value: Resolvable<{ nested: { value: number } }> = {
-      nested: { value: 42 },
-    };
-    expect(await resolve(value)).toEqual({ nested: { value: 42 } });
-  });
-
-  // Test resolving objects as frequently used in headers as a common example
-  describe('resolve headers', () => {
-    it('should resolve header objects', async () => {
-      const headers = { 'Content-Type': 'application/json' };
-      expect(await resolve(headers)).toEqual(headers);
-    });
-
-    it('should resolve header functions', async () => {
-      const headers = () => ({ Authorization: 'Bearer token' });
-      expect(await resolve(headers)).toEqual({ Authorization: 'Bearer token' });
-    });
-
-    it('should resolve async header functions', async () => {
-      const headers = async () => ({ 'X-Custom': 'value' });
-      expect(await resolve(headers)).toEqual({ 'X-Custom': 'value' });
-    });
-
-    it('should resolve header promises', async () => {
-      const headers = Promise.resolve({ Accept: 'application/json' });
-      expect(await resolve(headers)).toEqual({ Accept: 'application/json' });
-    });
-
-    it('should call async header functions each time when resolved multiple times', async () => {
-      let counter = 0;
-      const headers = async () => ({ 'X-Request-Number': String(++counter) });
-
-      // Resolve the same headers function multiple times
-      expect(await resolve(headers)).toEqual({ 'X-Request-Number': '1' });
-      expect(await resolve(headers)).toEqual({ 'X-Request-Number': '2' });
-      expect(await resolve(headers)).toEqual({ 'X-Request-Number': '3' });
-    });
-  });
-
-  // Test type inference
-  it('should maintain type information', async () => {
-    interface User {
-      id: number;
-      name: string;
-    }
-
-    const userPromise: Resolvable<User> = Promise.resolve({
-      id: 1,
-      name: 'Test User',
-    });
-
-    const result = await resolve(userPromise);
-    // TypeScript should recognize result as User type
-    expect(result.id).toBe(1);
-    expect(result.name).toBe('Test User');
-  });
-});

package/src/response-handler.test.ts

@@ -1,89 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { z } from 'zod/v4';
-import {
-  createBinaryResponseHandler,
-  createJsonResponseHandler,
-  createStatusCodeErrorResponseHandler,
-} from './response-handler';
-
-describe('createJsonResponseHandler', () => {
-  it('should return both parsed value and rawValue', async () => {
-    const responseSchema = z.object({
-      name: z.string(),
-      age: z.number(),
-    });
-
-    const rawData = {
-      name: 'John',
-      age: 30,
-      extraField: 'ignored',
-    };
-
-    const response = new Response(JSON.stringify(rawData));
-    const handler = createJsonResponseHandler(responseSchema);
-
-    const result = await handler({
-      url: 'test-url',
-      requestBodyValues: {},
-      response,
-    });
-
-    expect(result.value).toEqual({
-      name: 'John',
-      age: 30,
-    });
-    expect(result.rawValue).toEqual(rawData);
-  });
-});
-
-describe('createBinaryResponseHandler', () => {
-  it('should handle binary response successfully', async () => {
-    const binaryData = new Uint8Array([1, 2, 3, 4]);
-    const response = new Response(binaryData);
-    const handler = createBinaryResponseHandler();
-
-    const result = await handler({
-      url: 'test-url',
-      requestBodyValues: {},
-      response,
-    });
-
-    expect(result.value).toBeInstanceOf(Uint8Array);
-    expect(result.value).toEqual(binaryData);
-  });
-
-  it('should throw APICallError when response body is null', async () => {
-    const response = new Response(null);
-    const handler = createBinaryResponseHandler();
-
-    await expect(
-      handler({
-        url: 'test-url',
-        requestBodyValues: {},
-        response,
-      }),
-    ).rejects.toThrow('Response body is empty');
-  });
-});
-
-describe('createStatusCodeErrorResponseHandler', () => {
-  it('should create error with status text and response body', async () => {
-    const response = new Response('Error message', {
-      status: 404,
-      statusText: 'Not Found',
-    });
-    const handler = createStatusCodeErrorResponseHandler();
-
-    const result = await handler({
-      url: 'test-url',
-      requestBodyValues: { some: 'data' },
-      response,
-    });
-
-    expect(result.value.message).toBe('Not Found');
-    expect(result.value.statusCode).toBe(404);
-    expect(result.value.responseBody).toBe('Error message');
-    expect(result.value.url).toBe('test-url');
-    expect(result.value.requestBodyValues).toEqual({ some: 'data' });
-  });
-});

package/src/schema.test-d.ts

@@ -1,11 +0,0 @@
-import { describe, expectTypeOf, it } from 'vitest';
-import { InferSchema, StandardSchema } from './schema';
-
-describe('InferSchema type', () => {
-  it('should work with StandardSchema', () => {
-    type MySchema = StandardSchema<number>;
-    type Result = InferSchema<MySchema>;
-
-    expectTypeOf<Result>().toMatchTypeOf<number>();
-  });
-});