fix(webchat): create dashboard sessions from New Chat

vincentkoc · vincentkoc · commit 609743c47116 · 2026-04-28T18:21:12.000Z
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -12,6 +12,7 @@ Docs: https://docs.openclaw.ai
 
 ### Fixes
 
+- Control UI/WebChat: create a fresh dashboard session from the New Chat button instead of resetting the current transcript with `/new`, while keeping explicit `/new` reset behavior and preserving in-progress composer state when creation cannot safely switch sessions. Carries forward #52042 and #52746. Thanks @bobashopcashier.
 - CLI/plugins: use plugin metadata snapshots for install slot selection and add opt-in plugin lifecycle timing traces, so plugin install avoids runtime-loading the plugin registry for metadata-only decisions. Thanks @shakkernerd.
 - fix(plugins): restrict bundled plugin dir resolution to trusted package roots. (#73275) Thanks @pgondhi987.
 - fix(security): prevent workspace PATH injection via service env and trash helpers. (#73264) Thanks @pgondhi987.
diff --git a/ui/src/ui/app-render.helpers.node.test.ts b/ui/src/ui/app-render.helpers.node.test.ts
@@ -1,16 +1,18 @@
 // @vitest-environment node
-import { describe, expect, it, vi } from "vitest";
+import { beforeEach, describe, expect, it, vi } from "vitest";
 const {
   refreshChatMock,
   refreshChatAvatarMock,
   refreshSlashCommandsMock,
   loadChatHistoryMock,
+  createSessionAndRefreshMock,
   loadSessionsMock,
 } = vi.hoisted(() => ({
   refreshChatMock: vi.fn(),
   refreshChatAvatarMock: vi.fn(),
   refreshSlashCommandsMock: vi.fn(),
   loadChatHistoryMock: vi.fn(),
+  createSessionAndRefreshMock: vi.fn(),
   loadSessionsMock: vi.fn(),
 }));
 
@@ -28,10 +30,12 @@ vi.mock("./controllers/chat.ts", () => ({
 }));
 
 vi.mock("./controllers/sessions.ts", () => ({
+  createSessionAndRefresh: createSessionAndRefreshMock,
   loadSessions: loadSessionsMock,
 }));
 
 import {
+  createChatSession,
   isCronSessionKey,
   parseSessionKey,
   resolveAssistantAttachmentAuthToken,
@@ -44,6 +48,15 @@ import type { SessionsListResult } from "./types.ts";
 
 type SessionRow = SessionsListResult["sessions"][number];
 
+beforeEach(() => {
+  refreshChatMock.mockReset();
+  refreshChatAvatarMock.mockReset();
+  refreshSlashCommandsMock.mockReset();
+  loadChatHistoryMock.mockReset();
+  createSessionAndRefreshMock.mockReset();
+  loadSessionsMock.mockReset();
+});
+
 function row(overrides: Partial<SessionRow> & { key: string }): SessionRow {
   return { kind: "direct", updatedAt: 0, ...overrides };
 }
@@ -90,6 +103,53 @@ function createSettings(): AppViewState["settings"] {
   };
 }
 
+function createChatSessionState(overrides: Partial<AppViewState> = {}) {
+  const settings = createSettings();
+  const state = {
+    sessionKey: "agent:ops:main",
+    chatMessage: "draft prompt",
+    chatAttachments: [{ id: "att-1", mimeType: "image/png", dataUrl: "data:image/png;base64,AAA" }],
+    chatMessages: [{ role: "assistant", content: "old" }],
+    chatToolMessages: [{ id: "tool-1" }],
+    chatStreamSegments: [],
+    chatThinkingLevel: null,
+    chatStream: null,
+    chatSideResult: null,
+    lastError: null,
+    compactionStatus: null,
+    fallbackStatus: null,
+    chatAvatarUrl: null,
+    chatAvatarSource: null,
+    chatAvatarStatus: null,
+    chatAvatarReason: null,
+    chatQueue: [],
+    chatRunId: null,
+    chatSending: false,
+    chatLoading: false,
+    chatSideResultTerminalRuns: new Set<string>(),
+    chatStreamStartedAt: null,
+    connected: true,
+    client: { request: vi.fn() },
+    sessionsResult: {
+      ts: 0,
+      path: "",
+      count: 1,
+      defaults: { modelProvider: "openai", model: "gpt-5", contextTokens: null },
+      sessions: [row({ key: "agent:ops:main" })],
+    },
+    settings,
+    applySettings(next: typeof settings) {
+      state.settings = next;
+    },
+    loadAssistantIdentity: vi.fn(),
+    resetToolStream: vi.fn(),
+    resetChatScroll: vi.fn(),
+    resetChatInputHistoryNavigation: vi.fn(),
+    ...overrides,
+  } as unknown as AppViewState;
+  return state;
+}
+
 /* ================================================================
  *  parseSessionKey – low-level key → type / fallback mapping
  * ================================================================ */
@@ -493,6 +553,73 @@ describe("resolveSessionOptionGroups", () => {
   });
 });
 
