ai 7.0.93 → 7.0.94

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/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,