@fondation-io/ai 7.0.0-beta.45

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.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.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);
+  }
+}

package/src/util/retry-with-exponential-backoff.ts

@@ -0,0 +1,154 @@
+import { APICallError } from '@ai-sdk/provider';
+import { delay, getErrorMessage, isAbortError } from '@ai-sdk/provider-utils';
+import { RetryError } from './retry-error';
+
+export type RetryFunction = <OUTPUT>(
+  fn: () => PromiseLike<OUTPUT>,
+) => PromiseLike<OUTPUT>;
+
+function getRetryDelayInMs({
+  error,
+  exponentialBackoffDelay,
+}: {
+  error: APICallError;
+  exponentialBackoffDelay: number;
+}): number {
+  const headers = error.responseHeaders;
+
+  if (!headers) return exponentialBackoffDelay;
+
+  let ms: number | undefined;
+
+  // retry-ms is more precise than retry-after and used by e.g. OpenAI
+  const retryAfterMs = headers['retry-after-ms'];
+  if (retryAfterMs) {
+    const timeoutMs = parseFloat(retryAfterMs);
+    if (!Number.isNaN(timeoutMs)) {
+      ms = timeoutMs;
+    }
+  }
+
+  // About the Retry-After header: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After
+  const retryAfter = headers['retry-after'];
+  if (retryAfter && ms === undefined) {
+    const timeoutSeconds = parseFloat(retryAfter);
+    if (!Number.isNaN(timeoutSeconds)) {
+      ms = timeoutSeconds * 1000;
+    } else {
+      ms = Date.parse(retryAfter) - Date.now();
+    }
+  }
+
+  // check that the delay is reasonable:
+  if (
+    ms != null &&
+    !Number.isNaN(ms) &&
+    0 <= ms &&
+    (ms < 60 * 1000 || ms < exponentialBackoffDelay)
+  ) {
+    return ms;
+  }
+
+  return exponentialBackoffDelay;
+}
+
+/**
+ * The `retryWithExponentialBackoffRespectingRetryHeaders` strategy retries a failed API call with an exponential backoff,
+ * while respecting rate limit headers (retry-after-ms and retry-after) if they are provided and reasonable (0-60 seconds).
+ * You can configure the maximum number of retries, the initial delay, and the backoff factor.
+ */
+export const retryWithExponentialBackoffRespectingRetryHeaders =
+  ({
+    maxRetries = 2,
+    initialDelayInMs = 2000,
+    backoffFactor = 2,
+    abortSignal,
+  }: {
+    maxRetries?: number;
+    initialDelayInMs?: number;
+    backoffFactor?: number;
+    abortSignal?: AbortSignal;
+  } = {}): RetryFunction =>
+  async <OUTPUT>(f: () => PromiseLike<OUTPUT>) =>
+    _retryWithExponentialBackoff(f, {
+      maxRetries,
+      delayInMs: initialDelayInMs,
+      backoffFactor,
+      abortSignal,
+    });
+
+async function _retryWithExponentialBackoff<OUTPUT>(
+  f: () => PromiseLike<OUTPUT>,
+  {
+    maxRetries,
+    delayInMs,
+    backoffFactor,
+    abortSignal,
+  }: {
+    maxRetries: number;
+    delayInMs: number;
+    backoffFactor: number;
+    abortSignal: AbortSignal | undefined;
+  },
+  errors: unknown[] = [],
+): Promise<OUTPUT> {
+  try {
+    return await f();
+  } catch (error) {
+    if (isAbortError(error)) {
+      throw error; // don't retry when the request was aborted
+    }
+
+    if (maxRetries === 0) {
+      throw error; // don't wrap the error when retries are disabled
+    }
+
+    const errorMessage = getErrorMessage(error);
+    const newErrors = [...errors, error];
+    const tryNumber = newErrors.length;
+
+    if (tryNumber > maxRetries) {
+      throw new RetryError({
+        message: `Failed after ${tryNumber} attempts. Last error: ${errorMessage}`,
+        reason: 'maxRetriesExceeded',
+        errors: newErrors,
+      });
+    }
+
+    if (
+      error instanceof Error &&
+      APICallError.isInstance(error) &&
+      error.isRetryable === true &&
+      tryNumber <= maxRetries
+    ) {
+      await delay(
+        getRetryDelayInMs({
+          error,
+          exponentialBackoffDelay: delayInMs,
+        }),
+        { abortSignal },
+      );
+
+      return _retryWithExponentialBackoff(
+        f,
+        {
+          maxRetries,
+          delayInMs: backoffFactor * delayInMs,
+          backoffFactor,
+          abortSignal,
+        },
+        newErrors,
+      );
+    }
+
+    if (tryNumber === 1) {
+      throw error; // don't wrap the error when a non-retryable error occurs on the first try
+    }
+
+    throw new RetryError({
+      message: `Failed after ${tryNumber} attempts with non-retryable error: '${errorMessage}'`,
+      reason: 'errorNotRetryable',
+      errors: newErrors,
+    });
+  }
+}

