fix(webapp): keep an empty chat open instead of showing a new one

Selecting a stored chat with no messages dropped you into a fresh draft,
as if the chat had been deleted.

Author: kathiekiwi

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

@@ -20,6 +20,7 @@ import type { TurnActivity } from "./DashboardAgentMessages";
 import { DashboardAgentHeader } from "./DashboardAgentHeader";
 import type { DashboardAgentChat as DashboardAgentChatListItem } from "./DashboardAgentHistory";
 import type { SuggestedPrompt } from "@internal/dashboard-agent-contracts";
+import { resolveOpenedChat, type OpenedChatResponse } from "./opened-chat";
 import type { AgentPageContext } from "./page-context-types";
 import { agentPageLabel } from "./page-label";
 import { AgentPanelColumn } from "./panel-layout";
@@ -158,27 +159,10 @@ export function DashboardAgentPanel({
           console.error(`Dashboard agent: failed to open chat ${id} (${res.status})`);
           toast.error("We couldn't open that chat. Try again in a moment.");
         }
-        const data = res.ok
-          ? ((await res.json()) as {
-              messages?: UIMessage[];
-              session?: { publicAccessToken: string; lastEventId: string | null } | null;
-            })
-          : { messages: [], session: null };
+        const data = res.ok ? ((await res.json()) as OpenedChatResponse) : undefined;
         if (seq !== openChatRequestSeq.current) return;
-        if (data.messages && data.messages.length > 0) {
-          setActive({
-            chatId: id,
-            messages: data.messages,
-            session: data.session?.publicAccessToken
-              ? {
-                  publicAccessToken: data.session.publicAccessToken,
-                  lastEventId: data.session.lastEventId ?? undefined,
-                }
-              : null,
-          });
-        } else {
-          setActive(null);
-        }
+        const opened = resolveOpenedChat(id, data);
+        setActive(opened.kind === "gone" ? null : opened);
       } catch (error) {
         console.error(`Dashboard agent: failed to open chat ${id}`, error);
         toast.error("We couldn't open that chat. Try again in a moment.");

apps/webapp/app/components/dashboard-agent/opened-chat.test.ts

@@ -0,0 +1,57 @@
+import type { UIMessage } from "@ai-sdk/react";
+import { describe, expect, it } from "vitest";
+import { resolveOpenedChat } from "./opened-chat";
+
+const CHAT_ID = "chat_abc123";
+
+const message: UIMessage = {
+  id: "msg_1",
+  role: "user",
+  parts: [{ type: "text", text: "why did this run fail?" }],
+};
+
+describe("resolveOpenedChat", () => {
+  it("opens a chat that has messages", () => {
+    const opened = resolveOpenedChat(CHAT_ID, { messages: [message], session: null });
+
+    expect(opened).toEqual({ kind: "chat", chatId: CHAT_ID, messages: [message], session: null });
+  });
+
+  it("still opens a chat that exists but has no messages", () => {
+    const opened = resolveOpenedChat(CHAT_ID, { messages: [], session: null });
+
+    expect(opened.kind).toBe("chat");
+    expect(opened).toEqual({ kind: "chat", chatId: CHAT_ID, messages: [], session: null });
+  });
+
+  it("treats a chat with no messages field the same way", () => {
+    expect(resolveOpenedChat(CHAT_ID, {}).kind).toBe("chat");
+  });
+
+  it("reports a chat the server would not return as gone", () => {
+    expect(resolveOpenedChat(CHAT_ID, undefined)).toEqual({ kind: "gone" });
+  });
+
+  it("carries the session through, dropping a null last event id", () => {
+    const opened = resolveOpenedChat(CHAT_ID, {
+      messages: [message],
+      session: { publicAccessToken: "pat_1", lastEventId: null },
+    });
+
+    expect(opened).toMatchObject({ session: { publicAccessToken: "pat_1" } });
+    expect(opened.kind === "chat" && opened.session?.lastEventId).toBeUndefined();
+  });
+
+  it("keeps a last event id when there is one", () => {
+    const opened = resolveOpenedChat(CHAT_ID, {
+      messages: [],
+      session: { publicAccessToken: "pat_1", lastEventId: "evt_9" },
+    });
+
+    expect(opened).toMatchObject({ session: { publicAccessToken: "pat_1", lastEventId: "evt_9" } });
+  });
+
+  it("has no session when the token is missing", () => {
+    expect(resolveOpenedChat(CHAT_ID, { messages: [message] })).toMatchObject({ session: null });
+  });
+});

apps/webapp/app/components/dashboard-agent/opened-chat.ts

@@ -0,0 +1,37 @@
+import type { UIMessage } from "@ai-sdk/react";
+
+export type OpenedChatResponse = {
+  messages?: UIMessage[];
+  session?: { publicAccessToken: string; lastEventId: string | null } | null;
+};
+
+export type OpenedChat =
+  | {
+      kind: "chat";
+      chatId: string;
+      messages: UIMessage[];
+      session: { publicAccessToken: string; lastEventId?: string } | null;
+    }
+  // Deleted, or belonging to someone else: the read failed, so there is no chat to show.
+  | { kind: "gone" };
+
+/** An empty transcript is still a chat, so only a failed read drops you into a new one. */
+export function resolveOpenedChat(
+  chatId: string,
+  response: OpenedChatResponse | undefined
+): OpenedChat {
+  if (!response) return { kind: "gone" };
+
+  const session = response.session;
+  return {
+    kind: "chat",
+    chatId,
+    messages: response.messages ?? [],
+    session: session?.publicAccessToken
+      ? {
+          publicAccessToken: session.publicAccessToken,
+          lastEventId: session.lastEventId ?? undefined,
+        }
+      : null,
+  };
+}