@ai-sdk/provider-utils 4.0.34 → 4.0.36

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/provider-utils",
-  "version": "4.0.34",
+  "version": "4.0.36",
   "license": "Apache-2.0",
   "sideEffects": false,
   "main": "./dist/index.js",

package/src/index.ts

@@ -46,6 +46,7 @@ export {
 export { cancelResponseBody } from './cancel-response-body';
 export * from './remove-undefined-entries';
 export * from './resolve';
+export * from './retry-with-exponential-backoff';
 export * from './response-handler';
 export {
   asSchema,
@@ -58,6 +59,7 @@ export {
   type Schema,
   type ValidationResult,
 } from './schema';
+export { secureJsonParse } from './secure-json-parse';
 export { stripFileExtension } from './strip-file-extension';
 export * from './uint8-utils';
 export { validateDownloadUrl } from './validate-download-url';

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

@@ -0,0 +1,143 @@
+import { delay } from './delay';
+import { getErrorMessage } from './get-error-message';
+import { isAbortError } from './is-abort-error';
+
+export type RetryFunction = <OUTPUT>(
+  fn: () => PromiseLike<OUTPUT>,
+) => PromiseLike<OUTPUT>;
+
+export type RetryErrorReason = 'maxRetriesExceeded' | 'errorNotRetryable';
+
+export type RetryErrorFactory = ({
+  message,
+  reason,
+  errors,
+}: {
+  message: string;
+  reason: RetryErrorReason;
+  errors: Array<unknown>;
+}) => unknown;
+
+export type RetryDelayProvider = ({
+  error,
+  exponentialBackoffDelay,
+}: {
+  error: unknown;
+  exponentialBackoffDelay: number;
+}) => number;
+
+export type ShouldRetryFunction = (
+  error: unknown,
+) => boolean | Promise<boolean>;
+
+/**
+ * Retries a failed operation with exponential backoff.
+ */
+export const retryWithExponentialBackoff =
+  ({
+    maxRetries = 2,
+    initialDelayInMs = 2000,
+    backoffFactor = 2,
+    abortSignal,
+    shouldRetry,
+    getDelayInMs = ({ exponentialBackoffDelay }) => exponentialBackoffDelay,
+    createRetryError = ({ message }) => new Error(message),
+  }: {
+    maxRetries?: number;
+    initialDelayInMs?: number;
+    backoffFactor?: number;
+    abortSignal?: AbortSignal;
+    shouldRetry: ShouldRetryFunction;
+    getDelayInMs?: RetryDelayProvider;
+    createRetryError?: RetryErrorFactory;
+  }): RetryFunction =>
+  async <OUTPUT>(f: () => PromiseLike<OUTPUT>) =>
+    retryWithExponentialBackoffInternal(f, {
+      maxRetries,
+      delayInMs: initialDelayInMs,
+      backoffFactor,
+      abortSignal,
+      shouldRetry,
+      getDelayInMs,
+      createRetryError,
+    });
+
+async function retryWithExponentialBackoffInternal<OUTPUT>(
+  f: () => PromiseLike<OUTPUT>,
+  {
+    maxRetries,
+    delayInMs,
+    backoffFactor,
+    abortSignal,
+    shouldRetry,
+    getDelayInMs,
+    createRetryError,
+  }: {
+    maxRetries: number;
+    delayInMs: number;
+    backoffFactor: number;
+    abortSignal: AbortSignal | undefined;
+    shouldRetry: ShouldRetryFunction;
+    getDelayInMs: RetryDelayProvider;
+    createRetryError: RetryErrorFactory;
+  },
+  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 createRetryError({
+        message: `Failed after ${tryNumber} attempts. Last error: ${errorMessage}`,
+        reason: 'maxRetriesExceeded',
+        errors: newErrors,
+      });
+    }
+
+    if ((await shouldRetry(error)) && tryNumber <= maxRetries) {
+      await delay(
+        getDelayInMs({
+          error,
+          exponentialBackoffDelay: delayInMs,
+        }),
+        { abortSignal },
+      );
+
+      return retryWithExponentialBackoffInternal(
+        f,
+        {
+          maxRetries,
+          delayInMs: backoffFactor * delayInMs,
+          backoffFactor,
+          abortSignal,
+          shouldRetry,
+          getDelayInMs,
+          createRetryError,
+        },
+        newErrors,
+      );
+    }
+
+    if (tryNumber === 1) {
+      throw error; // don't wrap the error when a non-retryable error occurs on the first try
+    }
+
+    throw createRetryError({
+      message: `Failed after ${tryNumber} attempts with non-retryable error: '${errorMessage}'`,
+      reason: 'errorNotRetryable',
+      errors: newErrors,
+    });
+  }
+}

package/src/types/tool.ts

@@ -198,6 +198,8 @@ export type Tool<
      * Optional conversion function that maps the tool result to an output that can be used by the language model.
      *
      * If not provided, the tool result will be sent as a JSON object.
+     *
+     * This function is invoked on the server by `convertToModelMessages`, so ensure that you pass the same "tools" (ToolSet) to both "convertToModelMessages" and "streamText" (or other generation APIs).
      */
     toModelOutput?: (options: {
       /**