package/src/util/serial-job-executor.ts

@@ -0,0 +1,36 @@
+import { Job } from './job';
+
+export class SerialJobExecutor {
+  private queue: Array<Job> = [];
+  private isProcessing = false;
+
+  private async processQueue() {
+    if (this.isProcessing) {
+      return;
+    }
+
+    this.isProcessing = true;
+
+    while (this.queue.length > 0) {
+      await this.queue[0]();
+      this.queue.shift();
+    }
+
+    this.isProcessing = false;
+  }
+
+  async run(job: Job): Promise<void> {
+    return new Promise<void>((resolve, reject) => {
+      this.queue.push(async () => {
+        try {
+          await job();
+          resolve();
+        } catch (error) {
+          reject(error);
+        }
+      });
+
+      void this.processQueue();
+    });
+  }
+}

package/src/util/simulate-readable-stream.ts

@@ -0,0 +1,39 @@
+import { delay as delayFunction } from '@ai-sdk/provider-utils';
+
+/**
+ * Creates a ReadableStream that emits the provided values with an optional delay between each value.
+ *
+ * @param options - The configuration options
+ * @param options.chunks - Array of values to be emitted by the stream
+ * @param options.initialDelayInMs - Optional initial delay in milliseconds before emitting the first value (default: 0). Can be set to `null` to skip the initial delay. The difference between `initialDelayInMs: null` and `initialDelayInMs: 0` is that `initialDelayInMs: null` will emit the values without any delay, while `initialDelayInMs: 0` will emit the values with a delay of 0 milliseconds.
+ * @param options.chunkDelayInMs - Optional delay in milliseconds between emitting each value (default: 0). Can be set to `null` to skip the delay. The difference between `chunkDelayInMs: null` and `chunkDelayInMs: 0` is that `chunkDelayInMs: null` will emit the values without any delay, while `chunkDelayInMs: 0` will emit the values with a delay of 0 milliseconds.
+ * @returns A ReadableStream that emits the provided values
+ */
+export function simulateReadableStream<T>({
+  chunks,
+  initialDelayInMs = 0,
+  chunkDelayInMs = 0,
+  _internal,
+}: {
+  chunks: T[];
+  initialDelayInMs?: number | null;
+  chunkDelayInMs?: number | null;
+  _internal?: {
+    delay?: (ms: number | null) => Promise<void>;
+  };
+}): ReadableStream<T> {
+  const delay = _internal?.delay ?? delayFunction;
+
+  let index = 0;
+
+  return new ReadableStream({
+    async pull(controller) {
+      if (index < chunks.length) {
+        await delay(index === 0 ? initialDelayInMs : chunkDelayInMs);
+        controller.enqueue(chunks[index++]);
+      } else {
+        controller.close();
+      }
+    },
+  });
+}

package/src/util/split-array.ts

