@ai-sdk/provider-utils 4.0.8 → 4.0.10

package/src/delayed-promise.test.ts

@@ -1,132 +0,0 @@
-import { DelayedPromise } from './delayed-promise';
-import { delay } from '@ai-sdk/provider-utils';
-import { describe, it, expect } from 'vitest';
-
-describe('DelayedPromise', () => {
-  it('should resolve when accessed after resolution', async () => {
-    const dp = new DelayedPromise<string>();
-    dp.resolve('success');
-    expect(await dp.promise).toBe('success');
-  });
-
-  it('should reject when accessed after rejection', async () => {
-    const dp = new DelayedPromise<string>();
-    const error = new Error('failure');
-    dp.reject(error);
-    await expect(dp.promise).rejects.toThrow('failure');
-  });
-
-  it('should resolve when accessed before resolution', async () => {
-    const dp = new DelayedPromise<string>();
-    const promise = dp.promise;
-    dp.resolve('success');
-    expect(await promise).toBe('success');
-  });
-
-  it('should reject when accessed before rejection', async () => {
-    const dp = new DelayedPromise<string>();
-    const promise = dp.promise;
-    const error = new Error('failure');
-    dp.reject(error);
-    await expect(promise).rejects.toThrow('failure');
-  });
-
-  it('should maintain the resolved state after multiple accesses', async () => {
-    const dp = new DelayedPromise<string>();
-    dp.resolve('success');
-    expect(await dp.promise).toBe('success');
-    expect(await dp.promise).toBe('success');
-  });
-
-  it('should maintain the rejected state after multiple accesses', async () => {
-    const dp = new DelayedPromise<string>();
-    const error = new Error('failure');
-    dp.reject(error);
-    await expect(dp.promise).rejects.toThrow('failure');
-    await expect(dp.promise).rejects.toThrow('failure');
-  });
-
-  it('should block until resolved when accessed before resolution', async () => {
-    const dp = new DelayedPromise<string>();
-    let resolved = false;
-
-    // Access the promise before resolving
-    const promise = dp.promise.then(value => {
-      resolved = true;
-      return value;
-    });
-
-    // Promise should not be resolved yet
-    expect(resolved).toBe(false);
-
-    // Wait a bit to ensure it's truly blocking
-    await delay(10);
-    expect(resolved).toBe(false);
-
-    // Now resolve it
-    dp.resolve('delayed-success');
-
-    // Should now resolve
-    const result = await promise;
-    expect(result).toBe('delayed-success');
-    expect(resolved).toBe(true);
-  });
-
-  it('should block until rejected when accessed before rejection', async () => {
-    const dp = new DelayedPromise<string>();
-    let rejected = false;
-
-    // Access the promise before rejecting
-    const promise = dp.promise.catch(error => {
-      rejected = true;
-      throw error;
-    });
-
-    // Promise should not be rejected yet
-    expect(rejected).toBe(false);
-
-    // Wait a bit to ensure it's truly blocking
-    await delay(10);
-    expect(rejected).toBe(false);
-
-    // Now reject it
-    const error = new Error('delayed-failure');
-    dp.reject(error);
-
-    // Should now reject
-    await expect(promise).rejects.toThrow('delayed-failure');
-    expect(rejected).toBe(true);
-  });
-
-  it('should resolve all pending promises when resolved after access', async () => {
-    const dp = new DelayedPromise<string>();
-    const results: string[] = [];
-
-    // Access the promise multiple times before resolution
-    const promise1 = dp.promise.then(value => {
-      results.push(`first: ${value}`);
-      return value;
-    });
-
-    const promise2 = dp.promise.then(value => {
-      results.push(`second: ${value}`);
-      return value;
-    });
-
-    // Neither should be resolved yet
-    expect(results).toHaveLength(0);
-
-    // Wait to ensure they're blocking
-    await delay(10);
-    expect(results).toHaveLength(0);
-
-    // Resolve the promise
-    dp.resolve('success');
-
-    // Both should resolve
-    await Promise.all([promise1, promise2]);
-    expect(results).toHaveLength(2);
-    expect(results).toContain('first: success');
-    expect(results).toContain('second: success');
-  });
-});

package/src/download-blob.test.ts

