@nextclaw/ui 0.13.12 → 0.14.0

package/src/features/chat/managers/__tests__/chat-ui.manager.test.ts

@@ -0,0 +1,126 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { ChatUiManager } from '@/features/chat/managers/chat-ui.manager';
+import type { PanelAppEntryView } from '@/shared/lib/api';
+import type * as SharedApi from '@/shared/lib/api';
+
+const { listPanelAppsMock } = vi.hoisted(() => ({
+  listPanelAppsMock: vi.fn(),
+}));
+
+vi.mock('@/shared/lib/api', async (importOriginal) => {
+  const actual = await importOriginal<typeof SharedApi>();
+  return {
+    ...actual,
+    nextclawClient: {
+      panelApps: {
+        listPanelApps: listPanelAppsMock,
+      },
+    },
+  };
+});
+
+function createDocBrowserManager() {
+  return {
+    open: vi.fn(),
+    openTarget: vi.fn(),
+  };
+}
+
+function createPanelAppEntry(overrides: Partial<PanelAppEntryView> = {}): PanelAppEntryView {
+  return {
+    appId: 'reader',
+    clientDeclared: false,
+    clientGranted: false,
+    contentPath: '/api/panel-apps/encoded-reader/content',
+    createdAt: '2026-06-09T00:00:00.000Z',
+    favorite: false,
+    fileName: 'reader.panel',
+    id: 'encoded-reader',
+    kind: 'folder',
+    openCount: 0,
+    sizeBytes: 1024,
+    title: 'Reader',
+    updatedAt: '2026-06-09T00:00:00.000Z',
+    ...overrides,
+  };
+}
+
+describe('ChatUiManager content display', () => {
+  beforeEach(() => {
+    listPanelAppsMock.mockReset();
+    listPanelAppsMock.mockResolvedValue({ entries: [] });
+  });
+
+  it('shows URL content through DocBrowser', async () => {
+    const docBrowserManager = createDocBrowserManager();
+    const manager = new ChatUiManager(
+      docBrowserManager as unknown as ConstructorParameters<typeof ChatUiManager>[0],
+    );
+
+    await manager.showContent({
+      target: {
+        type: 'url',
+        payload: {
+          url: 'https://example.com/read',
+        },
+      },
+      title: 'Example URL',
+    });
+
+    expect(docBrowserManager.open).toHaveBeenCalledWith('https://example.com/read', {
+      title: 'Example URL',
+    });
+  });
+
+  it('opens a listed panel app as a managed DocBrowser target', async () => {
+    listPanelAppsMock.mockResolvedValue({
+      entries: [createPanelAppEntry()],
+    });
+    const docBrowserManager = createDocBrowserManager();
+    const manager = new ChatUiManager(
+      docBrowserManager as unknown as ConstructorParameters<typeof ChatUiManager>[0],
+    );
+
+    await manager.showContent({
+      target: {
+        type: 'panel_app',
+        payload: {
+          appId: 'reader',
+        },
+      },
+      title: 'Reader',
+    });
+
+    expect(docBrowserManager.openTarget).toHaveBeenCalledWith({
+      dedupeKey: 'panel-app:encoded-reader',
+      historyPolicy: 'managed',
+      kind: 'panel-app',
+      resourceUri: 'nextclaw://panel-app/encoded-reader',
+      title: 'Reader',
+      url: '/api/panel-apps/encoded-reader/content',
+    }, {
+      title: 'Reader',
+    });
+  });
+
+  it('falls back to the panel app resource URI when no listed entry matches', async () => {
+    const docBrowserManager = createDocBrowserManager();
+    const manager = new ChatUiManager(
+      docBrowserManager as unknown as ConstructorParameters<typeof ChatUiManager>[0],
+    );
+
+    await manager.showContent({
+      target: {
+        type: 'panel_app',
+        payload: {
+          appId: 'encoded-reader',
+        },
+      },
+      title: 'Reader',
+    });
+
+    expect(docBrowserManager.open).toHaveBeenCalledWith('nextclaw://panel-app/encoded-reader', {
+      title: 'Reader',
+    });
+  });
+});

package/src/features/chat/managers/{recent-selection.manager.test.ts → __tests__/recent-selection.manager.test.ts}

