@nextclaw/ui 0.13.12 → 0.14.0

package/src/features/chat/managers/chat-session-preference-sync.manager.ts

@@ -1,21 +1,26 @@
+import { isRuntimeDefaultModelValue } from '@nextclaw/shared';
 import type { SessionPatchUpdate, ThinkingLevel } from '@/shared/lib/api';
 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 {
+  resolveSelectedModelValue,
+  resolveSelectedThinkingLevelValue,
+} from '@/features/chat/features/session/utils/chat-session-preference-governance.utils';
 
 type QueuedSessionPreferenceSync = { sessionKey: string; patch: SessionPatchUpdate };
 
 function normalizeOptionalModel(value: string): string | null {
+  if (isRuntimeDefaultModelValue(value)) {
+    return null;
+  }
   const normalized = value.trim(); return normalized.length > 0 ? normalized : null;
 }
 
-function normalizeOptionalThinking(value: ThinkingLevel | null): ThinkingLevel | null {
-  return value ?? null;
-}
-
 export class ChatSessionPreferenceSync {
   private inFlight: Promise<void> | null = null;
   private queued: QueuedSessionPreferenceSync | null = null;
+  private previousPreferenceSessionKey: string | null | undefined = undefined;
 
   constructor(
     private readonly updateSession: (sessionKey: string, patch: SessionPatchUpdate) => Promise<unknown>
@@ -34,11 +39,61 @@ export class ChatSessionPreferenceSync {
       sessionKey,
       patch: {
         preferredModel: normalizeOptionalModel(inputSnapshot.selectedModel),
-        preferredThinking: normalizeOptionalThinking(inputSnapshot.selectedThinkingLevel)
+        preferredThinking: inputSnapshot.selectedThinkingLevel ?? null
       }
     });
   };
 
