@ai-sdk/provider-utils 4.0.8 → 4.0.10

package/src/convert-async-iterator-to-readable-stream.test.ts

@@ -1,78 +0,0 @@
-import { convertAsyncIteratorToReadableStream } from './convert-async-iterator-to-readable-stream';
-import { describe, it, expect } from 'vitest';
-
-async function* makeGenerator(onFinally: () => void) {
-  try {
-    let i = 0;
-    while (true) {
-      await new Promise(r => setTimeout(r, 0));
-      yield i++;
-    }
-  } finally {
-    onFinally();
-  }
-}
-
-describe('convertAsyncIteratorToReadableStream', () => {
-  it('calls iterator.return() on cancel and triggers finally', async () => {
-    let finallyCalled = false;
-    const it = makeGenerator(() => {
-      finallyCalled = true;
-    });
-    const stream = convertAsyncIteratorToReadableStream(it);
-    const reader = stream.getReader();
-
-    await reader.read();
-
-    await reader.cancel('stop');
-
-    // give microtasks a tick for finally to run
-    await new Promise(r => setTimeout(r, 0));
-
-    expect(finallyCalled).toBe(true);
-  });
-
-  it('does not enqueue further values after cancel', async () => {
-    const it = makeGenerator(() => {});
-    const stream = convertAsyncIteratorToReadableStream(it);
-    const reader = stream.getReader();
-
-    await reader.read();
-    await reader.cancel('stop');
-
-    const { done, value } = await reader.read();
-    expect(done).toBe(true);
-    expect(value).toBeUndefined();
-  });
-
-  it('works with iterator without return() method', async () => {
-    const it: AsyncIterator<number> = {
-      async next() {
-        return { value: 42, done: false };
-      },
-    };
-    const stream = convertAsyncIteratorToReadableStream(it);
-    const reader = stream.getReader();
-
-    const { value } = await reader.read();
-    expect(value).toBe(42);
-
-    await expect(reader.cancel()).resolves.toBeUndefined();
-  });
-
-  it('ignores errors from iterator.return()', async () => {
-    const it: AsyncIterator<number> = {
-      async next() {
-        return { value: 1, done: false };
-      },
-      async return() {
-        throw new Error('return() failed');
-      },
-    };
-    const stream = convertAsyncIteratorToReadableStream(it);
-    const reader = stream.getReader();
-
-    await reader.read();
-    await expect(reader.cancel()).resolves.toBeUndefined();
-  });
-});

package/src/convert-image-model-file-to-data-uri.test.ts

@@ -1,85 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { convertImageModelFileToDataUri } from './convert-image-model-file-to-data-uri';
-
-describe('convertImageModelFileToDataUri()', () => {
-  describe('URL files', () => {
-    it('should return the URL as-is for URL type files', () => {
-      const result = convertImageModelFileToDataUri({
-        type: 'url',
-        url: 'https://example.com/image.png',
-      });
-
-      expect(result).toBe('https://example.com/image.png');
-    });
-
-    it('should handle URLs with query parameters', () => {
-      const result = convertImageModelFileToDataUri({
-        type: 'url',
-        url: 'https://example.com/image.png?width=100&height=200',
-      });
-
-      expect(result).toBe('https://example.com/image.png?width=100&height=200');
-    });
-  });
-
-  describe('base64 string files', () => {
-    it('should return a data URI for base64 string data', () => {
-      const result = convertImageModelFileToDataUri({
-        type: 'file',
-        mediaType: 'image/png',
-        data: 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==',
-      });
-
-      expect(result).toBe(
-        'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==',
-      );
-    });
-
-    it('should handle different media types', () => {
-      const result = convertImageModelFileToDataUri({
-        type: 'file',
-        mediaType: 'image/jpeg',
-        data: 'base64data',
-      });
-
-      expect(result).toBe('data:image/jpeg;base64,base64data');
-    });
-  });
-
-  describe('Uint8Array files', () => {
-    it('should convert Uint8Array to base64 and return a data URI', () => {
-      // "Hello" in bytes
-      const data = new Uint8Array([72, 101, 108, 108, 111]);
-
-      const result = convertImageModelFileToDataUri({
-        type: 'file',
-        mediaType: 'image/png',
-        data,
-      });
-
-      expect(result).toBe('data:image/png;base64,SGVsbG8=');
-    });
-
-    it('should handle empty Uint8Array', () => {
-      const result = convertImageModelFileToDataUri({
-        type: 'file',
-        mediaType: 'image/png',
-        data: new Uint8Array([]),
-      });
-
-      expect(result).toBe('data:image/png;base64,');
-    });
-
-    it('should handle different media types with Uint8Array', () => {
-      const data = new Uint8Array([72, 101, 108, 108, 111]);
-
-      const result = convertImageModelFileToDataUri({
-        type: 'file',
-        mediaType: 'image/webp',
-        data,
-      });
-
-      expect(result).toBe('data:image/webp;base64,SGVsbG8=');
-    });
-  });
-});