@@ -1,4 +1,4 @@
-import { RecentSelectionManager } from './recent-selection.manager';
+import { RecentSelectionManager } from '../recent-selection.manager';
 
 describe('RecentSelectionManager', () => {
   const storageKey = 'test.recent-selection-manager';

package/src/features/chat/managers/{ncp-chat-input.manager.ts → chat-input.manager.ts}

@@ -1,4 +1,5 @@
 import type { ChatComposerNode } from '@nextclaw/agent-chat-ui';
+import { isRuntimeDefaultModelValue } from '@nextclaw/shared';
 import type { NcpDraftAttachment } from '@nextclaw/ncp-react';
 import type { SetStateAction } from 'react';
 import type { ThinkingLevel } from '@/shared/lib/api';
@@ -12,24 +13,31 @@ import {
   pruneComposerAttachments,
   syncComposerAttachments,
   syncComposerSkills
-} from '@/features/chat/utils/chat-composer-state.utils';
+} from '@/features/chat/features/input/utils/chat-composer-state.utils';
 import { useChatInputStore } from '@/features/chat/stores/chat-input.store';
 import { useChatSessionListStore } from '@/features/chat/stores/chat-session-list.store';
 import { useChatThreadStore } from '@/features/chat/stores/chat-thread.store';
 import type { ChatInputSnapshot } from '@/features/chat/stores/chat-input.store';
-import type { ChatStreamActionsManager } from '@/features/chat/managers/chat-stream-actions.manager';
-import type { ChatUiManager } from '@/features/chat/managers/chat-ui.manager';
+import type { ChatRunManager } from '@/features/chat/managers/chat-run.manager';
 import type { ChatSessionListManager } from '@/features/chat/managers/chat-session-list.manager';
 import { ChatSessionPreferenceSync } from '@/features/chat/managers/chat-session-preference-sync.manager';
-import { isNcpChatSendDisabled } from '@/features/chat/utils/ncp-chat-input-availability.utils';
-import { isNcpChatRuntimeBlocked } from '@/features/chat/utils/ncp-chat-runtime-availability.utils';
+import { isNcpChatSendDisabled } from '@/features/chat/features/input/utils/ncp-chat-input-availability.utils';
+import { isNcpChatRuntimeBlocked } from '@/features/chat/features/runtime/utils/ncp-chat-runtime-availability.utils';
 import { chatRecentModelsManager } from '@/features/chat/managers/chat-recent-models.manager';
 import { chatRecentSkillsManager } from '@/features/chat/managers/chat-recent-skills.manager';
 import type { ChatModelOption } from '@/features/chat/types/chat-input.types';
-import { normalizeSessionType } from '@/features/chat/hooks/use-chat-session-type-state';
+import { normalizeSessionType } from '@/features/chat/features/session-type/utils/chat-session-type.utils';
 import { systemStatusManager } from '@/features/system-status';
+import { shouldClearPendingProjectRootOverride } from '@/features/chat/features/session/utils/chat-run-metadata.utils';
 
-export class NcpChatInputManager {
+function resolveModelForSend(value: string): string | undefined {
+  if (isRuntimeDefaultModelValue(value)) {
+    return undefined;
+  }
+  return value || undefined;
+}
+
+export class ChatInputManager {
   private readonly sessionPreferenceSync = new ChatSessionPreferenceSync(updateNcpSession);
 
   private buildAttachmentSignature = (attachment: NcpDraftAttachment): string =>
@@ -43,8 +51,7 @@ export class NcpChatInputManager {
     ].join(':');
 
   constructor(
-    private uiManager: ChatUiManager,
-    private streamActionsManager: ChatStreamActionsManager,
+    private chatRunManager: ChatRunManager,
     private sessionListManager: ChatSessionListManager
   ) {}
 
@@ -109,20 +116,78 @@ export class NcpChatInputManager {
   };
 
   syncSnapshot = (patch: Partial<ChatInputSnapshot>) => {
-    if (!this.hasSnapshotChanges(patch)) {
+    const current = useChatInputStore.getState().snapshot;
+    let resolvedPatch = patch;
+    if (
+      patch.defaultSessionType &&
+      current.selectedSessionType === undefined &&
+      patch.selectedSessionType === undefined
+    ) {
+      resolvedPatch = Object.assign({}, patch, {
+        selectedSessionType: patch.defaultSessionType,
+      });
+    }
+    if (!this.hasSnapshotChanges(resolvedPatch)) {
       return;
     }
-    useChatInputStore.getState().setSnapshot(patch);
+    useChatInputStore.getState().setSnapshot(resolvedPatch);
     if (
-      Object.prototype.hasOwnProperty.call(patch, 'modelOptions') ||
-      Object.prototype.hasOwnProperty.call(patch, 'selectedModel') ||
-      Object.prototype.hasOwnProperty.call(patch, 'selectedThinkingLevel')
+      Object.prototype.hasOwnProperty.call(resolvedPatch, 'modelOptions') ||
+      Object.prototype.hasOwnProperty.call(resolvedPatch, 'selectedModel') ||
+      Object.prototype.hasOwnProperty.call(resolvedPatch, 'selectedThinkingLevel')
     ) {
       const { selectedModel } = useChatInputStore.getState().snapshot;
       this.reconcileThinkingForModel(selectedModel);
     }
   };
 
+  resolveProjectRootForSend = (params: {
+    sessionKey: string | null | undefined;
+    selectedSessionProjectRoot: string | null | undefined;
+  }): string | null => {
+    const { pendingProjectRoot, pendingProjectRootSessionKey } =
+      useChatInputStore.getState().snapshot;
+    if (
+      pendingProjectRoot !== null &&
+      (!params.sessionKey || params.sessionKey === pendingProjectRootSessionKey)
+    ) {
+      return pendingProjectRoot;
+    }
+    return params.selectedSessionProjectRoot ?? null;
+  };
+
+  clearPendingProjectRootOverrideForSession = (params: {
+    sessionKey: string | null | undefined;
+    selectedSessionProjectRoot: string | null | undefined;
+  }) => {
+    const { pendingProjectRoot, pendingProjectRootSessionKey } =
+      useChatInputStore.getState().snapshot;
+    if (
+      !shouldClearPendingProjectRootOverride({
+        pendingProjectRoot,
+        pendingProjectRootSessionKey,
+        sessionKey: params.sessionKey,
+        selectedSessionProjectRoot: params.selectedSessionProjectRoot,
+      })
+    ) {
+      return;
+    }
+    useChatInputStore.getState().setSnapshot({
+      pendingProjectRoot: null,
+      pendingProjectRootSessionKey: null,
+    });
+  };
+
+  clearPendingProjectRootOverrideForCurrentThread = () => {
+    const { sessionKey, sessionProjectRoot } = useChatThreadStore.getState().snapshot;
+    this.clearPendingProjectRootOverrideForSession({
+      sessionKey,
+      selectedSessionProjectRoot: sessionProjectRoot,
+    });
+  };
+
+  syncSessionPreferences = this.sessionPreferenceSync.syncInputSelection;
+
   setDraft = (next: SetStateAction<string>) => {
     const prev = useChatInputStore.getState().snapshot.draft;
     const value = this.resolveUpdateValue(prev, next);
@@ -189,7 +254,10 @@ export class NcpChatInputManager {
     if (value === prev) {
       return;
     }
-    useChatInputStore.getState().setSnapshot({ pendingSessionType: value });
+    useChatInputStore.getState().setSnapshot({
+      pendingSessionType: value,
+      selectedSessionType: value,
+    });
   };
 
   send = async () => {
@@ -220,28 +288,31 @@ export class NcpChatInputManager {
       this.sessionListManager.ensureDraftSession(inputSnapshot.selectedSessionType);
     }
     this.setComposerNodes(createInitialChatComposerNodes());
-    await this.streamActionsManager.sendMessage({
-      message,
-      ...(sessionKey ? { sessionKey } : {}),
-      agentId: sessionSnapshot.selectedAgentId,
-      sessionType: inputSnapshot.selectedSessionType,
-      model: inputSnapshot.selectedModel || undefined,
-      thinkingLevel: inputSnapshot.selectedThinkingLevel ?? undefined,
-      stopSupported: true,
-      requestedSkills,
-      attachments,
-      parts,
-      restoreDraftOnError: true,
-      composerNodes
-    });
+    try {
+      await this.chatRunManager.sendMessage({
+        message,
+        sessionKey: sessionKey ?? undefined,
+        agentId: sessionSnapshot.selectedAgentId,
+        sessionType: inputSnapshot.selectedSessionType,
+        model: resolveModelForSend(inputSnapshot.selectedModel),
+        thinkingLevel: inputSnapshot.selectedThinkingLevel ?? undefined,
+        projectRoot: this.resolveProjectRootForSend({
+          sessionKey,
+          selectedSessionProjectRoot: threadSnapshot.sessionProjectRoot,
+        }),
+        requestedSkills,
+        attachments,
+        parts,
+        composerNodes,
+      });
+    } catch (error) {
+      this.restoreComposerState(composerNodes, attachments);
+      throw error;
+    }
   };
 
   stop = async () => {
-    await this.streamActionsManager.stopCurrentRun();
-  };
-
-  goToProviders = () => {
-    this.uiManager.goToProviders();
+    await this.chatRunManager.stopCurrentRun();
   };
 
   setSelectedModel = (next: SetStateAction<string>) => {
@@ -280,7 +351,9 @@ export class NcpChatInputManager {
 
   selectModel = (value: string) => {
     this.setSelectedModel(value);
-    chatRecentModelsManager.remember(value);
+    if (!isRuntimeDefaultModelValue(value)) {
+      chatRecentModelsManager.remember(value);
+    }
     this.sessionPreferenceSync.syncSelectedSessionPreferences();
   };
 

package/src/features/chat/managers/chat-query.manager.ts

@@ -0,0 +1,48 @@
+import type { ChatQuerySnapshot } from '@/features/chat/stores/ncp-chat-query.store';
+import { useChatQueryStore } from '@/features/chat/stores/ncp-chat-query.store';
+
+function toQuerySnapshotComparable(snapshot: ChatQuerySnapshot) {
+  const toQueryComparable = (query: unknown) => {
+    if (!query || typeof query !== 'object') {
+      return query;
+    }
+    const record = query as Record<string, unknown>;
+    const error = record.error instanceof Error
+      ? { name: record.error.name, message: record.error.message }
+      : record.error;
+    return {
+      data: record.data,
+      error,
+      status: record.status,
+      fetchStatus: record.fetchStatus,
+      isLoading: record.isLoading,
+      isFetching: record.isFetching,
+      isFetched: record.isFetched,
+      isSuccess: record.isSuccess,
+    };
+  };
+  return {
+    configQuery: toQueryComparable(snapshot.configQuery),
+    providersQuery: toQueryComparable(snapshot.providersQuery),
+    providerTemplatesQuery: toQueryComparable(snapshot.providerTemplatesQuery),
+    sessionsQuery: toQueryComparable(snapshot.sessionsQuery),
+    sessionTypesQuery: toQueryComparable(snapshot.sessionTypesQuery),
+    sessionSkillsSessionId: snapshot.sessionSkillsSessionId,
+    sessionSkillsQuery: toQueryComparable(snapshot.sessionSkillsQuery),
+  };
+}
+
+function hasQuerySnapshotChange(current: ChatQuerySnapshot, patch: Partial<ChatQuerySnapshot>): boolean {
+  return JSON.stringify(toQuerySnapshotComparable(current)) !==
+    JSON.stringify(toQuerySnapshotComparable({ ...current, ...patch }));
+}
+
+export class ChatQueryManager {
+  syncSnapshot = (value: Partial<ChatQuerySnapshot>) => {
+    const store = useChatQueryStore.getState();
+    if (!hasQuerySnapshotChange(store.snapshot, value)) {
+      return;
+    }
+    store.setSnapshot(value);
+  };
+}

package/src/features/chat/managers/chat-run.manager.ts

@@ -0,0 +1,107 @@
+import { buildNcpRequestEnvelope } from '@nextclaw/ncp-react';
+import { useChatInputStore } from '@/features/chat/stores/chat-input.store';
+import { useChatThreadStore } from '@/features/chat/stores/chat-thread.store';
+import type { ChatUiManager } from '@/features/chat/managers/chat-ui.manager';
+import type {
+  ChatRunRuntime,
+  ChatRunSnapshot,
+  SendMessageParams,
+} from '@/features/chat/types/chat-run.types';
+import { buildChatRunMetadata } from '@/features/chat/features/session/utils/chat-run-metadata.utils';
+
+export class ChatRunManager {
+  private activeRuntime: ChatRunRuntime | null = null;
+
+  constructor(private uiManager: ChatUiManager) {}
+
+  setActiveRuntime = (runtime: ChatRunRuntime | null) => {
+    this.activeRuntime = runtime;
+  };
+
+  sendMessage = async (payload: SendMessageParams) => {
+    const runtime = this.activeRuntime;
+    if (!runtime || runtime.sessionKey !== (payload.sessionKey ?? null)) {
+      return;
+    }
+    const metadata = buildChatRunMetadata({
+      agentId: payload.agentId,
+      model: payload.model,
+      thinkingLevel: payload.thinkingLevel,
+      sessionType: payload.sessionType,
+      projectRoot: payload.projectRoot,
+      requestedSkills: payload.requestedSkills,
+      composerNodes: payload.composerNodes,
+    });
+    const envelope = buildNcpRequestEnvelope({
+      sessionId: payload.sessionKey,
+      text: payload.message,
+      attachments: payload.attachments,
+      parts: payload.parts,
+      metadata,
+    });
+    if (!envelope) {
+      return;
+    }
+    const handle = await runtime.sendEnvelope(envelope);
+    if (!payload.sessionKey && handle?.sessionId) {
+      this.materializeRootSessionRoute(handle.sessionId);
+    }
+  };
+
+  stopCurrentRun = async () => {
+    await this.activeRuntime?.abortCurrentRun();
+  };
+
+  resumeRun = async (run: { sessionKey: string }) => {
+    if (this.activeRuntime?.sessionKey !== run.sessionKey) {
+      return;
+    }
+    await this.activeRuntime.resumeCurrentSessionRun();
+  };
+
+  applyRunSnapshot = (snapshot: ChatRunSnapshot) => {
+    const isSending = snapshot.isSending || snapshot.isRunning;
+    useChatInputStore.getState().setSnapshot({
+      canStopGeneration: snapshot.isRunning,
+      stopDisabledReason: snapshot.isRunning ? null : '__preparing__',
+      stopSupported: true,
+      stopReason: undefined,
+      sendError: snapshot.sendErrorMessage,
+      isSending,
+    });
+    useChatThreadStore.getState().setSnapshot({
+      isHistoryLoading: snapshot.isHydrating,
+      messages: snapshot.visibleMessages,
+      isSending,
+      isAwaitingAssistantOutput: snapshot.isRunning,
+      contextWindow: snapshot.contextWindow,
+    });
+    if (!snapshot.routeSessionKey && snapshot.materializedSessionKey) {
+      this.materializeRootSessionRoute(snapshot.materializedSessionKey);
+    }
+  };
+
+  clearRunState = () => {
+    useChatInputStore.getState().setSnapshot({
+      canStopGeneration: false,
+      stopDisabledReason: '__preparing__',
+      sendError: null,
+      isSending: false,
+    });
+    useChatThreadStore.getState().setSnapshot({
+      isHistoryLoading: false,
+      messages: [],
+      isSending: false,
+      isAwaitingAssistantOutput: false,
+      contextWindow: null,
+    });
+  };
+
+  private materializeRootSessionRoute = (sessionKey: string) => {
+    const normalizedSessionKey = sessionKey.trim();
+    if (!normalizedSessionKey || !this.uiManager.isAtChatRoot()) {
+      return;
+    }
+    this.uiManager.goToSession(normalizedSessionKey, { replace: true });
+  };
+}

package/src/features/chat/managers/chat-session-list.manager.ts

@@ -3,14 +3,21 @@ import { useChatInputStore } from '@/features/chat/stores/chat-input.store';
 import { useChatThreadStore } from '@/features/chat/stores/chat-thread.store';
 import type { ChatUiManager } from '@/features/chat/managers/chat-ui.manager';
 import type { SetStateAction } from 'react';
-import type { ChatStreamActionsManager } from '@/features/chat/managers/chat-stream-actions.manager';
+import type { ChatRunManager } from '@/features/chat/managers/chat-run.manager';
 import { normalizeSessionProjectRootValue } from '@/shared/lib/session-project';
 import { updateNcpSession } from '@/shared/lib/api';
-import { CHAT_DRAFT_SESSION_PATH } from '@/features/chat/utils/chat-session-route.utils';
+import { CHAT_DRAFT_SESSION_PATH } from '@/features/chat/features/session/utils/chat-session-route.utils';
+
+type WorkspaceChildReadState = {
+  sessionKey: string | null | undefined;
+  lastMessageAt?: string | null;
+  readAt?: string | null;
+  runStatus?: string | null;
+};
 export class ChatSessionListManager {
   constructor(
     private uiManager: ChatUiManager,
-    private streamActionsManager: ChatStreamActionsManager
+    private chatRunManager: ChatRunManager
   ) {}
 
   private syncDraftThreadState = (hasSubmittedDraftMessage = false) => {
@@ -30,6 +37,8 @@ export class ChatSessionListManager {
       childSessionTabs: [],
       activeChildSessionKey: null,
       activeWorkspaceFileKey: null,
+      workspaceNavigationHistory: [],
+      workspaceNavigationHistoryIndex: 0,
     });
   };
 
@@ -64,6 +73,14 @@ export class ChatSessionListManager {
     useChatSessionListStore.getState().setSnapshot({ selectedAgentId: value });
   };
 
+  syncSelectedSessionAgent = () => {
+    const normalizedAgentId = useChatThreadStore.getState().snapshot.agentId?.trim();
+    if (!normalizedAgentId) {
+      return;
+    }
+    this.setSelectedAgentId(normalizedAgentId);
+  };
+
   setSelectedSessionKey = (next: SetStateAction<string | null>) => {
     const prev = useChatSessionListStore.getState().snapshot.selectedSessionKey;
     const value = this.resolveUpdateValue(prev, next);
@@ -73,6 +90,27 @@ export class ChatSessionListManager {
     useChatSessionListStore.getState().setSnapshot({ selectedSessionKey: value });
   };
 
+  syncRouteSessionSelection = (params: {
+    isChatView: boolean;
+    routeSessionKey: string | null;
+  }) => {
+    const { isChatView, routeSessionKey } = params;
+    if (!isChatView) {
+      return;
+    }
+    const { selectedSessionKey } = useChatSessionListStore.getState().snapshot;
+    if (routeSessionKey) {
+      if (selectedSessionKey !== routeSessionKey) {
+        this.setSelectedSessionKey(routeSessionKey);
+      }
+      return;
+    }
+    if (selectedSessionKey !== null) {
+      this.setSelectedSessionKey(null);
+      this.chatRunManager.clearRunState();
+    }
+  };
+
   setListMode = (next: SetStateAction<'time-first' | 'project-first'>) => {
     const prev = useChatSessionListStore.getState().snapshot.listMode;
     const value = this.resolveUpdateValue(prev, next);
@@ -99,6 +137,10 @@ export class ChatSessionListManager {
     void updateNcpSession(normalizedSessionKey, { uiReadAt: normalizedReadAt }).catch(() => undefined);
   };
 
+  markVisibleWorkspaceChildRead = (tab: WorkspaceChildReadState) => {
+    this.markSessionRead(tab.sessionKey, tab.runStatus === 'running' ? null : tab.lastMessageAt, tab.readAt);
+  };
+
   createSession = (sessionType?: string, projectRoot?: string | null): void => {
     const { snapshot } = useChatInputStore.getState();
     const { defaultSessionType: configuredDefaultSessionType } = snapshot;
@@ -108,13 +150,14 @@ export class ChatSessionListManager {
         ? sessionType.trim()
         : defaultSessionType;
     const normalizedProjectRoot = normalizeSessionProjectRootValue(projectRoot);
-    this.streamActionsManager.resetStreamState();
+    this.chatRunManager.clearRunState();
     useChatSessionListStore.getState().setSnapshot({
       selectedSessionKey: null,
     });
     this.syncDraftThreadState();
     useChatInputStore.getState().setSnapshot({
       pendingSessionType: nextSessionType,
+      selectedSessionType: nextSessionType,
       pendingProjectRoot: normalizedProjectRoot,
       pendingProjectRootSessionKey: null
     });
@@ -143,17 +186,6 @@ export class ChatSessionListManager {
     return null;
   };
 
-  materializeRootSessionRoute = (sessionKey: string) => {
-    const normalizedSessionKey = sessionKey.trim();
-    if (!normalizedSessionKey) {
-      return;
-    }
-    if (!this.uiManager.isAtChatRoot()) {
-      return;
-    }
-    this.uiManager.goToSession(normalizedSessionKey, { replace: true });
-  };
-
   selectSession = (sessionKey: string) => {
     this.uiManager.goToSession(sessionKey);
   };