ai 7.0.68 → 7.0.70

package/dist/internal/index.js

@@ -92,7 +92,7 @@ import {
 } from "@ai-sdk/provider-utils";
 
 // src/version.ts
-var VERSION = true ? "7.0.68" : "0.0.0-test";
+var VERSION = true ? "7.0.70" : "0.0.0-test";
 
 // src/util/download/download.ts
 var download = async ({

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

@@ -36,10 +36,10 @@ For simpler use cases that don't need durability, use [`ToolLoopAgent`](/docs/ag
 ## Installation
 
 ```bash
-npm install @ai-sdk/workflow workflow
+npm install @ai-sdk/workflow workflow@beta
 ```
 
-`@ai-sdk/workflow` requires the `ai` package and `zod` as peer dependencies. The `workflow` package provides the Workflow DevKit runtime (`getWritable`, `'use workflow'`, `'use step'`).
+`@ai-sdk/workflow` requires Workflow 5, which is currently available under the `beta` tag, as well as the `ai` package and `zod` peer dependencies. The `workflow` package provides the Workflow DevKit runtime (`getWritable`, `'use workflow'`, `'use step'`).
 
 ## Creating a WorkflowAgent
 
@@ -185,6 +185,11 @@ return createUIMessageStreamResponse({
 });
 ```
 
+The transform also forwards `reset-step` events emitted by `WorkflowAgent` on
+retries.
+Clients remove partial parts from the failed model-call step before processing
+the retried output.
+
 ## Resumable Streaming with WorkflowChatTransport
 
 Workflow functions can time out or be interrupted by network failures. `WorkflowChatTransport` is a [`ChatTransport`](/docs/ai-sdk-ui/transport) implementation that handles these interruptions automatically — it detects when a stream ends without a `finish` event and reconnects to resume from where it left off.
@@ -589,7 +594,7 @@ export type MyAgentUIMessage = InferWorkflowAgentUIMessage<typeof myAgent>;
 Install the new package alongside `workflow`:
 
 ```bash
-npm install @ai-sdk/workflow
+npm install @ai-sdk/workflow workflow@beta
 ```
 
 ### Write `ModelCallStreamPart`, not `UIMessageChunk`

package/docs/03-ai-sdk-harnesses/02-harness-agent.mdx

@@ -180,6 +180,11 @@ End every session explicitly:
 Use `destroy()` for one-off scripts and tests. Use `detach()` or `stop()` for
 HTTP routes that need multi-turn continuity.
 
+When you pass `sandboxSession` to `agent.createSession()`, the caller retains
+ownership of that sandbox. `session.stop()` and `session.destroy()` still end
+the harness runtime but do not stop or destroy the supplied sandbox session.
+In this case, the agent does not need a `sandbox` provider in its constructor.
+
 ```ts
 const session = await agent.createSession({ sessionId: chatId });
 
@@ -401,10 +406,7 @@ const sandboxFromSnapshot = await Sandbox.create({
 
 const agent = new HarnessAgent({
   harness: claudeCode,
-  sandbox: createVercelSandbox({
-    sandbox: sandboxFromSnapshot,
-    bridgePorts: [4000],
-  }),
+  sandbox: createVercelSandbox({ sandbox: sandboxFromSnapshot }),
   sandboxConfig,
 });
 
@@ -437,6 +439,51 @@ console.log(preparation.identity);
 Adapter-specific settings belong on the adapter factory, for example
 `createCodex({ reasoningEffort: 'high' })`.
 
+## Custom Sandbox Orchestration
+
+When your application creates and manages sandboxes itself, prepare the network
+sandbox session first and then pass that same session to `agent.createSession()`.
+The agent does not need a sandbox provider and does not stop or destroy the
+caller-owned sandbox.
+
+```ts
+import { HarnessAgent, prepareSandboxForHarness } from '@ai-sdk/harness/agent';
+import { claudeCode } from '@ai-sdk/harness-claude-code';
+import { createVercelSandbox } from '@ai-sdk/sandbox-vercel';
+import { Sandbox } from '@vercel/sandbox';
+
+const sandbox = await Sandbox.create({
+  runtime: 'node24',
+  ports: [4000],
+});
+const sandboxProvider = createVercelSandbox({ sandbox });
+const sandboxSession = await sandboxProvider.createSession();
+
+await prepareSandboxForHarness({
+  session: sandboxSession.restricted(),
+  harnesses: [claudeCode],
+});
+
+const agent = new HarnessAgent({ harness: claudeCode });
+const session = await agent.createSession({ sandboxSession });
+
+try {
+  const result = await agent.stream({
+    session,
+    prompt: 'Create a short TODO.md for this repository.',
+  });
+
+  for await (const part of result.stream) {
+    if (part.type === 'text-delta') {
+      process.stdout.write(part.text);
+    }
+  }
+} finally {
+  await session.destroy();
+  await sandbox.stop();
+}
+```
+
 ## Next Steps
 
 - [Tools](/docs/ai-sdk-harnesses/tools) for built-in and host-executed tools.

package/docs/04-ai-sdk-ui/50-stream-protocol.mdx

@@ -442,6 +442,22 @@ data: {"type":"finish-step"}
 
 ```
 
+### Reset Step Part
+
+Removes all message parts received since the most recent `start-step` part. If
+there is no step boundary, it removes all parts from the current message. This
+is useful when a streamed step is retried and partial output from the failed
+attempt must be invalidated before replacement output is sent.
+
+Format: Server-Sent Event with JSON object
+
+Example:
+
+```
+data: {"type":"reset-step"}
+
+```
+
 ### Finish Message Part
 
 A part indicating the completion of a message.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai",
-  "version": "7.0.68",
+  "version": "7.0.70",
   "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,9 +42,9 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/gateway": "4.0.54",
+    "@ai-sdk/gateway": "4.0.56",
     "@ai-sdk/provider": "4.0.7",
-    "@ai-sdk/provider-utils": "5.0.27"
+    "@ai-sdk/provider-utils": "5.0.28"
   },
   "devDependencies": {
     "@edge-runtime/vm": "^5.0.0",

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

@@ -68,6 +68,12 @@ import { validateObjectGenerationInput } from './validate-object-generation-inpu
 
 const originalGenerateId = createIdGenerator({ prefix: 'aiobj', size: 24 });
 
+async function markPromiseAsHandled<T>(promise: Promise<T>): Promise<void> {
+  try {
+    await promise;
+  } catch {}
+}
+
 /**
  * Callback that is set using the `onError` option.
  *
@@ -656,6 +662,7 @@ class DefaultStreamObjectResult<
       let providerMetadata: ProviderMetadata | undefined;
       let object: RESULT | undefined;
       let error: unknown | undefined;
+      let terminalError: { error: unknown } | undefined;
       let msToFirstChunk: number | undefined = undefined;
 
       let accumulatedText = '';
@@ -751,19 +758,35 @@ class DefaultStreamObjectResult<
                   break;
                 }
 
+                case 'error': {
+                  if (terminalError === undefined) {
+                    const wrappedError = wrapGatewayError(chunk.error);
+                    terminalError = { error: wrappedError };
+                    error = wrappedError;
+                    finishReason = 'error';
+                    self.rejectResultPromises(wrappedError);
+                  }
+
+                  controller.enqueue(chunk);
+                  break;
+                }
+
                 case 'finish': {
                   if (textDelta !== '') {
                     controller.enqueue({ type: 'text-delta', textDelta });
                   }
 
-                  finishReason = chunk.finishReason.unified;
+                  finishReason =
+                    terminalError === undefined
+                      ? chunk.finishReason.unified
+                      : 'error';
 
                   usage = asLanguageModelUsage(chunk.usage);
                   providerMetadata = chunk.providerMetadata;
 
                   controller.enqueue({
                     ...chunk,
-                    finishReason: chunk.finishReason.unified,
+                    finishReason,
                     usage,
                     response: fullResponse,
                   });
@@ -774,6 +797,10 @@ class DefaultStreamObjectResult<
                     model: model.modelId,
                   });
 
+                  if (terminalError !== undefined) {
+                    break;
+                  }
+
                   self._usage.resolve(usage);
                   self._providerMetadata.resolve(providerMetadata);
                   self._warnings.resolve(warnings);
@@ -867,9 +894,19 @@ class DefaultStreamObjectResult<
           }),
         );
 
-      stitchableStream.addStream(transformedStream);
+      stitchableStream.addStream(transformedStream, {
+        onError(error) {
+          const wrappedError = wrapGatewayError(error);
+          self.rejectResultPromises(wrappedError);
+          void notify({
+            event: { error: wrappedError },
+            callbacks: onError,
+          });
+        },
+      });
     })()
       .catch(async error => {
+        self.rejectResultPromises(error);
         await telemetryDispatcher.onError?.({ callId, error });
 
         stitchableStream.addStream(
@@ -888,6 +925,29 @@ class DefaultStreamObjectResult<
     this.outputStrategy = outputStrategy;
   }
 
+  private rejectResultPromises(error: unknown) {
+    this.rejectResultPromise({ delayedPromise: this._object, error });
+    this.rejectResultPromise({ delayedPromise: this._usage, error });
+    this.rejectResultPromise({ delayedPromise: this._providerMetadata, error });
+    this.rejectResultPromise({ delayedPromise: this._warnings, error });
+    this.rejectResultPromise({ delayedPromise: this._request, error });
+    this.rejectResultPromise({ delayedPromise: this._response, error });
+    this.rejectResultPromise({ delayedPromise: this._finishReason, error });
+  }
+
+  private rejectResultPromise<T>({
+    delayedPromise,
+    error,
+  }: {
+    delayedPromise: DelayedPromise<T>;
+    error: unknown;
+  }) {
+    if (delayedPromise.isPending()) {
+      delayedPromise.reject(error);
+      markPromiseAsHandled(delayedPromise.promise);
+    }
+  }
+
   get object() {
     return this._object.promise;
   }

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

@@ -11,6 +11,7 @@ import type { TimeoutConfiguration } from '../prompt/request-options';
 import type { Telemetry, TelemetryDispatcher } from '../telemetry/telemetry';
 import { getOwn } from '../util/get-own';
 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 { maybeSignApproval } from './tool-approval-signature';
@@ -197,6 +198,10 @@ export function executeToolsFromStream<
           }
 
           case 'model-call-end': {
+            if (!isToolExecutionAllowedFinishReason(chunk.finishReason)) {
+              return;
+            }
+
             await Promise.all(
               toolCallsToExecute.map(async toolCall => {
                 try {

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

@@ -79,6 +79,7 @@ import type {
 } from './generate-text-events';
 import type { GenerateTextResult } from './generate-text-result';
 import { DefaultGeneratedFile } from './generated-file';
+import { isToolExecutionAllowedFinishReason } from './is-tool-execution-allowed-finish-reason';
 import type {
   OnLanguageModelCallEndCallback,
   OnLanguageModelCallStartCallback,
@@ -1259,7 +1260,12 @@ export async function generateText<
               );
               const toolExecutionMs: Record<string, number> = {};
 
-              if (stepExecutionTools != null) {
+              if (
+                stepExecutionTools != null &&
+                isToolExecutionAllowedFinishReason(
+                  currentModelResponse.finishReason.unified,
+                )
+              ) {
                 const toolExecutionResults = await executeTools({
                   toolCalls: clientToolCalls.filter(
                     toolCall =>
@@ -1432,13 +1438,11 @@ export async function generateText<
           }
         }
       } while (
-        // Continue if:
-        // 1. There are client tool calls that have all been executed or denied, OR
-        // 2. There are pending deferred results from provider-executed tools
-        ((clientToolCalls.length > 0 &&
-          clientToolOutputs.length + deniedToolApprovalResponses.length ===
-            clientToolCalls.length) ||
-          pendingDeferredToolCalls.size > 0) &&
+        // Continue only after all client tool calls have been executed or denied,
+        // and if there are client results or pending deferred provider results.
+        clientToolOutputs.length + deniedToolApprovalResponses.length ===
+          clientToolCalls.length &&
+        (clientToolCalls.length > 0 || pendingDeferredToolCalls.size > 0) &&
         // continue until a stop condition is met:
         !(await isStopConditionMet({ stopConditions, steps }))
       );

package/src/generate-text/is-tool-execution-allowed-finish-reason.ts

@@ -0,0 +1,7 @@
+import type { FinishReason } from '../types/language-model';
+
+export function isToolExecutionAllowedFinishReason(
+  finishReason: FinishReason,
+): boolean {
+  return finishReason === 'stop' || finishReason === 'tool-calls';
+}

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

@@ -2422,13 +2422,12 @@ class DefaultStreamTextResult<
                   cleanupStepTimeouts();
 
                   if (
-                    // Continue if:
-                    // 1. There are client tool calls that have all been executed or denied, OR
-                    // 2. There are pending deferred results from provider-executed tools, OR
-                    ((clientToolCalls.length > 0 &&
-                      clientToolCalls.length ===
-                        clientToolOutputs.length +
-                          deniedToolApprovalResponses.length) ||
+                    // Continue only after all client tool calls have been executed or denied,
+                    // and if there are client results or pending deferred provider results.
+                    clientToolCalls.length ===
+                      clientToolOutputs.length +
+                        deniedToolApprovalResponses.length &&
+                    (clientToolCalls.length > 0 ||
                       pendingDeferredToolCalls.size > 0) &&
                     // continue until a stop condition is met:
                     !(await isStopConditionMet({

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

@@ -63,7 +63,7 @@ export async function convertToModelMessages<UI_MESSAGE extends UIMessage>(
         part =>
           !isToolUIPart(part) ||
           part.state === 'approval-responded' ||
-          part.state === 'output-available' ||
+          (part.state === 'output-available' && part.preliminary !== true) ||
           part.state === 'output-error' ||
           part.state === 'output-denied',
       ),

package/src/ui/process-ui-message-stream.ts

@@ -887,6 +887,23 @@ export function processUIMessageStream<UI_MESSAGE extends UIMessage>({
               break;
             }
 
+            case 'reset-step': {
+              const currentStepParts = getCurrentStepParts();
+
+              state.activeTextParts = createIdMap();
+              state.activeReasoningParts = createIdMap();
+              state.partialToolCalls = createIdMap();
+
+              if (currentStepParts.length > 0) {
+                state.message.parts.splice(
+                  state.message.parts.length - currentStepParts.length,
+                  currentStepParts.length,
+                );
+                write();
+              }
+              break;
+            }
+
             case 'start': {
               if (chunk.messageId != null) {
                 state.message.id = chunk.messageId;

package/src/ui-message-stream/ui-message-chunks.ts

@@ -183,6 +183,9 @@ export const uiMessageChunkSchema = lazySchema(() =>
       z.looseObject({
         type: z.literal('finish-step'),
       }),
+      z.looseObject({
+        type: z.literal('reset-step'),
+      }),
       z.looseObject({
         type: z.literal('start'),
         messageId: z.string().optional(),
@@ -378,6 +381,12 @@ export type UIMessageChunk<
   | {
       type: 'finish-step';
     }
+  | {
+      /**
+       * Removes all message parts added during the current step.
+       */
+      type: 'reset-step';
+    }
   | {
       type: 'start';
       messageId?: string;