@@ -1,145 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { downloadBlob } from './download-blob';
-import { DownloadError } from './download-error';
-
-describe('downloadBlob()', () => {
-  const originalFetch = globalThis.fetch;
-
-  beforeEach(() => {
-    vi.resetAllMocks();
-  });
-
-  afterEach(() => {
-    globalThis.fetch = originalFetch;
-  });
-
-  it('should download a blob successfully', async () => {
-    const mockBlob = new Blob(['test content'], { type: 'image/png' });
-    globalThis.fetch = vi.fn().mockResolvedValue({
-      ok: true,
-      blob: () => Promise.resolve(mockBlob),
-    });
-
-    const result = await downloadBlob('https://example.com/image.png');
-
-    expect(result).toBe(mockBlob);
-    expect(fetch).toHaveBeenCalledWith('https://example.com/image.png');
-  });
-
-  it('should throw DownloadError on non-ok response', async () => {
-    globalThis.fetch = vi.fn().mockResolvedValue({
-      ok: false,
-      status: 404,
-      statusText: 'Not Found',
-    });
-
-    await expect(
-      downloadBlob('https://example.com/not-found.png'),
-    ).rejects.toThrow(DownloadError);
-
-    try {
-      await downloadBlob('https://example.com/not-found.png');
-    } catch (error) {
-      expect(DownloadError.isInstance(error)).toBe(true);
-      if (DownloadError.isInstance(error)) {
-        expect(error.url).toBe('https://example.com/not-found.png');
-        expect(error.statusCode).toBe(404);
-        expect(error.statusText).toBe('Not Found');
-        expect(error.message).toBe(
-          'Failed to download https://example.com/not-found.png: 404 Not Found',
-        );
-      }
-    }
-  });
-
-  it('should throw DownloadError on network error', async () => {
-    const networkError = new Error('Network error');
-    globalThis.fetch = vi.fn().mockRejectedValue(networkError);
-
-    await expect(
-      downloadBlob('https://example.com/network-error.png'),
-    ).rejects.toThrow(DownloadError);
-
-    try {
-      await downloadBlob('https://example.com/network-error.png');
-    } catch (error) {
-      expect(DownloadError.isInstance(error)).toBe(true);
-      if (DownloadError.isInstance(error)) {
-        expect(error.url).toBe('https://example.com/network-error.png');
-        expect(error.cause).toBe(networkError);
-        expect(error.message).toContain('Network error');
-      }
-    }
-  });
-
-  it('should re-throw DownloadError without wrapping', async () => {
-    const originalError = new DownloadError({
-      url: 'https://example.com/original.png',
-      statusCode: 500,
-      statusText: 'Internal Server Error',
-    });
-    globalThis.fetch = vi.fn().mockRejectedValue(originalError);
-
-    try {
-      await downloadBlob('https://example.com/test.png');
-    } catch (error) {
-      expect(error).toBe(originalError);
-      expect(DownloadError.isInstance(error)).toBe(true);
-      if (DownloadError.isInstance(error)) {
-        expect(error.url).toBe('https://example.com/original.png');
-        expect(error.statusCode).toBe(500);
-      }
-    }
-  });
-});
-
-describe('DownloadError', () => {
-  it('should create error with status code and text', () => {
-    const error = new DownloadError({
-      url: 'https://example.com/test.png',
-      statusCode: 403,
-      statusText: 'Forbidden',
-    });
-
-    expect(error.name).toBe('AI_DownloadError');
-    expect(error.url).toBe('https://example.com/test.png');
-    expect(error.statusCode).toBe(403);
-    expect(error.statusText).toBe('Forbidden');
-    expect(error.message).toBe(
-      'Failed to download https://example.com/test.png: 403 Forbidden',
-    );
-  });
-
-  it('should create error with cause', () => {
-    const cause = new Error('Connection refused');
-    const error = new DownloadError({
-      url: 'https://example.com/test.png',
-      cause,
-    });
-
-    expect(error.url).toBe('https://example.com/test.png');
-    expect(error.cause).toBe(cause);
-    expect(error.message).toContain('Connection refused');
-  });
-
-  it('should create error with custom message', () => {
-    const error = new DownloadError({
-      url: 'https://example.com/test.png',
-      message: 'Custom error message',
-    });
-
-    expect(error.message).toBe('Custom error message');
-  });
-
-  it('should identify DownloadError instances correctly', () => {
-    const downloadError = new DownloadError({
-      url: 'https://example.com/test.png',
-    });
-    const regularError = new Error('Not a download error');
-
-    expect(DownloadError.isInstance(downloadError)).toBe(true);
-    expect(DownloadError.isInstance(regularError)).toBe(false);
-    expect(DownloadError.isInstance(null)).toBe(false);
-    expect(DownloadError.isInstance(undefined)).toBe(false);
-  });
-});

package/src/generate-id.test.ts

