ai 7.0.89 → 7.0.91

package/docs/02-foundations/02-providers-and-models.mdx

@@ -145,6 +145,7 @@ Here are the capabilities of popular models:
 | [OpenAI](/providers/ai-sdk-providers/openai)       | `gpt-5-codex`                               | <Check />   | <Check />         | <Check />  | <Check />      |
 | [OpenAI](/providers/ai-sdk-providers/openai)       | `gpt-5-chat-latest`                         | <Check />   | <Check />         | <Check />  | <Check />      |
 | [Anthropic](/providers/ai-sdk-providers/anthropic) | `claude-sonnet-5`                           | <Check />   | <Check />         | <Check />  | <Check />      |
+| [Anthropic](/providers/ai-sdk-providers/anthropic) | `claude-fable-5-1`                          | <Check />   | <Check />         | <Check />  | <Check />      |
 | [Anthropic](/providers/ai-sdk-providers/anthropic) | `claude-fable-5`                            | <Check />   | <Check />         | <Check />  | <Check />      |
 | [Anthropic](/providers/ai-sdk-providers/anthropic) | `claude-opus-4-8`                           | <Check />   | <Check />         | <Check />  | <Check />      |
 | [Anthropic](/providers/ai-sdk-providers/anthropic) | `claude-opus-4-7`                           | <Check />   | <Check />         | <Check />  | <Check />      |
@@ -154,6 +155,11 @@ Here are the capabilities of popular models:
 | [Anthropic](/providers/ai-sdk-providers/anthropic) | `claude-opus-4-1`                           | <Check />   | <Check />         | <Check />  | <Check />      |
 | [Anthropic](/providers/ai-sdk-providers/anthropic) | `claude-opus-4-0`                           | <Check />   | <Check />         | <Check />  | <Check />      |
 | [Anthropic](/providers/ai-sdk-providers/anthropic) | `claude-sonnet-4-0`                         | <Check />   | <Check />         | <Check />  | <Check />      |
+| [Google](/providers/ai-sdk-providers/google)       | `gemini-3.8-flash`                          | <Check />   | <Check />         | <Check />  | <Check />      |
+| [Google](/providers/ai-sdk-providers/google)       | `gemini-3.1-pro-preview`                    | <Check />   | <Check />         | <Check />  | <Check />      |
+| [Google](/providers/ai-sdk-providers/google)       | `gemini-3-pro-preview`                      | <Check />   | <Check />         | <Check />  | <Check />      |
+| [Google](/providers/ai-sdk-providers/google)       | `gemini-2.5-pro`                            | <Check />   | <Check />         | <Check />  | <Check />      |
+| [Google](/providers/ai-sdk-providers/google)       | `gemini-2.5-flash`                          | <Check />   | <Check />         | <Check />  | <Check />      |
 | [Mistral](/providers/ai-sdk-providers/mistral)     | `pixtral-large-latest`                      | <Check />   | <Check />         | <Check />  | <Check />      |
 | [Mistral](/providers/ai-sdk-providers/mistral)     | `mistral-large-latest`                      | <Cross />   | <Check />         | <Check />  | <Check />      |
 | [Mistral](/providers/ai-sdk-providers/mistral)     | `mistral-medium-latest`                     | <Cross />   | <Check />         | <Check />  | <Check />      |

package/docs/03-agents/06-policy-tool-approvals.mdx

@@ -156,9 +156,10 @@ Run with `opa test policy.rego policy_test.rego`.
 ### Errors fail closed
 
 - If the backend errors (server unreachable, WASM fault, misbuilt bundle), `opaPolicy` returns `denied` with the error message as the reason.
+- If the backend returns a present but unrecognized decision, such as an unknown `decision` value or a non-boolean legacy `allow` value, `opaPolicy` returns `denied`.
 - The error never rejects out of the callback and never aborts the run.
 - A backend outage blocks the affected call rather than silently allowing it.
-- This is distinct from a rule that returns no match, which normalizes to `not-applicable` (allow). Use a `default ... deny` rule if you want unmatched calls denied too.
+- This is distinct from a rule that returns no match: `null` or `undefined` normalizes to `not-applicable` (allow). Use a `default ... deny` rule if you want unmatched calls denied too.
 
 ## Loading the policy
 

package/docs/03-agents/06-tool-approvals.mdx