+  syncInputSelection = (params: {
+    selectedSessionExists: boolean;
+    selectedSessionPreferredModel?: string;
+    fallbackPreferredModel?: string;
+    defaultModel?: string;
+    selectedSessionPreferredThinking?: ThinkingLevel | null;
+    fallbackPreferredThinking?: ThinkingLevel | null;
+  }) => {
+    const {
+      defaultModel,
+      fallbackPreferredModel,
+      fallbackPreferredThinking,
+      selectedSessionExists,
+      selectedSessionPreferredModel,
+      selectedSessionPreferredThinking,
+    } = params;
+    const { snapshot } = useChatInputStore.getState();
+    const { modelOptions } = snapshot;
+    const selectedSessionKey = useChatThreadStore.getState().snapshot.sessionKey;
+    const sessionChanged = this.previousPreferenceSessionKey !== selectedSessionKey;
+    this.previousPreferenceSessionKey = selectedSessionKey;
+    const preserveCurrentPreference = sessionChanged && Boolean(selectedSessionKey) && !selectedSessionExists;
+    const selectedModel = resolveSelectedModelValue({
+      currentSelectedModel: snapshot.selectedModel,
+      modelOptions,
+      selectedSessionPreferredModel,
+      fallbackPreferredModel,
+      defaultModel,
+      preferSessionPreferredModel: sessionChanged,
+      preserveCurrentSelectedModelOnSessionChange: preserveCurrentPreference,
+    });
+    const modelOption = modelOptions.find((option) => option.value === selectedModel);
+    const supportedThinkingLevels =
+      (modelOption?.thinkingCapability?.supported as ThinkingLevel[] | undefined) ?? [];
+    const selectedThinking = resolveSelectedThinkingLevelValue({
+      currentSelectedThinkingLevel: snapshot.selectedThinkingLevel,
+      supportedThinkingLevels,
+      selectedSessionPreferredThinking,
+      fallbackPreferredThinking,
+      defaultThinkingLevel:
+        (modelOption?.thinkingCapability?.default as ThinkingLevel | null | undefined) ?? null,
+      preferSessionPreferredThinking: sessionChanged,
+      preserveCurrentSelectedThinkingOnSessionChange: preserveCurrentPreference,
+    });
+    useChatInputStore.getState().setSnapshot({
+      selectedModel,
+      selectedThinkingLevel: selectedThinking,
+    });
+  };
+
   private enqueue = (next: QueuedSessionPreferenceSync): void => {
     this.queued = next;
     if (this.inFlight) {

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

@@ -1,27 +1,54 @@
 import { appQueryClient } from '@/app-query-client';
-import { deleteNcpSessionSummaryInQueryClient } from '@/shared/lib/api';
-import { deleteNcpSession as deleteNcpSessionApi } from '@/shared/lib/api';
+import {
+  deleteNcpSession as deleteNcpSessionApi,
+  deleteNcpSessionSummaryInQueryClient,
+} from '@/shared/lib/api';
 import type {
   ChatFileOpenActionViewModel,
+  ChatUiShowContentRequest,
   ChatToolActionViewModel,
 } from '@nextclaw/agent-chat-ui';
+import type { UiShowContentEventPayload } from '@nextclaw/shared';
 import type { ChatSessionListManager } from '@/features/chat/managers/chat-session-list.manager';
-import type { ChatStreamActionsManager } from '@/features/chat/managers/chat-stream-actions.manager';
+import type { ChatRunManager } from '@/features/chat/managers/chat-run.manager';
 import type { ChatUiManager } from '@/features/chat/managers/chat-ui.manager';
 import { useChatSessionListStore } from '@/features/chat/stores/chat-session-list.store';
 import type {
   ChatThreadSnapshot,
+  ChatWorkspaceNavigationEntry,
   ChatWorkspaceFileTab,
 } from '@/features/chat/stores/chat-thread.store';
 import { useChatThreadStore } from '@/features/chat/stores/chat-thread.store';
-import { viewportLayoutManager } from '@/app/managers/viewport-layout.manager';
 import { t } from '@/shared/lib/i18n';
+import {
+  filterNavigationHistoryEntries,
+  pushNavigationHistoryEntry,
+  stepNavigationHistory,
+} from '@/shared/lib/navigation-history';
+
+function areWorkspaceNavigationEntriesEqual(
+  current: ChatWorkspaceNavigationEntry,
+  next: ChatWorkspaceNavigationEntry,
+): boolean {
+  if (current.kind !== next.kind) {
+    return false;
+  }
+  if (current.kind === 'cron') {
+    return true;
+  }
+  return next.kind !== 'cron' && current.key === next.key;
+}
+
+type WorkspaceChildReadState = Parameters<ChatSessionListManager['markVisibleWorkspaceChildRead']>[0];
+export type ChatVisibleWorkspaceSelection = { kind: 'child-session'; tab: WorkspaceChildReadState } | { kind: 'file' | 'cron' } | null;
+
+export class ChatThreadManager {
+  private readonly handledUiShowContentEventIds = new Set<string>();
 
-export class NcpChatThreadManager {
   constructor(
     private uiManager: ChatUiManager,
     private sessionListManager: ChatSessionListManager,
-    private streamActionsManager: ChatStreamActionsManager
+    private chatRunManager: ChatRunManager,
   ) {}
 
   private hasSnapshotChanges = (patch: Partial<ChatThreadSnapshot>): boolean => {
@@ -49,8 +76,6 @@ export class NcpChatThreadManager {
       sessionKey: null,
       sessionTypeLabel: null,
       agentId: null,
-      agentDisplayName: null,
-      agentAvatarUrl: null,
       sessionDisplayName: undefined,
       sessionProjectRoot: null,
       sessionProjectName: null,
@@ -67,6 +92,8 @@ export class NcpChatThreadManager {
       activeChildSessionKey: null,
       workspaceFileTabs: [],
       activeWorkspaceFileKey: null,
+      workspaceNavigationHistory: [],
+      workspaceNavigationHistoryIndex: 0,
     });
   };
 
@@ -134,16 +161,55 @@ export class NcpChatThreadManager {
     }
   };
 
-  deleteSession = () => {
-    void this.deleteCurrentSession();
-  };
-
-  createSession = () => {
-    this.sessionListManager.createSession();
+  private createWorkspaceSelectionPatch = (
+    entry: ChatWorkspaceNavigationEntry,
+    snapshot: ChatThreadSnapshot,
+  ): Partial<ChatThreadSnapshot> | null => {
+    if (entry.kind === 'cron') {
+      return {
+        activeWorkspacePanelKind: 'cron',
+        activeChildSessionKey: null,
+        activeWorkspaceFileKey: null,
+      };
+    }
+    if (entry.kind === 'file') {
+      if (!snapshot.workspaceFileTabs.some((tab) => tab.key === entry.key)) {
+        return null;
+      }
+      return {
+        activeWorkspacePanelKind: 'file',
+        activeChildSessionKey: null,
+        activeWorkspaceFileKey: entry.key,
+      };
+    }
+    if (!entry.key) {
+      return null;
+    }
+    return {
+      activeWorkspacePanelKind: 'child-session',
+      activeChildSessionKey: entry.key,
+      activeWorkspaceFileKey: null,
+    };
   };
 
-  goToProviders = () => {
-    this.uiManager.goToProviders();
+  private setWorkspaceSelection = (
+    patch: Partial<ChatThreadSnapshot>,
+    entry: ChatWorkspaceNavigationEntry,
+  ) => {
+    const { snapshot } = useChatThreadStore.getState();
+    const history = pushNavigationHistoryEntry(
+      {
+        entries: snapshot.workspaceNavigationHistory,
+        index: snapshot.workspaceNavigationHistoryIndex,
+      },
+      entry,
+      areWorkspaceNavigationEntriesEqual,
+    );
+    useChatThreadStore.getState().setSnapshot({
+      ...patch,
+      workspaceNavigationHistory: [...history.entries],
+      workspaceNavigationHistoryIndex: history.index,
+    });
   };
 
   openChildSessionPanel = (params: {
@@ -155,12 +221,20 @@ export class NcpChatThreadManager {
       return;
     }
     const activeChildSessionKey = params.activeChildSessionKey?.trim() || null;
-    useChatThreadStore.getState().setSnapshot({
+    const patch: Partial<ChatThreadSnapshot> = {
       workspacePanelParentKey: parentSessionKey,
       activeWorkspacePanelKind: 'child-session',
       activeChildSessionKey,
       activeWorkspaceFileKey: null,
-    });
+    };
+    if (activeChildSessionKey) {
+      this.setWorkspaceSelection(patch, {
+        kind: 'child-session',
+        key: activeChildSessionKey,
+      });
+    } else {
+      useChatThreadStore.getState().setSnapshot(patch);
+    }
     this.ensureWorkspaceParentRoute(parentSessionKey);
   };
 
@@ -170,21 +244,24 @@ export class NcpChatThreadManager {
     if (!nextTab) {
       return;
     }
-    useChatThreadStore.getState().setSnapshot({
+    this.setWorkspaceSelection({
       workspacePanelParentKey: parentSessionKey,
       activeWorkspacePanelKind: 'file',
       workspaceFileTabs: this.upsertWorkspaceFileTab(nextTab),
       activeWorkspaceFileKey: nextTab.key,
       activeChildSessionKey: null,
+    }, {
+      kind: 'file',
+      key: nextTab.key,
     });
     this.ensureWorkspaceParentRoute(parentSessionKey);
   };
 
-  openSessionFromToolAction = (action: ChatToolActionViewModel) => {
+  private openSessionFromToolAction = (action: ChatToolActionViewModel) => {
     if (action.kind !== 'open-session') {
       return;
     }
-    if (action.sessionKind === 'child' && !this.isCompactViewport()) {
+    if (action.sessionKind === 'child' && !this.uiManager.isCompactViewport()) {
       const parentSessionKey =
         action.parentSessionId?.trim() ||
         useChatSessionListStore.getState().snapshot.selectedSessionKey ||
@@ -197,15 +274,54 @@ export class NcpChatThreadManager {
         return;
       }
     }
-    useChatThreadStore.getState().setSnapshot({
-      workspacePanelParentKey: null,
-      activeWorkspacePanelKind: null,
-      activeChildSessionKey: null,
-      activeWorkspaceFileKey: null,
-    });
+    this.closeWorkspacePanel();
     this.uiManager.goToSession(action.sessionId);
   };
 
+  handleToolAction = async (action: ChatToolActionViewModel): Promise<void> => {
+    if (action.kind === 'show-content') {
+      await this.showContent(action.request);
+      return;
+    }
+    this.openSessionFromToolAction(action);
+  };
+
+  handleUiShowContentEvent = async (payload: UiShowContentEventPayload): Promise<void> => {
+    const eventId = payload.id.trim();
+    if (!eventId || this.handledUiShowContentEventIds.has(eventId)) {
+      return;
+    }
+    this.handledUiShowContentEventIds.add(eventId);
+    await this.showContent({
+      target: payload.target,
+      title: payload.title,
+      purpose: payload.purpose,
+    });
+  };
+
+  private showContent = async (request: ChatUiShowContentRequest): Promise<void> => {
+    if (request.target.type === 'file') {
+      this.openFilePreview({
+        path: request.target.payload.path,
+        label: request.title,
+        viewMode: 'preview',
+        line: request.target.payload.line,
+        column: request.target.payload.column,
+      });
+      return;
+    }
+    await this.uiManager.showContent({
+      target: request.target,
+      title: request.title,
+    });
+  };
+
+  syncVisibleWorkspaceSelection = (selection: ChatVisibleWorkspaceSelection) => {
+    if (selection?.kind === 'child-session') {
+      this.sessionListManager.markVisibleWorkspaceChildRead(selection.tab);
+    }
+  };
+
   selectChildSessionDetail = (sessionKey: string) => {
     const normalizedSessionKey = sessionKey.trim();
     if (!normalizedSessionKey) {
@@ -215,10 +331,13 @@ export class NcpChatThreadManager {
     if (!childSessionTabs.some((tab) => tab.sessionKey === normalizedSessionKey)) {
       return;
     }
-    useChatThreadStore.getState().setSnapshot({
+    this.setWorkspaceSelection({
       activeChildSessionKey: normalizedSessionKey,
       activeWorkspaceFileKey: null,
       activeWorkspacePanelKind: 'child-session',
+    }, {
+      kind: 'child-session',
+      key: normalizedSessionKey,
     });
   };
 
@@ -231,10 +350,13 @@ export class NcpChatThreadManager {
     if (!workspaceFileTabs.some((tab) => tab.key === normalizedFileKey)) {
       return;
     }
-    useChatThreadStore.getState().setSnapshot({
+    this.setWorkspaceSelection({
       activeWorkspaceFileKey: normalizedFileKey,
       activeChildSessionKey: null,
       activeWorkspacePanelKind: 'file',
+    }, {
+      kind: 'file',
+      key: normalizedFileKey,
     });
   };
 
@@ -248,11 +370,31 @@ export class NcpChatThreadManager {
     const nextTabs = workspaceFileTabs.filter(
       (tab) => tab.key !== normalizedFileKey,
     );
+    const history = filterNavigationHistoryEntries(
+      {
+        entries: snapshot.workspaceNavigationHistory,
+        index: snapshot.workspaceNavigationHistoryIndex,
+      },
+      (entry) => entry.kind !== 'file' || entry.key !== normalizedFileKey,
+    );
     const nextPatch: Partial<ChatThreadSnapshot> = {
       workspaceFileTabs: nextTabs,
+      workspaceNavigationHistory: [...history.entries],
+      workspaceNavigationHistoryIndex: history.index,
     };
     if (activeWorkspaceFileKey === normalizedFileKey) {
-      nextPatch.activeWorkspaceFileKey = null;
+      const nextSnapshot = {
+        ...snapshot,
+        workspaceFileTabs: nextTabs,
+      };
+      const restoreEntry = history.entries[history.index];
+      const restorePatch = restoreEntry
+        ? this.createWorkspaceSelectionPatch(restoreEntry, nextSnapshot)
+        : null;
+      Object.assign(nextPatch, restorePatch ?? {
+        activeWorkspacePanelKind: null,
+        activeWorkspaceFileKey: null,
+      });
     }
     useChatThreadStore.getState().setSnapshot(nextPatch);
   };
@@ -263,6 +405,8 @@ export class NcpChatThreadManager {
       activeWorkspacePanelKind: null,
       activeChildSessionKey: null,
       activeWorkspaceFileKey: null,
+      workspaceNavigationHistory: [],
+      workspaceNavigationHistoryIndex: 0,
     });
   };
 
@@ -271,15 +415,48 @@ export class NcpChatThreadManager {
     if (!parentSessionKey) {
       return;
     }
-    useChatThreadStore.getState().setSnapshot({
+    this.setWorkspaceSelection({
       workspacePanelParentKey: parentSessionKey,
       activeWorkspacePanelKind: 'cron',
       activeChildSessionKey: null,
       activeWorkspaceFileKey: null,
+    }, {
+      kind: 'cron',
     });
     this.ensureWorkspaceParentRoute(parentSessionKey);
   };
 
+  goBackWorkspacePanel = () => {
+    this.restoreWorkspaceNavigationStep('back');
+  };
+
+  goForwardWorkspacePanel = () => {
+    this.restoreWorkspaceNavigationStep('forward');
+  };
+
+  private restoreWorkspaceNavigationStep = (direction: 'back' | 'forward') => {
+    const { snapshot } = useChatThreadStore.getState();
+    const step = stepNavigationHistory(
+      {
+        entries: snapshot.workspaceNavigationHistory,
+        index: snapshot.workspaceNavigationHistoryIndex,
+      },
+      direction,
+    );
+    if (!step) {
+      return;
+    }
+    const selectionPatch = this.createWorkspaceSelectionPatch(step.entry, snapshot);
+    if (!selectionPatch) {
+      return;
+    }
+    useChatThreadStore.getState().setSnapshot({
+      ...selectionPatch,
+      workspaceNavigationHistory: [...step.history.entries],
+      workspaceNavigationHistoryIndex: step.history.index,
+    });
+  };
+
   closeChildSessionDetail = () => {
     this.closeWorkspacePanel();
   };
@@ -302,11 +479,7 @@ export class NcpChatThreadManager {
     this.uiManager.goToSession(resolvedParentSessionKey);
   };
 
-  private isCompactViewport = (): boolean => {
-    return viewportLayoutManager.getSnapshot().mode === 'mobile';
-  };
-
-  private deleteCurrentSession = async () => {
+  deleteSession = async () => {
     const {
       snapshot: { selectedSessionKey }
     } = useChatSessionListStore.getState();
@@ -326,7 +499,7 @@ export class NcpChatThreadManager {
       await deleteNcpSessionApi(selectedSessionKey);
       deleteNcpSessionSummaryInQueryClient(appQueryClient, selectedSessionKey);
       appQueryClient.removeQueries({ queryKey: ['ncp-session-messages', selectedSessionKey] });
-      this.streamActionsManager.resetStreamState();
+      this.chatRunManager.clearRunState();
       this.clearDeletedSessionState(selectedSessionKey);
       this.uiManager.goToChatRoot({ replace: true });
     } finally {

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

@@ -1,5 +1,13 @@
 import type { NavigateFunction, NavigateOptions } from 'react-router-dom';
-import { CHAT_DRAFT_SESSION_PATH, buildSessionPath } from '@/features/chat/utils/chat-session-route.utils';
+import type { ChatUiShowContentRequest } from '@nextclaw/agent-chat-ui';
+import { viewportLayoutManager } from '@/app/managers/viewport-layout.manager';
+import { CHAT_DRAFT_SESSION_PATH, buildSessionPath } from '@/features/chat/features/session/utils/chat-session-route.utils';
+import {
+  createPanelAppResourceUri,
+  createPanelAppRightPanelResourceTarget,
+} from '@/features/right-panel-resources';
+import type { DocBrowserManager } from '@/shared/components/doc-browser/managers/doc-browser.manager';
+import { nextclawClient, type PanelAppEntryView } from '@/shared/lib/api';
 
 type ChatUiState = {
   pathname: string;
@@ -14,11 +22,14 @@ type ChatUiActions = {
   }) => Promise<boolean>;
 };
 
-const noopConfirm = async (_params: {
-  title: string;
-  variant: 'destructive';
-  confirmLabel: string;
-}) => false;
+type ChatUiDisplayContentTarget = Extract<ChatUiShowContentRequest['target'], { type: 'url' | 'panel_app' }>;
+
+const noopConfirm: ChatUiActions['confirm'] = async () => false;
+
+function isPanelAppEntryMatch(entry: PanelAppEntryView, value: string): boolean {
+  const normalizedValue = value.trim();
+  return [entry.id, entry.appId, entry.fileName, entry.title].some((candidate) => candidate.trim() === normalizedValue);
+}
 
 export class ChatUiManager {
   private state: ChatUiState = {
@@ -30,6 +41,8 @@ export class ChatUiManager {
     confirm: noopConfirm
   };
 
+  constructor(private docBrowserManager: DocBrowserManager) {}
+
   syncState = (patch: Partial<ChatUiState>) => {
     this.state = {
       ...this.state,
@@ -44,9 +57,7 @@ export class ChatUiManager {
     };
   };
 
-  confirm = async (params: { title: string; variant: 'destructive'; confirmLabel: string }) => {
-    return this.actions.confirm(params);
-  };
+  confirm = async (params: { title: string; variant: 'destructive'; confirmLabel: string }) => this.actions.confirm(params);
 
   navigateTo = (to: string, options?: NavigateOptions) => {
     if (!this.actions.navigate) {
@@ -63,6 +74,41 @@ export class ChatUiManager {
     this.navigateTo('/providers');
   };
 
+  isCompactViewport = (): boolean => {
+    return viewportLayoutManager.getSnapshot().mode === 'mobile';
+  };
+
+  private resolvePanelAppEntry = async (value: string): Promise<PanelAppEntryView | null> => {
+    const normalizedValue = value.trim();
+    if (!normalizedValue) {
+      return null;
+    }
+    try {
+      return (await nextclawClient.panelApps.listPanelApps()).entries.find((entry) => isPanelAppEntryMatch(entry, normalizedValue)) ?? null;
+    } catch {
+      return null;
+    }
+  };
+
+  showContent = async (params: { target: ChatUiDisplayContentTarget; title?: string }) => {
+    const { target, title } = params;
+    if (target.type === 'url') {
+      this.docBrowserManager.open(target.payload.url, { title });
+      return;
+    }
+    const { appId } = target.payload;
+    const entry = await this.resolvePanelAppEntry(appId);
+    if (entry) {
+      this.docBrowserManager.openTarget(createPanelAppRightPanelResourceTarget(entry), {
+        title,
+      });
+      return;
+    }
+    this.docBrowserManager.open(createPanelAppResourceUri(appId), {
+      title,
+    });
+  };
+
   goToChatRoot = (options?: NavigateOptions) => {
     this.navigateTo('/chat', options);
   };