@nextclaw/ui 0.15.21 → 0.15.23

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

@@ -27,6 +27,7 @@ import {
   closeWorkspaceTabSnapshot,
   createWorkspaceSelectionPatch,
   createSideChatDraft,
+  materializeDraftWorkspaceSnapshot,
   materializeSideChatDraftSnapshot,
   upsertChildSessionTab,
 } from '@/features/chat/features/workspace/utils/chat-thread-workspace-session.utils';
@@ -75,16 +76,13 @@ export class ChatThreadManager {
     useChatThreadStore.getState().setSnapshot(patch);
   };
 
-  private clearDeletedSessionState = (sessionKey: string) => {
-    if (useChatSessionListStore.getState().snapshot.selectedSessionKey === sessionKey) {
-      this.sessionListManager.setSelectedSessionKey(null);
-    }
+  private clearDeletedSessionState = () => {
     useChatThreadStore.getState().setSnapshot({
       sessionKey: null,
       sessionTypeLabel: null,
       agentId: null,
       sessionDisplayName: undefined,
-      sessionProjectRoot: null,
+      draftProjectRoot: null,
       sessionProjectName: null,
       canDeleteSession: false,
       parentSessionKey: null,
@@ -180,11 +178,11 @@ export class ChatThreadManager {
   };
 
   private openWorkspacePage = (
-    rawParentSessionKey: string,
+    rawParentSessionKey: string | null,
     kind: 'overview' | 'child-sessions' | 'project-files' | 'cron',
   ) => {
-    const parentSessionKey = rawParentSessionKey.trim();
-    if (!parentSessionKey) {
+    const parentSessionKey = rawParentSessionKey?.trim() || null;
+    if (!parentSessionKey && kind !== 'project-files') {
       return;
     }
     this.setWorkspaceSelection({
@@ -202,11 +200,8 @@ export class ChatThreadManager {
     this.openWorkspacePage(sessionKey, 'overview');
   };
 
-  toggleWorkspacePanel = (sessionKey: string) => {
-    const normalizedSessionKey = sessionKey.trim();
-    if (!normalizedSessionKey) {
-      return;
-    }
+  toggleWorkspacePanel = (sessionKey: string | null) => {
+    const normalizedSessionKey = sessionKey?.trim() || null;
     const { snapshot } = useChatThreadStore.getState();
     if (
       snapshot.workspacePanelParentKey === normalizedSessionKey &&
@@ -215,7 +210,11 @@ export class ChatThreadManager {
       this.closeWorkspacePanel();
       return;
     }
-    this.openWorkspaceOverview(normalizedSessionKey);
+    if (normalizedSessionKey) {
+      this.openWorkspaceOverview(normalizedSessionKey);
+      return;
+    }
+    this.openProjectFiles(null);
   };
 
   setWorkspacePanelWidth = (width: number) => {
@@ -228,10 +227,27 @@ export class ChatThreadManager {
     this.openWorkspacePage(sessionKey, 'child-sessions');
   };
 
-  openProjectFiles = (sessionKey: string) => {
+  openProjectFiles = (sessionKey: string | null) => {
     this.openWorkspacePage(sessionKey, 'project-files');
   };
 
+  materializeRootDraftSession = (rawSessionKey: string) => {
+    const sessionKey = rawSessionKey.trim();
+    if (!sessionKey || !this.uiManager.isAtChatRoot()) {
+      return;
+    }
+    const patch = materializeDraftWorkspaceSnapshot(
+      useChatThreadStore.getState().snapshot,
+      sessionKey,
+    );
+    if (!patch) {
+      return;
+    }
+    this.sessionListManager.syncRouteSessionSelection(sessionKey);
+    useChatThreadStore.getState().setSnapshot(patch);
+    this.uiManager.goToSession(sessionKey, { replace: true });
+  };
+
   openChildSessionPanel = (params: {
     parentSessionKey: string;
     activeChildSessionKey?: string | null;
@@ -569,7 +585,7 @@ export class ChatThreadManager {
       await deleteNcpSessionApi(selectedSessionKey);
       deleteNcpSessionSummaryInQueryClient(appQueryClient, selectedSessionKey);
       appQueryClient.removeQueries({ queryKey: ['ncp-session-messages', selectedSessionKey] });
-      this.clearDeletedSessionState(selectedSessionKey);
+      this.clearDeletedSessionState();
       this.uiManager.goToChatRoot({ replace: true });
     } finally {
       useChatThreadStore.getState().setSnapshot({ isDeletePending: false });

package/src/features/chat/managers/provider-model-catalog-notice.manager.ts

@@ -0,0 +1,121 @@
+const STORAGE_KEY = 'nextclaw.chat.provider-model-catalog-notices';
+const STORAGE_VERSION = 1;
+
+export const LARGE_PROVIDER_MODEL_CATALOG_THRESHOLD = 50;
+
+type CatalogNoticeOption = {
+  readonly providerId: string;
+  readonly value: string;
+};
+
+type CatalogNoticeState = {
+  readonly version: typeof STORAGE_VERSION;
+  readonly acknowledgedModelsByProvider: Record<string, string[]>;
+};
+
+const EMPTY_STATE: CatalogNoticeState = {
+  version: STORAGE_VERSION,
+  acknowledgedModelsByProvider: {},
+};
+
+function readStorage(): Storage | null {
+  return typeof window === 'undefined' ? null : window.localStorage;
+}
+
+function groupOptions(options: readonly CatalogNoticeOption[]): Map<string, string[]> {
+  const grouped = new Map<string, string[]>();
+  for (const option of options) {
+    const values = grouped.get(option.providerId) ?? [];
+    if (!values.includes(option.value)) {
+      values.push(option.value);
+      grouped.set(option.providerId, values);
+    }
+  }
+  return grouped;
+}
+
+export class ProviderModelCatalogNoticeManager {
+  read = (): CatalogNoticeState => {
+    const storage = readStorage();
+    if (!storage) {
+      return EMPTY_STATE;
+    }
+    try {
+      const value = JSON.parse(storage.getItem(STORAGE_KEY) ?? 'null') as Partial<CatalogNoticeState> | null;
+      return value?.version === STORAGE_VERSION && value.acknowledgedModelsByProvider
+        ? {
+            version: STORAGE_VERSION,
+            acknowledgedModelsByProvider: value.acknowledgedModelsByProvider,
+          }
+        : EMPTY_STATE;
+    } catch {
+      return EMPTY_STATE;
+    }
+  };
+
+  write = (state: CatalogNoticeState): boolean => {
+    const storage = readStorage();
+    if (!storage) {
+      return false;
+    }
+    try {
+      storage.setItem(STORAGE_KEY, JSON.stringify(state));
+      return true;
+    } catch {
+      return false;
+    }
+  };
+
+  initializeLargeCatalogs = (options: readonly CatalogNoticeOption[]): boolean => {
+    const state = this.read();
+    const nextAcknowledged = { ...state.acknowledgedModelsByProvider };
+    let changed = false;
+    for (const [providerId, values] of groupOptions(options)) {
+      if (
+        values.length > LARGE_PROVIDER_MODEL_CATALOG_THRESHOLD &&
+        !Object.prototype.hasOwnProperty.call(nextAcknowledged, providerId)
+      ) {
+        nextAcknowledged[providerId] = values;
+        changed = true;
+      }
+    }
+    return changed && this.write({ version: STORAGE_VERSION, acknowledgedModelsByProvider: nextAcknowledged });
+  };
+
+  filterUnseen = <T extends CatalogNoticeOption>(options: readonly T[]): T[] => {
+    const acknowledged = this.read().acknowledgedModelsByProvider;
+    const grouped = groupOptions(options);
+    return options.filter((option) => {
+      const providerAcknowledged = acknowledged[option.providerId];
+      if (!providerAcknowledged) {
+        return (grouped.get(option.providerId)?.length ?? 0) <= LARGE_PROVIDER_MODEL_CATALOG_THRESHOLD;
+      }
+      return !providerAcknowledged.includes(option.value);
+    });
+  };
+
+  acknowledge = (options: readonly CatalogNoticeOption[]): boolean => {
+    if (options.length === 0) {
+      return false;
+    }
+    const state = this.read();
+    const nextAcknowledged = { ...state.acknowledgedModelsByProvider };
+    let changed = false;
+    for (const [providerId, values] of groupOptions(options)) {
+      const currentValues = nextAcknowledged[providerId] ?? [];
+      const currentSet = new Set(currentValues);
+      const merged = [...currentValues];
+      for (const value of values) {
+        if (!currentSet.has(value)) {
+          currentSet.add(value);
+          merged.push(value);
+          changed = true;
+        }
+      }
+      nextAcknowledged[providerId] = merged;
+    }
+    return changed && this.write({ version: STORAGE_VERSION, acknowledgedModelsByProvider: nextAcknowledged });
+  };
+}
+
+export const providerModelCatalogNoticeManager = new ProviderModelCatalogNoticeManager();

package/src/features/chat/pages/__tests__/ncp-chat-page.test.tsx

@@ -39,17 +39,11 @@ vi.mock('@/shared/hooks/use-confirm-dialog', () => ({
 vi.mock('@/features/chat/components/layout/chat-page-shell', () => ({
   ChatPageLayout: () => <div data-testid="chat-page-layout" />,
   useChatSessionSync: (params: {
-    syncRouteSessionSelection: (value: {
-      isChatView: boolean;
-      routeSessionKey: string | null;
-    }) => void;
+    routeSessionKey: string | null;
+    syncRouteSessionSelection: (routeSessionKey: string | null) => void;
   }) => {
     mocks.useChatSessionSync(params);
-    const { syncRouteSessionSelection } = params;
-    syncRouteSessionSelection({
-      isChatView: true,
-      routeSessionKey: null,
-    });
+    params.syncRouteSessionSelection(params.routeSessionKey);
   },
 }));
 

package/src/features/chat/pages/ncp-chat-page.tsx

@@ -76,7 +76,6 @@ function NcpChatPageContent({ view }: ChatPageProps) {
     sessionKey: sessionKey ?? null,
   });
   useChatSessionSync({
-    view,
     routeSessionKey,
     syncRouteSessionSelection:
       presenter.chatSessionListManager.syncRouteSessionSelection,

package/src/features/chat/presenters/chat.presenter.ts

@@ -2,6 +2,7 @@ import { ChatSessionListManager } from '@/features/chat/managers/chat-session-li
 import { ChatUiManager } from '@/features/chat/managers/chat-ui.manager';
 import { ChatQueryManager } from '@/features/chat/managers/chat-query.manager';
 import { ChatThreadManager } from '@/features/chat/managers/chat-thread.manager';
+import { ChatComposerIntentManager } from '@/features/chat/managers/chat-composer-intent.manager';
 import type { AppPresenter } from '@/app/presenters/app.presenter';
 
 export class ChatPresenter {
@@ -9,11 +10,13 @@ export class ChatPresenter {
   readonly chatSessionListManager: ChatSessionListManager;
   readonly chatQueryManager: ChatQueryManager;
   readonly chatThreadManager: ChatThreadManager;
+  readonly chatComposerIntentManager: ChatComposerIntentManager;
 
   constructor(appPresenter: AppPresenter) {
     this.chatUiManager = new ChatUiManager(appPresenter.docBrowserManager);
     this.chatSessionListManager = new ChatSessionListManager(this.chatUiManager);
     this.chatQueryManager = new ChatQueryManager();
+    this.chatComposerIntentManager = new ChatComposerIntentManager();
     this.chatThreadManager = new ChatThreadManager(
       this.chatUiManager,
       this.chatSessionListManager,

package/src/features/chat/stores/__tests__/chat-composer-draft.store.test.ts

@@ -0,0 +1,55 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+
+import {
+  CHAT_NEW_SESSION_DRAFT_KEY,
+  resolveChatComposerDraftKey,
+  useChatComposerDraftStore,
+  type ChatComposerDraftSnapshot,
+} from '@/features/chat/stores/chat-composer-draft.store';
+
+const STORAGE_KEY = 'nextclaw.chat.composer-drafts';
+
+const EMPTY_DRAFT: ChatComposerDraftSnapshot = {
+  text: '',
+  nodes: [],
+  selectedSkills: [],
+  skillRecords: [],
+  attachments: [],
+  selectedModel: undefined,
+  selectedThinkingLevel: null,
+  pendingSessionType: 'native',
+  selectedSessionType: 'native',
+  composerFocusRequestId: 0,
+  sendError: null,
+};
+
+describe('chat composer draft store', () => {
+  beforeEach(() => {
+    window.localStorage.clear();
+    useChatComposerDraftStore.setState({ drafts: {} });
+  });
+
+  it('uses one fixed partition for the uncreated session', () => {
+    expect(resolveChatComposerDraftKey(null)).toBe(CHAT_NEW_SESSION_DRAFT_KEY);
+    expect(resolveChatComposerDraftKey('  ')).toBe(CHAT_NEW_SESSION_DRAFT_KEY);
+    expect(resolveChatComposerDraftKey('session-a')).toBe('session:session-a');
+  });
+
+  it('restores persisted drafts after the store rehydrates', async () => {
+    useChatComposerDraftStore.getState().updateDraft(
+      'session:session-a',
+      EMPTY_DRAFT,
+      (snapshot) => ({ ...snapshot, text: '会话 A 草稿' }),
+    );
+    const persistedDrafts = window.localStorage.getItem(STORAGE_KEY);
+
+    expect(persistedDrafts).not.toBeNull();
+    useChatComposerDraftStore.setState({ drafts: {} });
+    window.localStorage.setItem(STORAGE_KEY, persistedDrafts!);
+    await useChatComposerDraftStore.persist.rehydrate();
+
+    expect(
+      useChatComposerDraftStore.getState().drafts['session:session-a']?.text,
+    ).toBe('会话 A 草稿');
+  });
+});

package/src/features/chat/stores/chat-composer-draft.store.ts

@@ -0,0 +1,92 @@
+import type { ChatComposerNode } from '@nextclaw/agent-chat-ui';
+import type { NcpDraftAttachment } from '@nextclaw/ncp-react';
+import { create } from 'zustand';
+import { createJSONStorage, persist } from 'zustand/middleware';
+
+import type { ThinkingLevel } from '@/shared/lib/api';
+
+export const CHAT_NEW_SESSION_DRAFT_KEY = 'new-session';
+
+type ChatComposerDraftSkillSelection = {
+  readonly ref: string;
+  readonly name: string;
+};
+
+export type ChatComposerDraftSnapshot = {
+  readonly text: string;
+  readonly nodes: readonly ChatComposerNode[];
+  readonly selectedSkills: readonly string[];
+  readonly skillRecords: readonly ChatComposerDraftSkillSelection[];
+  readonly attachments: readonly NcpDraftAttachment[];
+  readonly selectedModel: string | null | undefined;
+  readonly selectedThinkingLevel: ThinkingLevel | null;
+  readonly pendingSessionType: string;
+  readonly selectedSessionType: string | null;
+  readonly composerFocusRequestId: number;
+  readonly sendError: string | null;
+};
+
+type ChatComposerDraftStore = {
+  drafts: Record<string, ChatComposerDraftSnapshot>;
+  ensureDraft: (draftKey: string, initialSnapshot: ChatComposerDraftSnapshot) => void;
+  updateDraft: (
+    draftKey: string,
+    initialSnapshot: ChatComposerDraftSnapshot,
+    update: (
+      snapshot: ChatComposerDraftSnapshot,
+    ) => ChatComposerDraftSnapshot,
+  ) => void;
+};
+
+const CHAT_COMPOSER_DRAFT_STORAGE_KEY = 'nextclaw.chat.composer-drafts';
+const CHAT_COMPOSER_DRAFT_STORAGE_VERSION = 1;
+
+export function resolveChatComposerDraftKey(sessionKey: string | null): string {
+  const normalizedSessionKey = sessionKey?.trim();
+  return normalizedSessionKey
+    ? `session:${normalizedSessionKey}`
+    : CHAT_NEW_SESSION_DRAFT_KEY;
+}
+
+export const useChatComposerDraftStore = create<ChatComposerDraftStore>()(
+  persist(
+    (set) => ({
+      drafts: {},
+      ensureDraft: (draftKey, initialSnapshot) => {
+        set((state) => state.drafts[draftKey]
+          ? state
+          : {
+              drafts: {
+                ...state.drafts,
+                [draftKey]: initialSnapshot,
+              },
+            });
+      },
+      updateDraft: (draftKey, initialSnapshot, update) => {
+        set((state) => ({
+          drafts: {
+            ...state.drafts,
+            [draftKey]: update(state.drafts[draftKey] ?? initialSnapshot),
+          },
+        }));
+      },
+    }),
+    {
+      name: CHAT_COMPOSER_DRAFT_STORAGE_KEY,
+      version: CHAT_COMPOSER_DRAFT_STORAGE_VERSION,
+      storage: createJSONStorage(() => window.localStorage),
+      partialize: (state) => ({
+        drafts: Object.fromEntries(
+          Object.entries(state.drafts).map(([draftKey, snapshot]) => [
+            draftKey,
+            {
+              ...snapshot,
+              composerFocusRequestId: 0,
+              sendError: null,
+            },
+          ]),
+        ),
+      }),
+    },
+  ),
+);

package/src/features/chat/stores/chat-thread.store.ts

@@ -79,8 +79,7 @@ export type ChatThreadSnapshot = {
   sessionKey: string | null;
   agentId?: string | null;
   sessionDisplayName?: string;
-  sessionProjectRoot?: string | null;
-  sessionWorkingDir?: string | null;
+  draftProjectRoot: string | null;
   sessionProjectName?: string | null;
   canDeleteSession: boolean;
   isDeletePending: boolean;
@@ -149,8 +148,7 @@ const initialSnapshot: ChatThreadSnapshot = {
   sessionKey: null,
   agentId: null,
   sessionDisplayName: undefined,
-  sessionProjectRoot: null,
-  sessionWorkingDir: null,
+  draftProjectRoot: null,
   sessionProjectName: null,
   canDeleteSession: false,
   isDeletePending: false,

package/src/features/chat/types/chat-input-bar.types.ts

@@ -44,6 +44,12 @@ export type ChatInputBarAdapterTexts = {
   modelSearchEmptyLabel: string;
   favoriteModelLabel: string;
   unfavoriteModelLabel: string;
+  manageModelsLabel: string;
+  discoveredModelsSummaryLabel: string;
+  discoveredModelsViewLabel: string;
+  discoveredModelsGroupLabel: string;
+  discoveredModelAddLabel: string;
+  discoveredModelsDismissLabel: string;
   thinkingLabels: Record<ChatThinkingLevel, string>;
   noModelOptionsLabel: string;
   configureProviderLabel: string;

package/src/features/chat/types/chat-input.types.ts

@@ -13,6 +13,11 @@ export type ChatModelOption = {
   thinkingCapability?: ChatModelThinkingCapability | null;
 };
 
+export type DiscoveredChatModelOption = ChatModelOption & {
+  providerId: string;
+  providerModel: string;
+};
+
 export type ChatInputBarSlashItem = {
   kind: 'skill';
   key: string;

package/src/features/chat/types/chat-message.types.ts

@@ -57,6 +57,11 @@ export type ChatMessagePartSource =
         toolCallId?: string;
       };
     }
+  | {
+      type: "extension";
+      extensionType: string;
+      data: unknown;
+    }
   | {
       type: string;
       [key: string]: unknown;