@nextclaw/ui 0.13.13 → 0.14.0

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,54 @@ 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,
+    });
+  };
+
+  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) {
@@ -448,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();
@@ -472,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);
   };

package/src/features/chat/pages/{ncp-chat-page.test.ts → __tests__/ncp-chat-page.test.ts}

@@ -1,16 +1,17 @@
 import { describe, expect, it } from 'vitest';
+import { RUNTIME_DEFAULT_MODEL_VALUE } from '@nextclaw/shared';
 import type { SessionEntryView, ThinkingLevel } from '@/shared/lib/api';
 import type { ChatModelOption } from '@/features/chat/types/chat-input.types';
 import {
   resolveRecentSessionPreferredValue,
   resolveSelectedModelValue,
   resolveSelectedThinkingLevelValue
-} from '@/features/chat/utils/chat-session-preference-governance.utils';
+} from '@/features/chat/features/session/utils/chat-session-preference-governance.utils';
 import {
-  buildNcpSendMetadata,
+  buildChatRunMetadata,
   shouldClearPendingProjectRootOverride
-} from '@/features/chat/pages/ncp-chat-page';
-import { filterModelOptionsBySessionType } from '@/features/chat/hooks/use-ncp-chat-page-data';
+} from '@/features/chat/features/session/utils/chat-run-metadata.utils';
+import { filterNcpChatModelOptionsBySessionType } from '@/features/chat/features/ncp/utils/ncp-chat-query-derived.utils';
 
 const modelOptions: ChatModelOption[] = [
   {
@@ -39,10 +40,10 @@ const modelOptions: ChatModelOption[] = [
   }
 ];
 
-describe('filterModelOptionsBySessionType', () => {
+describe('filterNcpChatModelOptionsBySessionType', () => {
   it('keeps the full model catalog when the session type does not publish a supportedModels whitelist', () => {
     expect(
-      filterModelOptionsBySessionType({
+      filterNcpChatModelOptionsBySessionType({
         modelOptions
       })
     ).toEqual(modelOptions);
@@ -50,7 +51,7 @@ describe('filterModelOptionsBySessionType', () => {
 
   it('keeps only session-type-supported models when the runtime publishes a filtered list', () => {
     expect(
-      filterModelOptionsBySessionType({
+      filterNcpChatModelOptionsBySessionType({
         modelOptions,
         supportedModels: ['anthropic/claude-sonnet-4']
       })
@@ -59,18 +60,54 @@ describe('filterModelOptionsBySessionType', () => {
 
   it('falls back to the full model catalog when the advertised models do not match the current catalog', () => {
     expect(
-      filterModelOptionsBySessionType({
+      filterNcpChatModelOptionsBySessionType({
         modelOptions,
         supportedModels: ['unknown/model']
       })
     ).toEqual(modelOptions);
   });
+
+  it('uses only the runtime default option when the session type owns model selection', () => {
+    expect(
+      filterNcpChatModelOptionsBySessionType({
+        modelOptions,
+        modelSelectionMode: 'runtime-default',
+        runtimeDefaultModelLabel: 'Runtime default',
+      })
+    ).toEqual([{
+      value: RUNTIME_DEFAULT_MODEL_VALUE,
+      modelLabel: 'Runtime default',
+      providerLabel: '',
+      isRuntimeDefault: true,
+      thinkingCapability: null,
+    }]);
+  });
+
+  it('adds the runtime default option beside supported models for optional runtime selection', () => {
+    expect(
+      filterNcpChatModelOptionsBySessionType({
+        modelOptions,
+        modelSelectionMode: 'optional',
+        runtimeDefaultModelLabel: 'Runtime default',
+        supportedModels: ['openai/gpt-5'],
+      })
+    ).toEqual([
+      {
+        value: RUNTIME_DEFAULT_MODEL_VALUE,
+        modelLabel: 'Runtime default',
+        providerLabel: '',
+        isRuntimeDefault: true,
+        thinkingCapability: null,
+      },
+      modelOptions[1],
+    ]);
+  });
 });
 
-describe('buildNcpSendMetadata', () => {
+describe('buildChatRunMetadata', () => {
   it('includes the project root in the first-message metadata when present', () => {
     expect(
-      buildNcpSendMetadata({
+      buildChatRunMetadata({
         agentId: 'engineer',
         sessionType: 'codex',
         projectRoot: ' /tmp/project-alpha ',
@@ -87,7 +124,7 @@ describe('buildNcpSendMetadata', () => {
 
   it('omits project_root when the input is blank', () => {
     expect(
-      buildNcpSendMetadata({
+      buildChatRunMetadata({
         projectRoot: '   ',
       }),
     ).not.toHaveProperty('project_root');
@@ -95,7 +132,7 @@ describe('buildNcpSendMetadata', () => {
 
   it('sends requested skill refs instead of legacy requested skill names', () => {
     expect(
-      buildNcpSendMetadata({
+      buildChatRunMetadata({
         requestedSkills: ['project:/tmp/project-alpha/.agents/skills/review'],
       }),
     ).toMatchObject({