ai 6.0.32 → 6.0.34

package/src/util/merge-abort-signals.test.ts

@@ -0,0 +1,155 @@
+import { describe, expect, it } from 'vitest';
+import { mergeAbortSignals } from './merge-abort-signals';
+
+describe('mergeAbortSignals', () => {
+  it('should return a signal that is initially not aborted', () => {
+    const controller1 = new AbortController();
+    const controller2 = new AbortController();
+
+    const merged = mergeAbortSignals(controller1.signal, controller2.signal);
+
+    expect(merged!.aborted).toBe(false);
+  });
+
+  it('should abort when the first signal aborts', () => {
+    const controller1 = new AbortController();
+    const controller2 = new AbortController();
+
+    const merged = mergeAbortSignals(controller1.signal, controller2.signal);
+
+    controller1.abort();
+
+    expect(merged!.aborted).toBe(true);
+  });
+
+  it('should abort when the second signal aborts', () => {
+    const controller1 = new AbortController();
+    const controller2 = new AbortController();
+
+    const merged = mergeAbortSignals(controller1.signal, controller2.signal);
+
+    controller2.abort();
+
+    expect(merged!.aborted).toBe(true);
+  });
+
+  it('should preserve the abort reason from the triggering signal', () => {
+    const controller1 = new AbortController();
+    const controller2 = new AbortController();
+    const reason = new Error('custom abort reason');
+
+    const merged = mergeAbortSignals(controller1.signal, controller2.signal);
+
+    controller1.abort(reason);
+
+    expect(merged!.reason).toBe(reason);
+  });
+
+  it('should preserve string abort reason', () => {
+    const controller1 = new AbortController();
+
+    const merged = mergeAbortSignals(controller1.signal);
+
+    controller1.abort('string reason');
+
+    expect(merged!.reason).toBe('string reason');
+  });
+
+  it('should handle already-aborted signals', () => {
+    const controller1 = new AbortController();
+    const reason = new Error('already aborted');
+    controller1.abort(reason);
+
+    const merged = mergeAbortSignals(controller1.signal);
+
+    expect(merged!.aborted).toBe(true);
+    expect(merged!.reason).toBe(reason);
+  });
+
+  it('should use the first already-aborted signal reason when multiple are aborted', () => {
+    const controller1 = new AbortController();
+    const controller2 = new AbortController();
+    const reason1 = new Error('first reason');
+    const reason2 = new Error('second reason');
+
+    controller1.abort(reason1);
+    controller2.abort(reason2);
+
+    const merged = mergeAbortSignals(controller1.signal, controller2.signal);
+
+    expect(merged!.aborted).toBe(true);
+    expect(merged!.reason).toBe(reason1);
+  });
+
+  it('should return undefined when no signals provided', () => {
+    const merged = mergeAbortSignals();
+
+    expect(merged).toBeUndefined();
+  });
+
+  it('should return undefined when only null/undefined signals provided', () => {
+    const merged = mergeAbortSignals(null, undefined, null);
+
+    expect(merged).toBeUndefined();
+  });
+
+  it('should filter out null and undefined signals', () => {
+    const controller = new AbortController();
+    const reason = new Error('abort reason');
+
+    const merged = mergeAbortSignals(null, controller.signal, undefined);
+
+    expect(merged).not.toBeUndefined();
+    expect(merged!.aborted).toBe(false);
+
+    controller.abort(reason);
+
+    expect(merged!.aborted).toBe(true);
+    expect(merged!.reason).toBe(reason);
+  });
+
+  it('should return the signal directly when only one valid signal provided', () => {
+    const controller = new AbortController();
+
+    const merged = mergeAbortSignals(null, controller.signal, undefined);
+
+    expect(merged).toBe(controller.signal);
+  });
+
+  it('should use the first aborting signal reason when multiple abort simultaneously', () => {
+    const controller1 = new AbortController();
+    const controller2 = new AbortController();
+    const reason1 = new Error('first reason');
+    const reason2 = new Error('second reason');
+
+    const merged = mergeAbortSignals(controller1.signal, controller2.signal);
+
+    // Both abort, but the first one's listener was registered first
+    controller1.abort(reason1);
+    controller2.abort(reason2);
+
+    expect(merged!.reason).toBe(reason1);
+  });
+
+  it('should return the original signal when only one signal provided', () => {
+    const controller = new AbortController();
+
+    const merged = mergeAbortSignals(controller.signal);
+
+    expect(merged).toBe(controller.signal);
+  });
+
+  it('should work with many signals', () => {
+    const controllers = Array.from({ length: 10 }, () => new AbortController());
+    const reason = new Error('signal 5 reason');
+
+    const merged = mergeAbortSignals(...controllers.map(c => c.signal));
+
+    expect(merged!.aborted).toBe(false);
+
+    controllers[5].abort(reason);
+
+    expect(merged!.aborted).toBe(true);
+    expect(merged!.reason).toBe(reason);
+  });
+});

