ai 7.0.69 → 7.0.71

package/dist/internal/index.js

@@ -92,7 +92,7 @@ import {
 } from "@ai-sdk/provider-utils";
 
 // src/version.ts
-var VERSION = true ? "7.0.69" : "0.0.0-test";
+var VERSION = true ? "7.0.71" : "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.
@@ -202,7 +207,6 @@ export default function Chat() {
       new WorkflowChatTransport({
         api: '/api/chat',
         maxConsecutiveErrors: 5,
-        initialStartIndex: -50, // On page refresh, fetch last 50 chunks
       }),
     [],
   );
@@ -236,6 +240,7 @@ export async function POST(request: Request) {
 
 ```ts filename="app/api/chat/[runId]/stream/route.ts"
 import { createModelCallToUIChunkTransform } from '@ai-sdk/workflow';
+import { createUIMessageStreamResponse } from 'ai';
 import type { NextRequest } from 'next/server';
 import { getRun } from 'workflow/api';
 
@@ -247,23 +252,36 @@ export async function GET(
   const startIndex = Number(
     new URL(request.url).searchParams.get('startIndex') ?? '0',
   );
+  if (!Number.isSafeInteger(startIndex) || startIndex < 0) {
+    return Response.json(
+      { error: 'startIndex must be a non-negative safe integer' },
+      { status: 400 },
+    );
+  }
 
   const run = await getRun(runId);
   const readable = run
-    .getReadable({ startIndex })
-    .pipeThrough(createModelCallToUIChunkTransform());
+    .getReadable({ startIndex: 0 })
+    .pipeThrough(
+      createModelCallToUIChunkTransform({ uiStartIndex: startIndex }),
+    );
 
-  return new Response(readable, {
+  return createUIMessageStreamResponse({
+    stream: readable,
     headers: {
-      'Content-Type': 'text/event-stream',
-      'Cache-Control': 'no-cache',
-      Connection: 'keep-alive',
       'x-workflow-run-id': runId,
     },
   });
 }
 ```
 
+`WorkflowChatTransport` counts `UIMessageChunk` objects, while the durable
+`WorkflowAgent` stream stores raw `ModelCallStreamPart` objects. Replay the raw
+stream from index `0` and apply the non-negative UI cursor in
+`createModelCallToUIChunkTransform()` as shown above. Negative start indexes
+require a durable stream that already stores `UIMessageChunk` objects and
+cannot be used with this raw-to-UI conversion.
+
 For the full API reference, see [`WorkflowChatTransport`](/docs/reference/ai-sdk-workflow/workflow-chat-transport).
 
 ## Tools as Workflow Steps
@@ -589,7 +607,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

@@ -484,6 +484,64 @@ try {
 }
 ```
 
+### Basic Sandbox Sessions Without Network Control
+
+The following example demonstrates how the basic-session API works. If your
+project can expose a full network sandbox session, passing that session is
+strongly recommended. Pass a restricted basic session only when your project
+cannot expose the full network session.
+
+A basic sandbox session only exposes filesystem and process APIs. The agent
+still leaves the sandbox lifecycle to the caller. For a bridge-backed harness,
+configure the bridge port and its externally reachable endpoint on the adapter
+because the basic session cannot resolve them.
+
+```ts
+import { HarnessAgent, prepareSandboxForHarness } from '@ai-sdk/harness/agent';
+import { createClaudeCode } 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();
+const portEndpoint = await sandboxSession.getPortEndpoint({
+  port: 4000,
+  protocol: 'ws',
+});
+const restrictedSandboxSession = sandboxSession.restricted();
+const claudeCode = createClaudeCode({ port: 4000, portEndpoint });
+
+await prepareSandboxForHarness({
+  session: restrictedSandboxSession,
+  harnesses: [claudeCode],
+});
+
+const agent = new HarnessAgent({ harness: claudeCode });
+const session = await agent.createSession({
+  sandboxSession: restrictedSandboxSession,
+});
+
+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/21-transport.mdx

@@ -171,7 +171,6 @@ export default function Chat() {
       new WorkflowChatTransport({
         api: '/api/chat',
         maxConsecutiveErrors: 5,
-        initialStartIndex: -50, // On page refresh, fetch last 50 chunks
         onChatEnd: ({ chatId, chunkIndex }) => {
           console.log(`Chat complete: ${chunkIndex} chunks`);
         },
@@ -188,10 +187,15 @@ export default function Chat() {
 Key features:
 
 - **Automatic reconnection**: Detects interrupted streams (no `finish` event) and reconnects via GET to `{api}/{runId}/stream`
-- **Page refresh recovery**: `initialStartIndex` with negative values (e.g., `-50`) fetches only the tail of the stream instead of replaying everything
+- **Page refresh recovery**: `initialStartIndex` controls where the initial reconnection begins
 - **Configurable retries**: `maxConsecutiveErrors` controls how many consecutive reconnection failures to tolerate
 - **Lifecycle callbacks**: `onChatSendMessage` and `onChatEnd` for tracking chat state
 
+Negative `initialStartIndex` values can fetch only the tail when the durable
+server stream already stores `UIMessageChunk` objects. For raw `WorkflowAgent`
+streams, use a non-negative cursor and follow the server-side conversion in the
+WorkflowAgent guide.
+
 For the full API reference, see [`WorkflowChatTransport`](/docs/reference/ai-sdk-workflow/workflow-chat-transport). For server-side endpoint setup, see the [WorkflowAgent guide](/docs/agents/workflow-agent#resumable-streaming-with-workflowchattransport).
 
 ## Building Custom Transports

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/docs/07-reference/04-ai-sdk-workflow/01-workflow-agent.mdx

@@ -696,7 +696,7 @@ Returns a `Promise<WorkflowAgentStreamResult>` with the following properties:
 
 ## Utilities
 
-### `createModelCallToUIChunkTransform()`
+### `createModelCallToUIChunkTransform(options?)`
 
 Creates a `TransformStream` that converts raw `ModelCallStreamPart` chunks (written by the agent to the `writable` stream) into `UIMessageChunk` objects suitable for client consumption.
 
@@ -708,6 +708,20 @@ return createUIMessageStreamResponse({
 });
 ```
 
+When resuming with a `WorkflowChatTransport` cursor, replay the raw workflow
+stream from index `0` and pass the non-negative UI chunk index to the transform:
+
+```ts
+const readable = run
+  .getReadable({ startIndex: 0 })
+  .pipeThrough(createModelCallToUIChunkTransform({ uiStartIndex: startIndex }));
+```
+
+`uiStartIndex` must be a non-negative safe integer. Raw model stream parts and
+UI message chunks are not one-to-one, so do not pass a UI chunk index to
+`getReadable`. Negative tail indexes require a durable stream that already
+stores `UIMessageChunk` objects.
+
 ### `toUIMessageChunk()`
 
 Converts a single `ModelCallStreamPart` to a `UIMessageChunk`. Returns `undefined` for parts that don't map to UI chunks.

package/docs/07-reference/04-ai-sdk-workflow/02-workflow-chat-transport.mdx

@@ -20,7 +20,6 @@ export default function Chat() {
     transport: new WorkflowChatTransport({
       api: '/api/chat',
       maxConsecutiveErrors: 5,
-      initialStartIndex: -50,
     }),
   });
 
@@ -67,7 +66,7 @@ export default function Chat() {
       type: 'number',
       isOptional: true,
       description:
-        'Default chunk index to start from when reconnecting. Negative values read from the end of the stream (e.g., -50 fetches the last 50 chunks), useful for resuming after a page refresh without replaying the full conversation. Can be overridden per-call via reconnectToStream options. Default: 0.',
+        'Default chunk index to start from when reconnecting. Negative values read from the end of a durable UIMessageChunk stream (e.g., -50 fetches the last 50 chunks), useful for resuming after a page refresh without replaying the full conversation. Raw ModelCallStreamPart streams do not support negative UI chunk indexes. Can be overridden per-call via reconnectToStream options. Default: 0.',
     },
     {
       name: 'onChatSendMessage',
@@ -183,7 +182,7 @@ const stream = await transport.reconnectToStream({
       type: 'number',
       isOptional: true,
       description:
-        "Override the start index for this reconnection. Negative values read from the end of the stream. When omitted, falls back to the constructor's initialStartIndex.",
+        "Override the start index for this reconnection. Negative values read from the end when the server's durable stream and tail-index header use the same UIMessageChunk index space. When omitted, falls back to the constructor's initialStartIndex.",
     },
   ]}
 />
@@ -209,6 +208,10 @@ When `initialStartIndex` is negative (e.g., `-50`), the transport sends it as-is
 
 If the header is missing or invalid, the transport falls back to replaying from the beginning (`startIndex=0`).
 
+Negative indexes require a durable server stream whose stored objects are
+already `UIMessageChunk` objects. The raw `WorkflowAgent` conversion shown
+below supports non-negative indexes only.
+
 ## Server Requirements
 
 For `WorkflowChatTransport` to work, your server must provide two endpoints:
@@ -262,7 +265,7 @@ export default function Chat() {
 }
 ```
 
-### With Callbacks and Page Refresh Recovery
+### With Callbacks
 
 ```tsx
 'use client';
@@ -277,7 +280,6 @@ export default function Chat() {
       new WorkflowChatTransport({
         api: '/api/chat',
         maxConsecutiveErrors: 5,
-        initialStartIndex: -50, // Resume from last 50 chunks on page refresh
         onChatSendMessage: response => {
           const runId = response.headers.get('x-workflow-run-id');
           console.log('Workflow run started:', runId);
@@ -318,6 +320,7 @@ export async function POST(request: Request) {
 
 ```ts filename="app/api/chat/[runId]/stream/route.ts"
 import { createModelCallToUIChunkTransform } from '@ai-sdk/workflow';
+import { createUIMessageStreamResponse } from 'ai';
 import type { NextRequest } from 'next/server';
 import { getRun } from 'workflow/api';
 
@@ -329,19 +332,30 @@ export async function GET(
   const startIndex = Number(
     new URL(request.url).searchParams.get('startIndex') ?? '0',
   );
+  if (!Number.isSafeInteger(startIndex) || startIndex < 0) {
+    return Response.json(
+      { error: 'startIndex must be a non-negative safe integer' },
+      { status: 400 },
+    );
+  }
 
   const run = await getRun(runId);
   const readable = run
-    .getReadable({ startIndex })
-    .pipeThrough(createModelCallToUIChunkTransform());
+    .getReadable({ startIndex: 0 })
+    .pipeThrough(
+      createModelCallToUIChunkTransform({ uiStartIndex: startIndex }),
+    );
 
-  return new Response(readable, {
+  return createUIMessageStreamResponse({
+    stream: readable,
     headers: {
-      'Content-Type': 'text/event-stream',
-      'Cache-Control': 'no-cache',
-      Connection: 'keep-alive',
       'x-workflow-run-id': runId,
     },
   });
 }
 ```
+
+This `WorkflowAgent` endpoint replays raw `ModelCallStreamPart` objects from
+index `0`, then applies the transport's non-negative cursor after converting
+them to `UIMessageChunk` objects. Negative start indexes require a durable
+stream whose stored objects are already `UIMessageChunk` objects.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai",
-  "version": "7.0.69",
+  "version": "7.0.71",
   "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.55",
+    "@ai-sdk/gateway": "4.0.57",
     "@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.
  *
@@ -540,7 +546,10 @@ class DefaultStreamObjectResult<
         controller.enqueue(chunk);
 
         if (chunk.type === 'error') {
-          onError({ error: wrapGatewayError(chunk.error) });
+          void notify({
+            event: { error: wrapGatewayError(chunk.error) },
+            callbacks: onError,
+          });
         }
       },
     });
@@ -656,6 +665,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 +761,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 +800,10 @@ class DefaultStreamObjectResult<
                     model: model.modelId,
                   });
 
+                  if (terminalError !== undefined) {
+                    break;
+                  }
+
                   self._usage.resolve(usage);
                   self._providerMetadata.resolve(providerMetadata);
                   self._warnings.resolve(warnings);
@@ -867,9 +897,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 +928,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

@@ -1193,7 +1193,10 @@ class DefaultStreamTextResult<
 
         const { part } = chunk;
 
-        await onChunk?.({ chunk: part });
+        await notify({
+          event: { chunk: part },
+          callbacks: onChunk,
+        });
 
         if (part.type === 'error') {
           const error = wrapGatewayError(part.error);
@@ -1202,7 +1205,10 @@ class DefaultStreamTextResult<
             recordedNoOutputError = error;
           }
 
-          await onError({ error });
+          await notify({
+            event: { error },
+            callbacks: onError,
+          });
         }
 
         if (
@@ -2422,13 +2428,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;