@@ -284,14 +284,17 @@ If your tools perform sensitive operations (modifying data, spending money, call
 
 ### Signing approvals with `experimental_toolApprovalSecret`
 
-When you provide a secret, the server HMAC-signs each approval request at issuance and verifies the signature when the approval is replayed. A forged or tampered approval is rejected before the tool executes.
+When you provide a secret, the server HMAC-signs each approval request at issuance and verifies the signature when the approval is replayed. A forged or tampered approval is rejected before the tool executes. Configure the secret on `ToolLoopAgent` (or pass it directly to `generateText` or `streamText`).
 
-```ts highlight="5"
-const result = await streamText({
+```ts highlight="6"
+const agent = new ToolLoopAgent({
   model: __MODEL__,
   tools: { deleteFile, runQuery },
   toolApproval: { deleteFile: 'user-approval', runQuery: 'user-approval' },
   experimental_toolApprovalSecret: process.env.TOOL_APPROVAL_SECRET,
+});
+
+const result = await agent.generate({
   messages,
 });
 ```
@@ -308,7 +311,7 @@ The signature binds the approval to the exact tool name, tool call ID, and input
    ```
    TOOL_APPROVAL_SECRET=your-generated-secret-here
    ```
-3. Pass it to `generateText` or `streamText` via `experimental_toolApprovalSecret`.
+3. Pass it to `ToolLoopAgent`, `generateText`, or `streamText` via `experimental_toolApprovalSecret`.
 
 Every serverless instance that might handle a request needs the same secret, since one instance signs the approval and a different instance may verify it on the next turn.
 

package/docs/03-agents/07-workflow-agent.mdx

@@ -613,6 +613,21 @@ const agent = new WorkflowAgent({
 });
 ```
 
+Tool input callbacks (`onInputStart`, `onInputDelta`, and
+`onInputAvailable`) are also preserved by `WorkflowAgent`. The model call runs
+inside a durable step, while callback functions remain in the workflow
+context because arbitrary functions cannot cross the step boundary. As a
+result, `WorkflowAgent` records the callback events during the model step and
+replays them in order immediately after that step completes, before tool
+execution and step lifecycle callbacks. They do not run concurrently with
+model generation and cannot provide in-flight cancellation or backpressure.
+Each callback receives its tool's `toolsContext` entry after
+`contextSchema` validation.
+
+For highly fragmented tool inputs, `onInputDelta` replay data is part of the
+durable model-step result. Only configure `onInputDelta` when each generated
+delta is needed; omit it to avoid retaining delta replay data.
+
 The deprecated `experimental_onStart` and `experimental_onStepStart` names
 remain available for backwards compatibility. When both the stable and
 experimental name are provided in the same constructor or `stream()` call, the

package/docs/03-ai-sdk-core/50-error-handling.mdx

@@ -101,12 +101,89 @@ try {
 }
 ```
 
-Well-formed provider error events that arrive after streaming starts are
-normalized into [`StreamProviderError`](/docs/reference/ai-sdk-errors/ai-stream-provider-error)
-instances. The same instance is supplied to callbacks such as `onError` and to
-the `error` part in the full stream. The SDK does not automatically restart a
-partially consumed stream; use `isRetryable` to implement application-managed
-retries and decide how to handle any partial output.
+## Retrying provider errors after streaming starts
+
+`maxRetries` retries failures that happen while starting a model call. To retry
+well-formed provider error events received after response streaming has begun,
+set `streamRetries`:
+
+```ts highlight="7"
+import { streamText } from 'ai';
+__PROVIDER_IMPORT__;
+
+const { textStream } = streamText({
+  model: __MODEL__,
+  prompt: 'Write a vegetarian lasagna recipe for 4 people.',
+  streamRetries: 2,
+});
+
+for await (const textPart of textStream) {
+  process.stdout.write(textPart);
+}
+```
+
+Stream retries rerun only the failed model step with the same accumulated
+conversation and generation context. Earlier completed steps, including their
+tool calls and tool results, are not replayed. Tool input, tool calls, approval
+requests, tool callbacks, and client-side tool execution from a failed attempt
+are discarded. They are only exposed or executed after an attempt reaches a
+successful model-call finish.
+
+Well-formed provider error events are normalized into
+[`StreamProviderError`](/docs/reference/ai-sdk-errors/ai-stream-provider-error)
+instances. The same instance is supplied to `onError` and, if recovery is not
+requested or retries are exhausted, to the `error` part in the full stream. Use
+its `isRetryable` metadata when deciding whether to request recovery.
+
+A retry remains part of the same logical step. `onStepStart` runs once for that
+step. `onLanguageModelCallStart` runs for each provider call attempt, while
+`onLanguageModelCallEnd` runs only for attempts that reach a model-call finish.
+
+You can also decide dynamically in `onError`. Set `streamRetries` explicitly to
+enable stream recovery; use `0` when a single retry should only be
+callback-directed:
+
+```ts highlight="7-12"
+const result = streamText({
+  model: __MODEL__,
+  prompt: 'Write a vegetarian lasagna recipe for 4 people.',
+  streamRetries: 0,
+  onError: ({ error }) => {
+    if (isTransientProviderError(error)) {
+      return { retry: true };
+    }
+  },
+});
+```
+
+Callback-directed recovery is limited to one retry per logical step. When
+automatic retries are configured, `onError` can request one additional retry
+after the automatic retry budget is exhausted. This bounds the total number of
+recovery calls for a step to `streamRetries + 1`.
+
+When `streamRetries` is omitted, all stream retry behavior is disabled and an
+existing logging-only `onError` callback retains incremental tool streaming.
+An `onError` return value other than `{ retry: true }` keeps its previous
+behavior and does not request recovery. Provider error events that are
+recovered are not emitted as final `error` parts.
+
+<Note type="warning">
+  Non-tool output emitted before a provider error cannot be retracted. A retried
+  model step may therefore append repeated or divergent partial text, reasoning,
+  files, or sources to consumer streams. Open text and reasoning parts are ended
+  before recovered output begins so UI consumers do not retain them in a
+  streaming state. Failed-attempt output is excluded from the recovered step
+  result, structured output parsing, response messages, and subsequent model
+  steps. Final request and response metadata come from the recovered attempt.
+  Retries also add latency and may incur additional provider usage and cost.
+</Note>
+
+<Note type="warning">
+  Failed-attempt isolation prevents AI SDK client-side tools from executing, but
+  it cannot undo work already performed by provider-executed tools. Retrying a
+  step after provider-side work may repeat that work or its cost. Use
+  idempotency controls for provider-executed side effects.
+</Note>
 
 ## Handling stream aborts
 

package/docs/06-advanced/11-secure-url-fetching.mdx

@@ -17,6 +17,11 @@ To prevent that, the SDK validates every response-supplied URL before fetching
 it. This happens automatically inside the provider packages — you don't need to
 configure anything.
 
+For authenticated task-status polling, providers can construct the first URL
+from the configured API endpoint. The SDK trusts that configured origin for the
+initial request, but manually follows and validates every redirect away from it.
+MiniMax, Kling AI, and ByteDance video polling use this protected path.
+
 ## What the SDK protects against
 
 When the SDK fetches a URL taken from a provider response, it:
@@ -45,7 +50,8 @@ A blocked URL surfaces as a `DownloadError`.
 URLs that are same-origin with the provider endpoint **you configured** (e.g. a
 custom `baseURL` pointing at a self-hosted or `localhost` deployment) are
 exempt from these checks — they target exactly the host you told the SDK to
-talk to. Any redirect off that origin is still validated.
+talk to. This also applies to task-status polling. Any redirect off that origin
+is still validated before the redirected request is sent.
 
 ## DNS validation across runtimes
 

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

@@ -468,6 +468,13 @@ To see `streamText` in action, check out [these examples](#examples).
       description:
         'Maximum number of retries. Set to 0 to disable retries. Default: 2.',
     },
+    {
+      name: 'streamRetries',
+      type: 'number',
+      isOptional: true,
+      description:
+        'Maximum number of automatic retries for provider error events received after response streaming begins. Retries rerun only the current model step and preserve completed earlier steps and their tool results. Tool-related output and client-side tool work from failed attempts are discarded; other output already emitted cannot be retracted, but is excluded from the recovered step result, structured output parsing, response messages, and subsequent model steps. Final request and response metadata come from the recovered attempt. Open text and reasoning parts are ended before recovered output begins. onStepStart runs once for the logical step, onLanguageModelCallStart runs for each attempt, and onLanguageModelCallEnd runs for attempts that reach a model-call finish. Provider-executed tool work cannot be undone and may repeat. Set to 0 to disable automatic retries while allowing onError to request one callback-directed retry. With automatic retries configured, onError can request at most one additional retry after they are exhausted, bounding total recovery calls to streamRetries + 1. Omit to disable all stream retry behavior and preserve incremental tool streaming for existing onError observers. Default: 0.',
+    },
     {
       name: 'abortSignal',
       type: 'AbortSignal',
@@ -1184,10 +1191,10 @@ To see `streamText` in action, check out [these examples](#examples).
     },
     {
       name: 'onError',
-      type: '(event: OnErrorResult) => Promise<void> |void',
+      type: 'StreamTextOnErrorCallback | StreamTextOnErrorRetryCallback',
       isOptional: true,
       description:
-        'Callback that is called when an error occurs during streaming. Well-formed mid-stream provider error events are exposed as StreamProviderError instances.',
+        'Callback that is called when an error occurs during streaming. StreamTextOnErrorCallback preserves the existing PromiseLike<void> | void observer contract. StreamTextOnErrorRetryCallback additionally types `{ retry: true }` results for retry-capable handlers. Well-formed mid-stream provider error events are exposed as StreamProviderError instances. When streamRetries is explicitly configured, return `{ retry: true }` to request one callback-directed retry for the current model step after automatic retries are exhausted. Other return values do not request a retry.',
       properties: [
         {
           type: 'OnErrorResult',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai",
-  "version": "7.0.89",
+  "version": "7.0.91",
   "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.71",
+    "@ai-sdk/gateway": "4.0.73",
     "@ai-sdk/provider": "4.0.10",
-    "@ai-sdk/provider-utils": "5.0.35"
+    "@ai-sdk/provider-utils": "5.0.36"
   },
   "devDependencies": {
-    "@ai-sdk/amazon-bedrock": "5.0.71",
-    "@ai-sdk/deepseek": "3.0.38",
-    "@ai-sdk/google": "4.0.61",
-    "@ai-sdk/groq": "4.0.36",
-    "@ai-sdk/huggingface": "2.0.42",
-    "@ai-sdk/moonshotai": "3.0.44",
-    "@ai-sdk/openai": "4.0.55",
+    "@ai-sdk/amazon-bedrock": "5.0.73",
+    "@ai-sdk/deepseek": "3.0.39",
+    "@ai-sdk/google": "4.0.63",
+    "@ai-sdk/groq": "4.0.37",
+    "@ai-sdk/huggingface": "2.0.43",
+    "@ai-sdk/moonshotai": "3.0.45",
+    "@ai-sdk/openai": "4.0.57",
     "@ai-sdk/test-server": "2.0.1",
-    "@ai-sdk/xai": "4.0.52",
+    "@ai-sdk/xai": "4.0.54",
     "@edge-runtime/vm": "^5.0.0",
     "@smithy/eventstream-codec": "^4.3.3",
     "@smithy/util-utf8": "^4.3.3",

package/src/generate-text/execute-tools-from-stream.ts

@@ -14,6 +14,10 @@ import { executeToolCall } from './execute-tool-call';
 import { isToolExecutionAllowedFinishReason } from './is-tool-execution-allowed-finish-reason';
 import { resolveToolApproval } from './resolve-tool-approval';
 import type { LanguageModelStreamPart } from './stream-language-model-call';
+import {
+  isStreamRetryAttemptBoundaryPart,
+  type StreamRetryAttemptBoundaryPart,
+} from './stream-retry-attempt-boundary';
 import { maybeSignApproval } from './tool-approval-signature';
 import type { ToolApprovalConfiguration } from './tool-approval-configuration';
 import type { TypedToolCall } from './tool-call';
@@ -30,7 +34,12 @@ export type ToolExecutionEndStreamPart = {
 
 export type ExecuteToolsStreamPart<TOOLS extends ToolSet = ToolSet> =
   | LanguageModelStreamPart<TOOLS>
-  | ToolExecutionEndStreamPart;
+  | ToolExecutionEndStreamPart
+  | StreamRetryAttemptBoundaryPart;
+
+type ExecuteToolsInputStreamPart<TOOLS extends ToolSet> =
+  | LanguageModelStreamPart<TOOLS>
+  | StreamRetryAttemptBoundaryPart;
 
 export function executeToolsFromStream<
   TOOLS extends ToolSet,
@@ -53,7 +62,7 @@ export function executeToolsFromStream<
   executeToolInTelemetryContext,
   runInTracingChannelSpan,
 }: {
-  stream: ReadableStream<LanguageModelStreamPart<TOOLS>>;
+  stream: ReadableStream<ExecuteToolsInputStreamPart<TOOLS>>;
   tools: TOOLS | undefined;
   callId: string;
   messages: ModelMessage[];
@@ -77,11 +86,11 @@ export function executeToolsFromStream<
   // forward stream
   return stream.pipeThrough(
     new TransformStream<
-      LanguageModelStreamPart<TOOLS>,
+      ExecuteToolsInputStreamPart<TOOLS>,
       ExecuteToolsStreamPart<TOOLS>
     >({
       async transform(
-        chunk: LanguageModelStreamPart<TOOLS>,
+        chunk: ExecuteToolsInputStreamPart<TOOLS>,
         controller: TransformStreamDefaultController<
           ExecuteToolsStreamPart<TOOLS>
         >,
@@ -89,6 +98,11 @@ export function executeToolsFromStream<
         // immediately forward all chunks
         controller.enqueue(chunk);
 
+        if (isStreamRetryAttemptBoundaryPart(chunk)) {
+          toolCallsToExecute.length = 0;
+          return;
+        }
+
         const chunkType = chunk.type;
 
         switch (chunkType) {

package/src/generate-text/index.ts

@@ -70,6 +70,8 @@ export {
   type StreamTextOnChunkCallback,
   type StreamTextOnEndCallback,
   type StreamTextOnErrorCallback,
+  type StreamTextOnErrorRetryCallback,
+  type StreamTextOnErrorResult,
   type StreamTextTransform,
 } from './stream-text';
 export type {

package/src/generate-text/invoke-tool-callbacks-from-stream.ts

@@ -2,6 +2,14 @@ import type { Context, ModelMessage, ToolSet } from '@ai-sdk/provider-utils';
 import { createIdMap } from '../util/create-id-map';
 import { getOwn } from '../util/get-own';
 import type { LanguageModelStreamPart } from './stream-language-model-call';
+import {
+  isStreamRetryAttemptBoundaryPart,
+  type StreamRetryAttemptBoundaryPart,
+} from './stream-retry-attempt-boundary';
+
+type ToolCallbackStreamPart<TOOLS extends ToolSet> =
+  | LanguageModelStreamPart<TOOLS>
+  | StreamRetryAttemptBoundaryPart;
 
 export function invokeToolCallbacksFromStream<
   TOOLS extends ToolSet,
@@ -13,12 +21,12 @@ export function invokeToolCallbacksFromStream<
   abortSignal,
   runtimeContext,
 }: {
-  stream: ReadableStream<LanguageModelStreamPart<TOOLS>>;
+  stream: ReadableStream<ToolCallbackStreamPart<TOOLS>>;
   tools: TOOLS | undefined;
   stepInputMessages: Array<ModelMessage>;
   abortSignal: AbortSignal | undefined;
   runtimeContext: RUNTIME_CONTEXT;
-}): ReadableStream<LanguageModelStreamPart<TOOLS>> {
+}): ReadableStream<ToolCallbackStreamPart<TOOLS>> {
   if (tools == null) return stream;
 
   const ongoingToolCallToolNames: Record<string, string> = createIdMap();
@@ -28,6 +36,10 @@ export function invokeToolCallbacksFromStream<
       async transform(chunk, controller) {
         controller.enqueue(chunk);
 
+        if (isStreamRetryAttemptBoundaryPart(chunk)) {
+          return;
+        }
+
         switch (chunk.type) {
           case 'tool-input-start': {
             ongoingToolCallToolNames[chunk.id] = chunk.toolName;

package/src/generate-text/stream-retry-attempt-boundary.ts

@@ -0,0 +1,29 @@
+import type { SharedV4Warning } from '@ai-sdk/provider';
+
+const streamRetryAttemptBoundarySymbol = Symbol('streamRetryAttemptBoundary');
+
+export type StreamRetryAttemptBoundaryPart = {
+  [streamRetryAttemptBoundarySymbol]: true;
+  warnings: Array<SharedV4Warning>;
+};
+
+export function createStreamRetryAttemptBoundaryPart({
+  warnings,
+}: {
+  warnings: Array<SharedV4Warning>;
+}): StreamRetryAttemptBoundaryPart {
+  return {
+    [streamRetryAttemptBoundarySymbol]: true,
+    warnings,
+  };
+}
+
+export function isStreamRetryAttemptBoundaryPart(
+  part: unknown,
+): part is StreamRetryAttemptBoundaryPart {
+  return (
+    typeof part === 'object' &&
+    part != null &&
+    streamRetryAttemptBoundarySymbol in part
+  );
+}