package/src/util/merge-abort-signals.ts

@@ -0,0 +1,43 @@
+/**
+ * Merges multiple AbortSignals into a single AbortSignal.
+ * The returned signal will abort when any of the input signals abort,
+ * with the same reason as the first signal to abort.
+ *
+ * @param signals - The AbortSignals to merge. Null and undefined values are filtered out.
+ * @returns An AbortSignal that aborts when any of the input signals abort,
+ *          or undefined if no valid signals are provided.
+ */
+export function mergeAbortSignals(
+  ...signals: (AbortSignal | null | undefined)[]
+): AbortSignal | undefined {
+  const validSignals = signals.filter(
+    (signal): signal is AbortSignal => signal != null,
+  );
+
+  if (validSignals.length === 0) {
+    return undefined;
+  }
+
+  if (validSignals.length === 1) {
+    return validSignals[0];
+  }
+
+  const controller = new AbortController();
+
+  for (const signal of validSignals) {
+    if (signal.aborted) {
+      controller.abort(signal.reason);
+      return controller.signal;
+    }
+
+    signal.addEventListener(
+      'abort',
+      () => {
+        controller.abort(signal.reason);
+      },
+      { once: true },
+    );
+  }
+
+  return controller.signal;
+}

package/src/util/merge-objects.test.ts

@@ -0,0 +1,118 @@
+import { describe, it, expect } from 'vitest';
+import { mergeObjects } from './merge-objects';
+
+describe('mergeObjects', () => {
+  it('should merge two flat objects', () => {
+    const target = { a: 1, b: 2 };
+    const source = { b: 3, c: 4 };
+    const result = mergeObjects(target, source);
+
+    expect(result).toEqual({ a: 1, b: 3, c: 4 });
+    // Original objects should not be modified
+    expect(target).toEqual({ a: 1, b: 2 });
+    expect(source).toEqual({ b: 3, c: 4 });
+  });
+
+  it('should deeply merge nested objects', () => {
+    const target = { a: 1, b: { c: 2, d: 3 } };
+    const source = { b: { c: 4, e: 5 } };
+    const result = mergeObjects(target, source);
+
+    expect(result).toEqual({ a: 1, b: { c: 4, d: 3, e: 5 } });
+  });
+
+  it('should replace arrays instead of merging them', () => {
+    const target = { a: [1, 2, 3], b: 2 };
+    const source = { a: [4, 5] };
+    const result = mergeObjects(target, source);
+
+    expect(result).toEqual({ a: [4, 5], b: 2 });
+  });
+
+  it('should handle null and undefined values', () => {
+    const target = { a: 1, b: null, c: undefined };
+    const source = { a: null, b: 2, d: undefined };
+    const result = mergeObjects(target, source);
+
+    expect(result).toEqual({ a: null, b: 2, c: undefined, d: undefined });
+  });
+
+  it('should handle complex nested structures', () => {
+    const target = {
+      a: 1,
+      b: {
+        c: [1, 2, 3],
+        d: {
+          e: 4,
+          f: 5,
+        },
+      },
+    };
+    const source = {
+      b: {
+        c: [4, 5],
+        d: {
+          f: 6,
+          g: 7,
+        },
+      },
+      h: 8,
+    };
+
+    const result = mergeObjects(target, source);
+
+    expect(result).toEqual({
+      a: 1,
+      b: {
+        c: [4, 5],
+        d: {
+          e: 4,
+          f: 6,
+          g: 7,
+        },
+      },
+      h: 8,
+    });
+  });
+
+  it('should handle Date objects', () => {
+    const date1 = new Date('2023-01-01');
+    const date2 = new Date('2023-02-01');
+
+    const target = { a: date1 };
+    const source = { a: date2 };
+    const result = mergeObjects(target, source);
+
+    expect(result?.a).toBe(date2);
+  });
+
+  it('should handle RegExp objects', () => {
+    const regex1 = /abc/;
+    const regex2 = /def/;
+
+    const target = { a: regex1 };
+    const source = { a: regex2 };
+    const result = mergeObjects(target, source);
+
+    expect(result?.a).toBe(regex2);
+  });
+
+  it('should handle empty objects', () => {
+    const target = {};
+    const source = { a: 1 };
+    expect(mergeObjects(target, source)).toEqual({ a: 1 });
+
+    const target2 = { a: 1 };
+    const source2 = {};
+    expect(mergeObjects(target2, source2)).toEqual({ a: 1 });
+  });
+
+  it('should handle undefined inputs', () => {
+    // Both inputs undefined
+    expect(mergeObjects(undefined, undefined)).toBeUndefined();
+
+    // One input undefined
+    expect(mergeObjects({ a: 1 }, undefined)).toEqual({ a: 1 });
+    expect(mergeObjects(undefined, { b: 2 })).toEqual({ b: 2 });
+  });
+});