package/src/convert-to-form-data.test.ts

@@ -1,167 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { convertToFormData } from './convert-to-form-data';
-
-describe('convertToFormData()', () => {
-  describe('basic values', () => {
-    it('should add string values to form data', () => {
-      const formData = convertToFormData({
-        model: 'gpt-image-1',
-        prompt: 'A cute cat',
-      });
-
-      expect(formData.get('model')).toBe('gpt-image-1');
-      expect(formData.get('prompt')).toBe('A cute cat');
-    });
-
-    it('should add number values as strings', () => {
-      const formData = convertToFormData({
-        n: 2,
-        seed: 42,
-      });
-
-      expect(formData.get('n')).toBe('2');
-      expect(formData.get('seed')).toBe('42');
-    });
-
-    it('should add Blob values to form data', () => {
-      const blob = new Blob(['test'], { type: 'image/png' });
-      const formData = convertToFormData({
-        image: blob,
-      });
-
-      expect(formData.get('image')).toBeInstanceOf(Blob);
-    });
-  });
-
-  describe('null and undefined values', () => {
-    it('should skip null values', () => {
-      const formData = convertToFormData({
-        model: 'gpt-image-1',
-        mask: null,
-      });
-
-      expect(formData.get('model')).toBe('gpt-image-1');
-      expect(formData.has('mask')).toBe(false);
-    });
-
-    it('should skip undefined values', () => {
-      const formData = convertToFormData({
-        model: 'gpt-image-1',
-        size: undefined,
-      });
-
-      expect(formData.get('model')).toBe('gpt-image-1');
-      expect(formData.has('size')).toBe(false);
-    });
-  });
-
-  describe('array values', () => {
-    it('should add single-element arrays as single value without [] suffix', () => {
-      const blob = new Blob(['test'], { type: 'image/png' });
-      const formData = convertToFormData({
-        image: [blob],
-      });
-
-      expect(formData.get('image')).toBeInstanceOf(Blob);
-      expect(formData.has('image[]')).toBe(false);
-    });
-
-    it('should add multi-element arrays with [] suffix', () => {
-      const blob1 = new Blob(['test1'], { type: 'image/png' });
-      const blob2 = new Blob(['test2'], { type: 'image/jpeg' });
-      const formData = convertToFormData({
-        image: [blob1, blob2],
-      });
-
-      expect(formData.has('image')).toBe(false);
-      const images = formData.getAll('image[]');
-      expect(images).toHaveLength(2);
-      expect(images[0]).toBeInstanceOf(Blob);
-      expect(images[1]).toBeInstanceOf(Blob);
-    });
-
-    it('should add multi-element arrays without [] suffix when useArrayBrackets is false', () => {
-      const blob1 = new Blob(['test1'], { type: 'image/png' });
-      const blob2 = new Blob(['test2'], { type: 'image/jpeg' });
-      const formData = convertToFormData(
-        {
-          image: [blob1, blob2],
-        },
-        { useArrayBrackets: false },
-      );
-
-      expect(formData.has('image[]')).toBe(false);
-      const images = formData.getAll('image');
-      expect(images).toHaveLength(2);
-      expect(images[0]).toBeInstanceOf(Blob);
-      expect(images[1]).toBeInstanceOf(Blob);
-    });
-
-    it('should handle empty arrays by not adding any values', () => {
-      const formData = convertToFormData({
-        model: 'test',
-        images: [],
-      });
-
-      expect(formData.get('model')).toBe('test');
-      expect(formData.has('images')).toBe(false);
-      expect(formData.has('images[]')).toBe(false);
-    });
-
-    it('should add string arrays with [] suffix', () => {
-      const formData = convertToFormData({
-        tags: ['cat', 'cute', 'animal'],
-      });
-
-      const tags = formData.getAll('tags[]');
-      expect(tags).toHaveLength(3);
-      expect(tags).toEqual(['cat', 'cute', 'animal']);
-    });
-  });
-
-  describe('type validation', () => {
-    it('should accept typed input objects', () => {
-      type ImageInput = {
-        model: string;
-        prompt: string;
-        n: number;
-        size: `${number}x${number}` | undefined;
-      };
-
-      const formData = convertToFormData<ImageInput>({
-        model: 'dall-e-3',
-        prompt: 'A sunset',
-        n: 1,
-        size: '1024x1024',
-      });
-
-      expect(formData.get('model')).toBe('dall-e-3');
-      expect(formData.get('prompt')).toBe('A sunset');
-      expect(formData.get('n')).toBe('1');
-      expect(formData.get('size')).toBe('1024x1024');
-    });
-  });
-
-  describe('mixed values', () => {
-    it('should handle a complex input with various types', () => {
-      const blob = new Blob(['image data'], { type: 'image/png' });
-      const formData = convertToFormData({
-        model: 'gpt-image-1',
-        prompt: 'Edit this image',
-        image: [blob],
-        mask: null,
-        n: 1,
-        size: '1024x1024',
-        quality: 'high',
-      });
-
-      expect(formData.get('model')).toBe('gpt-image-1');
-      expect(formData.get('prompt')).toBe('Edit this image');
-      expect(formData.get('image')).toBeInstanceOf(Blob);
-      expect(formData.has('mask')).toBe(false);
-      expect(formData.get('n')).toBe('1');
-      expect(formData.get('size')).toBe('1024x1024');
-      expect(formData.get('quality')).toBe('high');
-    });
-  });
-});