@@ -0,0 +1,20 @@
+/**
+ * Splits an array into chunks of a specified size.
+ *
+ * @template T - The type of elements in the array.
+ * @param {T[]} array - The array to split.
+ * @param {number} chunkSize - The size of each chunk.
+ * @returns {T[][]} - A new array containing the chunks.
+ */
+export function splitArray<T>(array: T[], chunkSize: number): T[][] {
+  if (chunkSize <= 0) {
+    throw new Error('chunkSize must be greater than 0');
+  }
+
+  const result = [];
+  for (let i = 0; i < array.length; i += chunkSize) {
+    result.push(array.slice(i, i + chunkSize));
+  }
+
+  return result;
+}

package/src/util/value-of.ts

@@ -0,0 +1,65 @@
+// License for this File only:
+//
+// MIT License
+//
+// Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
+// Copyright (c) Vercel, Inc. (https://vercel.com)
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+// documentation files (the "Software"), to deal in the Software without restriction, including without limitation
+// the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and
+// to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all copies or substantial portions
+// of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+// TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+// CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+// IN THE SOFTWARE.
+
+/**
+ * Create a union of the given object's values, and optionally specify which keys to get the values from.
+ *
+ * Please upvote [this issue](https://github.com/microsoft/TypeScript/issues/31438) if you want to have this type as a built-in in TypeScript.
+ *
+ * @example
+ * ```
+ * // data.json
+ * {
+ * 	'foo': 1,
+ * 	'bar': 2,
+ * 	'biz': 3
+ * }
+ *
+ * // main.ts
+ * import type {ValueOf} from 'type-fest';
+ * import data = require('./data.json');
+ *
+ * export function getData(name: string): ValueOf<typeof data> {
+ * 	return data[name];
+ * }
+ *
+ * export function onlyBar(name: string): ValueOf<typeof data, 'bar'> {
+ * 	return data[name];
+ * }
+ *
+ * // file.ts
+ * import {getData, onlyBar} from './main';
+ *
+ * getData('foo');
+ * //=> 1
+ *
+ * onlyBar('foo');
+ * //=> TypeError ...
+ *
+ * onlyBar('bar');
+ * //=> 2
+ * ```
+ * @see https://github.com/sindresorhus/type-fest/blob/main/source/value-of.d.ts
+ */
+export type ValueOf<
+  ObjectType,
+  ValueType extends keyof ObjectType = keyof ObjectType,
+> = ObjectType[ValueType];

package/src/util/write-to-server-response.ts

@@ -0,0 +1,49 @@
+import { ServerResponse } from 'node:http';
+
+/**
+ * Writes the content of a stream to a server response.
+ */
+export function writeToServerResponse({
+  response,
+  status,
+  statusText,
+  headers,
+  stream,
+}: {
+  response: ServerResponse;
+  status?: number;
+  statusText?: string;
+  headers?: Record<string, string | number | string[]>;
+  stream: ReadableStream<Uint8Array>;
+}): void {
+  const statusCode = status ?? 200;
+  if (statusText !== undefined) {
+    response.writeHead(statusCode, statusText, headers);
+  } else {
+    response.writeHead(statusCode, headers);
+  }
+
+  const reader = stream.getReader();
+  const read = async () => {
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+
+        // Respect backpressure: if write() returns false, wait for 'drain' event
+        const canContinue = response.write(value);
+        if (!canContinue) {
+          await new Promise<void>(resolve => {
+            response.once('drain', resolve);
+          });
+        }
+      }
+    } catch (error) {
+      throw error;
+    } finally {
+      response.end();
+    }
+  };
+
+  read();
+}

package/src/version.ts

@@ -0,0 +1,5 @@
+declare const __PACKAGE_VERSION__: string | undefined;
+export const VERSION: string =
+  typeof __PACKAGE_VERSION__ !== 'undefined'
+    ? __PACKAGE_VERSION__
+    : '0.0.0-test';

package/test.d.ts

@@ -0,0 +1 @@
+export * from './dist/test';