+describe("createChatSession", () => {
+  it("creates a dashboard session, switches to it, and preserves the current composer", async () => {
+    const state = createChatSessionState();
+    createSessionAndRefreshMock.mockResolvedValue("agent:ops:dashboard:new-chat");
+    refreshChatAvatarMock.mockResolvedValue(undefined);
+    refreshSlashCommandsMock.mockResolvedValue(undefined);
+    loadChatHistoryMock.mockResolvedValue(undefined);
+    loadSessionsMock.mockResolvedValue(undefined);
+
+    await createChatSession(state);
+
+    expect(createSessionAndRefreshMock).toHaveBeenCalledWith(
+      state,
+      {
+        agentId: "ops",
+        parentSessionKey: "agent:ops:main",
+      },
+      {
+        activeMinutes: 0,
+        limit: 0,
+        includeGlobal: true,
+        includeUnknown: true,
+      },
+    );
+    expect(state.sessionKey).toBe("agent:ops:dashboard:new-chat");
+    expect(state.settings.sessionKey).toBe("agent:ops:dashboard:new-chat");
+    expect(state.chatMessage).toBe("draft prompt");
+    expect(state.chatAttachments).toEqual([
+      { id: "att-1", mimeType: "image/png", dataUrl: "data:image/png;base64,AAA" },
+    ]);
+    expect(state.chatMessages).toEqual([]);
+    expect(loadChatHistoryMock).toHaveBeenCalledWith(state);
+  });
+
+  it("ignores a stale create response after the active session changes", async () => {
+    const state = createChatSessionState();
+    createSessionAndRefreshMock.mockImplementation(async () => {
+      state.sessionKey = "agent:ops:other";
+      return "agent:ops:dashboard:new-chat";
+    });
+
+    await createChatSession(state);
+
+    expect(state.sessionKey).toBe("agent:ops:other");
+    expect(state.chatMessage).toBe("draft prompt");
+    expect(state.chatMessages).toEqual([{ role: "assistant", content: "old" }]);
+    expect(loadChatHistoryMock).not.toHaveBeenCalled();
+  });
+
+  it("does not create or switch while a run is active", async () => {
+    const state = createChatSessionState({
+      chatRunId: "run-1",
+      chatQueue: [{ id: "queued-1", text: "follow up", createdAt: 1 }],
+    });
+
+    await createChatSession(state);
+
+    expect(createSessionAndRefreshMock).not.toHaveBeenCalled();
+    expect(state.sessionKey).toBe("agent:ops:main");
+    expect(state.chatMessage).toBe("draft prompt");
+    expect(state.chatQueue).toEqual([{ id: "queued-1", text: "follow up", createdAt: 1 }]);
+    expect(state.lastError).toBe(
+      "Start a new session after the active run or queued messages finish.",
+    );
+  });
+});
+
 describe("switchChatSession", () => {
   it("refreshes the chat avatar after clearing session-scoped state", async () => {
     const settings = createSettings();
diff --git a/ui/src/ui/app-render.helpers.ts b/ui/src/ui/app-render.helpers.ts
@@ -14,10 +14,10 @@ import {
 import { refreshSlashCommands } from "./chat/slash-commands.ts";
 import { resolveControlUiAuthToken } from "./control-ui-auth.ts";
 import { ChatState, loadChatHistory } from "./controllers/chat.ts";
-import { loadSessions } from "./controllers/sessions.ts";
+import { createSessionAndRefresh, loadSessions } from "./controllers/sessions.ts";
 import { icons } from "./icons.ts";
 import { iconForTab, pathForTab, titleForTab, type Tab } from "./navigation.ts";
-import { parseAgentSessionKey } from "./session-key.ts";
+import { parseAgentSessionKey, resolveAgentIdFromSessionKey } from "./session-key.ts";
 import { normalizeOptionalString } from "./string-coerce.ts";
 import type { ThemeMode } from "./theme.ts";
 import type { SessionsListResult } from "./types.ts";
@@ -98,6 +98,16 @@ function resetChatStateForSessionSwitch(state: AppViewState, sessionKey: string)
   });
 }
 
+function canSwitchToNewChatSession(state: AppViewState): boolean {
+  return (
+    !state.chatLoading &&
+    !state.chatSending &&
+    !state.chatRunId &&
+    state.chatStream === null &&
+    state.chatQueue.length === 0
+  );
+}
+
 export function renderTab(state: AppViewState, tab: Tab, opts?: { collapsed?: boolean }) {
   const href = pathForTab(tab, state.basePath);
   const isActive = state.tab === tab;
@@ -547,6 +557,53 @@ export function switchChatSession(state: AppViewState, nextSessionKey: string) {
   void refreshSessionOptions(state);
 }
 
+export async function createChatSession(state: AppViewState) {
+  if (!state.client || !state.connected) {
+    return;
+  }
+  if (!canSwitchToNewChatSession(state)) {
+    state.lastError = "Start a new session after the active run or queued messages finish.";
+    return;
+  }
+
+  state.lastError = null;
+  const previousSessionKey = state.sessionKey;
+  const preservedDraft = state.chatMessage;
+  const preservedAttachments = state.chatAttachments;
+  const parentSessionKey = state.sessionsResult?.sessions.some(
+    (row) => row.key === previousSessionKey,
+  )
+    ? previousSessionKey
+    : undefined;
+  const nextSessionKey = await createSessionAndRefresh(
+    state as unknown as Parameters<typeof createSessionAndRefresh>[0],
+    {
+      agentId: resolveAgentIdFromSessionKey(previousSessionKey),
+      parentSessionKey,
+    },
+    {
+      activeMinutes: 0,
+      limit: 0,
+      includeGlobal: true,
+      includeUnknown: true,
+    },
+  );
+  if (
+    !nextSessionKey ||
+    state.sessionKey !== previousSessionKey ||
+    !canSwitchToNewChatSession(state)
+  ) {
+    if (!nextSessionKey && state.sessionsError) {
+      state.lastError = state.sessionsError;
+    }
+    return;
+  }
+
+  switchChatSession(state, nextSessionKey);
+  state.chatMessage = preservedDraft;
+  state.chatAttachments = preservedAttachments;
+}
+
 async function refreshSessionOptions(state: AppViewState) {
   await loadSessions(state as unknown as Parameters<typeof loadSessions>[0], {
     activeMinutes: 0,
diff --git a/ui/src/ui/app-render.ts b/ui/src/ui/app-render.ts
@@ -12,6 +12,7 @@ import {
   resolveAssistantAttachmentAuthToken,
   renderSidebarConnectionStatus,
   renderTopbarThemeModeToggle,
+  createChatSession,
   switchChatSession,
 } from "./app-render.helpers.ts";
 import { warnQueryToken } from "./app-settings.ts";
@@ -2357,8 +2358,7 @@ export function renderApp(state: AppViewState) {
               onDismissSideResult: () => {
                 state.chatSideResult = null;
               },
-              onNewSession: () =>
-                state.handleSendChat("/new", { confirmReset: true, restoreDraft: true }),
+              onNewSession: () => void createChatSession(state),
               onClearHistory: async () => {
                 if (!state.client || !state.connected) {
                   return;
diff --git a/ui/src/ui/controllers/sessions.test.ts b/ui/src/ui/controllers/sessions.test.ts
@@ -1,6 +1,7 @@
 import { afterEach, describe, expect, it, vi } from "vitest";
 import {
   applySessionsChangedEvent,
+  createSessionAndRefresh,
   deleteSessionsAndRefresh,
   loadSessions,
   subscribeSessions,
@@ -53,6 +54,72 @@ describe("subscribeSessions", () => {
   });
 });
 
+describe("createSessionAndRefresh", () => {
+  it("creates a dashboard session and refreshes the session list", async () => {
+    const request = vi.fn(async (method: string) => {
+      if (method === "sessions.create") {
+        return { key: "agent:main:dashboard:abc" };
+      }
+      if (method === "sessions.list") {
+        return {
+          ts: 2,
+          path: "(multiple)",
+          count: 1,
+          defaults: {},
+          sessions: [{ key: "agent:main:dashboard:abc", kind: "direct", updatedAt: 2 }],
+        };
+      }
+      throw new Error(`unexpected method: ${method}`);
+    });
+    const state = createState(request);
+
+    const key = await createSessionAndRefresh(
+      state,
+      { agentId: "main", parentSessionKey: "agent:main:main" },
+      { activeMinutes: 0, limit: 0, includeGlobal: true, includeUnknown: true },
+    );
+
+    expect(key).toBe("agent:main:dashboard:abc");
+    expect(request).toHaveBeenNthCalledWith(1, "sessions.create", {
+      agentId: "main",
+      parentSessionKey: "agent:main:main",
+    });
+    expect(request).toHaveBeenNthCalledWith(2, "sessions.list", {
+      includeGlobal: true,
+      includeUnknown: true,
+    });
+    expect(state.sessionsResult?.sessions[0]?.key).toBe("agent:main:dashboard:abc");
+    expect(state.sessionsLoading).toBe(false);
+  });
+
+  it("keeps the current state when create does not return a key", async () => {
+    const request = vi.fn(async (method: string) => {
+      if (method === "sessions.create") {
+        return {};
+      }
+      throw new Error(`unexpected method: ${method}`);
+    });
+    const state = createState(request);
+
+    const key = await createSessionAndRefresh(state);
+
+    expect(key).toBeNull();
+    expect(state.sessionsError).toBe("Error: sessions.create returned no key");
+    expect(state.sessionsLoading).toBe(false);
+    expect(request).toHaveBeenCalledTimes(1);
+  });
+
+  it("does not start a create mutation while sessions are loading", async () => {
+    const request = vi.fn(async () => ({ key: "agent:main:dashboard:abc" }));
+    const state = createState(request, { sessionsLoading: true });
+
+    const key = await createSessionAndRefresh(state);
+
+    expect(key).toBeNull();
+    expect(request).not.toHaveBeenCalled();
+  });
+});
+
 describe("deleteSessionsAndRefresh", () => {
   it("deletes multiple sessions and refreshes", async () => {
     const request = vi.fn(async (method: string) => {
diff --git a/ui/src/ui/controllers/sessions.ts b/ui/src/ui/controllers/sessions.ts
