chore: merge feat/dashboard-agent-ui (review fixes round 3)

Author: kathiekiwi

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

@@ -2,6 +2,7 @@ import { ArrowUpIcon, StopIcon } from "@heroicons/react/20/solid";
 import { useEffect, useRef } from "react";
 import { Button } from "~/components/primitives/Buttons";
 import { cn } from "~/utils/cn";
+import { composerKeepsEscape } from "./composer-escape";
 import {
   MAX_MESSAGE_CHARS,
   MESSAGE_CHARS_WARN_AT,
@@ -95,6 +96,10 @@ export function DashboardAgentComposer({
                 e.preventDefault();
                 onSubmit();
               }
+              // Keeping Escape from the panel's close handler, which skips a prevented event.
+              if (e.key === "Escape" && composerKeepsEscape(value)) {
+                e.preventDefault();
+              }
               // Only while empty, so with text present Tab keeps its normal focus behavior.
               if (e.key === "Tab" && !e.shiftKey && placeholderSuggestion && value === "") {
                 e.preventDefault();

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

@@ -45,6 +45,8 @@ export type DashboardAgentMessagesProps = {
 
 // Cached so a stripped message keeps its identity across renders and memoization holds:
 // rebuilding it re-renders every tool-calling turn on each streamed token.
+// Relies on @ai-sdk/react cloning a message per update: an SDK mutating one in place would
+// keep serving the cached copy of its earlier state.
 const strippedMessages = new WeakMap<UIMessage, UIMessage>();
 
 export function stripStepParts(message: UIMessage): UIMessage {

apps/webapp/app/components/dashboard-agent/composer-escape.test.ts

@@ -0,0 +1,16 @@
+import { describe, expect, it } from "vitest";
+import { composerKeepsEscape } from "./composer-escape";
+
+describe("Escape while the composer has focus", () => {
+  it("is kept by the composer while there is a draft, so the panel stays open", () => {
+    expect(composerKeepsEscape("half a question about a failing run")).toBe(true);
+  });
+
+  it("closes the panel when there is nothing to lose", () => {
+    expect(composerKeepsEscape("")).toBe(false);
+  });
+
+  it("reads whitespace as nothing to lose, matching what Send accepts", () => {
+    expect(composerKeepsEscape("  \n ")).toBe(false);
+  });
+});

apps/webapp/app/components/dashboard-agent/composer-escape.ts

@@ -0,0 +1,8 @@
+/**
+ * The panel closes on Escape unless a child has already prevented the event's default —
+ * `defaultPrevented` is how a child vetoes the close. A composer holding a draft takes the
+ * first Escape for itself, so the draft survives; an empty one lets Escape close the panel.
+ */
+export function composerKeepsEscape(value: string): boolean {
+  return value.trim() !== "";
+}

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

@@ -239,6 +239,36 @@ describe("an already-open panel when a turn is exhausted", () => {
     expect(reads).toBe(2);
   });
 
+  it("keeps re-reading a stream that died mid-tool with no card open", async () => {
+    // No investigation anywhere: only the dangling `get_report` says the turn is unfinished.
+    const DANGLING = {
+      id: "msg_step",
+      role: "assistant",
+      parts: [{ type: "tool-get_report", toolCallId: "call_1", state: "input-available" }],
+    };
+    const FINISHED = {
+      id: "msg_step",
+      role: "assistant",
+      parts: [
+        { type: "tool-get_report", toolCallId: "call_1", state: "output-available", output: {} },
+      ],
+    };
+
+    const responses = [[DANGLING], [DANGLING], [FINISHED]];
+    let rendered: (typeof DANGLING)[] = [DANGLING];
+    let reads = 0;
+
+    await pollSettledTranscript({
+      fetchTranscript: async () => responses[reads++] ?? null,
+      apply: (merge) => void (rendered = merge(rendered)),
+      wait: async () => {},
+    });
+
+    expect(reads).toBe(3);
+    expect(rendered).toEqual([FINISHED]);
+    expect(transcriptLooksUnfinished(rendered)).toBe(false);
+  });
+
   it("stops on a failed re-read instead of hammering the endpoint", async () => {
     let reads = 0;
     await pollSettledTranscript<typeof OPEN>({

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

@@ -86,8 +86,9 @@ export async function pollSettledTranscript<T extends Identified>(deps: {
     const fetched = await deps.fetchTranscript();
     if (!fetched) return;
     deps.apply((current) => mergeSettledMessages(current, fetched));
-    // The stored transcript is the authority on whether anything is still open.
-    if (!hasOpenInvestigation(fetched)) return;
+    // The stored transcript is the authority on whether anything is still open. Same test that
+    // starts the poll, so a stream that died mid-tool is followed until it settles too.
+    if (!transcriptLooksUnfinished(fetched)) return;
   }
 }