fix(webapp): undo a new agent chat only when its start never got anywhere

A start that rejects dispatched no handover and sent no message, so the chat
row is taken back. A failed access-token mint is left alone: the session is
live by then and removing the chat would hide a running agent.

Author: kathiekiwi

apps/webapp/app/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.dashboard-agent.ts

@@ -262,33 +262,59 @@ export const action = async ({ request, params }: ActionFunctionArgs) => {
         ...(clientData ? { metadata: { context: clientContext } } : {}),
       });
 
-      if (headStartMetadata) {
-        // Injects the delegated token and context into the run's payload server-side.
-        await startDashboardAgentHeadStart({
-          chatId,
-          messages: [firstMessage],
-          mode: repoSnapshot ? "code" : "assistant",
-          metadata: headStartMetadata,
-        });
-      } else {
-        // Cold start: the client sends the first message through the `in` proxy, which
-        // injects the token.
-        // Same server-owned identity the head-start path injects; the `in` proxy adds the
-        // delegated token on the first turn.
-        await startDashboardAgentSession({
-          chatId,
-          clientData: {
-            ...clientContext,
-            organizationId: project.organizationId,
-            userId,
-            projectId: project.id,
-            environmentId: runtimeEnv.id,
-            environmentName,
-          },
+      try {
+        if (headStartMetadata) {
+          // Injects the delegated token and context into the run's payload server-side.
+          await startDashboardAgentHeadStart({
+            chatId,
+            messages: [firstMessage],
+            mode: repoSnapshot ? "code" : "assistant",
+            metadata: headStartMetadata,
+          });
+        } else {
+          // Cold start: the client sends the first message through the `in` proxy, which
+          // injects the token.
+          // Same server-owned identity the head-start path injects; the `in` proxy adds the
+          // delegated token on the first turn.
+          await startDashboardAgentSession({
+            chatId,
+            clientData: {
+              ...clientContext,
+              organizationId: project.organizationId,
+              userId,
+              projectId: project.id,
+              environmentId: runtimeEnv.id,
+              environmentName,
+            },
+          });
+        }
+      } catch (error) {
+        // Both starts are one create-session-and-trigger round trip, so a rejection means no
+        // handover was dispatched and no message was sent: a session the call did create in
+        // spite of the error idles out having done nothing. The empty row is all there is to undo.
+        // Swallowed so the start's own error is what surfaces and gets logged.
+        await softDeleteChat(dashboardAgentDb, { chatId, userId }).catch((cleanupError) => {
+          logger.error("Failed to remove a dashboard agent chat whose start failed", {
+            chatId,
+            error: cleanupError,
+          });
         });
+        throw error;
       }
 
-      const publicAccessToken = await mintDashboardAgentToken(chatId);
+      let publicAccessToken: string;
+      try {
+        publicAccessToken = await mintDashboardAgentToken(chatId);
+      } catch (error) {
+        // The start resolved, so the session is live and a head start is already streaming into
+        // it. Deleting the chat here would hide a running agent; the client can ask for a token
+        // again through the `token` intent.
+        logger.error("Dashboard agent chat started but its token mint failed", { chatId, error });
+        return json(
+          { error: "The dashboard agent started but couldn't be opened. Try opening it again." },
+          { status: 500 }
+        );
+      }
       return json({ chatId, publicAccessToken, headStarted });
     } catch (error) {
       logger.error("Failed to create dashboard agent chat", { chatId, error });

apps/webapp/test/dashboardAgentCreateChatOrdering.test.ts

@@ -4,13 +4,20 @@ const mocks = vi.hoisted(() => ({
   createChat: vi.fn(),
   findEnvironmentBySlug: vi.fn(),
   mintUserActorToken: vi.fn(),
+  mintPublicToken: vi.fn(),
   headStart: vi.fn(),
+  startSession: vi.fn(),
+  softDeleteChat: vi.fn(),
+  logger: { debug: vi.fn(), error: vi.fn(), warn: vi.fn(), info: vi.fn() },
+  // Mutable so a test can take the head start away and drive the cold path.
+  env: { SESSION_SECRET: "test-session-secret", ANTHROPIC_API_KEY: "sk-test" } as Record<
+    string,
+    string | undefined
+  >,
 }));
 
 vi.mock("~/db.server", () => ({ $replica: {}, prisma: {} }));
-vi.mock("~/env.server", () => ({
-  env: { SESSION_SECRET: "test-session-secret", ANTHROPIC_API_KEY: "sk-test" },
-}));
+vi.mock("~/env.server", () => ({ env: mocks.env }));
 vi.mock("~/services/session.server", () => ({
   requireUser: async () => ({ id: "usr_real", admin: false, isImpersonating: false }),
 }));
@@ -30,10 +37,10 @@ vi.mock("~/models/runtimeEnvironment.server", () => ({
 vi.mock("~/services/dashboardAgent.server", () => ({
   dashboardAgentApiOrigin: () => "https://api.trigger.dev",
   isDashboardAgentConfigured: () => true,
-  mintDashboardAgentToken: async () => "pat_public",
+  mintDashboardAgentToken: mocks.mintPublicToken,
   mintDashboardAgentUserActorToken: mocks.mintUserActorToken,
   resolveDashboardAgentRepoSnapshot: async () => null,
-  startDashboardAgentSession: async () => {},
+  startDashboardAgentSession: mocks.startSession,
 }));
 vi.mock("~/services/dashboardAgentHeadStart.server", () => ({
   startDashboardAgentHeadStart: mocks.headStart,
@@ -50,11 +57,9 @@ vi.mock("@internal/dashboard-agent-db", () => ({
   listChats: vi.fn(),
   renameChat: vi.fn(),
   setChatPinned: vi.fn(),
-  softDeleteChat: vi.fn(),
-}));
-vi.mock("~/services/logger.server", () => ({
-  logger: { debug: vi.fn(), error: vi.fn(), warn: vi.fn(), info: vi.fn() },
+  softDeleteChat: mocks.softDeleteChat,
 }));
+vi.mock("~/services/logger.server", () => ({ logger: mocks.logger }));
 
 import { action } from "~/routes/resources.orgs.$organizationSlug.projects.$projectParam.env.$envParam.dashboard-agent";
 
@@ -86,6 +91,10 @@ describe("dashboard agent chat creation — nothing fallible after the row exist
       .mockReset()
       .mockResolvedValue({ id: "env_real", type: "DEVELOPMENT" });
     mocks.mintUserActorToken.mockReset().mockResolvedValue("tr_uat_real");
+    mocks.mintPublicToken.mockReset().mockResolvedValue("pat_public");
+    mocks.startSession.mockReset().mockResolvedValue(undefined);
+    mocks.softDeleteChat.mockReset().mockResolvedValue({ deleted: true, cancelledWatches: [] });
+    mocks.env.ANTHROPIC_API_KEY = "sk-test";
   });
 
   it("creates no chat when the environment slug resolves to nothing", async () => {
@@ -97,7 +106,7 @@ describe("dashboard agent chat creation — nothing fallible after the row exist
     expect(mocks.createChat).not.toHaveBeenCalled();
   });
 
-  it("creates no chat when the token mint fails", async () => {
+  it("creates no chat when the delegated token mint fails", async () => {
     mocks.mintUserActorToken.mockRejectedValue(new Error("signing key unavailable"));
 
     const response = await createChatRequest();
@@ -118,5 +127,83 @@ describe("dashboard agent chat creation — nothing fallible after the row exist
       environmentId: "env_real",
       environmentName: "dev",
     });
+    expect(mocks.softDeleteChat).not.toHaveBeenCalled();
+  });
+});
+
+// A failed start means no handover was dispatched and no message was sent, so any session it
+// did create idles out having done nothing — the chat row is safe to take back. Once the start
+// has resolved the session is live, and removing the chat would hide a running agent.
+describe("dashboard agent chat creation — a start that fails part way", () => {
+  beforeEach(() => {
+    mocks.createChat.mockReset().mockResolvedValue(undefined);
+    mocks.headStart.mockReset().mockResolvedValue(undefined);
+    mocks.findEnvironmentBySlug
+      .mockReset()
+      .mockResolvedValue({ id: "env_real", type: "DEVELOPMENT" });
+    mocks.mintUserActorToken.mockReset().mockResolvedValue("tr_uat_real");
+    mocks.mintPublicToken.mockReset().mockResolvedValue("pat_public");
+    mocks.startSession.mockReset().mockResolvedValue(undefined);
+    mocks.softDeleteChat.mockReset().mockResolvedValue({ deleted: true, cancelledWatches: [] });
+    mocks.env.ANTHROPIC_API_KEY = "sk-test";
+    mocks.logger.error.mockReset();
+  });
+
+  it("takes the chat back when the head start fails", async () => {
+    mocks.headStart.mockRejectedValue(new Error("session create failed"));
+
+    const response = await createChatRequest();
+
+    expect(response.status).toBe(500);
+    expect(mocks.createChat).toHaveBeenCalledTimes(1);
+    expect(mocks.softDeleteChat).toHaveBeenCalledTimes(1);
+    expect(mocks.softDeleteChat.mock.calls[0][1]).toMatchObject({
+      chatId: mocks.createChat.mock.calls[0][1].id,
+      userId: "usr_real",
+    });
+  });
+
+  it("takes the chat back when the cold start fails", async () => {
+    mocks.env.ANTHROPIC_API_KEY = undefined;
+    mocks.startSession.mockRejectedValue(new Error("session create failed"));
+
+    const response = await createChatRequest();
+
+    expect(response.status).toBe(500);
+    expect(mocks.createChat).toHaveBeenCalledTimes(1);
+    expect(mocks.softDeleteChat).toHaveBeenCalledTimes(1);
+  });
+
+  it("keeps the chat when the session is live and only its access token failed", async () => {
+    mocks.mintPublicToken.mockRejectedValue(new Error("token mint failed"));
+
+    const response = await createChatRequest();
+
+    expect(response.status).toBe(500);
+    expect(mocks.headStart).toHaveBeenCalledTimes(1);
+    expect(mocks.createChat).toHaveBeenCalledTimes(1);
+    expect(mocks.softDeleteChat).not.toHaveBeenCalled();
+  });
+
+  it("keeps the chat when a cold-started session's access token failed", async () => {
+    mocks.env.ANTHROPIC_API_KEY = undefined;
+    mocks.mintPublicToken.mockRejectedValue(new Error("token mint failed"));
+
+    const response = await createChatRequest();
+
+    expect(response.status).toBe(500);
+    expect(mocks.startSession).toHaveBeenCalledTimes(1);
+    expect(mocks.softDeleteChat).not.toHaveBeenCalled();
+  });
+
+  it("surfaces the start's own failure when taking the chat back also fails", async () => {
+    mocks.headStart.mockRejectedValue(new Error("session create failed"));
+    mocks.softDeleteChat.mockRejectedValue(new Error("chat store unavailable"));
+
+    const response = await createChatRequest();
+
+    expect(response.status).toBe(500);
+    const logged = mocks.logger.error.mock.calls.map((call: any[]) => call[1]?.error?.message);
+    expect(logged).toContain("session create failed");
   });
 });