package/src/create-tool-name-mapping.test.ts

@@ -1,163 +0,0 @@
-import {
-  LanguageModelV3FunctionTool,
-  LanguageModelV3ProviderTool,
-} from '@ai-sdk/provider';
-import { describe, expect, it } from 'vitest';
-import { createToolNameMapping } from './create-tool-name-mapping';
-
-describe('createToolNameMapping', () => {
-  it('should create mappings for provider-defined tools', () => {
-    const tools: Array<
-      LanguageModelV3FunctionTool | LanguageModelV3ProviderTool
-    > = [
-      {
-        type: 'provider',
-        id: 'anthropic.computer-use',
-        name: 'custom-computer-tool',
-        args: {},
-      },
-      {
-        type: 'provider',
-        id: 'openai.code-interpreter',
-        name: 'custom-code-tool',
-        args: {},
-      },
-    ];
-
-    const providerToolNames: Record<`${string}.${string}`, string> = {
-      'anthropic.computer-use': 'computer_use',
-      'openai.code-interpreter': 'code_interpreter',
-    };
-
-    const mapping = createToolNameMapping({ tools, providerToolNames });
-
-    expect(mapping.toProviderToolName('custom-computer-tool')).toBe(
-      'computer_use',
-    );
-    expect(mapping.toProviderToolName('custom-code-tool')).toBe(
-      'code_interpreter',
-    );
-    expect(mapping.toCustomToolName('computer_use')).toBe(
-      'custom-computer-tool',
-    );
-    expect(mapping.toCustomToolName('code_interpreter')).toBe(
-      'custom-code-tool',
-    );
-  });
-
-  it('should ignore function tools', () => {
-    const tools: Array<
-      LanguageModelV3FunctionTool | LanguageModelV3ProviderTool
-    > = [
-      {
-        type: 'function',
-        name: 'my-function-tool',
-        description: 'A function tool',
-        inputSchema: { type: 'object' },
-      },
-    ];
-
-    const providerToolNames: Record<`${string}.${string}`, string> = {};
-
-    const mapping = createToolNameMapping({ tools, providerToolNames });
-
-    expect(mapping.toProviderToolName('my-function-tool')).toBe(
-      'my-function-tool',
-    );
-    expect(mapping.toCustomToolName('my-function-tool')).toBe(
-      'my-function-tool',
-    );
-  });
-
-  it('should return input name when tool is not in providerToolNames', () => {
-    const tools: Array<
-      LanguageModelV3FunctionTool | LanguageModelV3ProviderTool
-    > = [
-      {
-        type: 'provider',
-        id: 'unknown.tool',
-        name: 'custom-tool',
-        args: {},
-      },
-    ];
-
-    const providerToolNames: Record<`${string}.${string}`, string> = {};
-
-    const mapping = createToolNameMapping({ tools, providerToolNames });
-
-    expect(mapping.toProviderToolName('custom-tool')).toBe('custom-tool');
-    expect(mapping.toCustomToolName('unknown-name')).toBe('unknown-name');
-  });
-
-  it('should return input name when mapping does not exist', () => {
-    const tools: Array<
-      LanguageModelV3FunctionTool | LanguageModelV3ProviderTool
-    > = [
-      {
-        type: 'provider',
-        id: 'anthropic.computer-use',
-        name: 'custom-computer-tool',
-        args: {},
-      },
-    ];
-
-    const providerToolNames: Record<`${string}.${string}`, string> = {
-      'anthropic.computer-use': 'computer_use',
-    };
-
-    const mapping = createToolNameMapping({ tools, providerToolNames });
-
-    expect(mapping.toProviderToolName('non-existent-tool')).toBe(
-      'non-existent-tool',
-    );
-    expect(mapping.toCustomToolName('non-existent-provider-tool')).toBe(
-      'non-existent-provider-tool',
-    );
-  });
-
-  it('should handle empty tools array', () => {
-    const tools: Array<
-      LanguageModelV3FunctionTool | LanguageModelV3ProviderTool
-    > = [];
-
-    const providerToolNames: Record<`${string}.${string}`, string> = {};
-
-    const mapping = createToolNameMapping({ tools, providerToolNames });
-
-    expect(mapping.toProviderToolName('any-tool')).toBe('any-tool');
-    expect(mapping.toCustomToolName('any-tool')).toBe('any-tool');
-  });
-
-  it('should handle mixed function and provider-defined tools', () => {
-    const tools: Array<
-      LanguageModelV3FunctionTool | LanguageModelV3ProviderTool
-    > = [
-      {
-        type: 'function',
-        name: 'function-tool',
-        description: 'A function tool',
-        inputSchema: { type: 'object' },
-      },
-      {
-        type: 'provider',
-        id: 'anthropic.computer-use',
-        name: 'provider-tool',
-        args: {},
-      },
-    ];
-
-    const providerToolNames: Record<`${string}.${string}`, string> = {
-      'anthropic.computer-use': 'computer_use',
-    };
-
-    const mapping = createToolNameMapping({ tools, providerToolNames });
-
-    // Function tool should not be mapped
-    expect(mapping.toProviderToolName('function-tool')).toBe('function-tool');
-    expect(mapping.toCustomToolName('function-tool')).toBe('function-tool');
-
-    // Provider-defined tool should be mapped
-    expect(mapping.toProviderToolName('provider-tool')).toBe('computer_use');
-    expect(mapping.toCustomToolName('computer_use')).toBe('provider-tool');
-  });
-});