package/src/util/merge-objects.ts

@@ -0,0 +1,79 @@
+/**
+ * Deeply merges two objects together.
+ * - Properties from the `overrides` object override those in the `base` object with the same key.
+ * - For nested objects, the merge is performed recursively (deep merge).
+ * - Arrays are replaced, not merged.
+ * - Primitive values are replaced.
+ * - If both `base` and `overrides` are undefined, returns undefined.
+ * - If one of `base` or `overrides` is undefined, returns the other.
+ *
+ * @param base The target object to merge into
+ * @param overrides The source object to merge from
+ * @returns A new object with the merged properties, or undefined if both inputs are undefined
+ */
+export function mergeObjects<T extends object, U extends object>(
+  base: T | undefined,
+  overrides: U | undefined,
+): (T & U) | T | U | undefined {
+  // If both inputs are undefined, return undefined
+  if (base === undefined && overrides === undefined) {
+    return undefined;
+  }
+
+  // If target is undefined, return source
+  if (base === undefined) {
+    return overrides;
+  }
+
+  // If source is undefined, return target
+  if (overrides === undefined) {
+    return base;
+  }
+
+  // Create a new object to avoid mutating the inputs
+  const result = { ...base } as T & U;
+
+  // Iterate through all keys in the source object
+  for (const key in overrides) {
+    if (Object.prototype.hasOwnProperty.call(overrides, key)) {
+      const overridesValue = overrides[key];
+
+      // Skip if the overrides value is undefined
+      if (overridesValue === undefined) continue;
+
+      // Get the base value if it exists
+      const baseValue =
+        key in base ? base[key as unknown as keyof T] : undefined;
+
+      // Check if both values are objects that can be deeply merged
+      const isSourceObject =
+        overridesValue !== null &&
+        typeof overridesValue === 'object' &&
+        !Array.isArray(overridesValue) &&
+        !(overridesValue instanceof Date) &&
+        !(overridesValue instanceof RegExp);
+
+      const isTargetObject =
+        baseValue !== null &&
+        baseValue !== undefined &&
+        typeof baseValue === 'object' &&
+        !Array.isArray(baseValue) &&
+        !(baseValue instanceof Date) &&
+        !(baseValue instanceof RegExp);
+
+      // If both values are mergeable objects, merge them recursively
+      if (isSourceObject && isTargetObject) {
+        result[key as keyof (T & U)] = mergeObjects(
+          baseValue as object,
+          overridesValue as object,
+        ) as any;
+      } else {
+        // For primitives, arrays, or when one value is not a mergeable object,
+        // simply override with the source value
+        result[key as keyof (T & U)] = overridesValue as any;
+      }
+    }
+  }
+
+  return result;
+}

package/src/util/now.ts

@@ -0,0 +1,4 @@
+// Shim for performance.now() to support environments that don't have it:
+export function now(): number {
+  return globalThis?.performance?.now() ?? Date.now();
+}

package/src/util/parse-partial-json.test.ts

