@nextclaw/ui 0.18.0 → 0.18.2

package/src/features/chat/features/conversation/components/session-conversation-input.tsx

@@ -14,7 +14,7 @@ import { isRuntimeDefaultModelValue } from '@nextclaw/shared';
 
 import { useI18n } from '@/app/components/i18n-provider';
 import { useViewportLayout } from '@/app/hooks/use-viewport-layout';
-import { updateNcpSession, type SessionSkillEntryView, type ThinkingLevel } from '@/shared/lib/api';
+import { type SessionSkillEntryView } from '@/shared/lib/api';
 import { t } from '@/shared/lib/i18n';
 import { usePresenter } from '@/features/chat/components/providers/chat-presenter.provider';
 import {
@@ -46,6 +46,7 @@ import {
 import { useSessionConversationInputAttachments } from '@/features/chat/features/conversation/hooks/use-session-conversation-input-attachments';
 import { useChatComposerReferenceIntent } from '@/features/chat/features/conversation/hooks/use-chat-composer-reference-intent';
 import { useSessionConversationComposerNodes } from '@/features/chat/features/conversation/hooks/use-session-conversation-composer-nodes';
+import { useSessionConversationPreferencePersistence } from '@/features/chat/features/conversation/hooks/use-session-conversation-preference-persistence';
 import { useSessionConversationSlashCommands } from '@/features/chat/features/conversation/hooks/use-session-conversation-slash-commands';
 import { useSystemObjectReferenceSelect } from '@/features/chat/features/conversation/hooks/use-system-object-reference-select';
 import { ChatConversationTrack } from '@/features/chat/components/conversation/chat-conversation-track';
@@ -281,15 +282,7 @@ export const SessionConversationInput = memo(function SessionConversationInput(p
     inputBarRef,
     addAttachments: inputActions.addAttachments,
   });
-  const syncSessionPreferences = useCallback((patch: {
-    preferredModel?: string | null;
-    preferredThinking?: ThinkingLevel | null;
-  }) => {
-    if (!inputQuery.selectedSessionKey || !inputQuery.selectedSession) {
-      return;
-    }
-    void updateNcpSession(inputQuery.selectedSessionKey, patch).catch(() => undefined);
-  }, [inputQuery.selectedSession, inputQuery.selectedSessionKey]);
+  const persistSessionPreferences = useSessionConversationPreferencePersistence({ inputActions, selectedSessionKey: inputQuery.selectedSessionKey });
   const handleNodesChange = useSessionConversationComposerNodes(inputActions);
 
   useChatComposerReferenceIntent({
@@ -315,17 +308,22 @@ export const SessionConversationInput = memo(function SessionConversationInput(p
     if (!isRuntimeDefaultModelValue(value)) {
       chatRecentModelsManager.remember(value);
     }
-    syncSessionPreferences({
-      preferredModel: isRuntimeDefaultModelValue(value) ? null : value,
-      preferredThinking: nextThinkingLevel,
-    });
+    persistSessionPreferences(
+      {
+        preferredModel: isRuntimeDefaultModelValue(value) ? null : value,
+        preferredThinking: nextThinkingLevel,
+      },
+      { selectedModel: value, selectedThinkingLevel: nextThinkingLevel },
+      { selectedModel, selectedThinkingLevel },
+    );
   }, [
     inputActions,
     discoveredModelRecords,
     inputQuery.sessionTypeState.selectedSessionType,
     modelRecords,
     selectedThinkingLevel,
-    syncSessionPreferences,
+    persistSessionPreferences,
+    selectedModel,
   ]);
   const handleDiscoveredModelSelect = useCallback(async (value: string) => {
     const option = await inputQuery.addDiscoveredModel(value);
@@ -339,8 +337,10 @@ export const SessionConversationInput = memo(function SessionConversationInput(p
   ]);
   const handleThinkingChange = useCallback((value: ChatThinkingLevel | null) => {
     inputActions.setSelectedThinkingLevel(value);
-    syncSessionPreferences({ preferredThinking: value });
-  }, [inputActions, syncSessionPreferences]);
+    persistSessionPreferences(
+      { preferredThinking: value }, { selectedThinkingLevel: value }, { selectedThinkingLevel },
+    );
+  }, [inputActions, persistSessionPreferences, selectedThinkingLevel]);
   const handleSelectedSkillsChange = useCallback((next: string[]) => {
     const previousSelection = inputSnapshot.selectedSkills;
     next

package/src/features/chat/features/conversation/hooks/__tests__/use-session-conversation-input-state.test.tsx

@@ -21,6 +21,18 @@ const MODEL_OPTIONS: ChatModelOption[] = [
   },
 ];
 
+const THINKING_MODEL_OPTIONS: ChatModelOption[] = [
+  {
+    value: 'openai/gpt-5.6',
+    modelLabel: 'GPT-5.6',
+    providerLabel: 'OpenAI',
+    thinkingCapability: {
+      supported: ['low', 'medium', 'high'],
+      default: 'high',
+    },
+  },
+];
+
 describe('useSessionConversationInputState session preferences', () => {
   beforeEach(() => {
     window.localStorage.clear();
@@ -36,6 +48,25 @@ describe('useSessionConversationInputState session preferences', () => {
     expect(result.current.inputSnapshot.composerFocusRequestId).toBe(1);
   });
 
+  it('does not let hydration overwrite explicit off when the provider only declares active levels', () => {
+    const { result } = renderHook(() => useSessionConversationInputState());
+
+    act(() => {
+      result.current.inputActions.setSelectedThinkingLevel('off');
+    });
+    act(() => {
+      result.current.inputActions.syncSessionPreferences({
+        fallbackPreferredThinking: 'high',
+        modelOptions: THINKING_MODEL_OPTIONS,
+        selectedSessionExists: false,
+        selectedSessionKey: null,
+        selectedSessionType: 'native',
+      });
+    });
+
+    expect(result.current.inputSnapshot.selectedThinkingLevel).toBe('off');
+  });
+
   it('restores the switched session model after its metadata becomes available', () => {
     const { result } = renderHook(() => useSessionConversationInputState());
 

package/src/features/chat/features/conversation/hooks/__tests__/use-session-conversation-preference-persistence.test.tsx

@@ -0,0 +1,110 @@
+import { act, renderHook, waitFor } from '@testing-library/react';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { useSessionConversationPreferencePersistence } from '@/features/chat/features/conversation/hooks/use-session-conversation-preference-persistence';
+import type { SessionConversationInputActions } from '@/features/chat/features/conversation/hooks/use-session-conversation-input-state';
+
+const mocks = vi.hoisted(() => ({
+  updateSession: vi.fn(),
+}));
+
+vi.mock('@/features/chat/features/session/hooks/use-chat-session-update', () => ({
+  useChatSessionUpdate: () => mocks.updateSession,
+}));
+
+function createInputActions() {
+  return {
+    update: vi.fn(),
+  } as unknown as SessionConversationInputActions;
+}
+
+describe('useSessionConversationPreferencePersistence', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mocks.updateSession.mockResolvedValue(undefined);
+  });
+
+  it('persists explicit off for a selected session without a success toast', async () => {
+    const inputActions = createInputActions();
+    const { result } = renderHook(() => useSessionConversationPreferencePersistence({
+      inputActions,
+      selectedSessionKey: 'session-1',
+    }));
+
+    act(() => result.current(
+      { preferredThinking: 'off' },
+      { selectedThinkingLevel: 'off' },
+      { selectedThinkingLevel: 'high' },
+    ));
+
+    await waitFor(() => expect(mocks.updateSession).toHaveBeenCalledWith({
+      invalidateSessionSkills: false,
+      sessionKey: 'session-1',
+      patch: { preferredThinking: 'off' },
+      successMessage: null,
+    }));
+  });
+
+  it('rolls back the latest failed thinking mutation only when it is still visible', async () => {
+    mocks.updateSession.mockRejectedValueOnce(new Error('save failed'));
+    const inputActions = createInputActions();
+    const { result } = renderHook(() => useSessionConversationPreferencePersistence({
+      inputActions,
+      selectedSessionKey: 'session-1',
+    }));
+
+    act(() => result.current(
+      { preferredThinking: 'off' },
+      { selectedThinkingLevel: 'off' },
+      { selectedThinkingLevel: 'high' },
+    ));
+
+    await waitFor(() => expect(inputActions.update).toHaveBeenCalledOnce());
+    const rollback = vi.mocked(inputActions.update).mock.calls[0]?.[0];
+    expect(typeof rollback).toBe('function');
+    expect((rollback as (current: never) => unknown)({
+      selectedModel: 'openai/gpt-5.6',
+      selectedThinkingLevel: 'off',
+    } as never)).toEqual({ selectedThinkingLevel: 'high' });
+  });
+
+  it('rolls back a failed runtime-default model selection using its UI value', async () => {
+    mocks.updateSession.mockRejectedValueOnce(new Error('save failed'));
+    const inputActions = createInputActions();
+    const { result } = renderHook(() => useSessionConversationPreferencePersistence({
+      inputActions,
+      selectedSessionKey: 'session-1',
+    }));
+
+    act(() => result.current(
+      { preferredModel: null },
+      { selectedModel: '__runtime_default__' },
+      { selectedModel: 'openai/gpt-5.6' },
+    ));
+
+    await waitFor(() => expect(inputActions.update).toHaveBeenCalledOnce());
+    const rollback = vi.mocked(inputActions.update).mock.calls[0]?.[0];
+    expect((rollback as (current: never) => unknown)({
+      selectedModel: '__runtime_default__',
+      selectedThinkingLevel: 'high',
+    } as never)).toEqual({ selectedModel: 'openai/gpt-5.6' });
+  });
+
+  it('does not write a draft preference to a remote session', async () => {
+    const inputActions = createInputActions();
+    const { result } = renderHook(() => useSessionConversationPreferencePersistence({
+      inputActions,
+      selectedSessionKey: null,
+    }));
+
+    act(() => result.current(
+      { preferredThinking: 'off' },
+      { selectedThinkingLevel: 'off' },
+      { selectedThinkingLevel: 'high' },
+    ));
+    await Promise.resolve();
+
+    expect(mocks.updateSession).not.toHaveBeenCalled();
+    expect(inputActions.update).not.toHaveBeenCalled();
+  });
+});

package/src/features/chat/features/conversation/hooks/use-session-conversation-input-state.ts

@@ -196,7 +196,7 @@ function usePersistedConversationInputSnapshot(
     });
   }, [draftKey, initialSnapshot]);
 
-  return { snapshot, update };
+  return { draftKey, snapshot, update };
 }
 
 export const useSessionConversationInputState = (
@@ -204,7 +204,7 @@ export const useSessionConversationInputState = (
   sessionKey: string | null = null,
 ) => {
   const pendingProjectRoot = useChatThreadStore((state) => state.snapshot.draftProjectRoot);
-  const { snapshot, update } = usePersistedConversationInputSnapshot(
+  const { draftKey, snapshot, update } = usePersistedConversationInputSnapshot(
     initialPrompt,
     sessionKey,
   );
@@ -268,6 +268,7 @@ export const useSessionConversationInputState = (
   });
 
   const preferenceActions = useSessionConversationPreferenceActions({
+    preferenceOwnerKey: draftKey,
     selectedModel: snapshot.selectedModel,
     selectedThinkingLevel: snapshot.selectedThinkingLevel,
     updatePreferences: update,

package/src/features/chat/features/conversation/hooks/use-session-conversation-preference-actions.ts

@@ -22,6 +22,7 @@ export type SessionConversationPreferenceSyncParams = {
 };
 
 type SessionConversationPreferenceActionsParams = {
+  readonly preferenceOwnerKey: string;
   readonly selectedModel: ConversationPreferenceValue;
   readonly selectedThinkingLevel: ThinkingLevel | null;
   readonly updatePreferences: (patch: {
@@ -31,14 +32,23 @@ type SessionConversationPreferenceActionsParams = {
 };
 
 export const useSessionConversationPreferenceActions = ({
+  preferenceOwnerKey,
   selectedModel: currentSelectedModel,
   selectedThinkingLevel: currentSelectedThinkingLevel,
   updatePreferences,
 }: SessionConversationPreferenceActionsParams) => {
   const previousPreferenceContextRef = useRef<string | undefined>(undefined);
+  const localThinkingSelectionRef = useRef<{
+    readonly ownerKey: string;
+    readonly value: ThinkingLevel | null;
+  } | null>(null);
   const setSelectedThinkingLevel = useCallback((selectedThinkingLevel: ThinkingLevel | null) => {
+    localThinkingSelectionRef.current = {
+      ownerKey: preferenceOwnerKey,
+      value: selectedThinkingLevel,
+    };
     updatePreferences({ selectedThinkingLevel });
-  }, [updatePreferences]);
+  }, [preferenceOwnerKey, updatePreferences]);
   const syncSessionPreferences = useCallback(({
     defaultModel,
     fallbackPreferredModel,
@@ -54,6 +64,17 @@ export const useSessionConversationPreferenceActions = ({
     const preferenceContextKey = JSON.stringify([selectedSessionType, selectedSessionKey]);
     const preferenceContextChanged = previousPreferenceContextRef.current !== preferenceContextKey;
     const preserveCurrentPreference = preferenceContextChanged && Boolean(selectedSessionKey) && !selectedSessionExists;
+    const localThinkingSelection = localThinkingSelectionRef.current;
+    const localThinkingSelectionAcknowledged =
+      localThinkingSelection?.ownerKey === preferenceOwnerKey &&
+      selectedSessionExists &&
+      selectedSessionPreferredThinking === localThinkingSelection.value;
+    if (localThinkingSelectionAcknowledged) {
+      localThinkingSelectionRef.current = null;
+    }
+    const preserveLocalThinkingSelection =
+      localThinkingSelection?.ownerKey === preferenceOwnerKey &&
+      !localThinkingSelectionAcknowledged;
     const selectedModel = resolveSelectedModelValue({
       currentSelectedModel: currentSelectedModel ?? undefined,
       modelOptions,
@@ -73,7 +94,8 @@ export const useSessionConversationPreferenceActions = ({
       defaultThinkingLevel:
         (modelOption?.thinkingCapability?.default as ThinkingLevel | null | undefined) ?? null,
       preferSessionPreferredThinking: preferenceContextChanged,
-      preserveCurrentSelectedThinkingOnSessionChange: preserveCurrentPreference,
+      preserveCurrentSelectedThinkingOnSessionChange:
+        preserveCurrentPreference || preserveLocalThinkingSelection,
     });
     if (
       currentSelectedModel !== selectedModel ||
@@ -84,7 +106,12 @@ export const useSessionConversationPreferenceActions = ({
     if (!selectedSessionKey || selectedSessionExists) {
       previousPreferenceContextRef.current = preferenceContextKey;
     }
-  }, [currentSelectedModel, currentSelectedThinkingLevel, updatePreferences]);
+  }, [
+    currentSelectedModel,
+    currentSelectedThinkingLevel,
+    preferenceOwnerKey,
+    updatePreferences,
+  ]);
 
   return useMemo(() => ({
     setSelectedThinkingLevel,

package/src/features/chat/features/conversation/hooks/use-session-conversation-preference-persistence.ts

@@ -0,0 +1,88 @@
+import { useCallback, useRef } from 'react';
+
+import type { SessionPatchUpdate, ThinkingLevel } from '@/shared/lib/api';
+import { useChatSessionUpdate } from '@/features/chat/features/session/hooks/use-chat-session-update';
+import type {
+  SessionConversationInputActions,
+  SessionConversationInputSnapshot,
+} from '@/features/chat/features/conversation/hooks/use-session-conversation-input-state';
+
+type SessionPreferencePatch = Pick<
+  SessionPatchUpdate,
+  'preferredModel' | 'preferredThinking'
+>;
+
+type SessionPreferenceRollback = Pick<
+  SessionConversationInputSnapshot,
+  'selectedModel' | 'selectedThinkingLevel'
+>;
+
+function ownsField<T extends object>(value: T, field: keyof T): boolean {
+  return Object.prototype.hasOwnProperty.call(value, field);
+}
+
+export function useSessionConversationPreferencePersistence(params: {
+  readonly inputActions: SessionConversationInputActions;
+  readonly selectedSessionKey: string | null;
+}) {
+  const { inputActions, selectedSessionKey } = params;
+  const updateSession = useChatSessionUpdate();
+  const mutationSequenceRef = useRef(0);
+  const latestMutationByFieldRef = useRef(new Map<string, number>());
+  const persistenceQueueRef = useRef<Promise<void>>(Promise.resolve());
+
+  return useCallback((
+    patch: SessionPreferencePatch,
+    optimistic: Partial<SessionPreferenceRollback>,
+    rollback: Partial<SessionPreferenceRollback>,
+  ) => {
+    const sessionKey = selectedSessionKey?.trim();
+    if (!sessionKey) {
+      return;
+    }
+
+    const mutationId = ++mutationSequenceRef.current;
+    const modelMutationKey = `${sessionKey}:model`;
+    const thinkingMutationKey = `${sessionKey}:thinking`;
+    if (ownsField(patch, 'preferredModel')) {
+      latestMutationByFieldRef.current.set(modelMutationKey, mutationId);
+    }
+    if (ownsField(patch, 'preferredThinking')) {
+      latestMutationByFieldRef.current.set(thinkingMutationKey, mutationId);
+    }
+
+    const operation = persistenceQueueRef.current.then(() => updateSession({
+      invalidateSessionSkills: false,
+      sessionKey,
+      patch,
+      successMessage: null,
+    }));
+    persistenceQueueRef.current = operation.catch(() => undefined);
+
+    void operation.catch(() => {
+      inputActions.update((current) => {
+        const next: {
+          selectedModel?: string | null | undefined;
+          selectedThinkingLevel?: ThinkingLevel | null;
+        } = {};
+        if (
+          ownsField(patch, 'preferredModel') &&
+          latestMutationByFieldRef.current.get(modelMutationKey) === mutationId &&
+          current.selectedModel === optimistic.selectedModel &&
+          ownsField(rollback, 'selectedModel')
+        ) {
+          next.selectedModel = rollback.selectedModel;
+        }
+        if (
+          ownsField(patch, 'preferredThinking') &&
+          latestMutationByFieldRef.current.get(thinkingMutationKey) === mutationId &&
+          current.selectedThinkingLevel === optimistic.selectedThinkingLevel &&
+          ownsField(rollback, 'selectedThinkingLevel')
+        ) {
+          next.selectedThinkingLevel = rollback.selectedThinkingLevel;
+        }
+        return next;
+      });
+    });
+  }, [inputActions, selectedSessionKey, updateSession]);
+}

package/src/features/chat/features/input/utils/chat-input-toolbar.utils.ts

@@ -8,6 +8,7 @@ import type {
   ChatThinkingLevel,
 } from "@/features/chat/types/chat-input-bar.types";
 import type { ChatModelOption } from "@/features/chat/types/chat-input.types";
+import { resolveSelectableThinkingLevels } from "@/shared/lib/provider-models";
 
 function formatModelOptionLabel(option: ChatModelRecord): string {
   const modelLabel = option.modelLabel.trim();
@@ -44,18 +45,6 @@ export function toChatModelRecords(snapshotModels: ChatModelOption[]): ChatModel
   }));
 }
 
-function normalizeThinkingLevels(
-  levels: ChatThinkingLevel[],
-): ChatThinkingLevel[] {
-  const deduped: ChatThinkingLevel[] = [];
-  for (const level of ["off", ...levels] as ChatThinkingLevel[]) {
-    if (!deduped.includes(level)) {
-      deduped.push(level);
-    }
-  }
-  return deduped;
-}
-
 export function buildModelStateHint(params: {
   isModelOptionsEmpty: boolean;
   onGoToProviders: () => void;
@@ -284,7 +273,7 @@ export function buildThinkingToolbarSelect(params: {
     return null;
   }
 
-  const options = normalizeThinkingLevels(supportedLevels);
+  const options = resolveSelectableThinkingLevels(supportedLevels);
   const fallback = options.includes("off") ? "off" : options[0];
   const resolvedValue =
     (selectedThinkingLevel &&

package/src/features/chat/features/session/hooks/__tests__/use-chat-session-update.test.tsx

@@ -71,4 +71,31 @@ describe('useChatSessionUpdate', () => {
     });
     expect(toast.success).toHaveBeenCalledWith('Project directory updated');
   });
+
+  it('can update an inline preference without showing a success toast', async () => {
+    const queryClient = new QueryClient();
+    const invalidateQueriesSpy = vi.spyOn(queryClient, 'invalidateQueries');
+    mocks.updateNcpSession.mockResolvedValue({
+      sessionId: 'session-1',
+      updatedAt: '2026-08-15T00:00:00.000Z',
+      status: 'idle',
+      metadata: { preferred_thinking: 'off' },
+    });
+    const { result } = renderHook(() => useChatSessionUpdate(), {
+      wrapper: createWrapper(queryClient),
+    });
+
+    await act(async () => {
+      await result.current({
+        invalidateSessionSkills: false,
+        sessionKey: 'session-1',
+        patch: { preferredThinking: 'off' },
+        successMessage: null,
+      });
+    });
+
+    expect(toast.success).not.toHaveBeenCalled();
+    expect(mocks.upsertNcpSessionSummaryInQueryClient).toHaveBeenCalledOnce();
+    expect(invalidateQueriesSpy).not.toHaveBeenCalled();
+  });
 });

package/src/features/chat/features/session/hooks/use-chat-session-update.ts

@@ -1,3 +1,4 @@
+import { useCallback } from 'react';
 import { useQueryClient } from '@tanstack/react-query';
 import { toast } from 'sonner';
 import type { SessionPatchUpdate } from '@/shared/lib/api';
@@ -6,9 +7,10 @@ import { upsertNcpSessionSummaryInQueryClient } from '@/shared/lib/api';
 import { t } from '@/shared/lib/i18n';
 
 type UpdateChatSessionParams = {
+  invalidateSessionSkills?: boolean;
   sessionKey: string;
   patch: SessionPatchUpdate;
-  successMessage?: string;
+  successMessage?: string | null;
 };
 
 type UpdateChatSessionLabelParams = {
@@ -19,18 +21,27 @@ type UpdateChatSessionLabelParams = {
 export function useChatSessionUpdate() {
   const queryClient = useQueryClient();
 
-  return async (params: UpdateChatSessionParams): Promise<void> => {
-    const { sessionKey, patch, successMessage } = params;
+  return useCallback(async (params: UpdateChatSessionParams): Promise<void> => {
+    const {
+      invalidateSessionSkills = true,
+      sessionKey,
+      patch,
+      successMessage,
+    } = params;
     try {
       const updated = await updateNcpSession(sessionKey, patch);
       upsertNcpSessionSummaryInQueryClient(queryClient, updated);
-      await queryClient.invalidateQueries({ queryKey: ['ncp-session-skills', sessionKey] });
-      toast.success(successMessage ?? t('configSavedApplied'));
+      if (invalidateSessionSkills) {
+        await queryClient.invalidateQueries({ queryKey: ['ncp-session-skills', sessionKey] });
+      }
+      if (successMessage !== null) {
+        toast.success(successMessage ?? t('configSavedApplied'));
+      }
     } catch (error) {
       toast.error(t('configSaveFailed') + ': ' + (error instanceof Error ? error.message : String(error)));
       throw error;
     }
-  };
+  }, [queryClient]);
 }
 
 export function useChatSessionLabel() {

package/src/features/chat/features/session/utils/chat-session-preference-governance.utils.ts

@@ -1,5 +1,6 @@
 import type { SessionEntryView, ThinkingLevel } from '@/shared/lib/api';
 import type { ChatModelOption } from '@/features/chat/types/chat-input.types';
+import { resolveSelectableThinkingLevels } from '@/shared/lib/provider-models';
 
 function normalizeSessionType(value: string | null | undefined): string {
   return value?.trim().toLowerCase() || 'native';
@@ -115,13 +116,14 @@ export function resolveSelectedThinkingLevelValue(params: {
   if (supportedThinkingLevels.length === 0) {
     return null;
   }
+  const selectableThinkingLevels = resolveSelectableThinkingLevels(supportedThinkingLevels);
   return resolveSessionPreferenceValue<ThinkingLevel>({
     currentValue: currentSelectedThinkingLevel,
     selectedSessionPreferredValue: selectedSessionPreferredThinking,
     fallbackPreferredValue: fallbackPreferredThinking,
     defaultValue: defaultThinkingLevel,
-    isValueSupported: (value): value is ThinkingLevel => hasThinkingLevelOption(supportedThinkingLevels, value),
-    firstAvailableValue: resolveFallbackThinkingLevel(supportedThinkingLevels) ?? 'off',
+    isValueSupported: (value): value is ThinkingLevel => hasThinkingLevelOption(selectableThinkingLevels, value),
+    firstAvailableValue: resolveFallbackThinkingLevel(selectableThinkingLevels) ?? 'off',
     preferSessionPreferredValue: preferSessionPreferredThinking,
     preserveCurrentValueOnSessionChange: preserveCurrentSelectedThinkingOnSessionChange
   });

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

@@ -539,6 +539,17 @@ describe('resolveRecentSessionPreferredModel', () => {
 });
 
 describe('resolveSelectedThinkingLevelValue', () => {
+  it('keeps explicit off when provider capabilities only declare active levels', () => {
+    expect(
+      resolveSelectedThinkingLevelValue({
+        currentSelectedThinkingLevel: 'off',
+        supportedThinkingLevels: ['low', 'medium', 'high'],
+        fallbackPreferredThinking: 'high',
+        defaultThinkingLevel: 'medium'
+      })
+    ).toBe('off');
+  });
+
   it('keeps the current selected thinking when it is still valid', () => {
     expect(
       resolveSelectedThinkingLevelValue({

package/src/shared/lib/i18n/locales/en-US/doc-browser.json

@@ -66,6 +66,8 @@
   "appPackagesBuiltIn": "Built into NextClaw",
   "appPackagesLocalService": "Local data service",
   "appPackagesIsolationLabel": "Runtime isolation",
+  "appPackagesPlatformsLabel": "Supported platforms",
+  "appPackagesAllPlatforms": "All platforms",
   "appPackagesIsolationPanel": "Isolated interface",
   "appPackagesIsolationMediated": "Host-mediated runtime",
   "appPackagesIsolationFullUser": "Runs with your user permissions",

package/src/shared/lib/i18n/locales/zh-CN/doc-browser.json

@@ -66,6 +66,8 @@
   "appPackagesBuiltIn": "NextClaw 内置",
   "appPackagesLocalService": "本地数据服务",
   "appPackagesIsolationLabel": "运行隔离",
+  "appPackagesPlatformsLabel": "支持平台",
+  "appPackagesAllPlatforms": "全部平台",
   "appPackagesIsolationPanel": "隔离界面",
   "appPackagesIsolationMediated": "受限运行",
   "appPackagesIsolationFullUser": "以当前用户权限运行",

package/src/shared/lib/provider-models/index.ts

@@ -108,6 +108,17 @@ export function normalizeThinkingLevels(values: unknown): ThinkingLevel[] {
   return deduped;
 }
 
+/**
+ * Provider capabilities describe active thinking efforts. NextClaw owns the
+ * explicit off state, so every declared thinking capability exposes it to chat
+ * consumers even when the provider does not repeat it in `supported`.
+ */
+export function resolveSelectableThinkingLevels(
+  supported: readonly ThinkingLevel[]
+): ThinkingLevel[] {
+  return supported.includes('off') ? [...supported] : ['off', ...supported];
+}
+
 export function normalizeModelConfigMap(
   input: ProviderConfigView['modelConfig'],
   aliases: string[]

package/dist/assets/doc-browser-DEdoMb3X.js

@@ -1 +0,0 @@
-import{t as e}from"./doc-browser-BFfstBoh.js";export{e as DocBrowser};