@tanstack/ai 0.39.0 → 0.39.1

package/dist/esm/activities/chat/stream/processor.d.ts

@@ -220,6 +220,24 @@ export declare class StreamProcessor {
      * Handle MESSAGES_SNAPSHOT event
      */
     private handleMessagesSnapshotEvent;
+    /**
+     * Reconcile a freshly normalized snapshot with the pre-snapshot message
+     * state so unreconstructable tool-call metadata is preserved.
+     *
+     * Post-pass (a): anchor `tool-result`-only assistant messages (the shape
+     * `aguiSnapshotMessageToUIMessage` emits for AG-UI `role: 'tool'` wire
+     * messages) into the message containing the matching `tool-call` part, or —
+     * when the snapshot supplies no such part — the nearest earlier anchorable
+     * assistant message, matching the in-stream fan-out shape
+     * `assistant: [text, tool-call, tool-result, ...]`. Detached messages with
+     * no earlier anchorable assistant are kept verbatim.
+     *
+     * Post-pass (b): when a `tool-result` part references a `toolCallId` whose
+     * `tool-call` part is absent from the snapshot, carry the `tool-call` part
+     * forward from the pre-snapshot state (state and output untouched) so a
+     * subsequent `addToolResult(toolCallId)` can still locate the call.
+     */
+    private reconcileSnapshotToolCalls;
     /**
      * Handle TEXT_MESSAGE_CONTENT event.
      *

package/dist/esm/activities/chat/stream/processor.js

@@ -1,5 +1,6 @@
 import { generateMessageId, uiMessageToModelMessages, aguiSnapshotMessageToUIMessage } from "../messages.js";
 import { normalizeToolResult } from "../../../utilities/tool-result.js";
+import { isProviderExecutedToolCall } from "../../../utilities/provider-executed.js";
 import { defaultJSONParser } from "./json-parser.js";
 import { updateToolCallWithOutput, updateToolResultPart, updateToolCallApprovalResponse, appendStructuredOutputDelta, updateToolCallPart, errorStructuredOutputPart, updateThinkingPart, completeStructuredOutputPart, updateToolCallApproval, updateTextPart } from "./message-updaters.js";
 import { ImmediateStrategy } from "./strategies.js";
@@ -197,7 +198,7 @@ class StreamProcessor {
       lastAssistant.parts.filter((p) => p.type === "tool-result").map((p) => p.toolCallId)
     );
     return toolParts.every(
-      (part) => part.state === "complete" || part.state === "approval-responded" || part.output !== void 0 && !part.approval || toolResultIds.has(part.id)
+      (part) => part.state === "complete" || part.state === "approval-responded" || part.output !== void 0 && !part.approval || toolResultIds.has(part.id) || isProviderExecutedToolCall(part)
     );
   }
   /**
@@ -548,9 +549,87 @@ class StreamProcessor {
    */
   handleMessagesSnapshotEvent(chunk) {
     this.resetStreamState();
-    this.messages = chunk.messages.map(aguiSnapshotMessageToUIMessage);
+    const prevMessages = this.messages;
+    const normalized = chunk.messages.map(aguiSnapshotMessageToUIMessage);
+    this.messages = this.reconcileSnapshotToolCalls(normalized, prevMessages);
     this.emitMessagesChange();
   }
+  /**
+   * Reconcile a freshly normalized snapshot with the pre-snapshot message
+   * state so unreconstructable tool-call metadata is preserved.
+   *
+   * Post-pass (a): anchor `tool-result`-only assistant messages (the shape
+   * `aguiSnapshotMessageToUIMessage` emits for AG-UI `role: 'tool'` wire
+   * messages) into the message containing the matching `tool-call` part, or —
+   * when the snapshot supplies no such part — the nearest earlier anchorable
+   * assistant message, matching the in-stream fan-out shape
+   * `assistant: [text, tool-call, tool-result, ...]`. Detached messages with
+   * no earlier anchorable assistant are kept verbatim.
+   *
+   * Post-pass (b): when a `tool-result` part references a `toolCallId` whose
+   * `tool-call` part is absent from the snapshot, carry the `tool-call` part
+   * forward from the pre-snapshot state (state and output untouched) so a
+   * subsequent `addToolResult(toolCallId)` can still locate the call.
+   */
+  reconcileSnapshotToolCalls(snapshot, prevMessages) {
+    const prevToolCalls = /* @__PURE__ */ new Map();
+    for (const msg of prevMessages) {
+      for (const part of msg.parts) {
+        if (part.type === "tool-call") {
+          prevToolCalls.set(part.id, part);
+        }
+      }
+    }
+    const snapshotToolCallIds = /* @__PURE__ */ new Set();
+    for (const msg of snapshot) {
+      for (const part of msg.parts) {
+        if (part.type === "tool-call") {
+          snapshotToolCallIds.add(part.id);
+        }
+      }
+    }
+    const reconciled = [];
+    for (const msg of snapshot) {
+      const toolResultPart = msg.role === "assistant" && msg.parts.length === 1 ? msg.parts.find((p) => p.type === "tool-result") : void 0;
+      if (!toolResultPart) {
+        reconciled.push(msg);
+        continue;
+      }
+      const target = reconciled.findLast(
+        (m) => m.parts.some(
+          (p) => p.type === "tool-call" && p.id === toolResultPart.toolCallId
+        )
+      ) ?? reconciled.findLast(
+        (m) => m.role === "assistant" && !(m.parts.length === 1 && m.parts[0]?.type === "tool-result")
+      );
+      if (!target) {
+        if (!snapshotToolCallIds.has(toolResultPart.toolCallId)) {
+          console.warn(
+            `[StreamProcessor] MESSAGES_SNAPSHOT contains a tool-result for "${toolResultPart.toolCallId}" but no matching tool-call exists in the snapshot, and there is no assistant message to anchor into; addToolResult("${toolResultPart.toolCallId}") will not be able to locate this call`
+          );
+        }
+        reconciled.push(msg);
+        continue;
+      }
+      const parts = [...target.parts];
+      if (!snapshotToolCallIds.has(toolResultPart.toolCallId) && !parts.some(
+        (p) => p.type === "tool-call" && p.id === toolResultPart.toolCallId
+      )) {
+        const prev = prevToolCalls.get(toolResultPart.toolCallId);
+        if (prev) {
+          parts.push({ ...prev });
+          snapshotToolCallIds.add(prev.id);
+        } else {
+          console.warn(
+            `[StreamProcessor] MESSAGES_SNAPSHOT contains a tool-result for "${toolResultPart.toolCallId}" but no matching tool-call exists in the snapshot or the pre-snapshot state; addToolResult("${toolResultPart.toolCallId}") will not be able to locate this call`
+          );
+        }
+      }
+      parts.push(toolResultPart);
+      target.parts = parts;
+    }
+    return reconciled;
+  }
   /**
    * Handle TEXT_MESSAGE_CONTENT event.
    *
@@ -1185,8 +1264,11 @@ class StreamProcessor {
    */
   isToolCallPartErrored(toolCallId) {
     return this.messages.some(
-      (msg) => msg.parts.some(
-        (part) => part.type === "tool-call" && part.id === toolCallId && part.state === "error"
+      (msg) => (
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- `parts` is typed as required, but seeded ModelMessage-shaped messages can lack it at runtime.
+        msg.parts?.some(
+          (part) => part.type === "tool-call" && part.id === toolCallId && part.state === "error"
+        )
       )
     );
   }