@nextclaw/ui 0.14.0 → 0.14.1-beta.1

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

@@ -483,6 +483,7 @@ describe('ChatThreadManager showContent', () => {
       },
       title: 'Example URL',
       purpose: 'read',
+      placement: undefined,
     });
     await manager.handleUiShowContentEvent({
       id: 'tool:call-show-content-1:show-content',
@@ -495,6 +496,7 @@ describe('ChatThreadManager showContent', () => {
       },
       title: 'Example URL',
       purpose: 'read',
+      placement: undefined,
     });
 
     expect(uiManager.showContent).toHaveBeenCalledTimes(1);
@@ -541,6 +543,34 @@ describe('ChatThreadManager showContent', () => {
       title: 'Reader',
     });
   });
+
+});
+
+describe('ChatThreadManager inline showContent', () => {
+  it('does not auto-open inline panel app content outside the message card', async () => {
+    const uiManager = createUiManager();
+    const manager = new ChatThreadManager(
+      uiManager,
+      {} as ConstructorParameters<typeof ChatThreadManager>[1],
+      {} as ConstructorParameters<typeof ChatThreadManager>[2],
+    );
+
+    await manager.handleUiShowContentEvent({
+      id: 'tool:call-show-content-inline:show-content',
+      toolCallId: 'call-show-content-inline',
+      target: {
+        type: 'panel_app',
+        payload: {
+          appId: 'reader',
+        },
+      },
+      title: 'Reader',
+      purpose: 'interact',
+      placement: 'inline',
+    });
+
+    expect(uiManager.showContent).not.toHaveBeenCalled();
+  });
 });
 
 describe('ChatThreadManager visible workspace selection', () => {

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

@@ -1,22 +1,16 @@
-import { RecentSelectionManager } from '../recent-selection.manager';
+import { RecentSelectionManager } from '@/features/chat/managers/recent-selection.manager';
+import { useRecentSelectionStore } from '@/features/chat/stores/recent-selection.store';
 
 describe('RecentSelectionManager', () => {
   const storageKey = 'test.recent-selection-manager';
-  let storageState: Record<string, string>;
-  let storage: Pick<Storage, 'getItem' | 'setItem'>;
 
   beforeEach(() => {
-    storageState = {};
-    storage = {
-      getItem: (key) => storageState[key] ?? null,
-      setItem: (key, value) => {
-        storageState[key] = value;
-      }
-    };
+    window.localStorage.clear();
+    useRecentSelectionStore.setState({ entriesByKey: {} });
   });
 
   it('stores recent values in LRU order and respects the size limit', () => {
-    const manager = new RecentSelectionManager({ storageKey, limit: 3, storage });
+    const manager = new RecentSelectionManager({ storageKey, limit: 3 });
 
     manager.remember('openai/gpt-5');
     manager.remember('anthropic/claude-sonnet-4');
@@ -31,7 +25,7 @@ describe('RecentSelectionManager', () => {
   });
 
   it('filters recent values by the currently available list and threshold', () => {
-    const manager = new RecentSelectionManager({ storageKey, limit: 4, storage });
+    const manager = new RecentSelectionManager({ storageKey, limit: 4 });
     manager.remember('openai/gpt-5');
     manager.remember('anthropic/claude-sonnet-4');
     manager.remember('missing/model');
@@ -60,9 +54,38 @@ describe('RecentSelectionManager', () => {
   });
 
   it('returns an empty list when storage content is malformed', () => {
-    storageState[storageKey] = '{broken-json';
-    const manager = new RecentSelectionManager({ storageKey, limit: 3, storage });
+    window.localStorage.setItem(storageKey, '{broken-json');
+    const manager = new RecentSelectionManager({ storageKey, limit: 3 });
 
     expect(manager.read()).toEqual([]);
   });
+
+  it('does not mutate an empty store while reading recent values', () => {
+    const manager = new RecentSelectionManager({ storageKey, limit: 3 });
+
+    expect(manager.read()).toEqual([]);
+    expect(useRecentSelectionStore.getState().entriesByKey).toEqual({});
+  });
+
+  it('keeps namespaced recent values separate from the global list', () => {
+    const manager = new RecentSelectionManager({ storageKey, limit: 3 });
+
+    manager.remember('openai/gpt-5');
+    manager.remember('anthropic/claude-sonnet-4', { namespace: 'codex' });
+    manager.remember('minimax/MiniMax-M2.7', { namespace: 'hermes' });
+    manager.remember('openai/gpt-5.1', { namespace: 'codex' });
+
+    expect(manager.read()).toEqual(['openai/gpt-5']);
+    expect(manager.read({ namespace: 'codex' })).toEqual([
+      'openai/gpt-5.1',
+      'anthropic/claude-sonnet-4'
+    ]);
+    expect(
+      manager.resolveVisible({
+        namespace: 'hermes',
+        availableValues: ['minimax/MiniMax-M2.7', 'openai/gpt-5'],
+        minAvailableCount: 0
+      })
+    ).toEqual(['minimax/MiniMax-M2.7']);
+  });
 });

package/src/features/chat/managers/chat-draft-intent.manager.ts

@@ -0,0 +1,46 @@
+export type ChatDraftIntent = {
+  id: number;
+  prompt: string;
+};
+
+type ChatDraftIntentListener = (intent: ChatDraftIntent) => void;
+
+export class ChatDraftIntentManager {
+  private nextId = 0;
+  private pendingIntent: ChatDraftIntent | null = null;
+  private readonly listeners = new Set<ChatDraftIntentListener>();
+
+  requestDraft = (prompt: string) => {
+    const normalizedPrompt = prompt.trim();
+    if (!normalizedPrompt) {
+      return;
+    }
+    const intent: ChatDraftIntent = {
+      id: this.nextId + 1,
+      prompt: normalizedPrompt,
+    };
+    this.nextId = intent.id;
+    this.pendingIntent = intent;
+    this.listeners.forEach((listener) => listener(intent));
+  };
+
+  consumePending = (): ChatDraftIntent | null => {
+    const intent = this.pendingIntent;
+    this.pendingIntent = null;
+    return intent;
+  };
+
+  markConsumed = (intentId: number) => {
+    if (this.pendingIntent?.id !== intentId) {
+      return;
+    }
+    this.pendingIntent = null;
+  };
+
+  subscribe = (listener: ChatDraftIntentListener) => {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  };
+}

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

@@ -29,11 +29,9 @@ import type { ChatModelOption } from '@/features/chat/types/chat-input.types';
 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';
+import { normalizeSessionProjectRootValue } from '@/shared/lib/session-project';
 
 function resolveModelForSend(value: string): string | undefined {
-  if (isRuntimeDefaultModelValue(value)) {
-    return undefined;
-  }
   return value || undefined;
 }
 
@@ -55,16 +53,6 @@ export class ChatInputManager {
     private sessionListManager: ChatSessionListManager
   ) {}
 
-  private hasSnapshotChanges = (patch: Partial<ChatInputSnapshot>): boolean => {
-    const current = useChatInputStore.getState().snapshot;
-    for (const [key, value] of Object.entries(patch) as Array<[keyof ChatInputSnapshot, ChatInputSnapshot[keyof ChatInputSnapshot]]>) {
-      if (!Object.is(current[key], value)) {
-        return true;
-      }
-    }
-    return false;
-  };
-
   private resolveUpdateValue = <T>(prev: T, next: SetStateAction<T>): T => {
     if (typeof next === 'function') {
       return (next as (value: T) => T)(prev);
@@ -75,6 +63,16 @@ export class ChatInputManager {
   private isSameStringArray = (left: string[], right: string[]): boolean =>
     left.length === right.length && left.every((value, index) => value === right[index]);
 
+  private hasSnapshotChanges = (patch: Partial<ChatInputSnapshot>): boolean => {
+    const current = useChatInputStore.getState().snapshot;
+    for (const [key, value] of Object.entries(patch) as Array<[keyof ChatInputSnapshot, ChatInputSnapshot[keyof ChatInputSnapshot]]>) {
+      if (!Object.is(current[key], value)) {
+        return true;
+      }
+    }
+    return false;
+  };
+
   private isRuntimeBlockedForSend = (): boolean =>
     isNcpChatRuntimeBlocked(systemStatusManager.getStatusView());
 
@@ -145,15 +143,19 @@ export class ChatInputManager {
     sessionKey: string | null | undefined;
     selectedSessionProjectRoot: string | null | undefined;
   }): string | null => {
+    const { sessionKey, selectedSessionProjectRoot } = params;
     const { pendingProjectRoot, pendingProjectRootSessionKey } =
       useChatInputStore.getState().snapshot;
     if (
       pendingProjectRoot !== null &&
-      (!params.sessionKey || params.sessionKey === pendingProjectRootSessionKey)
+      (!sessionKey || sessionKey === pendingProjectRootSessionKey)
     ) {
       return pendingProjectRoot;
     }
-    return params.selectedSessionProjectRoot ?? null;
+    if (!sessionKey) {
+      return useChatInputStore.getState().snapshot.defaultProjectRoot;
+    }
+    return selectedSessionProjectRoot ?? null;
   };
 
   clearPendingProjectRootOverrideForSession = (params: {
@@ -197,6 +199,15 @@ export class ChatInputManager {
     this.syncComposerSnapshot(createChatComposerNodesFromDraft(value));
   };
 
+  applyPromptSuggestion = (prompt: string) => {
+    const normalizedPrompt = prompt.trim();
+    if (!normalizedPrompt) {
+      return;
+    }
+    this.setDraft(normalizedPrompt);
+    this.requestComposerFocusAtEnd();
+  };
+
   requestComposerFocusAtEnd = () => {
     const currentRequest = useChatInputStore.getState().snapshot.composerFocusRequest;
     useChatInputStore.getState().setSnapshot({
@@ -260,6 +271,14 @@ export class ChatInputManager {
     });
   };
 
+  setPendingProjectRoot = (projectRoot: string | null) => {
+    const normalizedProjectRoot = normalizeSessionProjectRootValue(projectRoot);
+    useChatInputStore.getState().setSnapshot({
+      pendingProjectRoot: normalizedProjectRoot,
+      pendingProjectRootSessionKey: null,
+    });
+  };
+
   send = async () => {
     const inputSnapshot = useChatInputStore.getState().snapshot;
     const sessionSnapshot = useChatSessionListStore.getState().snapshot;
@@ -351,6 +370,9 @@ export class ChatInputManager {
 
   selectModel = (value: string) => {
     this.setSelectedModel(value);
+    chatRecentModelsManager.remember(value, {
+      namespace: useChatInputStore.getState().snapshot.selectedSessionType,
+    });
     if (!isRuntimeDefaultModelValue(value)) {
       chatRecentModelsManager.remember(value);
     }

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

@@ -61,6 +61,8 @@ export class ChatRunManager {
 
   applyRunSnapshot = (snapshot: ChatRunSnapshot) => {
     const isSending = snapshot.isSending || snapshot.isRunning;
+    const sessionKey =
+      snapshot.routeSessionKey ?? snapshot.materializedSessionKey ?? null;
     useChatInputStore.getState().setSnapshot({
       canStopGeneration: snapshot.isRunning,
       stopDisabledReason: snapshot.isRunning ? null : '__preparing__',
@@ -70,6 +72,7 @@ export class ChatRunManager {
       isSending,
     });
     useChatThreadStore.getState().setSnapshot({
+      sessionKey,
       isHistoryLoading: snapshot.isHydrating,
       messages: snapshot.visibleMessages,
       isSending,

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

@@ -45,6 +45,7 @@ export class ChatSessionPreferenceSync {
   };
 
   syncInputSelection = (params: {
+    selectedSessionKey?: string | null;
     selectedSessionExists: boolean;
     selectedSessionPreferredModel?: string;
     fallbackPreferredModel?: string;
@@ -56,15 +57,14 @@ export class ChatSessionPreferenceSync {
       defaultModel,
       fallbackPreferredModel,
       fallbackPreferredThinking,
+      selectedSessionKey = null,
       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,
@@ -88,10 +88,27 @@ export class ChatSessionPreferenceSync {
       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 => {

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

@@ -296,10 +296,14 @@ export class ChatThreadManager {
       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,

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

@@ -6,6 +6,7 @@ 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';
 
@@ -26,11 +27,6 @@ type ChatUiDisplayContentTarget = Extract<ChatUiShowContentRequest['target'], {
 
 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 = {
     pathname: ''
@@ -84,7 +80,7 @@ export class ChatUiManager {
       return null;
     }
     try {
-      return (await nextclawClient.panelApps.listPanelApps()).entries.find((entry) => isPanelAppEntryMatch(entry, normalizedValue)) ?? null;
+      return findPanelAppEntryByDisplayId((await nextclawClient.panelApps.listPanelApps()).entries, normalizedValue);
     } catch {
       return null;
     }

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;
-  };
 }

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

@@ -11,7 +11,9 @@ import {
   buildChatRunMetadata,
   shouldClearPendingProjectRootOverride
 } from '@/features/chat/features/session/utils/chat-run-metadata.utils';
-import { filterNcpChatModelOptionsBySessionType } from '@/features/chat/features/ncp/utils/ncp-chat-query-derived.utils';
+import {
+  filterNcpChatModelOptionsBySessionType,
+} from '@/features/chat/features/ncp/utils/ncp-chat-query-derived.utils';
 
 const modelOptions: ChatModelOption[] = [
   {
@@ -83,6 +85,29 @@ describe('filterNcpChatModelOptionsBySessionType', () => {
     }]);
   });
 
+  it('attaches runtime default thinking capability when the runtime publishes one', () => {
+    expect(
+      filterNcpChatModelOptionsBySessionType({
+        modelOptions,
+        modelSelectionMode: 'runtime-default',
+        runtimeDefaultModelLabel: 'Runtime default',
+        runtimeDefaultThinkingCapability: {
+          supported: ['minimal', 'low', 'medium', 'high'],
+          default: 'high',
+        },
+      })
+    ).toEqual([{
+      value: RUNTIME_DEFAULT_MODEL_VALUE,
+      modelLabel: 'Runtime default',
+      providerLabel: '',
+      isRuntimeDefault: true,
+      thinkingCapability: {
+        supported: ['minimal', 'low', 'medium', 'high'],
+        default: 'high',
+      },
+    }]);
+  });
+
   it('adds the runtime default option beside supported models for optional runtime selection', () => {
     expect(
       filterNcpChatModelOptionsBySessionType({
@@ -102,6 +127,27 @@ describe('filterNcpChatModelOptionsBySessionType', () => {
       modelOptions[1],
     ]);
   });
+
+  it('adds runtime default thinking capability beside supported models for optional runtime selection', () => {
+    expect(
+      filterNcpChatModelOptionsBySessionType({
+        modelOptions,
+        modelSelectionMode: 'optional',
+        runtimeDefaultModelLabel: 'Runtime default',
+        runtimeDefaultThinkingCapability: {
+          supported: ['minimal', 'low', 'medium', 'high'],
+          default: 'high',
+        },
+        supportedModels: ['openai/gpt-5'],
+      })[0]
+    ).toMatchObject({
+      value: RUNTIME_DEFAULT_MODEL_VALUE,
+      thinkingCapability: {
+        supported: ['minimal', 'low', 'medium', 'high'],
+        default: 'high',
+      },
+    });
+  });
 });
 
 describe('buildChatRunMetadata', () => {

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

@@ -30,6 +30,23 @@ import { isNcpChatRuntimeBlocked, resolveNcpChatSendErrorMessage } from "@/featu
 import { useUiShowContentEvent } from "@/features/chat/features/ncp/hooks/use-ui-show-content-event";
 import { readNcpContextWindowValue } from "@/features/chat/features/session/utils/ncp-session-context-metadata.utils";
 
+function useChatDraftIntentConsumer() {
+  const appPresenter = useAppPresenter();
+  const presenter = usePresenter();
+  useEffect(() => {
+    const applyIntent = (intent: { id: number; prompt: string }) => {
+      presenter.startAgentCreationDraft(intent.prompt);
+      appPresenter.chatDraftIntentManager.markConsumed(intent.id);
+    };
+    const unsubscribe = appPresenter.chatDraftIntentManager.subscribe(applyIntent);
+    const pendingIntent = appPresenter.chatDraftIntentManager.consumePending();
+    if (pendingIntent) {
+      applyIntent(pendingIntent);
+    }
+    return unsubscribe;
+  }, [appPresenter, presenter]);
+}
+
 function useNcpChatRouteSelection() {
   const { sessionId: routeSessionIdParam } = useParams<{ sessionId?: string }>();
   const routeSessionKey = useMemo(
@@ -170,6 +187,7 @@ function NcpChatPageContent({ view }: ChatPageProps) {
     syncRouteSessionSelection:
       presenter.chatSessionListManager.syncRouteSessionSelection,
   });
+  useChatDraftIntentConsumer();
   useUiShowContentEvent();
   useChatRunSnapshotSync({
     agent,

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

@@ -2,7 +2,12 @@ import { create } from 'zustand';
 import type { ChatComposerNode } from '@nextclaw/agent-chat-ui';
 import type { NcpDraftAttachment } from '@nextclaw/ncp-react';
 import type { RuntimeModelSelectionMode } from '@nextclaw/shared';
-import type { SessionSkillEntryView, SessionTypeIconView, ThinkingLevel } from '@/shared/lib/api';
+import type {
+  RuntimeDefaultThinkingView,
+  SessionSkillEntryView,
+  SessionTypeIconView,
+  ThinkingLevel,
+} from '@/shared/lib/api';
 import type { ChatModelOption } from '@/features/chat/types/chat-input.types';
 import { createInitialChatComposerNodes } from '@/features/chat/features/input/utils/chat-composer-state.utils';
 
@@ -14,6 +19,7 @@ export type ChatInputSnapshot = {
   pendingSessionType: string;
   pendingProjectRoot: string | null;
   pendingProjectRootSessionKey: string | null;
+  defaultProjectRoot: string | null;
   defaultSessionType: string;
   canStopGeneration: boolean;
   stopDisabledReason: string | null;
@@ -32,6 +38,7 @@ export type ChatInputSnapshot = {
     supportedModels?: string[];
     recommendedModel?: string | null;
     modelSelectionMode?: RuntimeModelSelectionMode;
+    runtimeDefaultThinking?: RuntimeDefaultThinkingView | null;
     cta?: {
       kind: string;
       label?: string;
@@ -63,6 +70,7 @@ const initialSnapshot: ChatInputSnapshot = {
   pendingSessionType: 'native',
   pendingProjectRoot: null,
   pendingProjectRootSessionKey: null,
+  defaultProjectRoot: null,
   defaultSessionType: 'native',
   canStopGeneration: false,
   stopDisabledReason: null,