ai 7.0.92 → 7.0.94

package/src/generate-text/output.ts

@@ -11,6 +11,7 @@ import {
   safeValidateTypes,
   type FlexibleSchema,
 } from '@ai-sdk/provider-utils';
+import { InvalidArgumentError } from '../error/invalid-argument-error';
 import { NoObjectGeneratedError } from '../error/no-object-generated-error';
 import type { FinishReason } from '../types/language-model';
 import type { LanguageModelResponseMetadata } from '../types/language-model-response-metadata';
@@ -189,6 +190,8 @@ export const object = <OBJECT>({
  * When the model generates a text response, it will return an array of elements.
  *
  * @param element - The schema of the array elements to generate.
+ * @param minItems - Optional minimum number of elements to generate.
+ * @param maxItems - Optional maximum number of elements to generate.
  * @param name - Optional name of the output that should be generated. Used by some providers for additional LLM guidance, e.g. via tool or schema name.
  * @param description - Optional description of the output that should be generated. Used by some providers for additional LLM guidance, e.g. via tool or schema description.
  *
@@ -196,10 +199,20 @@ export const object = <OBJECT>({
  */
 export const array = <ELEMENT>({
   element: inputElementSchema,
+  minItems,
+  maxItems,
   name,
   description,
 }: {
   element: FlexibleSchema<ELEMENT>;
+  /**
+   * Optional minimum number of elements to generate.
+   */
+  minItems?: number;
+  /**
+   * Optional maximum number of elements to generate.
+   */
+  maxItems?: number;
   /**
    * Optional name of the output that should be generated.
    * Used by some providers for additional LLM guidance, e.g. via tool or schema name.
@@ -211,6 +224,17 @@ export const array = <ELEMENT>({
    */
   description?: string;
 }): Output<Array<ELEMENT>, Array<ELEMENT>, ELEMENT> => {
+  validateArrayBound({ name: 'minItems', value: minItems });
+  validateArrayBound({ name: 'maxItems', value: maxItems });
+
+  if (minItems != null && maxItems != null && minItems > maxItems) {
+    throw new InvalidArgumentError({
+      parameter: 'minItems',
+      value: minItems,
+      message: 'minItems must be less than or equal to maxItems',
+    });
+  }
+
   const elementSchema = asSchema(inputElementSchema);
 
   return {
@@ -236,7 +260,12 @@ export const array = <ELEMENT>({
           ...($defs != null && { $defs }),
           type: 'object',
           properties: {
-            elements: { type: 'array', items: itemSchema },
+            elements: {
+              type: 'array',
+              items: itemSchema,
+              ...(minItems != null && { minItems }),
+              ...(maxItems != null && { maxItems }),
+            },
           },
           required: ['elements'],
           additionalProperties: false,
@@ -288,6 +317,23 @@ export const array = <ELEMENT>({
         });
       }
 
+      const lengthValidationError = getArrayLengthValidationError({
+        value: outerValue.elements,
+        minItems,
+        maxItems,
+      });
+
+      if (lengthValidationError != null) {
+        throw new NoObjectGeneratedError({
+          message: 'No object generated: response did not match schema.',
+          cause: lengthValidationError,
+          text,
+          response: context.response,
+          usage: context.usage,
+          finishReason: context.finishReason,
+        });
+      }
+
       const validatedElements: Array<ELEMENT> = [];
       for (const element of outerValue.elements) {
         const validationResult = await safeValidateTypes({
@@ -372,6 +418,16 @@ export const array = <ELEMENT>({
               publishedElements < partialOutput.length;
               publishedElements++
             ) {
+              if (maxItems != null && publishedElements >= maxItems) {
+                controller.error(
+                  getArrayLengthValidationError({
+                    value: partialOutput,
+                    maxItems,
+                  }),
+                );
+                return;
+              }
+
               controller.enqueue(partialOutput[publishedElements]);
             }
           }
@@ -381,6 +437,60 @@ export const array = <ELEMENT>({
   };
 };
 
+function validateArrayBound({
+  name,
+  value,
+}: {
+  name: 'minItems' | 'maxItems';
+  value: number | undefined;
+}) {
+  if (value == null) {
+    return;
+  }
+
+  if (!Number.isInteger(value)) {
+    throw new InvalidArgumentError({
+      parameter: name,
+      value,
+      message: `${name} must be an integer`,
+    });
+  }
+
+  if (value < 0) {
+    throw new InvalidArgumentError({
+      parameter: name,
+      value,
+      message: `${name} must be greater than or equal to 0`,
+    });
+  }
+}
+
+function getArrayLengthValidationError({
+  value,
+  minItems,
+  maxItems,
+}: {
+  value: Array<unknown>;
+  minItems?: number;
+  maxItems?: number;
+}): TypeValidationError | undefined {
+  if (minItems != null && value.length < minItems) {
+    return new TypeValidationError({
+      value,
+      cause: `elements array must contain at least ${minItems} items`,
+    });
+  }
+
+  if (maxItems != null && value.length > maxItems) {
+    return new TypeValidationError({
+      value,
+      cause: `elements array must contain at most ${maxItems} items`,
+    });
+  }
+
+  return undefined;
+}
+
 /**
  * Output specification for choice generation.
  * When the model generates a text response, it will return a one of the choice options.

package/src/generate-text/stream-language-model-call.ts

@@ -1,7 +1,9 @@
 import {
   getErrorMessage,
+  type LanguageModelV4Content,
   type LanguageModelV4Prompt,
   type LanguageModelV4StreamPart,
+  type LanguageModelV4ToolChoice,
   type SharedV4Headers,
 } from '@ai-sdk/provider';
 import {
@@ -40,6 +42,7 @@ import {
 import type { DownloadFunction } from '../util/download/download-function';
 import { notify } from '../util/notify';
 import { now as originalNow } from '../util/now';
+import { ToolChoiceViolationError } from '../error';
 import { calculateTokensPerSecond } from './calculate-tokens-per-second';
 import type { ContentPart } from './content-part';
 import { DefaultGeneratedFileWithType } from './generated-file';
@@ -372,6 +375,7 @@ export async function streamLanguageModelCall<
       callId: effectiveCallId,
       provider: resolvedModel.provider,
       modelId: resolvedModel.modelId,
+      toolChoice: stepToolChoice,
       generateId,
       now,
       callStartTimestampMs,
@@ -398,6 +402,7 @@ function createLanguageModelV4StreamPartToLanguageModelStreamPartTransform<
   callId,
   provider,
   modelId,
+  toolChoice,
   generateId,
   now,
   callStartTimestampMs,
@@ -411,6 +416,7 @@ function createLanguageModelV4StreamPartToLanguageModelStreamPartTransform<
   callId: string;
   provider: string;
   modelId: string;
+  toolChoice: LanguageModelV4ToolChoice;
   generateId: IdGenerator;
   now: () => number;
   callStartTimestampMs: number;
@@ -420,8 +426,11 @@ function createLanguageModelV4StreamPartToLanguageModelStreamPartTransform<
   // keep track of tool inputs for provider-side tool results
   const toolCallsByToolCallId = new Map<string, TypedToolCall<TOOLS>>();
   const modelCallContent: Array<ContentPart<TOOLS>> = [];
+  const rawModelCallContent: Array<LanguageModelV4Content> = [];
   const textPartIndexes = new Map<string, number>();
   const reasoningPartIndexes = new Map<string, number>();
+  const rawTextPartIndexes = new Map<string, number>();
+  const rawReasoningPartIndexes = new Map<string, number>();
   let responseId = generateId();
   let responseModelId = modelId;
   let timeToFirstOutputMs: number | undefined;
@@ -458,7 +467,9 @@ function createLanguageModelV4StreamPartToLanguageModelStreamPartTransform<
         case 'text-start':
           upsertTextContentPart({
             content: modelCallContent,
+            rawContent: rawModelCallContent,
             partIndexes: textPartIndexes,
+            rawPartIndexes: rawTextPartIndexes,
             id: chunk.id,
             type: 'text',
             providerMetadata: chunk.providerMetadata,
@@ -469,7 +480,9 @@ function createLanguageModelV4StreamPartToLanguageModelStreamPartTransform<
         case 'text-delta':
           upsertTextContentPart({
             content: modelCallContent,
+            rawContent: rawModelCallContent,
             partIndexes: textPartIndexes,
+            rawPartIndexes: rawTextPartIndexes,
             id: chunk.id,
             type: 'text',
             textDelta: chunk.delta,
@@ -486,19 +499,24 @@ function createLanguageModelV4StreamPartToLanguageModelStreamPartTransform<
         case 'text-end':
           upsertTextContentPart({
             content: modelCallContent,
+            rawContent: rawModelCallContent,
             partIndexes: textPartIndexes,
+            rawPartIndexes: rawTextPartIndexes,
             id: chunk.id,
             type: 'text',
             providerMetadata: chunk.providerMetadata,
           });
           textPartIndexes.delete(chunk.id);
+          rawTextPartIndexes.delete(chunk.id);
           controller.enqueue(chunk);
           break;
 
         case 'reasoning-start':
           upsertTextContentPart({
             content: modelCallContent,
+            rawContent: rawModelCallContent,
             partIndexes: reasoningPartIndexes,
+            rawPartIndexes: rawReasoningPartIndexes,
             id: chunk.id,
             type: 'reasoning',
             providerMetadata: chunk.providerMetadata,
@@ -509,7 +527,9 @@ function createLanguageModelV4StreamPartToLanguageModelStreamPartTransform<
         case 'reasoning-delta':
           upsertTextContentPart({
             content: modelCallContent,
+            rawContent: rawModelCallContent,
             partIndexes: reasoningPartIndexes,
+            rawPartIndexes: rawReasoningPartIndexes,
             id: chunk.id,
             type: 'reasoning',
             textDelta: chunk.delta,
@@ -526,12 +546,15 @@ function createLanguageModelV4StreamPartToLanguageModelStreamPartTransform<
         case 'reasoning-end':
           upsertTextContentPart({
             content: modelCallContent,
+            rawContent: rawModelCallContent,
             partIndexes: reasoningPartIndexes,
+            rawPartIndexes: rawReasoningPartIndexes,
             id: chunk.id,
             type: 'reasoning',
             providerMetadata: chunk.providerMetadata,
           });
           reasoningPartIndexes.delete(chunk.id);
+          rawReasoningPartIndexes.delete(chunk.id);
           controller.enqueue(chunk);
           break;
 
@@ -552,6 +575,7 @@ function createLanguageModelV4StreamPartToLanguageModelStreamPartTransform<
               ? { providerMetadata: chunk.providerMetadata }
               : {}),
           });
+          rawModelCallContent.push(chunk);
 
           controller.enqueue({
             type: chunk.type,
@@ -612,6 +636,9 @@ function createLanguageModelV4StreamPartToLanguageModelStreamPartTransform<
             callbacks: onLanguageModelCallEnd,
           });
 
+          // Preserve the completed model call's usage, metadata, and
+          // performance even when response validation below surfaces a
+          // semantic error.
           controller.enqueue({
             type: 'model-call-end',
             finishReason: chunk.finishReason.unified,
@@ -620,10 +647,38 @@ function createLanguageModelV4StreamPartToLanguageModelStreamPartTransform<
             providerMetadata: chunk.providerMetadata,
             performance,
           });
+
+          const enforcedToolChoice =
+            toolChoice.type === 'required' || toolChoice.type === 'tool'
+              ? toolChoice
+              : undefined;
+
+          if (
+            enforcedToolChoice != null &&
+            ![...toolCallsByToolCallId.values()].some(
+              toolCall =>
+                enforcedToolChoice.type === 'required' ||
+                toolCall.toolName === enforcedToolChoice.toolName,
+            )
+          ) {
+            controller.enqueue({
+              type: 'error',
+              error: new ToolChoiceViolationError({
+                toolChoice: enforcedToolChoice,
+                finishReason: chunk.finishReason.unified,
+                provider,
+                modelId,
+                content: rawModelCallContent,
+              }),
+            });
+            break;
+          }
           break;
         }
 
         case 'tool-call': {
+          rawModelCallContent.push(chunk);
+
           try {
             const toolCall = await parseToolCall({
               toolCall: chunk,
@@ -663,6 +718,8 @@ function createLanguageModelV4StreamPartToLanguageModelStreamPartTransform<
         }
 
         case 'tool-approval-request': {
+          rawModelCallContent.push(chunk);
+
           const toolCall = toolCallsByToolCallId.get(chunk.toolCallId);
 
           if (toolCall == null) {
@@ -688,6 +745,8 @@ function createLanguageModelV4StreamPartToLanguageModelStreamPartTransform<
         }
 
         case 'tool-result': {
+          rawModelCallContent.push(chunk);
+
           const toolName = chunk.toolName as keyof TOOLS & string;
           const toolCall = toolCallsByToolCallId.get(chunk.toolCallId);
 
@@ -765,6 +824,7 @@ function createLanguageModelV4StreamPartToLanguageModelStreamPartTransform<
         default:
           if (chunk.type === 'custom' || chunk.type === 'source') {
             modelCallContent.push(chunk);
+            rawModelCallContent.push(chunk);
           }
 
           controller.enqueue(chunk);
@@ -818,14 +878,18 @@ function calculateNearestRankPercentile(
  */
 function upsertTextContentPart<TOOLS extends ToolSet>({
   content,
+  rawContent,
   partIndexes,
+  rawPartIndexes,
   id,
   type,
   textDelta,
   providerMetadata,
 }: {
   content: Array<ContentPart<TOOLS>>;
+  rawContent: Array<LanguageModelV4Content>;
   partIndexes: Map<string, number>;
+  rawPartIndexes: Map<string, number>;
   id: string;
   type: 'text' | 'reasoning';
   textDelta?: string;
@@ -843,16 +907,34 @@ function upsertTextContentPart<TOOLS extends ToolSet>({
     partIndexes.set(id, partIndex);
   }
 
+  let rawPartIndex = rawPartIndexes.get(id);
+
+  if (rawPartIndex == null) {
+    rawPartIndex =
+      rawContent.push({
+        type,
+        text: '',
+        ...(providerMetadata != null ? { providerMetadata } : {}),
+      }) - 1;
+    rawPartIndexes.set(id, rawPartIndex);
+  }
+
   const part = content[partIndex] as {
     text: string;
     providerMetadata?: ProviderMetadata;
   };
+  const rawPart = rawContent[rawPartIndex] as {
+    text: string;
+    providerMetadata?: ProviderMetadata;
+  };
 
   if (textDelta != null) {
     part.text += textDelta;
+    rawPart.text += textDelta;
   }
 
   if (providerMetadata != null) {
     part.providerMetadata = providerMetadata;
+    rawPart.providerMetadata = providerMetadata;
   }
 }

package/src/generate-text/stream-text.ts

@@ -22,7 +22,7 @@ import {
   type ToolSet,
 } from '@ai-sdk/provider-utils';
 import type { ServerResponse } from 'node:http';
-import { NoOutputGeneratedError } from '../error';
+import { NoOutputGeneratedError, ToolChoiceViolationError } from '../error';
 import { logWarnings } from '../logger/log-warnings';
 import { resolveLanguageModel } from '../model/resolve-model';
 import { cloneModelMessages } from '../prompt/clone-model-message';
@@ -2573,6 +2573,8 @@ class DefaultStreamTextResult<
                   callbacks: onChunk,
                 });
                 const error = wrapGatewayError(value.error);
+                const isToolChoiceViolation =
+                  ToolChoiceViolationError.isInstance(error);
                 let onErrorResult: unknown;
                 try {
                   onErrorResult = await onError({ error });
@@ -2584,8 +2586,10 @@ class DefaultStreamTextResult<
                   'retry' in onErrorResult &&
                   onErrorResult.retry === true;
                 const automaticRetry =
+                  !isToolChoiceViolation &&
                   automaticStreamRetryCount < streamRetries;
                 const callbackRetry =
+                  !isToolChoiceViolation &&
                   !automaticRetry &&
                   callbackRequestedRetry &&
                   callbackStreamRetryCount < 1;

package/src/ui/chat.ts

@@ -420,8 +420,8 @@ export abstract class AbstractChat<UI_MESSAGE extends UIMessage> {
 
       // update the message with the new content
       this.state.replaceMessage(messageIndex, {
-        ...uiMessage,
         id: message.messageId,
+        ...uiMessage,
         role: uiMessage.role ?? 'user',
         metadata: message.metadata,
       } as UI_MESSAGE);

package/src/ui/convert-to-model-messages.ts

@@ -212,6 +212,12 @@ export async function convertToModelMessages<UI_MESSAGE extends UIMessage>(
                 const toolName = getToolName(part);
 
                 if (part.state !== 'input-streaming') {
+                  const callProviderMetadata =
+                    part.callProviderMetadata ??
+                    (part.state === 'output-error'
+                      ? part.resultProviderMetadata
+                      : undefined);
+
                   content.push({
                     type: 'tool-call' as const,
                     toolCallId: part.toolCallId,
@@ -222,8 +228,8 @@ export async function convertToModelMessages<UI_MESSAGE extends UIMessage>(
                           ('rawInput' in part ? part.rawInput : undefined))
                         : part.input,
                     providerExecuted: part.providerExecuted,
-                    ...(part.callProviderMetadata != null
-                      ? { providerOptions: part.callProviderMetadata }
+                    ...(callProviderMetadata != null
+                      ? { providerOptions: callProviderMetadata }
                       : {}),
                   });
 

package/src/ui/validate-ui-messages.ts

@@ -117,6 +117,7 @@ const uiMessagesSchema = lazySchema(() =>
                   type: z.literal('dynamic-tool'),
                   toolName: z.string(),
                   toolCallId: z.string(),
+                  title: z.string().optional(),
                   toolMetadata: toolMetadataSchema.optional(),
                   state: z.literal('input-streaming'),
                   input: z.unknown().optional(),
@@ -130,6 +131,7 @@ const uiMessagesSchema = lazySchema(() =>
                   type: z.literal('dynamic-tool'),
                   toolName: z.string(),
                   toolCallId: z.string(),
+                  title: z.string().optional(),
                   toolMetadata: toolMetadataSchema.optional(),
                   state: z.literal('input-available'),
                   input: z.unknown(),
@@ -143,6 +145,7 @@ const uiMessagesSchema = lazySchema(() =>
                   type: z.literal('dynamic-tool'),
                   toolName: z.string(),
                   toolCallId: z.string(),
+                  title: z.string().optional(),
                   toolMetadata: toolMetadataSchema.optional(),
                   state: z.literal('approval-requested'),
                   input: z.unknown(),
@@ -164,6 +167,7 @@ const uiMessagesSchema = lazySchema(() =>
                   type: z.literal('dynamic-tool'),
                   toolName: z.string(),
                   toolCallId: z.string(),
+                  title: z.string().optional(),
                   toolMetadata: toolMetadataSchema.optional(),
                   state: z.literal('approval-responded'),
                   input: z.unknown(),
@@ -185,6 +189,7 @@ const uiMessagesSchema = lazySchema(() =>
                   type: z.literal('dynamic-tool'),
                   toolName: z.string(),
                   toolCallId: z.string(),
+                  title: z.string().optional(),
                   toolMetadata: toolMetadataSchema.optional(),
                   state: z.literal('output-available'),
                   input: z.unknown(),
@@ -210,6 +215,7 @@ const uiMessagesSchema = lazySchema(() =>
                   type: z.literal('dynamic-tool'),
                   toolName: z.string(),
                   toolCallId: z.string(),
+                  title: z.string().optional(),
                   toolMetadata: toolMetadataSchema.optional(),
                   state: z.literal('output-error'),
                   input: z.unknown().optional(),
@@ -235,6 +241,7 @@ const uiMessagesSchema = lazySchema(() =>
                   type: z.literal('dynamic-tool'),
                   toolName: z.string(),
                   toolCallId: z.string(),
+                  title: z.string().optional(),
                   toolMetadata: toolMetadataSchema.optional(),
                   state: z.literal('output-denied'),
                   input: z.unknown(),
@@ -255,6 +262,7 @@ const uiMessagesSchema = lazySchema(() =>
                 z.object({
                   type: z.string().startsWith('tool-'),
                   toolCallId: z.string(),
+                  title: z.string().optional(),
                   toolMetadata: toolMetadataSchema.optional(),
                   state: z.literal('input-streaming'),
                   providerExecuted: z.boolean().optional(),
@@ -267,6 +275,7 @@ const uiMessagesSchema = lazySchema(() =>
                 z.object({
                   type: z.string().startsWith('tool-'),
                   toolCallId: z.string(),
+                  title: z.string().optional(),
                   toolMetadata: toolMetadataSchema.optional(),
                   state: z.literal('input-available'),
                   providerExecuted: z.boolean().optional(),
@@ -279,6 +288,7 @@ const uiMessagesSchema = lazySchema(() =>
                 z.object({
                   type: z.string().startsWith('tool-'),
                   toolCallId: z.string(),
+                  title: z.string().optional(),
                   toolMetadata: toolMetadataSchema.optional(),
                   state: z.literal('approval-requested'),
                   input: z.unknown(),
@@ -299,6 +309,7 @@ const uiMessagesSchema = lazySchema(() =>
                 z.object({
                   type: z.string().startsWith('tool-'),
                   toolCallId: z.string(),
+                  title: z.string().optional(),
                   toolMetadata: toolMetadataSchema.optional(),
                   state: z.literal('approval-responded'),
                   input: z.unknown(),
@@ -319,6 +330,7 @@ const uiMessagesSchema = lazySchema(() =>
                 z.object({
                   type: z.string().startsWith('tool-'),
                   toolCallId: z.string(),
+                  title: z.string().optional(),
                   toolMetadata: toolMetadataSchema.optional(),
                   state: z.literal('output-available'),
                   providerExecuted: z.boolean().optional(),
@@ -343,6 +355,7 @@ const uiMessagesSchema = lazySchema(() =>
                 z.object({
                   type: z.string().startsWith('tool-'),
                   toolCallId: z.string(),
+                  title: z.string().optional(),
                   toolMetadata: toolMetadataSchema.optional(),
                   state: z.literal('output-error'),
                   providerExecuted: z.boolean().optional(),
@@ -367,6 +380,7 @@ const uiMessagesSchema = lazySchema(() =>
                 z.object({
                   type: z.string().startsWith('tool-'),
                   toolCallId: z.string(),
+                  title: z.string().optional(),
                   toolMetadata: toolMetadataSchema.optional(),
                   state: z.literal('output-denied'),
                   providerExecuted: z.boolean().optional(),

package/src/util/data-url.ts

@@ -10,7 +10,7 @@ export function getTextFromDataUrl(dataUrl: string): string {
   }
 
   try {
-    return window.atob(base64Content);
+    return globalThis.atob(base64Content);
   } catch {
     throw new Error(`Error decoding data URL`);
   }

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

@@ -14,7 +14,7 @@ export function mergeAbortSignals(
   ...signals: (AbortSignal | null | undefined | number)[]
 ): AbortSignal | undefined {
   const validSignals = filterNullable(...signals).map(signal =>
-    signal instanceof AbortSignal ? signal : AbortSignal.timeout(signal),
+    typeof signal === 'number' ? AbortSignal.timeout(signal) : signal,
   );
 
   return validSignals.length === 0

package/src/util/prepare-retries.ts

@@ -1,5 +1,8 @@
 import { InvalidArgumentError } from '../error/invalid-argument-error';
-import type { RetryFunction } from '@ai-sdk/provider-utils';
+import type {
+  RetryFunction,
+  ShouldRetryFunction,
+} from '@ai-sdk/provider-utils';
 import { retryWithExponentialBackoffRespectingRetryHeaders } from '../util/retry-with-exponential-backoff';
 /**
  * Validate and prepare retries.
@@ -7,11 +10,13 @@ import { retryWithExponentialBackoffRespectingRetryHeaders } from '../util/retry
 export function prepareRetries({
   maxRetries,
   abortSignal,
+  additionalRetryableError,
   parameter = 'maxRetries',
   defaultMaxRetries = 2,
 }: {
   maxRetries: number | undefined;
   abortSignal: AbortSignal | undefined;
+  additionalRetryableError?: ShouldRetryFunction;
   parameter?: string;
   defaultMaxRetries?: number;
 }): {
@@ -43,6 +48,7 @@ export function prepareRetries({
     retry: retryWithExponentialBackoffRespectingRetryHeaders({
       maxRetries: maxRetriesResult,
       abortSignal,
+      additionalRetryableError,
     }),
   };
 }

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

@@ -3,6 +3,7 @@ import { GatewayError } from '@ai-sdk/gateway';
 import {
   retryWithExponentialBackoff,
   type RetryFunction,
+  type ShouldRetryFunction,
 } from '@ai-sdk/provider-utils';
 import { RetryError } from './retry-error';
 
@@ -66,21 +67,25 @@ export const retryWithExponentialBackoffRespectingRetryHeaders = ({
   initialDelayInMs = 2000,
   backoffFactor = 2,
   abortSignal,
+  additionalRetryableError,
 }: {
   maxRetries?: number;
   initialDelayInMs?: number;
   backoffFactor?: number;
   abortSignal?: AbortSignal;
+  additionalRetryableError?: ShouldRetryFunction;
 } = {}): RetryFunction =>
   retryWithExponentialBackoff({
     maxRetries,
     initialDelayInMs,
     backoffFactor,
     abortSignal,
-    shouldRetry: error =>
-      error instanceof Error &&
-      ((APICallError.isInstance(error) && error.isRetryable === true) ||
-        (GatewayError.isInstance(error) && error.isRetryable === true)),
+    shouldRetry: async error =>
+      (error instanceof Error &&
+        ((APICallError.isInstance(error) && error.isRetryable === true) ||
+          (GatewayError.isInstance(error) && error.isRetryable === true))) ||
+      (additionalRetryableError != null &&
+        (await additionalRetryableError(error))),
     getDelayInMs: ({ error, exponentialBackoffDelay }) =>
       getRetryDelayInMs({
         error: error as APICallError | GatewayError,