@ai-sdk/workflow 1.0.70 → 2.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/workflow",
-  "version": "1.0.70",
+  "version": "2.0.1",
   "type": "module",
   "description": "WorkflowAgent for building AI agents with AI SDK",
   "license": "Apache-2.0",
@@ -27,21 +27,22 @@
   },
   "dependencies": {
     "ajv": "^8.20.0",
-    "@ai-sdk/provider-utils": "5.0.27",
-    "ai": "7.0.69",
-    "@ai-sdk/provider": "4.0.7"
+    "@ai-sdk/provider": "4.0.7",
+    "@ai-sdk/provider-utils": "5.0.28",
+    "ai": "7.0.71"
   },
   "devDependencies": {
     "@types/node": "22.19.19",
-    "@workflow/vitest": "4.0.5",
+    "@workflow/vitest": "5.0.0-beta.42",
     "tsup": "^8.5.1",
     "typescript": "5.8.3",
     "vitest": "4.1.6",
-    "workflow": "4.2.4",
-    "zod": "3.25.76",
+    "workflow": "5.0.0-beta.42",
+    "zod": "4.4.3",
     "@vercel/ai-tsconfig": "0.0.0"
   },
   "peerDependencies": {
+    "workflow": "^5.0.0-beta.42",
     "zod": "^3.25.76 || ^4.1.8"
   },
   "engines": {

package/src/do-stream-step.ts

@@ -6,7 +6,7 @@ import { isAbortError } from '@ai-sdk/provider-utils';
 import {
   experimental_streamLanguageModelCall as streamModelCall,
   gateway,
-  type Experimental_LanguageModelStreamPart as ModelCallStreamPart,
+  type Experimental_LanguageModelStreamPart,
   type FinishReason,
   type LanguageModel,
   type LanguageModelUsage,
@@ -22,7 +22,10 @@ import {
   resolveSerializableTools,
   type SerializableToolDef,
 } from './serializable-schema.js';
-export type { Experimental_LanguageModelStreamPart as ModelCallStreamPart } from 'ai';
+
+export type ModelCallStreamPart<TTools extends ToolSet = ToolSet> =
+  | Experimental_LanguageModelStreamPart<TTools>
+  | { type: 'reset-step' };
 
 export type ModelStopCondition = StopCondition<NoInfer<ToolSet>, any>;
 
@@ -248,6 +251,11 @@ export async function doStreamStep(
   const writer = writable?.getWriter();
 
   try {
+    // A workflow step can be retried after already writing partial output.
+    // Reset the current UI step before every attempt so a retry invalidates
+    // chunks left behind by an earlier execution.
+    await writer?.write({ type: 'reset-step' });
+
     for await (const part of modelStream) {
       switch (part.type) {
         case 'text-delta':

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

@@ -115,6 +115,16 @@ export async function* normalizeUIMessageStreamParts(
 
   for await (const chunk of source) {
     switch (chunk.type) {
+      case 'reset-step':
+        // A retried model-call step starts a new frame. Forget parts from the
+        // invalidated attempt so reused ids are framed normally.
+        text.open.clear();
+        text.ended.clear();
+        reasoning.open.clear();
+        reasoning.ended.clear();
+        yield chunk;
+        break;
+
       case 'finish-step':
         // The consumer clears its active-part maps here, so part ids may be
         // legitimately reused in the next step. Reset to match.

package/src/stream-text-iterator.ts

@@ -7,7 +7,6 @@ import type {
 import type { Context } from '@ai-sdk/provider-utils';
 import {
   experimental_filterActiveTools as filterActiveTools,
-  type Experimental_LanguageModelStreamPart as ModelCallStreamPart,
   type Experimental_SandboxSession as SandboxSession,
   type Instructions,
   type LanguageModel,
@@ -22,6 +21,7 @@ import { createRestrictedTelemetryDispatcher } from 'ai/internal';
 import {
   type DoStreamStepRawResult,
   doStreamStep,
+  type ModelCallStreamPart,
   type ModelStopCondition,
   type ParsedToolCall,
   type ProviderExecutedToolResult,

package/src/to-ui-message-chunk.ts

@@ -1,8 +1,5 @@
-import type {
-  Experimental_LanguageModelStreamPart as ModelCallStreamPart,
-  ToolSet,
-  UIMessageChunk,
-} from 'ai';
+import type { ToolSet, UIMessageChunk } from 'ai';
+import type { ModelCallStreamPart } from './do-stream-step.js';
 
 /**
  * Convert a single ModelCallStreamPart to a UIMessageChunk.
@@ -12,6 +9,9 @@ export function toUIMessageChunk(
   part: ModelCallStreamPart<ToolSet>,
 ): UIMessageChunk | undefined {
   switch (part.type) {
+    case 'reset-step':
+      return { type: 'reset-step' };
+
     case 'text-start':
       return {
         type: 'text-start',
@@ -214,24 +214,50 @@ export function toUIMessageChunk(
 /**
  * Create a TransformStream that converts ModelCallStreamPart to UIMessageChunk.
  * Wraps toUIMessageChunk with start/start-step/finish-step lifecycle chunks.
+ *
+ * When resuming a stream, provide `uiStartIndex` and replay the source
+ * ModelCallStreamPart stream from index 0. The transform will omit the UI
+ * chunks that the client has already received. Raw model stream parts and UI
+ * message chunks do not have a one-to-one relationship, so a UI chunk index
+ * must not be used as the source stream's start index.
  */
-export function createModelCallToUIChunkTransform(): TransformStream<
-  ModelCallStreamPart<ToolSet>,
-  UIMessageChunk
-> {
+export function createModelCallToUIChunkTransform({
+  uiStartIndex = 0,
+}: {
+  /**
+   * Number of transformed UIMessageChunks to omit from the output.
+   * Must be a non-negative safe integer.
+   */
+  uiStartIndex?: number;
+} = {}): TransformStream<ModelCallStreamPart<ToolSet>, UIMessageChunk> {
+  if (!Number.isSafeInteger(uiStartIndex) || uiStartIndex < 0) {
+    throw new RangeError('uiStartIndex must be a non-negative safe integer');
+  }
+
+  let uiChunkIndex = 0;
+
+  const enqueue = (
+    controller: TransformStreamDefaultController<UIMessageChunk>,
+    chunk: UIMessageChunk,
+  ) => {
+    if (uiChunkIndex++ >= uiStartIndex) {
+      controller.enqueue(chunk);
+    }
+  };
+
   return new TransformStream<ModelCallStreamPart<ToolSet>, UIMessageChunk>({
     start: controller => {
-      controller.enqueue({ type: 'start' });
-      controller.enqueue({ type: 'start-step' });
+      enqueue(controller, { type: 'start' });
+      enqueue(controller, { type: 'start-step' });
     },
     flush: controller => {
-      controller.enqueue({ type: 'finish-step' });
-      controller.enqueue({ type: 'finish' });
+      enqueue(controller, { type: 'finish-step' });
+      enqueue(controller, { type: 'finish' });
     },
     transform: (part, controller) => {
       const uiChunk = toUIMessageChunk(part);
       if (uiChunk) {
-        controller.enqueue(uiChunk);
+        enqueue(controller, uiChunk);
       }
     },
   });

package/src/workflow-agent.ts

@@ -20,7 +20,6 @@ import {
   type FinishReason,
   type LanguageModelResponseMetadata,
   type LanguageModelUsage,
-  type Experimental_LanguageModelStreamPart as ModelCallStreamPart,
   type ModelMessage,
   type StepResult,
   type StopCondition,
@@ -45,6 +44,7 @@ import {
   validateApprovedToolApprovals,
 } from 'ai/internal';
 import { createLanguageModelToolResultOutput } from './create-language-model-tool-result-output.js';
+import type { ModelCallStreamPart } from './do-stream-step.js';
 import { streamTextIterator } from './stream-text-iterator.js';
 
 // Re-export for consumers

package/src/workflow-chat-transport.ts

@@ -59,6 +59,10 @@ function createOrphanFilter(): OrphanFilter {
 
   function shouldDrop(chunk: UIMessageChunk): boolean {
     switch (chunk.type) {
+      case 'reset-step':
+        seenStartedIds.clear();
+        seenStartedToolCallIds.clear();
+        return false;
       case 'text-start':
       case 'reasoning-start':
         seenStartedIds.add(chunk.id);
@@ -109,7 +113,8 @@ export interface ReconnectToStreamOptions {
   abortSignal?: AbortSignal;
   /**
    * Override the `startIndex` for this reconnection.
-   * Negative values read from the end of the stream.
+   * 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`.
    */
   startIndex?: number;
@@ -174,9 +179,10 @@ export interface WorkflowChatTransportOptions<UI_MESSAGE extends UIMessage> {
   /**
    * Default `startIndex` to use when reconnecting to a stream without a known
    * chunk position (i.e. the initial reconnection, not a retry).
-   * Negative values read from the end of the stream (e.g. `-10` fetches the
-   * last 10 chunks), which is useful for resuming a chat UI after a page
-   * refresh without replaying the full conversation.
+   * Negative values read from the end of a durable UIMessageChunk stream (e.g.
+   * `-10` fetches the last 10 chunks), which is useful for resuming a chat UI
+   * 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 `ReconnectToStreamOptions.startIndex`.
    *