fix(webapp): a dead stream with a dangling tool call self-heals from the settled transcript

Author: kathiekiwi

apps/webapp/app/components/dashboard-agent/DashboardAgentChat.tsx

@@ -19,8 +19,8 @@ import type { AgentPageContext } from "./page-context-types";
 import { retryAction } from "./retry-action";
 import {
   fetchChatTranscript,
-  hasOpenInvestigation,
   pollSettledTranscript,
+  transcriptLooksUnfinished,
 } from "./settled-transcript";
 import { useAgentMessageQuota } from "./useAgentMessageQuota";
 import { useTriggerUriResolver } from "./useTriggerUriResolver";
@@ -281,8 +281,9 @@ export function DashboardAgentChat({
 
     onTurnSettled();
     // The terminal card is written to the chat row after the stream closes, so this
-    // mounted panel would otherwise keep showing the last `in_progress` revision.
-    if (!hasOpenInvestigation(messagesRef.current)) return;
+    // mounted panel would otherwise keep showing the last `in_progress` revision — or,
+    // if the stream died mid-tool, the tool call it never got an output for.
+    if (!transcriptLooksUnfinished(messagesRef.current)) return;
     void pollSettledTranscript<UIMessage>({
       fetchTranscript: () => fetchChatTranscript(actionPath, chatId),
       apply: (merge) => setMessages((current) => merge(current)),

apps/webapp/app/components/dashboard-agent/settled-transcript.test.ts

@@ -6,6 +6,7 @@ import {
   hasOpenInvestigation,
   mergeSettledMessages,
   pollSettledTranscript,
+  transcriptLooksUnfinished,
 } from "./settled-transcript";
 
 /**
@@ -119,6 +120,27 @@ describe("reading the transcript endpoint", () => {
   });
 });
 
+describe("deciding whether a settled turn is worth re-reading", () => {
+  // The stream EOF'd while `get_report` was running: the part never gets an output.
+  const DANGLING_TOOL = {
+    id: "msg_dangling",
+    role: "assistant",
+    parts: [{ type: "tool-get_report", toolCallId: "call_1", state: "input-available" }],
+  };
+
+  it("re-reads when the stream died mid-tool, not only when a card is open", () => {
+    expect(transcriptLooksUnfinished([DANGLING_TOOL])).toBe(true);
+  });
+
+  it("re-reads while a card is still open", () => {
+    expect(transcriptLooksUnfinished([OPEN])).toBe(true);
+  });
+
+  it("leaves a fully settled transcript alone", () => {
+    expect(transcriptLooksUnfinished([OPEN, SETTLED])).toBe(false);
+  });
+});
+
 describe("an already-open panel when a turn is exhausted", () => {
   it("stops showing Working… without a reload or a reopen", async () => {
     // What the mounted panel holds when the stream closes: the card the model opened

apps/webapp/app/components/dashboard-agent/settled-transcript.ts

@@ -1,4 +1,4 @@
-import { liveInvestigation } from "./progress-line";
+import { inFlightToolName, liveInvestigation } from "./progress-line";
 
 /**
  * Re-reading the stored transcript once a turn settles.
@@ -29,6 +29,15 @@ export function hasOpenInvestigation(messages: ReadonlyArray<unknown>): boolean
   return liveInvestigation(messages as never) !== null;
 }
 
+/**
+ * Whether the transcript still reads as mid-turn. A stream that dies without
+ * `turn-complete` leaves the tool part it was on dangling forever, so an open card is
+ * not the only shape a re-read has to recover from.
+ */
+export function transcriptLooksUnfinished(messages: ReadonlyArray<unknown>): boolean {
+  return hasOpenInvestigation(messages) || inFlightToolName(messages as never) !== null;
+}
+
 /**
  * The settlement is written in `onTurnComplete`, which runs AFTER the client's stream
  * closes, so the first re-read can legitimately land before it. Retry a few times,