@nextclaw/ui 0.13.13 → 0.14.1-beta.0

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) => {
@@ -66,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);
@@ -75,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);
@@ -101,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;
@@ -110,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
     });
@@ -145,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);
   };

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,78 @@ export class ChatSessionPreferenceSync {
       sessionKey,
       patch: {
         preferredModel: normalizeOptionalModel(inputSnapshot.selectedModel),
-        preferredThinking: normalizeOptionalThinking(inputSnapshot.selectedThinkingLevel)
+        preferredThinking: inputSnapshot.selectedThinkingLevel ?? null
       }
     });
   };
 
+  syncInputSelection = (params: {
+    selectedSessionKey?: string | null;
+    selectedSessionExists: boolean;
+    selectedSessionPreferredModel?: string;
+    fallbackPreferredModel?: string;
+    defaultModel?: string;
+    selectedSessionPreferredThinking?: ThinkingLevel | null;
+    fallbackPreferredThinking?: ThinkingLevel | null;
+  }) => {
+    const {
+      defaultModel,
+      fallbackPreferredModel,
+      fallbackPreferredThinking,
+      selectedSessionKey = null,
+      selectedSessionExists,
+      selectedSessionPreferredModel,
+      selectedSessionPreferredThinking,
+    } = params;
+    const { snapshot } = useChatInputStore.getState();
+    const { modelOptions } = snapshot;
+    const sessionChanged = 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,
+    });
+    if (
+      snapshot.selectedModel === selectedModel &&
+      snapshot.selectedThinkingLevel === selectedThinking
+    ) {
+      this.recordSyncedPreferenceSessionKey(selectedSessionKey, selectedSessionExists);
+      return;
+    }
+    useChatInputStore.getState().setSnapshot({
+      selectedModel,
+      selectedThinkingLevel: selectedThinking,
+    });
+    this.recordSyncedPreferenceSessionKey(selectedSessionKey, selectedSessionExists);
+  };
+
+  private recordSyncedPreferenceSessionKey = (
+    selectedSessionKey: string | null,
+    selectedSessionExists: boolean,
+  ): void => {
+    if (!selectedSessionKey || selectedSessionExists) {
+      this.previousPreferenceSessionKey = selectedSessionKey;
+    }
+  };
+
   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,12 +1,16 @@
 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 {
@@ -15,7 +19,6 @@ import type {
   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,
@@ -36,11 +39,16 @@ function areWorkspaceNavigationEntriesEqual(
   return next.kind !== 'cron' && current.key === next.key;
 }
 
-export class NcpChatThreadManager {
+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>();
+
   constructor(
     private uiManager: ChatUiManager,
     private sessionListManager: ChatSessionListManager,
-    private streamActionsManager: ChatStreamActionsManager
+    private chatRunManager: ChatRunManager,
   ) {}
 
   private hasSnapshotChanges = (patch: Partial<ChatThreadSnapshot>): boolean => {
@@ -68,8 +76,6 @@ export class NcpChatThreadManager {
       sessionKey: null,
       sessionTypeLabel: null,
       agentId: null,
-      agentDisplayName: null,
-      agentAvatarUrl: null,
       sessionDisplayName: undefined,
       sessionProjectRoot: null,
       sessionProjectName: null,
@@ -206,18 +212,6 @@ export class NcpChatThreadManager {
     });
   };
 
-  deleteSession = () => {
-    void this.deleteCurrentSession();
-  };
-
-  createSession = () => {
-    this.sessionListManager.createSession();
-  };
-
-  goToProviders = () => {
-    this.uiManager.goToProviders();
-  };
-
   openChildSessionPanel = (params: {
     parentSessionKey: string;
     activeChildSessionKey?: string | null;
@@ -263,11 +257,11 @@ export class NcpChatThreadManager {
     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 ||
@@ -280,17 +274,58 @@ export class NcpChatThreadManager {
         return;
       }
     }
-    useChatThreadStore.getState().setSnapshot({
-      workspacePanelParentKey: null,
-      activeWorkspacePanelKind: null,
-      activeChildSessionKey: null,
-      activeWorkspaceFileKey: null,
-      workspaceNavigationHistory: [],
-      workspaceNavigationHistoryIndex: 0,
-    });
+    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,
+      placement: payload.placement,
+    });
+  };
+
+  private showContent = async (request: ChatUiShowContentRequest): Promise<void> => {
+    if (request.placement === 'inline') {
+      return;
+    }
+    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) {
@@ -448,11 +483,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();
@@ -472,7 +503,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,14 @@
 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 { findPanelAppEntryByDisplayId } from '@/features/panel-apps';
+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 +23,9 @@ 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;
 
 export class ChatUiManager {
   private state: ChatUiState = {
@@ -30,6 +37,8 @@ export class ChatUiManager {
     confirm: noopConfirm
   };
 
+  constructor(private docBrowserManager: DocBrowserManager) {}
+
   syncState = (patch: Partial<ChatUiState>) => {
     this.state = {
       ...this.state,
@@ -44,9 +53,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 +70,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 findPanelAppEntryByDisplayId((await nextclawClient.panelApps.listPanelApps()).entries, normalizedValue);
+    } 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);
   };

package/src/features/chat/managers/recent-selection.manager.ts

@@ -1,49 +1,51 @@
+import {
+  useRecentSelectionStore,
+  normalizeRecentSelectionList,
+  normalizeRecentSelectionValue,
+  resolveRecentSelectionKey,
+  type RecentSelectionScope,
+} from '@/features/chat/stores/recent-selection.store';
+
 type RecentSelectionManagerOptions = {
   storageKey: string;
   limit: number;
-  storage?: Pick<Storage, 'getItem' | 'setItem'> | null;
 };
 
 type VisibleRecentSelectionParams = {
   availableValues: string[];
   minAvailableCount: number;
   limit?: number;
-};
+} & RecentSelectionScope;
 
 export class RecentSelectionManager {
   constructor(private readonly options: RecentSelectionManagerOptions) {}
 
-  read = (): string[] => {
-    const storage = this.getStorage();
-    if (!storage) {
-      return [];
-    }
-    try {
-      return this.normalizeList(JSON.parse(storage.getItem(this.options.storageKey) ?? '[]'));
-    } catch {
-      return [];
-    }
+  read = (scope: RecentSelectionScope = {}): string[] => {
+    const key = resolveRecentSelectionKey(this.options, scope);
+    return normalizeRecentSelectionList(useRecentSelectionStore.getState().entriesByKey[key], this.options.limit);
   };
 
-  remember = (value: string): string[] => {
-    const normalizedValue = this.normalizeValue(value);
+  remember = (value: string, scope: RecentSelectionScope = {}): string[] => {
+    const normalizedValue = normalizeRecentSelectionValue(value);
     if (!normalizedValue) {
-      return this.read();
+      return this.read(scope);
     }
-    const next = [normalizedValue, ...this.read().filter((item) => item !== normalizedValue)].slice(0, this.options.limit);
-    this.write(next);
+    const key = resolveRecentSelectionKey(this.options, scope);
+    const next = [normalizedValue, ...this.read(scope).filter((item) => item !== normalizedValue)]
+      .slice(0, this.options.limit);
+    useRecentSelectionStore.getState().setEntries(key, next);
     return next;
   };
 
   resolveVisible = (params: VisibleRecentSelectionParams): string[] => {
-    const availableValues = this.normalizeList(params.availableValues, Number.POSITIVE_INFINITY);
+    const availableValues = normalizeRecentSelectionList(params.availableValues, Number.POSITIVE_INFINITY);
     if (availableValues.length <= params.minAvailableCount) {
       return [];
     }
     const availableSet = new Set(availableValues);
     const visible: string[] = [];
     const maxVisibleItems = Math.max(1, params.limit ?? this.options.limit);
-    for (const value of this.read()) {
+    for (const value of this.read(params)) {
       if (!availableSet.has(value) || visible.includes(value)) {
         continue;
       }
@@ -54,52 +56,4 @@ export class RecentSelectionManager {
     }
     return visible;
   };
-
-  private write = (values: string[]): void => {
-    const storage = this.getStorage();
-    if (!storage) {
-      return;
-    }
-    try {
-      storage.setItem(this.options.storageKey, JSON.stringify(this.normalizeList(values)));
-    } catch {
-      // Ignore storage write failures and keep the runtime behavior deterministic.
-    }
-  };
-
-  private getStorage = (): Storage | null => {
-    if (Object.prototype.hasOwnProperty.call(this.options, 'storage')) {
-      return (this.options.storage as Storage | null | undefined) ?? null;
-    }
-    if (typeof window === 'undefined') {
-      return null;
-    }
-    return window.localStorage;
-  };
-
-  private normalizeList = (values: unknown, limit = this.options.limit): string[] => {
-    if (!Array.isArray(values)) {
-      return [];
-    }
-    const deduped: string[] = [];
-    for (const value of values) {
-      const normalized = this.normalizeValue(value);
-      if (!normalized || deduped.includes(normalized)) {
-        continue;
-      }
-      deduped.push(normalized);
-      if (deduped.length >= limit) {
-        break;
-      }
-    }
-    return deduped;
-  };
-
-  private normalizeValue = (value: unknown): string | null => {
-    if (typeof value !== 'string') {
-      return null;
-    }
-    const normalized = value.trim();
-    return normalized.length > 0 ? normalized : null;
-  };
 }