@@ -1,31 +0,0 @@
-import { InvalidArgumentError } from '@ai-sdk/provider';
-import { expect, it } from 'vitest';
-import { createIdGenerator, generateId } from './generate-id';
-import { describe } from 'vitest';
-
-describe('createIdGenerator', () => {
-  it('should generate an ID with the correct length', () => {
-    const idGenerator = createIdGenerator({ size: 10 });
-    expect(idGenerator()).toHaveLength(10);
-  });
-
-  it('should generate an ID with the correct default length', () => {
-    const idGenerator = createIdGenerator();
-    expect(idGenerator()).toHaveLength(16);
-  });
-
-  it('should throw an error if the separator is part of the alphabet', () => {
-    expect(() => createIdGenerator({ separator: 'a', prefix: 'b' })).toThrow(
-      InvalidArgumentError,
-    );
-  });
-});
-
-describe('generateId', () => {
-  it('should generate unique IDs', () => {
-    const id1 = generateId();
-    const id2 = generateId();
-
-    expect(id1).not.toBe(id2);
-  });
-});

package/src/get-from-api.test.ts

@@ -1,199 +0,0 @@
-import { APICallError } from '@ai-sdk/provider';
-import { describe, it, expect, vi } from 'vitest';
-import { getFromApi } from './get-from-api';
-import {
-  createJsonResponseHandler,
-  createStatusCodeErrorResponseHandler,
-} from './response-handler';
-import { z } from 'zod/v4';
-import { getRuntimeEnvironmentUserAgent } from './get-runtime-environment-user-agent';
-import { withUserAgentSuffix } from './with-user-agent-suffix';
-
-vi.mock('./get-runtime-environment-user-agent', async () => {
-  const actual = await vi.importActual('./get-runtime-environment-user-agent');
-  return {
-    ...actual,
-    getRuntimeEnvironmentUserAgent: () => 'runtime/test-env',
-  };
-});
-
-describe('getFromApi', () => {
-  const mockSuccessResponse = {
-    name: 'test',
-    value: 123,
-  };
-
-  const mockResponseSchema = z.object({
-    name: z.string(),
-    value: z.number(),
-  });
-
-  const mockHeaders = {
-    'Content-Type': 'application/json',
-    Authorization: 'Bearer test',
-    'user-agent': 'runtime/test-env',
-  };
-
-  it('should successfully fetch and parse data', async () => {
-    const mockFetch = vi.fn().mockResolvedValue(
-      new Response(JSON.stringify(mockSuccessResponse), {
-        status: 200,
-        headers: withUserAgentSuffix(
-          mockHeaders,
-          getRuntimeEnvironmentUserAgent(),
-        ),
-      }),
-    );
-
-    const result = await getFromApi({
-      url: 'https://api.test.com/data',
-      headers: { Authorization: 'Bearer test' },
-      successfulResponseHandler: createJsonResponseHandler(mockResponseSchema),
-      failedResponseHandler: createStatusCodeErrorResponseHandler(),
-      fetch: mockFetch,
-    });
-
-    expect(result.value).toEqual(mockSuccessResponse);
-    expect(mockFetch).toHaveBeenCalledWith(
-      'https://api.test.com/data',
-      expect.objectContaining({
-        method: 'GET',
-        headers: {
-          authorization: 'Bearer test',
-          'user-agent': 'ai-sdk/provider-utils/0.0.0-test runtime/test-env',
-        },
-      }),
-    );
-  });
-
-  it('should handle API errors', async () => {
-    const errorResponse = { error: 'Not Found' };
-    const mockFetch = vi.fn().mockResolvedValue(
-      new Response(JSON.stringify(errorResponse), {
-        status: 404,
-        statusText: 'Not Found',
-        headers: mockHeaders,
-      }),
-    );
-
-    await expect(
-      getFromApi({
-        url: 'https://api.test.com/data',
-        successfulResponseHandler:
-          createJsonResponseHandler(mockResponseSchema),
-        failedResponseHandler: createStatusCodeErrorResponseHandler(),
-        fetch: mockFetch,
-      }),
-    ).rejects.toThrow(APICallError);
-  });
-
-  it('should handle network errors', async () => {
-    const mockFetch = vi.fn().mockRejectedValue(
-      Object.assign(new TypeError('fetch failed'), {
-        cause: new Error('Failed to connect'),
-      }),
-    );
-
-    await expect(
-      getFromApi({
-        url: 'https://api.test.com/data',
-        successfulResponseHandler:
-          createJsonResponseHandler(mockResponseSchema),
-        failedResponseHandler: createStatusCodeErrorResponseHandler(),
-        fetch: mockFetch,
-      }),
-    ).rejects.toThrow('Cannot connect to API: Failed to connect');
-  });
-
-  it('should handle abort signals', async () => {
-    const abortController = new AbortController();
-    const mockFetch = vi.fn().mockImplementation(() => {
-      abortController.abort();
-      return Promise.reject(new DOMException('Aborted', 'AbortError'));
-    });
-
-    await expect(
-      getFromApi({
-        url: 'https://api.test.com/data',
-        successfulResponseHandler:
-          createJsonResponseHandler(mockResponseSchema),
-        failedResponseHandler: createStatusCodeErrorResponseHandler(),
-        fetch: mockFetch,
-        abortSignal: abortController.signal,
-      }),
-    ).rejects.toThrow('Aborted');
-  });
-
-  it('should remove undefined header entries', async () => {
-    const mockFetch = vi.fn().mockResolvedValue(
-      new Response(JSON.stringify(mockSuccessResponse), {
-        status: 200,
-        headers: mockHeaders,
-      }),
-    );
-
-    await getFromApi({
-      url: 'https://api.test.com/data',
-      headers: {
-        Authorization: 'Bearer test',
-        'X-Custom-Header': undefined,
-      },
-      successfulResponseHandler: createJsonResponseHandler(mockResponseSchema),
-      failedResponseHandler: createStatusCodeErrorResponseHandler(),
-      fetch: mockFetch,
-    });
-
-    expect(mockFetch).toHaveBeenCalledWith(
-      'https://api.test.com/data',
-      expect.objectContaining({
-        headers: {
-          authorization: 'Bearer test',
-          'user-agent': 'ai-sdk/provider-utils/0.0.0-test runtime/test-env',
-        },
-      }),
-    );
-  });
-
-  it('should handle errors in response handlers', async () => {
-    const mockFetch = vi.fn().mockResolvedValue(
-      new Response('invalid json', {
-        status: 200,
-        headers: mockHeaders,
-      }),
-    );
-
-    await expect(
-      getFromApi({
-        url: 'https://api.test.com/data',
-        successfulResponseHandler:
-          createJsonResponseHandler(mockResponseSchema),
-        failedResponseHandler: createStatusCodeErrorResponseHandler(),
-        fetch: mockFetch,
-      }),
-    ).rejects.toThrow(APICallError);
-  });
-
-  it('should use default fetch when not provided', async () => {
-    const originalFetch = global.fetch;
-    const mockFetch = vi.fn().mockResolvedValue(
-      new Response(JSON.stringify(mockSuccessResponse), {
-        status: 200,
-        headers: mockHeaders,
-      }),
-    );
-    global.fetch = mockFetch;
-
-    try {
-      await getFromApi({
-        url: 'https://api.test.com/data',
-        successfulResponseHandler:
-          createJsonResponseHandler(mockResponseSchema),
-        failedResponseHandler: createStatusCodeErrorResponseHandler(),
-      });
-
-      expect(mockFetch).toHaveBeenCalled();
-    } finally {
-      global.fetch = originalFetch;
-    }
-  });
-});