@@ -0,0 +1,80 @@
+import { safeParseJSON } from '@ai-sdk/provider-utils';
+import { fixJson } from './fix-json';
+import { parsePartialJson } from './parse-partial-json';
+import { JSONParseError } from '@ai-sdk/provider';
+import { describe, it, expect, vi } from 'vitest';
+
+vi.mock('@ai-sdk/provider-utils');
+vi.mock('./fix-json');
+
+describe('parsePartialJson', () => {
+  it('should handle nullish input', async () => {
+    expect(await parsePartialJson(undefined)).toEqual({
+      value: undefined,
+      state: 'undefined-input',
+    });
+  });
+
+  it('should parse valid JSON', async () => {
+    const validJson = '{"key": "value"}';
+    const parsedValue = { key: 'value' };
+
+    vi.mocked(safeParseJSON).mockResolvedValueOnce({
+      success: true,
+      value: parsedValue,
+      rawValue: parsedValue,
+    });
+
+    expect(await parsePartialJson(validJson)).toEqual({
+      value: parsedValue,
+      state: 'successful-parse',
+    });
+    expect(safeParseJSON).toHaveBeenCalledWith({ text: validJson });
+  });
+
+  it('should repair and parse partial JSON', async () => {
+    const partialJson = '{"key": "value"';
+    const fixedJson = '{"key": "value"}';
+    const parsedValue = { key: 'value' };
+
+    vi.mocked(safeParseJSON)
+      .mockResolvedValueOnce({
+        success: false,
+        error: new JSONParseError({ text: partialJson, cause: undefined }),
+        rawValue: partialJson,
+      })
+      .mockResolvedValueOnce({
+        success: true,
+        value: parsedValue,
+        rawValue: parsedValue,
+      });
+    vi.mocked(fixJson).mockReturnValueOnce(fixedJson);
+
+    expect(await parsePartialJson(partialJson)).toEqual({
+      value: parsedValue,
+      state: 'repaired-parse',
+    });
+    expect(safeParseJSON).toHaveBeenCalledWith({ text: partialJson });
+    expect(fixJson).toHaveBeenCalledWith(partialJson);
+    expect(safeParseJSON).toHaveBeenCalledWith({ text: fixedJson });
+  });
+
+  it('should handle invalid JSON that cannot be repaired', async () => {
+    const invalidJson = 'not json at all';
+
+    vi.mocked(safeParseJSON).mockResolvedValue({
+      success: false,
+      error: new JSONParseError({ text: invalidJson, cause: undefined }),
+      rawValue: invalidJson,
+    });
+    vi.mocked(fixJson).mockReturnValueOnce(invalidJson);
+
+    expect(await parsePartialJson(invalidJson)).toEqual({
+      value: undefined,
+      state: 'failed-parse',
+    });
+    expect(safeParseJSON).toHaveBeenCalledWith({ text: invalidJson });
+    expect(fixJson).toHaveBeenCalledWith(invalidJson);
+    expect(safeParseJSON).toHaveBeenCalledWith({ text: invalidJson });
+  });
+});

package/src/util/parse-partial-json.ts

@@ -0,0 +1,30 @@
+import { JSONValue } from '@ai-sdk/provider';
+import { safeParseJSON } from '@ai-sdk/provider-utils';
+import { fixJson } from './fix-json';
+
+export async function parsePartialJson(jsonText: string | undefined): Promise<{
+  value: JSONValue | undefined;
+  state:
+    | 'undefined-input'
+    | 'successful-parse'
+    | 'repaired-parse'
+    | 'failed-parse';
+}> {
+  if (jsonText === undefined) {
+    return { value: undefined, state: 'undefined-input' };
+  }
+
+  let result = await safeParseJSON({ text: jsonText });
+
+  if (result.success) {
+    return { value: result.value, state: 'successful-parse' };
+  }
+
+  result = await safeParseJSON({ text: fixJson(jsonText) });
+
+  if (result.success) {
+    return { value: result.value, state: 'repaired-parse' };
+  }
+
+  return { value: undefined, state: 'failed-parse' };
+}

package/src/util/prepare-headers.test.ts

