@nextclaw/ui 0.13.13 → 0.14.0

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) => {
@@ -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,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) {