@nextclaw/ui 0.18.0 → 0.18.1

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

@@ -29,9 +29,12 @@ import type {
 } from '@/features/chat/features/conversation/hooks/use-session-conversation-input-state';
 import { useSessionConversationInputState } from '@/features/chat/features/conversation/hooks/use-session-conversation-input-state';
 import { useChatMessageLayoutStore } from '@/features/chat/stores/chat-message-layout.store';
+import { useChatComposerDraftStore } from '@/features/chat/stores/chat-composer-draft.store';
 import { ChatComposerIntentManager } from '@/features/chat/managers/chat-composer-intent.manager';
+import type { ThinkingLevel } from '@/shared/lib/api';
 
 const uploadNcpAssetsMock = vi.hoisted(() => vi.fn());
+const updateNcpSessionMock = vi.hoisted(() => vi.fn());
 
 function renderInput(input: ReactElement) {
   const queryClient = new QueryClient({
@@ -59,6 +62,7 @@ Object.defineProperty(Range.prototype, 'getBoundingClientRect', {
 
 afterEach(() => {
   useChatMessageLayoutStore.getState().setLayout('card');
+  updateNcpSessionMock.mockReset();
 });
 
 vi.mock('@/app/hooks/use-viewport-layout', () => ({
@@ -111,11 +115,106 @@ vi.mock('@/shared/lib/api', async (importOriginal) => {
   const actual = await importOriginal();
   return {
     ...(actual as object),
-    updateNcpSession: vi.fn(),
+    updateNcpSession: updateNcpSessionMock,
     uploadNcpAssets: uploadNcpAssetsMock,
   };
 });
 
+function ThinkingPreferenceHarness() {
+  const { inputActions, inputSnapshot } = useSessionConversationInputState(
+    undefined,
+    'thinking-session',
+  );
+  const inputQuery = useMemo(() => ({
+    addDiscoveredModel: vi.fn(async () => null),
+    dismissDiscoveredModels: vi.fn(),
+    defaultModel: 'openai/gpt-5.6',
+    defaultProjectRoot: null,
+    discoveredModelOptions: [],
+    fallbackPreferredModel: undefined,
+    fallbackPreferredThinking: 'high' as const,
+    isProviderStateResolved: true,
+    isSkillsLoading: false,
+    modelOptions: [{
+      value: 'openai/gpt-5.6',
+      modelLabel: 'GPT-5.6',
+      providerLabel: 'OpenAI',
+      thinkingCapability: {
+        supported: ['off', 'low', 'medium', 'high'] as ThinkingLevel[],
+        default: 'high' as const,
+      },
+    }],
+    providersView: null,
+    refreshProviderModelCatalog: vi.fn(),
+    selectedSession: null,
+    selectedSessionKey: 'thinking-session',
+    sessionTypeState: {
+      canEditSessionType: true,
+      defaultSessionType: 'native',
+      selectedSessionType: 'native',
+      selectedSessionTypeOption: null,
+      sessionTypeOptions: [],
+      sessionTypeUnavailable: false,
+      sessionTypeUnavailableMessage: null,
+    },
+    skillRecords: [],
+  }), []);
+
+  return (
+    <I18nProvider>
+      <ChatPresenterProvider presenter={presenter}>
+        <SessionConversationInput
+          contextWindow={null}
+          controller={{ ...controller, isSending: false, sendDisabled: false }}
+          inputActions={inputActions}
+          inputQuery={inputQuery}
+          inputSnapshot={inputSnapshot}
+        />
+      </ChatPresenterProvider>
+    </I18nProvider>
+  );
+}
+
+describe('SessionConversationInput thinking preference', () => {
+  it('switches from high to explicit off and persists the same value', async () => {
+    useChatComposerDraftStore.setState({
+      drafts: {
+        'session:thinking-session': {
+          attachments: [],
+          composerFocusRequestId: 0,
+          nodes: [],
+          pendingSessionType: 'native',
+          selectedModel: 'openai/gpt-5.6',
+          selectedSessionType: 'native',
+          selectedSkills: [],
+          selectedThinkingLevel: 'high',
+          sendError: null,
+          skillRecords: [],
+          text: '',
+        },
+      },
+    });
+    updateNcpSessionMock.mockResolvedValue({
+      sessionId: 'thinking-session',
+      updatedAt: '2026-08-15T00:00:00.000Z',
+      status: 'idle',
+      metadata: { preferred_thinking: 'off' },
+    });
+    renderInput(<ThinkingPreferenceHarness />);
+
+    fireEvent.click(screen.getByRole('combobox', { name: /High/ }));
+    fireEvent.click(await screen.findByRole('option', { name: /Off|关闭/ }));
+
+    await waitFor(() => expect(
+      screen.getByRole('combobox', { name: /Off|关闭/ }),
+    ).toBeTruthy());
+    await waitFor(() => expect(updateNcpSessionMock).toHaveBeenCalledWith(
+      'thinking-session',
+      { preferredThinking: 'off' },
+    ));
+  });
+});
+
 type StreamingInputControl = {
   bumpStream: () => void;
 };

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: ['off', '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 first preference hydration overwrite an explicit off selection', () => {
+    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/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/dist/assets/remote-BYPq49kD.js

@@ -1 +0,0 @@
-import{Mt as e}from"./index-L58BO782.js";export{e as RemoteAccessPage};