fix(dashboard-agent): one failed tool call no longer fails the whole turn

A tool's exception is handed to the same hook a stream failure is, so a single
failed call marked the turn failed: the agent worked around it and answered, and
the user still got "Something went wrong" under a finished answer. The model was
also told the turn was over instead of what happened to that call, so it was
flying blind on the retry, and the exception itself was never logged.

A failed call now reads as a failed call, is logged, and leaves the turn alone;
only a stream failure ends it.

Author: kathiekiwi

internal-packages/dashboard-agent/src/dashboard-agent.test.ts

@@ -36,6 +36,7 @@ import {
   prepareTurnMessages,
   sanitizeReplayedToolInputs,
   truncateEvalToolOutput,
+  TOOL_FAILED_MESSAGE,
   TURN_FAILED_MESSAGE,
   turnFailureMessageId,
   type DashboardAgentEvalPolicyCheck,
@@ -1182,6 +1183,63 @@ describe("a turn that ends in an error", () => {
     // The user's question stays in the transcript next to it.
     expect(stored.some((message) => message.role === "user")).toBe(true);
   });
+
+  /**
+   * A tool's exception is handed to the same hook a stream failure is, so one failed
+   * call used to mark the whole turn failed: the model worked around it, answered,
+   * and the user still got "Something went wrong" under a finished answer — and the
+   * model was told the turn was over instead of what to try next.
+   */
+  it("a failed tool call the model works around is not a failed turn", async () => {
+    const { store, history } = transcriptStore();
+    harness = mockChatAgent(dashboardAgent, {
+      chatId: "chat_tool_error",
+      clientData: CLIENT_DATA,
+      setupLocals: ({ set }) => {
+        set(dashboardAgentStoreKey, store);
+        set(dashboardAgentToolsKey, {
+          render_view: tool({
+            description: "test double",
+            inputSchema: z.object({ blocks: z.array(z.unknown()).optional() }),
+            execute: async () => ({ blocks: [] }),
+          }),
+          offer_watch: tool({
+            description: "test double that fails the way a tool bug does",
+            inputSchema: z.object({ note: z.string().optional() }),
+            execute: async (): Promise<{ ok: boolean }> => {
+              throw new Error("Cannot read properties of undefined (reading 'fingerprint')");
+            },
+          }),
+        });
+        set(
+          dashboardAgentModelKey,
+          mockModel([
+            toolCallStep("render_view", {}, "tc_verdict"),
+            toolCallStep("offer_watch", {}, "tc_offer"),
+            textStep("Rate limited — the retries all land in one window."),
+          ])
+        );
+      },
+    });
+
+    const turn = await harness.sendMessage(userMessage("why is send-order-receipt failing?"));
+
+    // The model is told what happened to that call, not that the turn is over.
+    const toolError = turn.chunks.find(
+      (chunk) => (chunk as { type?: string }).type === "tool-output-error"
+    ) as { errorText?: string } | undefined;
+    expect(toolError?.errorText).toBe(TOOL_FAILED_MESSAGE);
+    expect(collectText(turn.chunks)).toBe("Rate limited — the retries all land in one window.");
+
+    await new Promise((r) => setTimeout(r, 30));
+
+    // And nothing tells the user the turn didn't finish, because it did.
+    const stored = history();
+    expect(stored.find((message) => message.id === turnFailureMessageId(0))).toBeUndefined();
+    expect(JSON.stringify(stored)).not.toContain(TURN_FAILED_MESSAGE);
+    // The tool's own words never reach the transcript either.
+    expect(JSON.stringify(stored)).not.toContain("fingerprint");
+  });
 });
 
 // Back-compat: resumed chats replay their original metadata shape.

internal-packages/dashboard-agent/src/dashboard-agent.ts

@@ -88,6 +88,14 @@ export {
 export const TURN_FAILED_MESSAGE =
   "Something went wrong on my side, so that turn didn't finish. Ask again and I'll pick it up.";
 
+/**
+ * What one failed tool call leaves behind. The panel shows it verbatim on the call,
+ * so it stays one clause and what to do next is the system prompt's job; the turn
+ * itself is still alive, and saying it isn't would end a turn the model can still
+ * finish.
+ */
+export const TOOL_FAILED_MESSAGE = "That call failed and returned no data.";
+
 /** Stable per turn, so a re-run of the error path can't stack two records. */
 export function turnFailureMessageId(turn: number): string {
   return `turn-error:${turn}`;
@@ -391,15 +399,27 @@ export const dashboardAgent = chat.agent({
   idleTimeoutInSeconds: 60,
 
   uiMessageStreamOptions: {
-    // The stream carries the same sentence the transcript keeps, so the live chunk
-    // and the stored record never disagree. The provider's own message is logged
-    // here and goes no further.
+    /**
+     * Called for a failed TOOL CALL as well as a failed stream, and what it returns
+     * is both what the panel shows and what the model reads back as that call's
+     * result. Only `run`'s own `onError` sees a stream failure, and it has already
+     * run by the time an error reaches here, so the flag is what tells the two
+     * apart: a call the model can recover from must neither claim the turn is over
+     * nor be the only thing the model is told about it.
+     *
+     * For a turn failure the stream carries the same sentence the transcript keeps,
+     * so the live chunk and the stored record never disagree. Either way the
+     * provider's — or the tool's — own message is logged here and goes no further.
+     */
     onError: (error) => {
-      locals.set(turnErroredKey, true);
-      logger.error("dashboard-agent turn failed", {
+      if (locals.get(turnErroredKey) === true) return TURN_FAILED_MESSAGE;
+      // A tool's exception is swallowed into that call's result, so this is the only
+      // place it is ever visible.
+      logger.error("dashboard-agent tool call failed", {
         error: error instanceof Error ? error.message : String(error),
+        stack: error instanceof Error ? error.stack : undefined,
       });
-      return TURN_FAILED_MESSAGE;
+      return TOOL_FAILED_MESSAGE;
     },
   },
 
@@ -616,6 +636,16 @@ export const dashboardAgent = chat.agent({
         resolveDashboardAgentModel(resolved.model ?? "anthropic:claude-sonnet-4-6"),
       messages,
       abortSignal: signal,
+      // Only a stream failure reaches here — a tool's own failure never does. That
+      // is what makes this the turn's error flag: a failed call the model then
+      // works around used to mark the whole turn failed and append the apology to
+      // a turn that had already answered.
+      onError: ({ error }) => {
+        locals.set(turnErroredKey, true);
+        logger.error("dashboard-agent turn failed", {
+          error: error instanceof Error ? error.message : String(error),
+        });
+      },
       prepareStep: stepCachePrepareStep(options) as never,
       // Per model call, so the head-start prefix and this one can be compared.
       onStepFinish: (finished) =>