package/src/get-runtime-environment-user-agent.test.ts

@@ -1,47 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-
-// Stabilize provider utils version used inside UA string construction
-vi.mock('./version', () => ({
-  VERSION: '0.0.0-test',
-}));
-
-import { getRuntimeEnvironmentUserAgent } from './get-runtime-environment-user-agent';
-
-describe('getRuntimeEnvironmentUserAgent', () => {
-  it('should return the correct user agent for browsers', () => {
-    expect(
-      getRuntimeEnvironmentUserAgent({
-        window: true,
-      }),
-    ).toBe('runtime/browser');
-  });
-
-  it('should return the correct user agent for test', () => {
-    expect(
-      getRuntimeEnvironmentUserAgent({
-        navigator: {
-          userAgent: 'test',
-        },
-      }),
-    ).toBe('runtime/test');
-  });
-
-  it('should return the correct user agent for Edge Runtime', () => {
-    expect(
-      getRuntimeEnvironmentUserAgent({
-        EdgeRuntime: true,
-      }),
-    ).toBe('runtime/vercel-edge');
-  });
-
-  it('should return the correct user agent for Node.js', () => {
-    expect(
-      getRuntimeEnvironmentUserAgent({
-        process: {
-          versions: { node: 'test' },
-          version: 'test',
-        },
-      }),
-    ).toBe('runtime/node.js/test');
-  });
-});