@@ -0,0 +1,51 @@
+import { prepareHeaders } from './prepare-headers';
+import { describe, it, expect } from 'vitest';
+
+describe('prepareHeaders', () => {
+  it('should set Content-Type header if not present', () => {
+    const headers = prepareHeaders({}, { 'content-type': 'application/json' });
+
+    expect(headers.get('Content-Type')).toBe('application/json');
+  });
+
+  it('should not overwrite existing Content-Type header', () => {
+    const headers = prepareHeaders(
+      { 'Content-Type': 'text/html' },
+      { 'content-type': 'application/json' },
+    );
+
+    expect(headers.get('Content-Type')).toBe('text/html');
+  });
+
+  it('should handle undefined init', () => {
+    const headers = prepareHeaders(undefined, {
+      'content-type': 'application/json',
+    });
+
+    expect(headers.get('Content-Type')).toBe('application/json');
+  });
+
+  it('should handle init headers as Headers object', () => {
+    const headers = prepareHeaders(new Headers({ init: 'foo' }), {
+      'content-type': 'application/json',
+    });
+
+    expect(headers.get('init')).toBe('foo');
+    expect(headers.get('Content-Type')).toBe('application/json');
+  });
+
+  it('should handle Response object headers', () => {
+    const initHeaders = { init: 'foo' };
+    const response = new Response(null, {
+      headers: { ...initHeaders, extra: 'bar' },
+    });
+
+    const headers = prepareHeaders(response.headers, {
+      'content-type': 'application/json',
+    });
+
+    expect(headers.get('init')).toBe('foo');
+    expect(headers.get('extra')).toBe('bar');
+    expect(headers.get('Content-Type')).toBe('application/json');
+  });
+});

package/src/util/prepare-headers.ts

@@ -0,0 +1,14 @@
+export function prepareHeaders(
+  headers: HeadersInit | undefined,
+  defaultHeaders: Record<string, string>,
+): Headers {
+  const responseHeaders = new Headers(headers ?? {});
+
+  for (const [key, value] of Object.entries(defaultHeaders)) {
+    if (!responseHeaders.has(key)) {
+      responseHeaders.set(key, value);
+    }
+  }
+
+  return responseHeaders;
+}

package/src/util/prepare-retries.test.ts

@@ -0,0 +1,10 @@
+import { expect, it } from 'vitest';
+import { prepareRetries } from './prepare-retries';
+
+it('should set default values correctly when no input is provided', () => {
+  const defaultResult = prepareRetries({
+    maxRetries: undefined,
+    abortSignal: undefined,
+  });
+  expect(defaultResult.maxRetries).toBe(2);
+});

package/src/util/prepare-retries.ts

@@ -0,0 +1,47 @@
+import { InvalidArgumentError } from '../error/invalid-argument-error';
+import {
+  RetryFunction,
+  retryWithExponentialBackoffRespectingRetryHeaders,
+} from '../util/retry-with-exponential-backoff';
+
+/**
+ * Validate and prepare retries.
+ */
+export function prepareRetries({
+  maxRetries,
+  abortSignal,
+}: {
+  maxRetries: number | undefined;
+  abortSignal: AbortSignal | undefined;
+}): {
+  maxRetries: number;
+  retry: RetryFunction;
+} {
+  if (maxRetries != null) {
+    if (!Number.isInteger(maxRetries)) {
+      throw new InvalidArgumentError({
+        parameter: 'maxRetries',
+        value: maxRetries,
+        message: 'maxRetries must be an integer',
+      });
+    }
+
+    if (maxRetries < 0) {
+      throw new InvalidArgumentError({
+        parameter: 'maxRetries',
+        value: maxRetries,
+        message: 'maxRetries must be >= 0',
+      });
+    }
+  }
+
+  const maxRetriesResult = maxRetries ?? 2;
+
+  return {
+    maxRetries: maxRetriesResult,
+    retry: retryWithExponentialBackoffRespectingRetryHeaders({
+      maxRetries: maxRetriesResult,
+      abortSignal,
+    }),
+  };
+}

package/src/util/retry-error.ts

@@ -0,0 +1,41 @@
+import { AISDKError } from '@ai-sdk/provider';
+
+const name = 'AI_RetryError';
+const marker = `vercel.ai.error.${name}`;
+const symbol = Symbol.for(marker);
+
+export type RetryErrorReason =
+  | 'maxRetriesExceeded'
+  | 'errorNotRetryable'
+  | 'abort';
+
+export class RetryError extends AISDKError {
+  private readonly [symbol] = true; // used in isInstance
+
+  // note: property order determines debugging output
+  readonly reason: RetryErrorReason;
+  readonly lastError: unknown;
+  readonly errors: Array<unknown>;
+
+  constructor({
+    message,
+    reason,
+    errors,
+  }: {
+    message: string;
+    reason: RetryErrorReason;
+    errors: Array<unknown>;
+  }) {
+    super({ name, message });
+
+    this.reason = reason;
+    this.errors = errors;
+
+    // separate our last error to make debugging via log easier:
+    this.lastError = errors[errors.length - 1];
+  }
+
+  static isInstance(error: unknown): error is RetryError {
+    return AISDKError.hasMarker(error, marker);
+  }
+}