@ai-sdk/workflow 1.0.15 → 1.0.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/workflow",
-  "version": "1.0.15",
+  "version": "1.0.17",
   "description": "WorkflowAgent for building AI agents with AI SDK",
   "license": "Apache-2.0",
   "main": "./dist/index.js",
@@ -29,13 +29,14 @@
     "ajv": "^8.20.0",
     "@ai-sdk/provider": "4.0.2",
     "@ai-sdk/provider-utils": "5.0.5",
-    "ai": "7.0.15"
+    "ai": "7.0.17"
   },
   "devDependencies": {
     "@types/node": "22.19.19",
     "@workflow/vitest": "4.0.1",
     "tsup": "^8.5.1",
     "typescript": "5.8.3",
+    "vitest": "4.1.6",
     "workflow": "4.2.4",
     "zod": "3.25.76",
     "@vercel/ai-tsconfig": "0.0.0"

package/src/do-stream-step.ts

@@ -2,7 +2,6 @@ import type {
   LanguageModelV4CallOptions,
   LanguageModelV4Prompt,
 } from '@ai-sdk/provider';
-import type { Context } from '@ai-sdk/provider-utils';
 import {
   experimental_streamLanguageModelCall as streamModelCall,
   gateway,
@@ -11,7 +10,6 @@ import {
   type LanguageModel,
   type LanguageModelUsage,
   type ModelMessage,
-  type StepResult,
   type StopCondition,
   type ToolCallRepairFunction,
   type ToolChoice,
@@ -57,13 +55,6 @@ export interface DoStreamStepOptions {
   includeRawChunks?: boolean;
   repairToolCall?: ToolCallRepairFunction<ToolSet>;
   responseFormat?: LanguageModelV4CallOptions['responseFormat'];
-  runtimeContext?: Context;
-  toolsContext?: Record<string, Context | undefined>;
-  /**
-   * The step number for the returned StepResult. Defaults to 0 for direct
-   * callers; stream iterators pass their current index. See #15151.
-   */
-  stepNumber?: number;
 }
 
 /**
@@ -91,6 +82,23 @@ export interface StreamFinish {
   providerMetadata?: Record<string, unknown>;
 }
 
+/**
+ * Minimal aggregates needed to reconstruct a `StepResult` outside the step
+ * boundary. By returning only these fields (instead of a fully-populated
+ * StepResult plus the raw `chunks[]` array), the durable event log doesn't
+ * carry StepResult's redundant copies — `content`, the duplicate
+ * `toolCalls`/`dynamicToolCalls` lists, `reasoningText`, the always-empty
+ * `*ToolResults` arrays, and the per-chunk `chunks[]` snapshot the iterator
+ * never reads. The caller reconstructs the full StepResult via
+ * `buildStepResult`.
+ */
+export interface DoStreamStepRawResult {
+  text: string;
+  reasoning: Array<{ text: string }>;
+  responseMetadata?: { id?: string; timestamp?: Date; modelId?: string };
+  warnings?: unknown[];
+}
+
 export async function doStreamStep(
   conversationPrompt: LanguageModelV4Prompt,
   modelInit: LanguageModel,
@@ -100,8 +108,7 @@ export async function doStreamStep(
 ): Promise<{
   toolCalls: ParsedToolCall[];
   finish: StreamFinish | undefined;
-  step: StepResult<ToolSet, any>;
-  chunks?: unknown[];
+  raw: DoStreamStepRawResult;
   providerExecutedToolResults: Map<string, ProviderExecutedToolResult>;
 }> {
   'use step';
@@ -155,10 +162,9 @@ export async function doStreamStep(
   >();
   let finish: StreamFinish | undefined;
 
-  // Aggregation for StepResult
+  // Minimal aggregation — only what buildStepResult needs outside the step.
   let text = '';
   const reasoningParts: Array<{ text: string }> = [];
-  const chunks: unknown[] = [];
   let responseMetadata:
     | { id?: string; timestamp?: Date; modelId?: string }
     | undefined;
@@ -169,14 +175,6 @@ export async function doStreamStep(
 
   try {
     for await (const part of modelStream) {
-      if (
-        part.type !== 'model-call-start' &&
-        part.type !== 'model-call-end' &&
-        part.type !== 'model-call-response-metadata'
-      ) {
-        chunks.push(part);
-      }
-
       switch (part.type) {
         case 'text-delta':
           text += part.text;
@@ -253,109 +251,15 @@ export async function doStreamStep(
     writer?.releaseLock();
   }
 
-  // Build StepResult
-  const reasoningText = reasoningParts.map(r => r.text).join('') || undefined;
-
-  const step: StepResult<ToolSet, any> = {
-    callId: 'workflow-agent',
-    stepNumber: options?.stepNumber ?? 0,
-    model: {
-      provider: responseMetadata?.modelId?.split(':')[0] ?? 'unknown',
-      modelId: responseMetadata?.modelId ?? 'unknown',
-    },
-    functionId: undefined,
-    metadata: undefined,
-    runtimeContext: options?.runtimeContext ?? {},
-    toolsContext: options?.toolsContext ?? {},
-    content: [
-      ...(text ? [{ type: 'text' as const, text }] : []),
-      ...toolCalls
-        .filter(tc => !tc.invalid)
-        .map(tc => ({
-          type: 'tool-call' as const,
-          toolCallId: tc.toolCallId,
-          toolName: tc.toolName,
-          input: tc.input,
-          ...(tc.dynamic ? { dynamic: true as const } : {}),
-        })),
-    ],
-    text,
-    reasoning: reasoningParts.map(r => ({
-      type: 'reasoning' as const,
-      text: r.text,
-    })),
-    reasoningText,
-    files: [],
-    sources: [],
-    toolCalls: toolCalls
-      .filter(tc => !tc.invalid)
-      .map(tc => ({
-        type: 'tool-call' as const,
-        toolCallId: tc.toolCallId,
-        toolName: tc.toolName,
-        input: tc.input,
-        ...(tc.dynamic ? { dynamic: true as const } : {}),
-      })),
-    staticToolCalls: [],
-    dynamicToolCalls: toolCalls
-      .filter(tc => !tc.invalid && tc.dynamic)
-      .map(tc => ({
-        type: 'tool-call' as const,
-        toolCallId: tc.toolCallId,
-        toolName: tc.toolName,
-        input: tc.input,
-        dynamic: true as const,
-      })),
-    toolResults: [],
-    staticToolResults: [],
-    dynamicToolResults: [],
-    finishReason: finish?.finishReason ?? 'other',
-    rawFinishReason: finish?.rawFinishReason,
-    usage:
-      finish?.usage ??
-      ({
-        inputTokens: 0,
-        inputTokenDetails: {
-          noCacheTokens: undefined,
-          cacheReadTokens: undefined,
-          cacheWriteTokens: undefined,
-        },
-        outputTokens: 0,
-        outputTokenDetails: {
-          textTokens: undefined,
-          reasoningTokens: undefined,
-        },
-        totalTokens: 0,
-      } as LanguageModelUsage),
-    performance: {
-      effectiveOutputTokensPerSecond: 0,
-      outputTokensPerSecond: undefined,
-      inputTokensPerSecond: undefined,
-      effectiveTotalTokensPerSecond: 0,
-      stepTimeMs: 0,
-      responseTimeMs: 0,
-      toolExecutionMs: {},
-      timeToFirstOutputMs: undefined,
-    },
-    warnings,
-    request: {
-      body: '',
-      messages: [], // TODO implement step request messages
-    },
-    response: {
-      id: responseMetadata?.id ?? 'unknown',
-      timestamp: responseMetadata?.timestamp ?? new Date(),
-      modelId: responseMetadata?.modelId ?? 'unknown',
-      messages: [],
-    },
-    providerMetadata: finish?.providerMetadata ?? {},
-  } as StepResult<ToolSet, any>;
-
   return {
     toolCalls,
     finish,
-    step,
-    chunks,
+    raw: {
+      text,
+      reasoning: reasoningParts,
+      responseMetadata,
+      warnings,
+    },
     providerExecutedToolResults,
   };
 }

package/src/stream-text-iterator.ts

@@ -9,6 +9,7 @@ import {
   type Experimental_LanguageModelStreamPart as ModelCallStreamPart,
   type Experimental_SandboxSession as SandboxSession,
   type LanguageModel,
+  type LanguageModelUsage,
   type ModelMessage,
   type StepResult,
   type ToolCallRepairFunction,
@@ -17,10 +18,12 @@ import {
 } from 'ai';
 import { createRestrictedTelemetryDispatcher } from 'ai/internal';
 import {
+  type DoStreamStepRawResult,
   doStreamStep,
   type ModelStopCondition,
   type ParsedToolCall,
   type ProviderExecutedToolResult,
+  type StreamFinish,
 } from './do-stream-step.js';
 import { serializeToolSet } from './serializable-schema.js';
 import type {
@@ -344,7 +347,7 @@ export async function* streamTextIterator({
         headers: currentGenerationSettings.headers,
       } as never);
 
-      const { toolCalls, finish, step, providerExecutedToolResults } =
+      const { toolCalls, finish, raw, providerExecutedToolResults } =
         await doStreamStep(
           conversationPrompt,
           currentModel,
@@ -356,11 +359,16 @@ export async function* streamTextIterator({
             includeRawChunks,
             repairToolCall,
             responseFormat,
-            runtimeContext: currentRuntimeContext,
-            toolsContext: currentToolsContext,
-            stepNumber,
           },
         );
+      // Reconstruct the full StepResult outside the step boundary so the
+      // durable event log doesn't carry StepResult's redundant copies (or the
+      // per-chunk snapshot the step used to return).
+      const step = buildStepResult(raw, toolCalls, finish, {
+        stepNumber,
+        runtimeContext: currentRuntimeContext,
+        toolsContext: currentToolsContext,
+      });
 
       await telemetryDispatcher.onLanguageModelCallEnd?.({
         callId: step.callId,
@@ -514,6 +522,108 @@ function normalizeStepForTelemetry(step: StepResult<any, any>) {
   };
 }
 
+/**
+ * Reconstruct a full `StepResult` from the minimal aggregates returned by
+ * `doStreamStep`. Runs outside the step boundary so StepResult's redundant
+ * fields (duplicate tool-call lists, `content`, `reasoningText`, the
+ * always-empty `*ToolResults` arrays) and the per-chunk snapshot don't cross
+ * it. The shape matches what the AI SDK's `streamText` exposes to callers.
+ */
+function buildStepResult(
+  raw: DoStreamStepRawResult,
+  toolCalls: ParsedToolCall[],
+  finish: StreamFinish | undefined,
+  opts: {
+    stepNumber: number;
+    runtimeContext: Context;
+    toolsContext: Record<string, Context | undefined>;
+  },
+): StepResult<ToolSet, any> {
+  const { text, reasoning: reasoningParts, responseMetadata, warnings } = raw;
+  const reasoningText = reasoningParts.map(r => r.text).join('') || undefined;
+
+  const validToolCalls = toolCalls
+    .filter(tc => !tc.invalid)
+    .map(tc => ({
+      type: 'tool-call' as const,
+      toolCallId: tc.toolCallId,
+      toolName: tc.toolName,
+      input: tc.input,
+      ...(tc.dynamic ? { dynamic: true as const } : {}),
+    }));
+
+  return {
+    callId: 'workflow-agent',
+    stepNumber: opts.stepNumber,
+    model: {
+      provider: responseMetadata?.modelId?.split(':')[0] ?? 'unknown',
+      modelId: responseMetadata?.modelId ?? 'unknown',
+    },
+    functionId: undefined,
+    metadata: undefined,
+    runtimeContext: opts.runtimeContext ?? {},
+    toolsContext: opts.toolsContext ?? {},
+    content: [
+      ...(text ? [{ type: 'text' as const, text }] : []),
+      ...validToolCalls,
+    ],
+    text,
+    reasoning: reasoningParts.map(r => ({
+      type: 'reasoning' as const,
+      text: r.text,
+    })),
+    reasoningText,
+    files: [],
+    sources: [],
+    toolCalls: validToolCalls,
+    staticToolCalls: [],
+    dynamicToolCalls: validToolCalls.filter(tc => tc.dynamic),
+    toolResults: [],
+    staticToolResults: [],
+    dynamicToolResults: [],
+    finishReason: finish?.finishReason ?? 'other',
+    rawFinishReason: finish?.rawFinishReason,
+    usage:
+      finish?.usage ??
+      ({
+        inputTokens: 0,
+        inputTokenDetails: {
+          noCacheTokens: undefined,
+          cacheReadTokens: undefined,
+          cacheWriteTokens: undefined,
+        },
+        outputTokens: 0,
+        outputTokenDetails: {
+          textTokens: undefined,
+          reasoningTokens: undefined,
+        },
+        totalTokens: 0,
+      } as LanguageModelUsage),
+    performance: {
+      effectiveOutputTokensPerSecond: 0,
+      outputTokensPerSecond: undefined,
+      inputTokensPerSecond: undefined,
+      effectiveTotalTokensPerSecond: 0,
+      stepTimeMs: 0,
+      responseTimeMs: 0,
+      toolExecutionMs: {},
+      timeToFirstOutputMs: undefined,
+    },
+    warnings,
+    request: {
+      body: '',
+      messages: [], // TODO implement step request messages
+    },
+    response: {
+      id: responseMetadata?.id ?? 'unknown',
+      timestamp: responseMetadata?.timestamp ?? new Date(),
+      modelId: responseMetadata?.modelId ?? 'unknown',
+      messages: [],
+    },
+    providerMetadata: finish?.providerMetadata ?? {},
+  } as StepResult<ToolSet, any>;
+}
+
 /**
  * Strip OpenAI's itemId from providerMetadata (requires reasoning items we don't preserve).
  * Preserves all other provider metadata (e.g., Gemini's thoughtSignature).

package/src/workflow-agent.ts

@@ -1148,6 +1148,16 @@ export interface WorkflowAgentStreamResult<
    */
   toolResults: ToolResult[];
 
+  /**
+   * The finish reason from the last step.
+   */
+  finishReason: FinishReason;
+
+  /**
+   * The total token usage across all steps.
+   */
+  totalUsage: LanguageModelUsage;
+
   /**
    * The generated structured output. It uses the `output` specification.
    * Only available when `output` is specified.
@@ -2062,6 +2072,8 @@ export class WorkflowAgent<
         steps,
         toolCalls: [],
         toolResults: [],
+        finishReason: 'other',
+        totalUsage: aggregateUsage(steps),
         output: undefined as OUTPUT,
       };
     }
@@ -2264,15 +2276,16 @@ export class WorkflowAgent<
             }
 
             const messages = iterMessages as unknown as ModelMessage[];
+            const lastStep = steps[steps.length - 1];
+            const totalUsage = aggregateUsage(steps);
+            const finishReason = lastStep?.finishReason ?? 'other';
 
             if (mergedOnEnd && !wasAborted) {
-              const lastStep = steps[steps.length - 1];
-              const totalUsage = aggregateUsage(steps);
               await mergedOnEnd({
                 steps,
                 messages,
                 text: lastStep?.text ?? '',
-                finishReason: lastStep?.finishReason ?? 'other',
+                finishReason,
                 usage: totalUsage,
                 totalUsage,
                 runtimeContext,
@@ -2283,10 +2296,10 @@ export class WorkflowAgent<
             }
             if (!wasAborted && steps.length > 0) {
               const telemetrySteps = steps.map(normalizeStepForTelemetry);
-              const lastStep = telemetrySteps[telemetrySteps.length - 1];
-              const totalUsage = aggregateUsage(steps);
+              const lastTelemetryStep =
+                telemetrySteps[telemetrySteps.length - 1];
               await telemetryDispatcher.onEnd?.({
-                ...lastStep,
+                ...lastTelemetryStep,
                 steps: telemetrySteps,
                 usage: totalUsage,
                 totalUsage,
@@ -2327,6 +2340,8 @@ export class WorkflowAgent<
               steps,
               toolCalls: allToolCalls,
               toolResults: allToolResults,
+              finishReason,
+              totalUsage,
               output: undefined as OUTPUT,
             };
           }
@@ -2491,15 +2506,17 @@ export class WorkflowAgent<
       }
     }
 
+    const lastStep = steps[steps.length - 1];
+    const totalUsage = aggregateUsage(steps);
+    const finishReason = lastStep?.finishReason ?? 'other';
+
     // Call onEnd callback if provided (always call, even on errors, but not on abort)
     if (mergedOnEnd && !wasAborted) {
-      const lastStep = steps[steps.length - 1];
-      const totalUsage = aggregateUsage(steps);
       await mergedOnEnd({
         steps,
         messages: messages as ModelMessage[],
         text: lastStep?.text ?? '',
-        finishReason: lastStep?.finishReason ?? 'other',
+        finishReason,
         usage: totalUsage,
         totalUsage,
         runtimeContext,
@@ -2509,10 +2526,9 @@ export class WorkflowAgent<
     }
     if (!wasAborted && steps.length > 0) {
       const telemetrySteps = steps.map(normalizeStepForTelemetry);
-      const lastStep = telemetrySteps[telemetrySteps.length - 1];
-      const totalUsage = aggregateUsage(steps);
+      const lastTelemetryStep = telemetrySteps[telemetrySteps.length - 1];
       await telemetryDispatcher.onEnd?.({
-        ...lastStep,
+        ...lastTelemetryStep,
         steps: telemetrySteps,
         usage: totalUsage,
         totalUsage,
@@ -2546,6 +2562,8 @@ export class WorkflowAgent<
       steps,
       toolCalls: lastStepToolCalls,
       toolResults: lastStepToolResults,
+      finishReason,
+      totalUsage,
       output: experimentalOutput,
     };
   }

package/src/workflow-chat-transport.ts

@@ -15,6 +15,87 @@ import {
 import { createAsyncIterableStream } from 'ai/internal';
 import { normalizeUIMessageStreamParts } from './normalize-ui-message-stream.js';
 
+/**
+ * Tracks `*-start` chunks the client has accepted so we can drop deltas/ends
+ * that refer to a part whose start was emitted before the resume cursor.
+ *
+ * AI SDK's UI stream processor throws on `text-delta`/`reasoning-delta`/
+ * `tool-input-delta` (and the matching `*-end`) when the start chunk for that
+ * id was never observed, and on tool output/approval chunks when no tool part
+ * exists for the call id. A negative `startIndex` on a flat chunk stream can
+ * easily land mid-part, so without this guard the client crashes on resume.
+ *
+ * A tool part is established by `tool-input-start` OR by a self-contained
+ * `tool-input-available`/`tool-input-error` chunk (the AI SDK creates the
+ * part from those directly), so all three mark the call id as seen.
+ *
+ * This is a best-effort safety net — it preserves only the parts that the
+ * resumed window includes a `*-start` for. Server-side rewinding to a step
+ * boundary is the proper fix when you want the full message preserved.
+ */
+type OrphanFilter = {
+  shouldDrop: (chunk: UIMessageChunk) => boolean;
+};
+
+function createOrphanFilter(): OrphanFilter {
+  const seenStartedIds = new Set<string>();
+  const seenStartedToolCallIds = new Set<string>();
+  let warnedOnce = false;
+
+  function warnOnce(orphanKind: string, orphanRef: string) {
+    if (warnedOnce) return;
+    warnedOnce = true;
+    console.warn(
+      '[WorkflowChatTransport] Dropping orphan UI chunk ' +
+        `(${orphanKind} for id "${orphanRef}") on resume — ` +
+        'the resume position landed mid-part. The dropped chunk(s) ' +
+        "reference a part whose start chunk wasn't in the resumed " +
+        'window. To preserve the full message, configure your ' +
+        'stream endpoint to rewind to a step boundary before ' +
+        'returning the readable. See: ' +
+        'https://workflow.dev/docs/ai/resumable-streams#mid-part-resumes',
+    );
+  }
+
+  function shouldDrop(chunk: UIMessageChunk): boolean {
+    switch (chunk.type) {
+      case 'text-start':
+      case 'reasoning-start':
+        seenStartedIds.add(chunk.id);
+        return false;
+      case 'tool-input-start':
+      // `tool-input-available` / `tool-input-error` are self-contained: the
+      // AI SDK creates the tool part from them directly (non-streamed tool
+      // calls are emitted as a bare `tool-input-available`), so they must
+      // never be dropped. They also carry the full input, so they recover a
+      // tool call whose `tool-input-start` fell outside the resumed window.
+      case 'tool-input-available':
+      case 'tool-input-error':
+        seenStartedToolCallIds.add(chunk.toolCallId);
+        return false;
+      case 'text-delta':
+      case 'text-end':
+      case 'reasoning-delta':
+      case 'reasoning-end':
+        if (seenStartedIds.has(chunk.id)) return false;
+        warnOnce(chunk.type, chunk.id);
+        return true;
+      case 'tool-input-delta':
+      case 'tool-approval-request':
+      case 'tool-output-available':
+      case 'tool-output-error':
+      case 'tool-output-denied':
+        if (seenStartedToolCallIds.has(chunk.toolCallId)) return false;
+        warnOnce(chunk.type, chunk.toolCallId);
+        return true;
+      default:
+        return false;
+    }
+  }
+
+  return { shouldDrop };
+}
+
 export interface SendMessagesOptions<UI_MESSAGE extends UIMessage> {
   trigger: 'submit-message' | 'regenerate-message';
   chatId: string;
@@ -339,6 +420,17 @@ export class WorkflowChatTransport<
     // the incremental chunkIndex which would be wrong.
     let replayFromStart = false;
 
+    // When resuming with a negative startIndex, the resolved chunk can land in
+    // the middle of a `*-start` / `*-delta` / `*-end` sequence, which crashes
+    // the AI SDK UI stream processor. The orphan filter drops chunks whose
+    // start chunk was emitted before the resume window. Only activated for
+    // negative resumes — non-negative startIndex is the caller's explicit
+    // choice and we trust them. See: https://github.com/vercel/workflow/issues/1835
+    const orphanFilter =
+      useExplicitStartIndex && explicitStartIndex < 0
+        ? createOrphanFilter()
+        : null;
+
     while (!gotFinish) {
       const startIndex = useExplicitStartIndex
         ? explicitStartIndex
@@ -404,6 +496,8 @@ export class WorkflowChatTransport<
 
           chunkIndex++;
 
+          if (orphanFilter?.shouldDrop(chunk.value)) continue;
+
           yield chunk.value;
 
           if (chunk.value.type === 'finish') {