package/src/delay.test.ts

@@ -1,212 +0,0 @@
-import { delay } from './delay';
-import { describe, beforeEach, afterEach, expect, it, vi } from 'vitest';
-
-describe('delay', () => {
-  beforeEach(() => {
-    vi.useFakeTimers();
-  });
-
-  afterEach(() => {
-    vi.useRealTimers();
-  });
-
-  describe('basic delay functionality', () => {
-    it('should resolve after the specified delay', async () => {
-      const delayPromise = delay(1000);
-
-      // Promise should not be resolved immediately
-      let resolved = false;
-      delayPromise.then(() => {
-        resolved = true;
-      });
-
-      expect(resolved).toBe(false);
-
-      // Advance timers by less than the delay
-      await vi.advanceTimersByTimeAsync(500);
-      expect(resolved).toBe(false);
-
-      // Advance timers to complete the delay
-      await vi.advanceTimersByTimeAsync(500);
-      expect(resolved).toBe(true);
-
-      // Verify the promise resolves
-      await expect(delayPromise).resolves.toBeUndefined();
-    });
-
-    it('should resolve immediately when delayInMs is null', async () => {
-      const delayPromise = delay(null);
-      await expect(delayPromise).resolves.toBeUndefined();
-    });
-
-    it('should resolve immediately when delayInMs is undefined', async () => {
-      const delayPromise = delay(undefined);
-      await expect(delayPromise).resolves.toBeUndefined();
-    });
-
-    it('should resolve immediately when delayInMs is 0', async () => {
-      const delayPromise = delay(0);
-
-      // Even with 0 delay, setTimeout is used, so we need to advance timers
-      await vi.advanceTimersByTimeAsync(0);
-      await expect(delayPromise).resolves.toBeUndefined();
-    });
-  });
-
-  describe('abort signal functionality', () => {
-    it('should reject immediately if signal is already aborted', async () => {
-      const controller = new AbortController();
-      controller.abort();
-
-      const delayPromise = delay(1000, { abortSignal: controller.signal });
-
-      await expect(delayPromise).rejects.toThrow('Delay was aborted');
-      expect(vi.getTimerCount()).toBe(0); // No timer should be set
-    });
-
-    it('should reject when signal is aborted during delay', async () => {
-      const controller = new AbortController();
-      const delayPromise = delay(1000, { abortSignal: controller.signal });
-
-      // Advance time partially
-      await vi.advanceTimersByTimeAsync(500);
-
-      // Abort the signal
-      controller.abort();
-
-      await expect(delayPromise).rejects.toThrow('Delay was aborted');
-    });
-
-    it('should clean up timeout when aborted', async () => {
-      const controller = new AbortController();
-      const delayPromise = delay(1000, { abortSignal: controller.signal });
-
-      expect(vi.getTimerCount()).toBe(1);
-
-      controller.abort();
-
-      try {
-        await delayPromise;
-      } catch {
-        // Expected to throw
-      }
-
-      expect(vi.getTimerCount()).toBe(0);
-    });
-
-    it('should clean up event listener when delay completes normally', async () => {
-      const controller = new AbortController();
-      const addEventListenerSpy = vi.spyOn(
-        controller.signal,
-        'addEventListener',
-      );
-      const removeEventListenerSpy = vi.spyOn(
-        controller.signal,
-        'removeEventListener',
-      );
-
-      const delayPromise = delay(1000, { abortSignal: controller.signal });
-
-      expect(addEventListenerSpy).toHaveBeenCalledWith(
-        'abort',
-        expect.any(Function),
-      );
-
-      await vi.advanceTimersByTimeAsync(1000);
-      await delayPromise;
-
-      expect(removeEventListenerSpy).toHaveBeenCalledWith(
-        'abort',
-        expect.any(Function),
-      );
-    });
-
-    it('should work without signal option', async () => {
-      const delayPromise = delay(1000);
-
-      await vi.advanceTimersByTimeAsync(1000);
-      await expect(delayPromise).resolves.toBeUndefined();
-    });
-  });
-
-  describe('error handling', () => {
-    it('should create proper DOMException for abort', async () => {
-      const controller = new AbortController();
-      controller.abort();
-
-      const delayPromise = delay(1000, { abortSignal: controller.signal });
-
-      try {
-        await delayPromise;
-        expect.fail('Should have thrown');
-      } catch (error) {
-        expect(error).toBeInstanceOf(DOMException);
-        expect((error as DOMException).message).toBe('Delay was aborted');
-        expect((error as DOMException).name).toBe('AbortError');
-      }
-    });
-  });
-
-  describe('edge cases', () => {
-    it('should handle very large delays', async () => {
-      const delayPromise = delay(Number.MAX_SAFE_INTEGER);
-
-      await vi.advanceTimersByTimeAsync(1000);
-      let resolved = false;
-      delayPromise.then(() => {
-        resolved = true;
-      });
-
-      expect(resolved).toBe(false);
-
-      // Fast forward to complete
-      await vi.advanceTimersByTimeAsync(1000);
-      await expect(delayPromise).resolves.toBeUndefined();
-    });
-
-    it('should handle negative delays (treated as 0)', async () => {
-      const delayPromise = delay(-100);
-
-      vi.advanceTimersByTime(0);
-      await expect(delayPromise).resolves.toBeUndefined();
-    });
-
-    it('should handle multiple delays simultaneously', async () => {
-      const delay1 = delay(100);
-      const delay2 = delay(200);
-      const delay3 = delay(300);
-
-      let resolved1 = false;
-      let resolved2 = false;
-      let resolved3 = false;
-
-      delay1.then(() => {
-        resolved1 = true;
-      });
-      delay2.then(() => {
-        resolved2 = true;
-      });
-      delay3.then(() => {
-        resolved3 = true;
-      });
-
-      // After 100ms, only first should resolve
-      await vi.advanceTimersByTimeAsync(100);
-      expect(resolved1).toBe(true);
-      expect(resolved2).toBe(false);
-      expect(resolved3).toBe(false);
-
-      // After 200ms, first two should resolve
-      await vi.advanceTimersByTimeAsync(100);
-      expect(resolved1).toBe(true);
-      expect(resolved2).toBe(true);
-      expect(resolved3).toBe(false);
-
-      // After 300ms, all should resolve
-      await vi.advanceTimersByTimeAsync(100);
-      expect(resolved1).toBe(true);
-      expect(resolved2).toBe(true);
-      expect(resolved3).toBe(true);
-    });
-  });
-});