@ai-sdk/workflow 1.0.16 → 1.0.17

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # @ai-sdk/workflow
 
+## 1.0.17
+
+### Patch Changes
+
+- 148babc: `WorkflowChatTransport` now drops orphan UI chunks (deltas/ends and tool output/approval chunks whose part was started before the resumed window) when reconnecting with a negative `initialStartIndex`, instead of crashing the AI SDK client. Self-contained `tool-input-available`/`tool-input-error` chunks establish the tool part and are never dropped. A one-time warning links to docs on rewinding to a step boundary server-side.
+- e660e45: Reduce the `doStreamStep` step-boundary payload by returning minimal raw aggregates and reconstructing the `StepResult` outside the step, instead of serializing the full `StepResult` plus the per-chunk array into the durable event log.
+- cc773bc: Expose `totalUsage` and `finishReason` on the `WorkflowAgent.stream()` result, mirroring `GenerateTextResult`/`StreamTextResult` and the existing `onEnd` event payload.
+  - ai@7.0.17
+
 ## 1.0.16
 
 ### Patch Changes

package/dist/index.d.mts

@@ -876,6 +876,14 @@ interface WorkflowAgentStreamResult<TTools extends ToolSet = ToolSet, OUTPUT = n
      * This matches the AI SDK's `GenerateTextResult.toolResults` behavior.
      */
     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.

package/dist/index.mjs

