ai 7.0.110 → 7.0.112

package/docs/03-ai-sdk-core/40-middleware.mdx

@@ -310,6 +310,9 @@ You can implement any of the following three function to modify the behavior of
 3. `wrapStream`: Wraps the `doStream` method of the [language model](https://github.com/vercel/ai/blob/main/packages/provider/src/language-model/v4/language-model-v4.ts).
    You can modify the parameters, call the language model, and modify the result.
 
+Every `LanguageModelV4Middleware` object must set
+`specificationVersion: 'v4'`.
+
 Here are some examples of how to implement language model middleware:
 
 ## Examples
@@ -330,6 +333,8 @@ import type {
 } from '@ai-sdk/provider';
 
 export const yourLogMiddleware: LanguageModelV4Middleware = {
+  specificationVersion: 'v4',
+
   wrapGenerate: async ({ doGenerate, params }) => {
     console.log('doGenerate called');
     console.log(`params: ${JSON.stringify(params, null, 2)}`);
@@ -407,6 +412,8 @@ import type { LanguageModelV4Middleware } from '@ai-sdk/provider';
 const cache = new Map<string, any>();
 
 export const yourCacheMiddleware: LanguageModelV4Middleware = {
+  specificationVersion: 'v4',
+
   wrapGenerate: async ({ doGenerate, params }) => {
     const cacheKey = JSON.stringify(params);
 
@@ -439,6 +446,8 @@ This example shows how to use RAG as middleware.
 import type { LanguageModelV4Middleware } from '@ai-sdk/provider';
 
 export const yourRagMiddleware: LanguageModelV4Middleware = {
+  specificationVersion: 'v4',
+
   transformParams: async ({ params }) => {
     const lastUserMessageText = getLastUserMessageText({
       prompt: params.prompt,
@@ -465,28 +474,102 @@ Guard rails are a way to ensure that the generated text of a language model call
 is safe and appropriate. This example shows how to use guardrails as middleware.
 
 ```ts
-import type { LanguageModelV4Middleware } from '@ai-sdk/provider';
+import type {
+  LanguageModelV4Middleware,
+  LanguageModelV4StreamPart,
+} from '@ai-sdk/provider';
+
+const redactText = (text: string) => text.replace(/badword/g, '<REDACTED>');
 
 export const yourGuardrailMiddleware: LanguageModelV4Middleware = {
+  specificationVersion: 'v4',
+
   wrapGenerate: async ({ doGenerate }) => {
     const result = await doGenerate();
 
     // filtering approach, e.g. for PII or other sensitive information:
     const content = result.content.map(part =>
-      part.type === 'text'
-        ? { ...part, text: part.text.replace(/badword/g, '<REDACTED>') }
-        : part,
+      part.type === 'text' ? { ...part, text: redactText(part.text) } : part,
     );
 
     return { ...result, content };
   },
 
-  // here you would implement the guardrail logic for streaming
-  // Note: streaming guardrails are difficult to implement, because
-  // you do not know the full content of the stream until it's finished.
+  wrapStream: async ({ doStream }) => {
+    const { stream, ...rest } = await doStream();
+
+    // Keep a separate buffer for each text block in the stream.
+    const buffers = new Map<string, string>();
+
+    const transformStream = new TransformStream<
+      LanguageModelV4StreamPart,
+      LanguageModelV4StreamPart
+    >({
+      transform(chunk, controller) {
+        if (chunk.type === 'text-start') {
+          buffers.set(chunk.id, '');
+          controller.enqueue(chunk);
+          return;
+        }
+
+        if (chunk.type === 'text-delta') {
+          buffers.set(chunk.id, (buffers.get(chunk.id) ?? '') + chunk.delta);
+          return;
+        }
+
+        if (chunk.type === 'text-end') {
+          const bufferedText = buffers.get(chunk.id);
+
+          if (bufferedText != null) {
+            const redactedText = redactText(bufferedText);
+
+            if (redactedText) {
+              controller.enqueue({
+                type: 'text-delta',
+                id: chunk.id,
+                delta: redactedText,
+              });
+            }
+
+            buffers.delete(chunk.id);
+          }
+        }
+
+        controller.enqueue(chunk);
+      },
+
+      flush(controller) {
+        for (const [id, bufferedText] of buffers) {
+          const redactedText = redactText(bufferedText);
+
+          if (redactedText) {
+            controller.enqueue({
+              type: 'text-delta',
+              id,
+              delta: redactedText,
+            });
+          }
+        }
+      },
+    });
+
+    return {
+      stream: stream.pipeThrough(transformStream),
+      ...rest,
+    };
+  },
 };
 ```
 
+<Note>
+  The streaming example buffers each text block until `text-end` so matches
+  split across `text-delta` chunks cannot leak through. This delays output and
+  uses memory proportional to the text block size. Do not redact each delta
+  independently. An incremental implementation must retain every possible
+  incomplete match, and a fixed-size buffer alone is not safe for unbounded
+  variable-length patterns.
+</Note>
+
 ## Configuring Per Request Custom Metadata
 
 To send and access custom metadata in Middleware, you can use `providerOptions`. This is useful when building logging middleware where you want to pass additional context like user IDs, timestamps, or other contextual data that can help with tracking and debugging.
@@ -497,6 +580,8 @@ __PROVIDER_IMPORT__;
 import type { LanguageModelV4Middleware } from '@ai-sdk/provider';
 
 export const yourLogMiddleware: LanguageModelV4Middleware = {
+  specificationVersion: 'v4',
+
   wrapGenerate: async ({ doGenerate, params }) => {
     console.log('METADATA', params?.providerMetadata?.yourLogMiddleware);
     const result = await doGenerate();

package/docs/03-ai-sdk-core/60-telemetry.mdx

@@ -126,7 +126,7 @@ const result = await generateText({
 });
 ```
 
-In this example, telemetry integrations receive `runtimeContext` as `{ requestId: 'req_abc' }`. Properties set to `false` or omitted are excluded. If `telemetry.includeRuntimeContext` is omitted, no runtime context properties are included. `telemetry.includeRuntimeContext` is supported by `generateText`, `streamText`, `ToolLoopAgent`, `embed`, `embedMany`, and `rerank`.
+In this example, telemetry integrations receive `runtimeContext` as `{ requestId: 'req_abc' }`. Properties set to `false` or omitted are excluded. If `telemetry.includeRuntimeContext` is omitted, no runtime context properties are included. `telemetry.includeRuntimeContext` is supported by `generateText`, `streamText`, `ToolLoopAgent`, `embed`, `embedMany`, `rerank`, and `experimental_evaluate`.
 
 <Note>
   `telemetry.includeRuntimeContext` only filters telemetry integrations,
@@ -383,6 +383,29 @@ export function myIntegration(): Telemetry {
       type: '(event: RerankingModelCallEndEvent) => void | PromiseLike<void>',
       description: 'Called when an individual reranking model call completes.',
     },
+    {
+      name: 'experimental_onEvaluateStart',
+      type: '(event: Experimental_EvaluateStartEvent) => void | PromiseLike<void>',
+      description: 'Called when an experimental evaluation operation begins.',
+    },
+    {
+      name: 'experimental_onEvaluationModelCallStart',
+      type: '(event: Experimental_EvaluationModelCallStartEvent) => void | PromiseLike<void>',
+      description:
+        'Called when the logical evaluation model call begins. The call includes any provider retries.',
+    },
+    {
+      name: 'experimental_onEvaluationModelCallEnd',
+      type: '(event: Experimental_EvaluationModelCallEndEvent) => void | PromiseLike<void>',
+      description:
+        'Called when the logical evaluation model call, including any retries, completes.',
+    },
+    {
+      name: 'experimental_onEvaluateEnd',
+      type: '(event: Experimental_EvaluateEndEvent) => void | PromiseLike<void>',
+      description:
+        'Called when an experimental evaluation operation completes.',
+    },
     {
       name: 'onEnd',
       type: '(event: GenerateTextEndEvent) => void | PromiseLike<void>',
@@ -398,6 +421,9 @@ export function myIntegration(): Telemetry {
   ]}
 />
 
+Experimental evaluation events use the four `experimental_*` callbacks above.
+They are not included in the stable `onStart` and `onEnd` event unions.
+
 The event types for each method are the same as the corresponding [lifecycle callbacks](/docs/ai-sdk-core/lifecycle-callbacks). See the lifecycle callbacks documentation for the full property reference of each event.
 
 ## Collected Data
@@ -524,6 +550,31 @@ For `rerank`, the integration records spans with `CLIENT` kind:
   - `gen_ai.provider.name`: the provider
   - `gen_ai.request.model`: the model ID
 
+#### experimental_evaluate
+
+For `experimental_evaluate`, the integration records two spans with `CLIENT`
+kind: an **`evaluate {modelId}`** root span for the whole operation and one
+**`evaluate {modelId}`** child span for evaluation model work, including
+retries. Both include the provider and requested model with
+`gen_ai.operation.name: "evaluate"`. Token
+usage is recorded on the child span. When evaluation attributes are enabled,
+answers are recorded on both spans so the operation span contains its output.
+
+`evaluate` is an AI SDK-defined custom operation name, not a well-known
+OpenTelemetry GenAI operation. OpenTelemetry permits custom operation names
+when no well-known value describes the operation.
+
+OpenTelemetry's `gen_ai.evaluation.result` event describes the result of
+evaluating a GenAI output for quality or other characteristics. In contrast,
+`experimental_evaluate` can evaluate arbitrary JSON state for classification,
+routing, scoring, and similar tasks. The integration therefore does not emit a
+`gen_ai.evaluation.result` event.
+
+Evaluation state, questions, and answers also do not have applicable GenAI
+semantic-convention attributes. Enable the `experimental_evaluation`
+supplemental option to record them under AI SDK-specific
+`ai.evaluation.*` attributes.
+
 #### GenAI span details
 
 ##### GenAI message format
@@ -579,10 +630,10 @@ registerTelemetry(
 
 The callback runs when each span is created and receives:
 
-- `spanType`: the type of span being created (`operation`, `step`, `languageModel`, `tool`, `embedding`, or `reranking`).
+- `spanType`: the type of span being created (`operation`, `step`, `languageModel`, `tool`, `embedding`, `reranking`, or `experimental_evaluation`).
 - `operationId`: the AI SDK operation ID for the current call, such as `ai.generateText` or `ai.streamText`.
 - `callId`: the unique ID for the current AI SDK call.
-- `runtimeContext`: the telemetry-filtered runtime context for text generation, embedding, and reranking spans. Text generation spans also reflect updates from `prepareStep`.
+- `runtimeContext`: the telemetry-filtered runtime context for text generation, embedding, reranking, and evaluation spans. Text generation spans also reflect updates from `prepareStep`.
 
 Custom attributes are merged with AI SDK attributes on the span. AI SDK-owned
 attributes take precedence when a custom attribute uses the same key.
@@ -642,6 +693,7 @@ registerTelemetry(
     providerMetadata: true,
     embedding: true,
     reranking: true,
+    experimental_evaluation: true,
     runtimeContext: true,
     headers: true,
     toolChoice: true,
@@ -656,6 +708,7 @@ The available options are:
 - `providerMetadata`: `ai.response.providerMetadata` on operation, step, and model-call spans.
 - `embedding`: embedding inputs and outputs.
 - `reranking`: rerank input documents and ranking output.
+- `experimental_evaluation`: experimental evaluation state, questions, and answers.
 - `runtimeContext`: `ai.settings.context.*`.
 - `headers`: `ai.request.headers.*`.
 - `toolChoice`: `ai.prompt.toolChoice`.

package/docs/03-ai-sdk-core/65-lifecycle-callbacks.mdx

@@ -1,12 +1,12 @@
 ---
 title: Lifecycle Callbacks
-description: Observe AI SDK lifecycle events in generateText, streamText, embed, embedMany, and rerank calls
+description: Observe AI SDK lifecycle events in generateText, streamText, embed, embedMany, rerank, and experimental_evaluate calls
 ---
 
 # Lifecycle Callbacks
 
 Event callbacks let you run your own code at important points in an AI SDK call.
-You can attach them directly to `generateText`, `streamText`, `embed`, `embedMany`, and `rerank` calls to observe what happened, record usage, debug multi-step generations, and monitor tool execution.
+You can attach them directly to `generateText`, `streamText`, `embed`, `embedMany`, `rerank`, and `experimental_evaluate` calls to observe what happened, record usage, debug multi-step generations, and monitor tool execution.
 
 They are especially useful when you want application-specific logic close to the call site:
 
@@ -449,6 +449,25 @@ const result = await generateText({
   ]}
 />
 
+### `experimental_evaluate`
+
+<PropertiesTable
+  content={[
+    {
+      name: 'onStart',
+      type: '(event: Experimental_EvaluateStartEvent) => void | Promise<void>',
+      description:
+        'Called when the evaluation operation begins, before the evaluation model is called.',
+    },
+    {
+      name: 'onEnd',
+      type: '(event: Experimental_EvaluateEndEvent) => void | Promise<void>',
+      description:
+        'Called when the evaluation operation completes successfully.',
+    },
+  ]}
+/>
+
 ## Event Data Reference
 
 The exact event data depends on the callback. The tables below summarize the fields you will most commonly use.
@@ -1151,3 +1170,106 @@ For `embed`, `value` is a single string. For `embedMany`, `value` is an array of
     },
   ]}
 />
+
+### Evaluation Events
+
+Evaluation callbacks are experimental. Their exported types are
+`Experimental_EvaluateStartEvent` and `Experimental_EvaluateEndEvent`.
+
+#### onStart
+
+<PropertiesTable
+  content={[
+    {
+      name: 'callId',
+      type: 'string',
+      description: 'Unique identifier for this evaluation call.',
+    },
+    {
+      name: 'operationId',
+      type: "'ai.evaluate'",
+      description: 'Evaluation operation identifier.',
+    },
+    {
+      name: 'runtimeContext',
+      type: 'RUNTIME_CONTEXT',
+      description: 'Full user-defined runtime context.',
+    },
+    {
+      name: 'provider',
+      type: 'string',
+      description: 'Provider identifier for the evaluation model.',
+    },
+    {
+      name: 'modelId',
+      type: 'string',
+      description: 'Evaluation model identifier.',
+    },
+    {
+      name: 'state',
+      type: 'string | object | array',
+      description: 'Shared state being evaluated.',
+    },
+    {
+      name: 'questions',
+      type: 'Readonly<Record<string, Experimental_EvaluationQuestion>>',
+      description: 'Questions being evaluated against the shared state.',
+    },
+    {
+      name: 'maxRetries',
+      type: 'number',
+      description: 'Maximum number of retries for the model call.',
+    },
+    {
+      name: 'headers',
+      type: 'Record<string, string> | undefined',
+      description: 'Additional HTTP headers sent with the request.',
+    },
+    {
+      name: 'providerOptions',
+      type: 'ProviderOptions',
+      description: 'Provider-specific options.',
+    },
+  ]}
+/>
+
+#### onEnd
+
+Includes every `onStart` field plus:
+
+<PropertiesTable
+  content={[
+    {
+      name: 'answers',
+      type: 'Record<string, Experimental_EvaluationAnswer>',
+      description: 'Exactly one typed answer per question ID.',
+    },
+    {
+      name: 'usage',
+      type: '{ inputTokens: number | undefined; outputTokens: number | undefined; totalTokens: number | undefined }',
+      description: 'Token usage for the evaluation operation.',
+    },
+    {
+      name: 'warnings',
+      type: 'Array<Warning>',
+      description: 'Warnings from the evaluation model.',
+    },
+    {
+      name: 'rounding',
+      type: '{ probabilityDecimals?: number; scoreDecimals?: number } | undefined',
+      description:
+        'Provider-declared decimal precision for probabilities and scores.',
+    },
+    {
+      name: 'providerMetadata',
+      type: 'ProviderMetadata | undefined',
+      description: 'Optional provider-specific metadata.',
+    },
+    {
+      name: 'response',
+      type: '{ id?: string; timestamp: Date; modelId: string; headers?: Record<string, string>; body?: unknown }',
+      description:
+        'Response metadata including the resolved model and timestamp.',
+    },
+  ]}
+/>

package/docs/06-advanced/02-stopping-streams.mdx

@@ -205,6 +205,14 @@ export async function POST(req: Request) {
 
 The `consumeStream` function is necessary for proper abort handling in UI message streams. It ensures that the stream is properly consumed even when aborted, preventing potential memory leaks or hanging connections.
 
+The `onEnd` callback distinguishes consumer cancellation from an observed
+abort. When the consumer cancels the UI message stream before an outcome is
+declared, such as during a client disconnect, `isCancelled` is `true`,
+`outcome.status` remains `'unknown'`, and `isAborted` remains `false`. When the
+stream observes an `abort` part first, `outcome.status` is `'aborted'`,
+`isAborted` is `true`, and `isCancelled` is absent. Check both flags when the
+same cleanup should run for either case.
+
 ## AI SDK RSC
 
 <Note type="warning">

package/docs/07-reference/01-ai-sdk-core/02-stream-text.mdx

@@ -4082,13 +4082,13 @@ To see `streamText` in action, check out [these examples](#examples).
             },
             {
               name: 'onEnd',
-              type: '(options: { messages: UIMessage[]; isContinuation: boolean; responseMessage: UIMessage; isAborted: boolean; outcome: UIMessageStreamOutcome; finishReason?: FinishReason; }) => PromiseLike<void> | void',
+              type: '(options: { messages: UIMessage[]; isContinuation: boolean; responseMessage: UIMessage; isAborted: boolean; isCancelled?: true; outcome: UIMessageStreamOutcome; finishReason?: FinishReason; }) => PromiseLike<void> | void',
               isOptional: true,
-              description: 'Callback function called when the stream ends. Provides the updated messages, continuation and abort state, model finish reason, and operation-level outcome.',
+              description: 'Callback function called when the stream ends. Provides the updated messages, continuation, abort and consumer-cancellation state, model finish reason, and operation-level outcome.',
             },
             {
               name: 'onFinish',
-              type: '(options: { messages: UIMessage[]; isContinuation: boolean; responseMessage: UIMessage; isAborted: boolean; outcome: UIMessageStreamOutcome; finishReason?: FinishReason; }) => PromiseLike<void> | void',
+              type: '(options: { messages: UIMessage[]; isContinuation: boolean; responseMessage: UIMessage; isAborted: boolean; isCancelled?: true; outcome: UIMessageStreamOutcome; finishReason?: FinishReason; }) => PromiseLike<void> | void',
               isOptional: true,
               description: 'Deprecated alias for `onEnd`.',
             },

package/docs/07-reference/01-ai-sdk-core/14-evaluate.mdx

@@ -14,15 +14,22 @@ state. See [Evaluation](/docs/ai-sdk-core/evaluation) for examples and semantics
 
 ## Parameters
 
-| Parameter         | Type                                              | Description                                                                                                                                 |
-| ----------------- | ------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------- |
-| `model`           | `Experimental_EvaluationModel`                    | Required experimental v4 model instance or a string ID resolved by Gateway or an explicitly configured evaluation-capable default provider. |
-| `state`           | `string \| object \| array`                       | Required JSON-compatible shared state.                                                                                                      |
-| `questions`       | `Record<string, Experimental_EvaluationQuestion>` | Required nonempty question map.                                                                                                             |
-| `maxRetries`      | `number`                                          | Nonnegative integer; defaults to 2.                                                                                                         |
-| `abortSignal`     | `AbortSignal`                                     | Cancels evaluation.                                                                                                                         |
-| `headers`         | `Record<string, string>`                          | Additional HTTP headers.                                                                                                                    |
-| `providerOptions` | `ProviderOptions`                                 | Provider-specific options.                                                                                                                  |
+| Parameter         | Type                                               | Description                                                                                                                                 |
+| ----------------- | -------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------- |
+| `model`           | `Experimental_EvaluationModel`                     | Required experimental v4 model instance or a string ID resolved by Gateway or an explicitly configured evaluation-capable default provider. |
+| `state`           | `string \| object \| array`                        | Required JSON-compatible shared state.                                                                                                      |
+| `questions`       | `Record<string, Experimental_EvaluationQuestion>`  | Required nonempty question map.                                                                                                             |
+| `maxRetries`      | `number`                                           | Nonnegative integer; defaults to 2.                                                                                                         |
+| `abortSignal`     | `AbortSignal`                                      | Cancels evaluation.                                                                                                                         |
+| `headers`         | `Record<string, string>`                           | Additional HTTP headers.                                                                                                                    |
+| `providerOptions` | `ProviderOptions`                                  | Provider-specific options.                                                                                                                  |
+| `telemetry`       | `TelemetryOptions`                                 | Telemetry configuration, including per-call integrations, input/output recording, and a function ID.                                        |
+| `runtimeContext`  | `Record<string, unknown>`                          | Context available to lifecycle callbacks and selectively included in telemetry with `telemetry.includeRuntimeContext`.                      |
+| `onStart`         | `(event: Experimental_EvaluateStartEvent) => void` | Called when the evaluation operation begins.                                                                                                |
+| `onEnd`           | `(event: Experimental_EvaluateEndEvent) => void`   | Called when the evaluation operation completes successfully.                                                                                |
+
+See [Lifecycle Callbacks](/docs/ai-sdk-core/lifecycle-callbacks#experimental_evaluate)
+for the complete `onStart` and `onEnd` event fields.
 
 ## Result
 

package/docs/07-reference/02-ai-sdk-ui/40-create-ui-message-stream.mdx

@@ -134,7 +134,7 @@ outcomes and call `setOutcome` once.
     },
     {
       name: 'onEnd',
-      type: '(options: { messages: UIMessage[]; isContinuation: boolean; isAborted: boolean; outcome: UIMessageStreamOutcome; responseMessage: UIMessage; finishReason?: FinishReason }) => PromiseLike<void> | void',
+      type: '(options: { messages: UIMessage[]; isContinuation: boolean; isAborted: boolean; isCancelled?: true; outcome: UIMessageStreamOutcome; responseMessage: UIMessage; finishReason?: FinishReason }) => PromiseLike<void> | void',
       description: 'A callback function that is called when the stream ends.',
       properties: [
         {
@@ -156,11 +156,17 @@ outcomes and call `setOutcome` once.
               type: 'boolean',
               description: 'Indicates whether the stream was aborted.',
             },
+            {
+              name: 'isCancelled',
+              type: 'true | undefined',
+              description:
+                'Present and true when the consumer cancelled the stream before an outcome was declared, for example because the client disconnected.',
+            },
             {
               name: 'outcome',
               type: "UIMessageStreamOutcome = { status: 'completed' } | { status: 'failed'; error?: unknown } | { status: 'aborted' } | { status: 'unknown' }",
               description:
-                'The operation-level outcome of the stream. It reflects the stream owner declaration unless a fatal stream-processing failure occurs, and is separate from model finish reasons and individual error chunks.',
+                "The operation-level outcome of the stream. It reflects the stream owner declaration unless a fatal stream-processing failure occurs, and is separate from model finish reasons and individual error chunks. It remains 'unknown' when the consumer cancels before an outcome is declared; check isCancelled to distinguish that case from normal closure without a declared outcome.",
             },
             {
               name: 'responseMessage',
@@ -180,7 +186,7 @@ outcomes and call `setOutcome` once.
     },
     {
       name: 'onFinish',
-      type: '(options: { messages: UIMessage[]; isContinuation: boolean; isAborted: boolean; outcome: UIMessageStreamOutcome; responseMessage: UIMessage; finishReason?: FinishReason }) => PromiseLike<void> | void',
+      type: '(options: { messages: UIMessage[]; isContinuation: boolean; isAborted: boolean; isCancelled?: true; outcome: UIMessageStreamOutcome; responseMessage: UIMessage; finishReason?: FinishReason }) => PromiseLike<void> | void',
       description: 'Deprecated alias for `onEnd`.',
     },
     {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai",
-  "version": "7.0.110",
+  "version": "7.0.112",
   "type": "module",
   "description": "AI SDK by Vercel - build apps like ChatGPT, Claude, Gemini, and more with a single interface for any model using the Vercel AI Gateway or go direct to OpenAI, Anthropic, Google, or any other model provider.",
   "license": "Apache-2.0",
@@ -42,20 +42,20 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/gateway": "4.0.89",
-    "@ai-sdk/provider": "4.0.17",
-    "@ai-sdk/provider-utils": "5.0.45"
+    "@ai-sdk/gateway": "4.0.90",
+    "@ai-sdk/provider": "4.0.18",
+    "@ai-sdk/provider-utils": "5.0.46"
   },
   "devDependencies": {
-    "@ai-sdk/amazon-bedrock": "5.0.91",
-    "@ai-sdk/deepseek": "3.0.50",
-    "@ai-sdk/google": "4.0.77",
-    "@ai-sdk/groq": "4.0.46",
-    "@ai-sdk/huggingface": "2.0.53",
-    "@ai-sdk/moonshotai": "3.0.54",
-    "@ai-sdk/openai": "4.0.72",
+    "@ai-sdk/amazon-bedrock": "5.0.92",
+    "@ai-sdk/deepseek": "3.0.51",
+    "@ai-sdk/google": "4.0.78",
+    "@ai-sdk/groq": "4.0.47",
+    "@ai-sdk/huggingface": "2.0.54",
+    "@ai-sdk/moonshotai": "3.0.55",
+    "@ai-sdk/openai": "4.0.73",
     "@ai-sdk/test-server": "2.0.1",
-    "@ai-sdk/xai": "5.0.5",
+    "@ai-sdk/xai": "5.0.6",
     "@edge-runtime/vm": "^5.0.0",
     "@smithy/eventstream-codec": "^4.3.3",
     "@smithy/util-utf8": "^4.3.3",

package/src/batch/batch.ts

@@ -374,7 +374,13 @@ export function getBatchResults<TOOLS extends ToolSet>({
     cancel?: (reason?: unknown) => void;
   } = {
     async transform(item, controller) {
-      controller.enqueue(await convertBatchItemResult({ item, tools }));
+      controller.enqueue(
+        await convertBatchItemResult({
+          item,
+          tools,
+          abortSignal: operationAbortSignal,
+        }),
+      );
     },
 
     cancel(reason) {
@@ -507,9 +513,11 @@ function validateBatchReference({
 async function convertBatchItemResult<TOOLS extends ToolSet>({
   item,
   tools,
+  abortSignal,
 }: {
   item: BatchV4ItemResult;
   tools: TOOLS | undefined;
+  abortSignal: AbortSignal | undefined;
 }): Promise<BatchItemResult<TOOLS>> {
   switch (item.type) {
     case 'text':
@@ -519,7 +527,11 @@ async function convertBatchItemResult<TOOLS extends ToolSet>({
             type: item.type,
             id: item.id,
             status: item.status,
-            ...(await convertGenerateResult({ result: item.result, tools })),
+            ...(await convertGenerateResult({
+              result: item.result,
+              tools,
+              abortSignal,
+            })),
           };
         case 'failed':
           return {
@@ -600,9 +612,11 @@ function convertImageResult(
 async function convertGenerateResult<TOOLS extends ToolSet>({
   result,
   tools,
+  abortSignal,
 }: {
   result: LanguageModelV4GenerateResult;
   tools: TOOLS | undefined;
+  abortSignal: AbortSignal | undefined;
 }): Promise<TextBatchGenerationResult<TOOLS>> {
   const toolCalls = await Promise.all(
     result.content
@@ -620,13 +634,14 @@ async function convertGenerateResult<TOOLS extends ToolSet>({
         }),
       ),
   );
-  const content = convertLanguageModelContent<TOOLS>({
+  const content = await convertLanguageModelContent<TOOLS>({
     content: result.content,
     toolCalls,
     toolOutputs: [],
     toolApprovalRequests: [],
     toolApprovalResponses: [],
     tools,
+    abortSignal,
   });
 
   return {