@ai-sdk/provider-utils 4.0.5 → 4.0.6

package/src/resolve.test.ts

@@ -0,0 +1,125 @@
+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/resolve.ts

@@ -0,0 +1,17 @@
+import { MaybePromiseLike } from './maybe-promise-like';
+
+export type Resolvable<T> = MaybePromiseLike<T> | (() => MaybePromiseLike<T>);
+
+/**
+ * Resolves a value that could be a raw value, a Promise, a function returning a value,
+ * or a function returning a Promise.
+ */
+export async function resolve<T>(value: Resolvable<T>): Promise<T> {
+  // If it's a function, call it to get the value/promise
+  if (typeof value === 'function') {
+    value = (value as Function)();
+  }
+
+  // Otherwise just resolve whatever we got (value or promise)
+  return Promise.resolve(value as T);
+}

package/src/response-handler.test.ts

@@ -0,0 +1,89 @@
+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/response-handler.ts

@@ -0,0 +1,187 @@
+import { APICallError, EmptyResponseBodyError } from '@ai-sdk/provider';
+import { ZodType } from 'zod/v4';
+import { extractResponseHeaders } from './extract-response-headers';
+import { parseJSON, ParseResult, safeParseJSON } from './parse-json';
+import { parseJsonEventStream } from './parse-json-event-stream';
+import { FlexibleSchema } from './schema';
+
+export type ResponseHandler<RETURN_TYPE> = (options: {
+  url: string;
+  requestBodyValues: unknown;
+  response: Response;
+}) => PromiseLike<{
+  value: RETURN_TYPE;
+  rawValue?: unknown;
+  responseHeaders?: Record<string, string>;
+}>;
+
+export const createJsonErrorResponseHandler =
+  <T>({
+    errorSchema,
+    errorToMessage,
+    isRetryable,
+  }: {
+    errorSchema: FlexibleSchema<T>;
+    errorToMessage: (error: T) => string;
+    isRetryable?: (response: Response, error?: T) => boolean;
+  }): ResponseHandler<APICallError> =>
+  async ({ response, url, requestBodyValues }) => {
+    const responseBody = await response.text();
+    const responseHeaders = extractResponseHeaders(response);
+
+    // Some providers return an empty response body for some errors:
+    if (responseBody.trim() === '') {
+      return {
+        responseHeaders,
+        value: new APICallError({
+          message: response.statusText,
+          url,
+          requestBodyValues,
+          statusCode: response.status,
+          responseHeaders,
+          responseBody,
+          isRetryable: isRetryable?.(response),
+        }),
+      };
+    }
+
+    // resilient parsing in case the response is not JSON or does not match the schema:
+    try {
+      const parsedError = await parseJSON({
+        text: responseBody,
+        schema: errorSchema,
+      });
+
+      return {
+        responseHeaders,
+        value: new APICallError({
+          message: errorToMessage(parsedError),
+          url,
+          requestBodyValues,
+          statusCode: response.status,
+          responseHeaders,
+          responseBody,
+          data: parsedError,
+          isRetryable: isRetryable?.(response, parsedError),
+        }),
+      };
+    } catch (parseError) {
+      return {
+        responseHeaders,
+        value: new APICallError({
+          message: response.statusText,
+          url,
+          requestBodyValues,
+          statusCode: response.status,
+          responseHeaders,
+          responseBody,
+          isRetryable: isRetryable?.(response),
+        }),
+      };
+    }
+  };
+
+export const createEventSourceResponseHandler =
+  <T>(
+    chunkSchema: FlexibleSchema<T>,
+  ): ResponseHandler<ReadableStream<ParseResult<T>>> =>
+  async ({ response }: { response: Response }) => {
+    const responseHeaders = extractResponseHeaders(response);
+
+    if (response.body == null) {
+      throw new EmptyResponseBodyError({});
+    }
+
+    return {
+      responseHeaders,
+      value: parseJsonEventStream({
+        stream: response.body,
+        schema: chunkSchema,
+      }),
+    };
+  };
+
+export const createJsonResponseHandler =
+  <T>(responseSchema: FlexibleSchema<T>): ResponseHandler<T> =>
+  async ({ response, url, requestBodyValues }) => {
+    const responseBody = await response.text();
+
+    const parsedResult = await safeParseJSON({
+      text: responseBody,
+      schema: responseSchema,
+    });
+
+    const responseHeaders = extractResponseHeaders(response);
+
+    if (!parsedResult.success) {
+      throw new APICallError({
+        message: 'Invalid JSON response',
+        cause: parsedResult.error,
+        statusCode: response.status,
+        responseHeaders,
+        responseBody,
+        url,
+        requestBodyValues,
+      });
+    }
+
+    return {
+      responseHeaders,
+      value: parsedResult.value,
+      rawValue: parsedResult.rawValue,
+    };
+  };
+
+export const createBinaryResponseHandler =
+  (): ResponseHandler<Uint8Array> =>
+  async ({ response, url, requestBodyValues }) => {
+    const responseHeaders = extractResponseHeaders(response);
+
+    if (!response.body) {
+      throw new APICallError({
+        message: 'Response body is empty',
+        url,
+        requestBodyValues,
+        statusCode: response.status,
+        responseHeaders,
+        responseBody: undefined,
+      });
+    }
+
+    try {
+      const buffer = await response.arrayBuffer();
+      return {
+        responseHeaders,
+        value: new Uint8Array(buffer),
+      };
+    } catch (error) {
+      throw new APICallError({
+        message: 'Failed to read response as array buffer',
+        url,
+        requestBodyValues,
+        statusCode: response.status,
+        responseHeaders,
+        responseBody: undefined,
+        cause: error,
+      });
+    }
+  };
+
+export const createStatusCodeErrorResponseHandler =
+  (): ResponseHandler<APICallError> =>
+  async ({ response, url, requestBodyValues }) => {
+    const responseHeaders = extractResponseHeaders(response);
+    const responseBody = await response.text();
+
+    return {
+      responseHeaders,
+      value: new APICallError({
+        message: response.statusText,
+        url,
+        requestBodyValues: requestBodyValues as Record<string, unknown>,
+        statusCode: response.status,
+        responseHeaders,
+        responseBody,
+      }),
+    };
+  };

package/src/schema.test-d.ts

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