@@ -144,7 +144,6 @@ function resolveSerializableTools(tools) {
 // src/do-stream-step.ts
 async function doStreamStep(conversationPrompt, modelInit, writable, serializedTools, options) {
   "use step";
-  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
   const model = typeof modelInit === "string" ? gateway.languageModel(modelInit) : modelInit;
   const tools = serializedTools ? resolveSerializableTools(serializedTools) : void 0;
   const { stream: modelStream } = await streamModelCall({
@@ -176,15 +175,11 @@ async function doStreamStep(conversationPrompt, modelInit, writable, serializedT
   let finish;
   let text = "";
   const reasoningParts = [];
-  const chunks = [];
   let responseMetadata;
   let warnings;
   const writer = writable == null ? void 0 : writable.getWriter();
   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;
@@ -251,99 +246,15 @@ async function doStreamStep(conversationPrompt, modelInit, writable, serializedT
   } finally {
     writer == null ? void 0 : writer.releaseLock();
   }
-  const reasoningText = reasoningParts.map((r) => r.text).join("") || void 0;
-  const step = {
-    callId: "workflow-agent",
-    stepNumber: (_a = options == null ? void 0 : options.stepNumber) != null ? _a : 0,
-    model: {
-      provider: (_c = (_b = responseMetadata == null ? void 0 : responseMetadata.modelId) == null ? void 0 : _b.split(":")[0]) != null ? _c : "unknown",
-      modelId: (_d = responseMetadata == null ? void 0 : responseMetadata.modelId) != null ? _d : "unknown"
-    },
-    functionId: void 0,
-    metadata: void 0,
-    runtimeContext: (_e = options == null ? void 0 : options.runtimeContext) != null ? _e : {},
-    toolsContext: (_f = options == null ? void 0 : options.toolsContext) != null ? _f : {},
-    content: [
-      ...text ? [{ type: "text", text }] : [],
-      ...toolCalls.filter((tc) => !tc.invalid).map((tc) => ({
-        type: "tool-call",
-        toolCallId: tc.toolCallId,
-        toolName: tc.toolName,
-        input: tc.input,
-        ...tc.dynamic ? { dynamic: true } : {}
-      }))
-    ],
-    text,
-    reasoning: reasoningParts.map((r) => ({
-      type: "reasoning",
-      text: r.text
-    })),
-    reasoningText,
-    files: [],
-    sources: [],
-    toolCalls: toolCalls.filter((tc) => !tc.invalid).map((tc) => ({
-      type: "tool-call",
-      toolCallId: tc.toolCallId,
-      toolName: tc.toolName,
-      input: tc.input,
-      ...tc.dynamic ? { dynamic: true } : {}
-    })),
-    staticToolCalls: [],
-    dynamicToolCalls: toolCalls.filter((tc) => !tc.invalid && tc.dynamic).map((tc) => ({
-      type: "tool-call",
-      toolCallId: tc.toolCallId,
-      toolName: tc.toolName,
-      input: tc.input,
-      dynamic: true
-    })),
-    toolResults: [],
-    staticToolResults: [],
-    dynamicToolResults: [],
-    finishReason: (_g = finish == null ? void 0 : finish.finishReason) != null ? _g : "other",
-    rawFinishReason: finish == null ? void 0 : finish.rawFinishReason,
-    usage: (_h = finish == null ? void 0 : finish.usage) != null ? _h : {
-      inputTokens: 0,
-      inputTokenDetails: {
-        noCacheTokens: void 0,
-        cacheReadTokens: void 0,
-        cacheWriteTokens: void 0
-      },
-      outputTokens: 0,
-      outputTokenDetails: {
-        textTokens: void 0,
-        reasoningTokens: void 0
-      },
-      totalTokens: 0
-    },
-    performance: {
-      effectiveOutputTokensPerSecond: 0,
-      outputTokensPerSecond: void 0,
-      inputTokensPerSecond: void 0,
-      effectiveTotalTokensPerSecond: 0,
-      stepTimeMs: 0,
-      responseTimeMs: 0,
-      toolExecutionMs: {},
-      timeToFirstOutputMs: void 0
-    },
-    warnings,
-    request: {
-      body: "",
-      messages: []
-      // TODO implement step request messages
-    },
-    response: {
-      id: (_i = responseMetadata == null ? void 0 : responseMetadata.id) != null ? _i : "unknown",
-      timestamp: (_j = responseMetadata == null ? void 0 : responseMetadata.timestamp) != null ? _j : /* @__PURE__ */ new Date(),
-      modelId: (_k = responseMetadata == null ? void 0 : responseMetadata.modelId) != null ? _k : "unknown",
-      messages: []
-    },
-    providerMetadata: (_l = finish == null ? void 0 : finish.providerMetadata) != null ? _l : {}
-  };
   return {
     toolCalls,
     finish,
-    step,
-    chunks,
+    raw: {
+      text,
+      reasoning: reasoningParts,
+      responseMetadata,
+      warnings
+    },
     providerExecutedToolResults
   };
 }
@@ -562,7 +473,7 @@ async function* streamTextIterator({
         providerOptions: currentGenerationSettings.providerOptions,
         headers: currentGenerationSettings.headers
       }));
-      const { toolCalls, finish, step, providerExecutedToolResults } = await doStreamStep(
+      const { toolCalls, finish, raw, providerExecutedToolResults } = await doStreamStep(
         conversationPrompt,
         currentModel,
         writable,
@@ -572,12 +483,14 @@ async function* streamTextIterator({
           toolChoice: currentToolChoice,
           includeRawChunks,
           repairToolCall,
-          responseFormat,
-          runtimeContext: currentRuntimeContext,
-          toolsContext: currentToolsContext,
-          stepNumber
+          responseFormat
         }
       );
+      const step = buildStepResult(raw, toolCalls, finish, {
+        stepNumber,
+        runtimeContext: currentRuntimeContext,
+        toolsContext: currentToolsContext
+      });
       await ((_j = telemetryDispatcher.onLanguageModelCallEnd) == null ? void 0 : _j.call(telemetryDispatcher, {
         callId: step.callId,
         provider: (_g = (_f = step.model) == null ? void 0 : _f.provider) != null ? _g : "unknown",
@@ -692,6 +605,87 @@ function normalizeStepForTelemetry(step) {
     model: (_a = step.model) != null ? _a : { provider: "unknown", modelId: "unknown" }
   };
 }
+function buildStepResult(raw, toolCalls, finish, opts) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
+  const { text, reasoning: reasoningParts, responseMetadata, warnings } = raw;
+  const reasoningText = reasoningParts.map((r) => r.text).join("") || void 0;
+  const validToolCalls = toolCalls.filter((tc) => !tc.invalid).map((tc) => ({
+    type: "tool-call",
+    toolCallId: tc.toolCallId,
+    toolName: tc.toolName,
+    input: tc.input,
+    ...tc.dynamic ? { dynamic: true } : {}
+  }));
+  return {
+    callId: "workflow-agent",
+    stepNumber: opts.stepNumber,
+    model: {
+      provider: (_b = (_a = responseMetadata == null ? void 0 : responseMetadata.modelId) == null ? void 0 : _a.split(":")[0]) != null ? _b : "unknown",
+      modelId: (_c = responseMetadata == null ? void 0 : responseMetadata.modelId) != null ? _c : "unknown"
+    },
+    functionId: void 0,
+    metadata: void 0,
+    runtimeContext: (_d = opts.runtimeContext) != null ? _d : {},
+    toolsContext: (_e = opts.toolsContext) != null ? _e : {},
+    content: [
+      ...text ? [{ type: "text", text }] : [],
+      ...validToolCalls
+    ],
+    text,
+    reasoning: reasoningParts.map((r) => ({
+      type: "reasoning",
+      text: r.text
+    })),
+    reasoningText,
+    files: [],
+    sources: [],
+    toolCalls: validToolCalls,
+    staticToolCalls: [],
+    dynamicToolCalls: validToolCalls.filter((tc) => tc.dynamic),
+    toolResults: [],
+    staticToolResults: [],
+    dynamicToolResults: [],
+    finishReason: (_f = finish == null ? void 0 : finish.finishReason) != null ? _f : "other",
+    rawFinishReason: finish == null ? void 0 : finish.rawFinishReason,
+    usage: (_g = finish == null ? void 0 : finish.usage) != null ? _g : {
+      inputTokens: 0,
+      inputTokenDetails: {
+        noCacheTokens: void 0,
+        cacheReadTokens: void 0,
+        cacheWriteTokens: void 0
+      },
+      outputTokens: 0,
+      outputTokenDetails: {
+        textTokens: void 0,
+        reasoningTokens: void 0
+      },
+      totalTokens: 0
+    },
+    performance: {
+      effectiveOutputTokensPerSecond: 0,
+      outputTokensPerSecond: void 0,
+      inputTokensPerSecond: void 0,
+      effectiveTotalTokensPerSecond: 0,
+      stepTimeMs: 0,
+      responseTimeMs: 0,
+      toolExecutionMs: {},
+      timeToFirstOutputMs: void 0
+    },
+    warnings,
+    request: {
+      body: "",
+      messages: []
+      // TODO implement step request messages
+    },
+    response: {
+      id: (_h = responseMetadata == null ? void 0 : responseMetadata.id) != null ? _h : "unknown",
+      timestamp: (_i = responseMetadata == null ? void 0 : responseMetadata.timestamp) != null ? _i : /* @__PURE__ */ new Date(),
+      modelId: (_j = responseMetadata == null ? void 0 : responseMetadata.modelId) != null ? _j : "unknown",
+      messages: []
+    },
+    providerMetadata: (_k = finish == null ? void 0 : finish.providerMetadata) != null ? _k : {}
+  };
+}
 function sanitizeProviderMetadataForToolCall(metadata) {
   if (metadata == null) return void 0;
   const meta = metadata;
@@ -1356,6 +1350,8 @@ var WorkflowAgent = class {
         steps,
         toolCalls: [],
         toolResults: [],
+        finishReason: "other",
+        totalUsage: aggregateUsage(steps),
         output: void 0
       };
     }
@@ -1515,16 +1511,17 @@ var WorkflowAgent = class {
               });
             }
             const messages2 = iterMessages;
+            const lastStep2 = steps[steps.length - 1];
+            const totalUsage2 = aggregateUsage(steps);
+            const finishReason2 = (_E = lastStep2 == null ? void 0 : lastStep2.finishReason) != null ? _E : "other";
             if (mergedOnEnd && !wasAborted) {
-              const lastStep = steps[steps.length - 1];
-              const totalUsage = aggregateUsage(steps);
               await mergedOnEnd({
                 steps,
                 messages: messages2,
-                text: (_E = lastStep == null ? void 0 : lastStep.text) != null ? _E : "",
-                finishReason: (_F = lastStep == null ? void 0 : lastStep.finishReason) != null ? _F : "other",
-                usage: totalUsage,
-                totalUsage,
+                text: (_F = lastStep2 == null ? void 0 : lastStep2.text) != null ? _F : "",
+                finishReason: finishReason2,
+                usage: totalUsage2,
+                totalUsage: totalUsage2,
                 runtimeContext,
                 toolsContext,
                 output: void 0
@@ -1532,13 +1529,12 @@ var WorkflowAgent = class {
             }
             if (!wasAborted && steps.length > 0) {
               const telemetrySteps = steps.map(normalizeStepForTelemetry2);
-              const lastStep = telemetrySteps[telemetrySteps.length - 1];
-              const totalUsage = aggregateUsage(steps);
+              const lastTelemetryStep = telemetrySteps[telemetrySteps.length - 1];
               await ((_G = telemetryDispatcher.onEnd) == null ? void 0 : _G.call(telemetryDispatcher, {
-                ...lastStep,
+                ...lastTelemetryStep,
                 steps: telemetrySteps,
-                usage: totalUsage,
-                totalUsage
+                usage: totalUsage2,
+                totalUsage: totalUsage2
               }));
             }
             if (options.writable) {
@@ -1570,6 +1566,8 @@ var WorkflowAgent = class {
               steps,
               toolCalls: allToolCalls,
               toolResults: allToolResults,
+              finishReason: finishReason2,
+              totalUsage: totalUsage2,
               output: void 0
             };
           }
@@ -1690,16 +1688,16 @@ var WorkflowAgent = class {
     const effectiveOutput = (_K = options.output) != null ? _K : this.output;
     let experimentalOutput = void 0;
     if (effectiveOutput && steps.length > 0) {
-      const lastStep = steps[steps.length - 1];
-      const text = lastStep.text;
+      const lastStep2 = steps[steps.length - 1];
+      const text = lastStep2.text;
       if (text) {
         try {
           experimentalOutput = await effectiveOutput.parseCompleteOutput(
             { text },
             {
-              response: lastStep.response,
-              usage: lastStep.usage,
-              finishReason: lastStep.finishReason
+              response: lastStep2.response,
+              usage: lastStep2.usage,
+              finishReason: lastStep2.finishReason
             }
           );
         } catch (parseError) {
@@ -1709,14 +1707,15 @@ var WorkflowAgent = class {
         }
       }
     }
+    const lastStep = steps[steps.length - 1];
+    const totalUsage = aggregateUsage(steps);
+    const finishReason = (_L = lastStep == null ? void 0 : lastStep.finishReason) != null ? _L : "other";
     if (mergedOnEnd && !wasAborted) {
-      const lastStep = steps[steps.length - 1];
-      const totalUsage = aggregateUsage(steps);
       await mergedOnEnd({
         steps,
         messages,
-        text: (_L = lastStep == null ? void 0 : lastStep.text) != null ? _L : "",
-        finishReason: (_M = lastStep == null ? void 0 : lastStep.finishReason) != null ? _M : "other",
+        text: (_M = lastStep == null ? void 0 : lastStep.text) != null ? _M : "",
+        finishReason,
         usage: totalUsage,
         totalUsage,
         runtimeContext,
@@ -1726,10 +1725,9 @@ var WorkflowAgent = class {
     }
     if (!wasAborted && steps.length > 0) {
       const telemetrySteps = steps.map(normalizeStepForTelemetry2);
-      const lastStep = telemetrySteps[telemetrySteps.length - 1];
-      const totalUsage = aggregateUsage(steps);
+      const lastTelemetryStep = telemetrySteps[telemetrySteps.length - 1];
       await ((_N = telemetryDispatcher.onEnd) == null ? void 0 : _N.call(telemetryDispatcher, {
-        ...lastStep,
+        ...lastTelemetryStep,
         steps: telemetrySteps,
         usage: totalUsage,
         totalUsage
@@ -1757,6 +1755,8 @@ var WorkflowAgent = class {
       steps,
       toolCalls: lastStepToolCalls,
       toolResults: lastStepToolResults,
+      finishReason,
+      totalUsage,
       output: experimentalOutput
     };
   }
@@ -2249,6 +2249,54 @@ async function* normalizeUIMessageStreamParts(source) {
 }
 
 // src/workflow-chat-transport.ts
+function createOrphanFilter() {
+  const seenStartedIds = /* @__PURE__ */ new Set();
+  const seenStartedToolCallIds = /* @__PURE__ */ new Set();
+  let warnedOnce = false;
+  function warnOnce(orphanKind, orphanRef) {
+    if (warnedOnce) return;
+    warnedOnce = true;
+    console.warn(
+      `[WorkflowChatTransport] Dropping orphan UI chunk (${orphanKind} for id "${orphanRef}") on resume \u2014 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) {
+    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 };
+}
 var WorkflowChatTransport = class {
   /**
    * Creates a new WorkflowChatTransport instance.
@@ -2394,6 +2442,7 @@ var WorkflowChatTransport = class {
     let gotFinish = false;
     let consecutiveErrors = 0;
     let replayFromStart = false;
+    const orphanFilter = useExplicitStartIndex && explicitStartIndex < 0 ? createOrphanFilter() : null;
     while (!gotFinish) {
       const startIndex = useExplicitStartIndex ? explicitStartIndex : replayFromStart ? 0 : chunkIndex;
       const url = `${baseUrl}?startIndex=${startIndex}`;
@@ -2434,6 +2483,7 @@ var WorkflowChatTransport = class {
             throw chunk.error;
           }
           chunkIndex++;
+          if (orphanFilter == null ? void 0 : orphanFilter.shouldDrop(chunk.value)) continue;
           yield chunk.value;
           if (chunk.value.type === "finish") {
             gotFinish = true;