@nextclaw/ui 0.17.2 → 0.18.1

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

@@ -180,6 +180,52 @@ describe('useSessionConversationController backend run queue', () => {
     expect(params.resetComposer).toHaveBeenCalledTimes(1);
   });
 
+  it('sends a preset message without clearing the existing composer draft', async () => {
+    const send = createSendMock();
+    const params = createControllerParams({ isRunning: false, send });
+    const paramsWithSelectedSkill = {
+      ...params,
+      inputSnapshot: {
+        ...params.inputSnapshot,
+        selectedSkills: ['skill-ref'],
+        skillRecords: [{ ref: 'skill-ref', name: 'Selected skill' }],
+      },
+    } as unknown as Parameters<typeof useSessionConversationController>[0];
+    const { result } = renderHook(() => useSessionConversationController(paramsWithSelectedSkill));
+
+    await act(async () => {
+      await result.current.sendPresetMessage('Update this session title');
+    });
+
+    const envelope = send.mock.calls[0]?.[0];
+    expect(envelope).toMatchObject({
+      sessionId: 'session-1',
+      message: expect.objectContaining({
+        parts: [{ type: 'text', text: 'Update this session title' }],
+      }),
+    });
+    expect(envelope?.metadata).not.toHaveProperty('requested_skill_refs');
+    expect(params.resetComposer).not.toHaveBeenCalled();
+    expect(params.restoreComposer).not.toHaveBeenCalled();
+  });
+
+  it('keeps the existing composer draft untouched when a preset message fails', async () => {
+    const sendError = new Error('preset submission failed');
+    const send = vi.fn<TestAgentSend>(async () => {
+      throw sendError;
+    });
+    const params = createControllerParams({ isRunning: false, send });
+    const { result } = renderHook(() => useSessionConversationController(params));
+
+    await act(async () => {
+      await expect(result.current.sendPresetMessage('Update title')).rejects.toThrow(sendError);
+    });
+
+    expect(params.resetComposer).not.toHaveBeenCalled();
+    expect(params.restoreComposer).not.toHaveBeenCalled();
+    expect(params.setSendError).toHaveBeenLastCalledWith(sendError.message);
+  });
+
   it('projects a submitting queue row before the backend acknowledges the message', async () => {
     let resolveSend!: (handle: NcpRunHandle) => void;
     const send = vi.fn<TestAgentSend>(() => new Promise((resolve) => {

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/__tests__/use-session-conversation-slash-commands.test.tsx

@@ -7,6 +7,7 @@ import { useSessionConversationSlashCommands } from '@/features/chat/features/co
 const mocks = vi.hoisted(() => ({
   compactNcpSessionContext: vi.fn(),
   openSideChatDraft: vi.fn(),
+  sendPresetMessage: vi.fn(),
 }));
 
 vi.mock('sonner', () => ({
@@ -35,12 +36,14 @@ describe('useSessionConversationSlashCommands', () => {
   it('exposes the runtime compaction command for the selected session', async () => {
     const { result } = renderHook(() => useSessionConversationSlashCommands({
       language: 'en',
+      onSendPresetMessage: mocks.sendPresetMessage,
       selectedSessionKey: ' session-1 ',
     }));
     const command = result.current.find((entry) => entry.key === 'compact-context');
 
     expect(result.current.map(({ key, icon }) => ({ key, icon }))).toEqual([
       { key: 'side-chat', icon: 'message-square-plus' },
+      { key: 'update-session-title', icon: 'command' },
       { key: 'compact-context', icon: 'list-collapse' },
     ]);
     act(() => command?.onSelect());
@@ -56,6 +59,7 @@ describe('useSessionConversationSlashCommands', () => {
     }));
     const { result } = renderHook(() => useSessionConversationSlashCommands({
       language: 'en',
+      onSendPresetMessage: mocks.sendPresetMessage,
       selectedSessionKey: 'session-1',
     }));
     const command = result.current.find((entry) => entry.key === 'compact-context');
@@ -83,6 +87,7 @@ describe('useSessionConversationSlashCommands', () => {
     const onContextCompactingChange = vi.fn();
     const { result } = renderHook(() => useSessionConversationSlashCommands({
       language: 'en',
+      onSendPresetMessage: mocks.sendPresetMessage,
       selectedSessionKey: 'session-1',
       onContextCompactingChange,
     }));
@@ -100,9 +105,24 @@ describe('useSessionConversationSlashCommands', () => {
     ));
   });
 
+  it('sends the localized title update prompt through the conversation callback', () => {
+    const { result } = renderHook(() => useSessionConversationSlashCommands({
+      language: 'en',
+      onSendPresetMessage: mocks.sendPresetMessage,
+      selectedSessionKey: 'session-1',
+    }));
+
+    act(() => result.current.find((entry) => entry.key === 'update-session-title')?.onSelect());
+
+    expect(mocks.sendPresetMessage).toHaveBeenCalledWith(
+      expect.stringContaining('sessions_update'),
+    );
+  });
+
   it('does not expose session commands before a session exists', () => {
     const { result } = renderHook(() => useSessionConversationSlashCommands({
       language: 'en',
+      onSendPresetMessage: mocks.sendPresetMessage,
       selectedSessionKey: null,
     }));
 

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

@@ -3,7 +3,10 @@ import { buildNcpRequestEnvelope } from '@nextclaw/ncp-react';
 import type { UiNcpSessionQueuedInputView } from '@nextclaw/client-sdk';
 import type { NcpAgentSendEnvelope, NcpRunHandle } from '@nextclaw/ncp';
 
-import { deriveNcpMessagePartsFromComposer } from '@/features/chat/features/input/utils/chat-composer-state.utils';
+import {
+  createChatComposerNodesFromDraft,
+  deriveNcpMessagePartsFromComposer,
+} from '@/features/chat/features/input/utils/chat-composer-state.utils';
 import { isNcpChatSendDisabled } from '@/features/chat/features/input/utils/ncp-chat-input-availability.utils';
 import { buildChatRunMetadata } from '@/features/chat/features/session/utils/chat-run-metadata.utils';
 import { createNcpSessionId } from '@/features/chat/features/session/utils/ncp-session-adapter.utils';
@@ -74,6 +77,7 @@ type UseSessionConversationControllerParams = {
 
 type BuildSubmissionDraftParams = {
   readonly agentIsSending: boolean;
+  readonly composerSnapshot?: ComposerDraftSnapshot;
   readonly inputSnapshot: SessionConversationInputSnapshot;
   readonly inputQuery: SessionConversationInputQuery;
   readonly isRuntimeBlocked: boolean;
@@ -87,6 +91,8 @@ type SubmissionDraft = {
   readonly metadata: Record<string, unknown>;
 };
 
+type SubmissionComposerBehavior = 'preserve' | 'reset-and-restore';
+
 type SubmittingQueuedInput = {
   readonly id: string;
   readonly preview: string;
@@ -113,6 +119,7 @@ function buildInputAvailabilitySnapshot(inputQuery: SessionConversationInputQuer
 function buildSubmissionDraft(params: BuildSubmissionDraftParams): SubmissionDraft | null {
   const {
     agentIsSending,
+    composerSnapshot: requestedComposerSnapshot,
     inputQuery,
     inputSnapshot,
     isRuntimeBlocked,
@@ -120,9 +127,16 @@ function buildSubmissionDraft(params: BuildSubmissionDraftParams): SubmissionDra
     selectedAgentId,
     sessionKey,
   } = params;
+  const composerSnapshot: ComposerDraftSnapshot = requestedComposerSnapshot ?? {
+    text: inputSnapshot.text,
+    nodes: [...inputSnapshot.nodes],
+    selectedSkills: [...inputSnapshot.selectedSkills],
+    skillRecords: [...inputSnapshot.skillRecords],
+    attachments: [...inputSnapshot.attachments],
+  };
   const currentParts = deriveNcpMessagePartsFromComposer(
-    [...inputSnapshot.nodes],
-    inputSnapshot.attachments,
+    [...composerSnapshot.nodes],
+    composerSnapshot.attachments,
   );
   if (
     isNcpChatSendDisabled({
@@ -134,13 +148,6 @@ function buildSubmissionDraft(params: BuildSubmissionDraftParams): SubmissionDra
   ) {
     return null;
   }
-  const composerSnapshot: ComposerDraftSnapshot = {
-    text: inputSnapshot.text,
-    nodes: [...inputSnapshot.nodes],
-    selectedSkills: [...inputSnapshot.selectedSkills],
-    skillRecords: [...inputSnapshot.skillRecords],
-    attachments: [...inputSnapshot.attachments],
-  };
   return {
     composerSnapshot,
     metadata: buildChatRunMetadata({
@@ -165,11 +172,11 @@ function buildSubmissionDraft(params: BuildSubmissionDraftParams): SubmissionDra
         : sessionKey
           ? inputQuery.selectedSession?.projectRoot ?? null
           : inputSnapshot.pendingProjectRoot,
-      requestedSkills: [...inputSnapshot.selectedSkills],
+      requestedSkills: [...composerSnapshot.selectedSkills],
       skillRecords: inputQuery.skillRecords.filter((record) =>
-        inputSnapshot.selectedSkills.includes(record.ref)
+        composerSnapshot.selectedSkills.includes(record.ref)
       ),
-      composerNodes: [...inputSnapshot.nodes],
+      composerNodes: [...composerSnapshot.nodes],
       sessionMaterialization: materializationContext
         ? {
             kind: materializationContext.kind,
@@ -288,6 +295,72 @@ function useQueuedInputActions(params: {
   return { deleteQueuedInput, editQueuedInput };
 }
 
+function useSubmissionDraftRunner(params: {
+  readonly agent: SessionConversationAgent;
+  readonly clearSubmittingInput: (input: SubmittingQueuedInput) => void;
+  readonly materializationContext?: SessionConversationMaterializationContext | null;
+  readonly onSessionMaterialized?: (sessionKey: string) => void;
+  readonly resetComposer: () => void;
+  readonly restoreComposer: (snapshot: ComposerDraftSnapshot) => void;
+  readonly runQueue: SessionRunQueue;
+  readonly sessionKey: string | null;
+  readonly setSendError: (message: string | null) => void;
+  readonly stageSubmittingInput: (envelope: NcpAgentSendEnvelope) => SubmittingQueuedInput | null;
+}) {
+  const {
+    agent,
+    clearSubmittingInput,
+    materializationContext,
+    onSessionMaterialized,
+    resetComposer,
+    restoreComposer,
+    runQueue,
+    sessionKey,
+    setSendError,
+    stageSubmittingInput,
+  } = params;
+  return useCallback(async (
+    draft: SubmissionDraft,
+    composerBehavior: SubmissionComposerBehavior,
+  ) => {
+    const submissionSessionKey =
+      sessionKey ?? (materializationContext ? null : createNcpSessionId());
+    const envelope = buildSubmissionEnvelope(draft, submissionSessionKey);
+    if (!envelope) return;
+    const queuedSubmission = agent.isRunning ? stageSubmittingInput(envelope) : null;
+    if (composerBehavior === 'reset-and-restore') resetComposer();
+    setSendError(null);
+    try {
+      const handle = await agent.send(envelope);
+      if (queuedSubmission && handle?.runId === null) {
+        await runQueue.refreshQueuedInputs().catch(() => undefined);
+      }
+      if (queuedSubmission) clearSubmittingInput(queuedSubmission);
+      const materializedSessionKey =
+        handle?.sessionId?.trim() || agent.snapshot.activeRun?.sessionId?.trim() || null;
+      if (!sessionKey && materializedSessionKey) {
+        onSessionMaterialized?.(materializedSessionKey);
+      }
+    } catch (error) {
+      if (queuedSubmission) clearSubmittingInput(queuedSubmission);
+      if (composerBehavior === 'reset-and-restore') restoreComposer(draft.composerSnapshot);
+      setSendError(error instanceof Error ? error.message : String(error));
+      throw error;
+    }
+  }, [
+    agent,
+    clearSubmittingInput,
+    materializationContext,
+    onSessionMaterialized,
+    resetComposer,
+    restoreComposer,
+    runQueue,
+    sessionKey,
+    setSendError,
+    stageSubmittingInput,
+  ]);
+}
+
 export function useSessionConversationController(params: UseSessionConversationControllerParams) {
   const {
     agent,
@@ -343,6 +416,19 @@ export function useSessionConversationController(params: UseSessionConversationC
     setSendError,
   });
 
+  const submitDraft = useSubmissionDraftRunner({
+    agent,
+    clearSubmittingInput,
+    materializationContext,
+    onSessionMaterialized,
+    resetComposer,
+    restoreComposer,
+    runQueue,
+    sessionKey,
+    setSendError,
+    stageSubmittingInput,
+  });
+
   const send = useCallback(async () => {
     if (primaryAction === 'continue') {
       await continueRun();
@@ -357,58 +443,55 @@ export function useSessionConversationController(params: UseSessionConversationC
       selectedAgentId,
       sessionKey,
     });
-    if (!draft) {
-      return;
+    if (draft) {
+      await submitDraft(draft, 'reset-and-restore');
     }
-    const submissionSessionKey =
-      sessionKey ?? (materializationContext ? null : createNcpSessionId());
-    const envelope = buildSubmissionEnvelope(draft, submissionSessionKey);
-    if (!envelope) {
+  }, [
+    agent.isSending,
+    continueRun,
+    inputQuery,
+    inputSnapshot,
+    isRuntimeBlocked,
+    materializationContext,
+    primaryAction,
+    selectedAgentId,
+    sessionKey,
+    submitDraft,
+  ]);
+
+  const sendPresetMessage = useCallback(async (message: string) => {
+    const text = message.trim();
+    if (!text) {
       return;
     }
-    const queuedSubmission = agent.isRunning ? stageSubmittingInput(envelope) : null;
-    resetComposer();
-    setSendError(null);
-    try {
-      const handle = await agent.send(envelope);
-      if (queuedSubmission && handle?.runId === null) {
-        await runQueue.refreshQueuedInputs().catch(() => undefined);
-      }
-      if (queuedSubmission) {
-        clearSubmittingInput(queuedSubmission);
-      }
-      const materializedSessionKey =
-        handle?.sessionId?.trim() ||
-        agent.snapshot.activeRun?.sessionId?.trim() ||
-        null;
-      if (!sessionKey && materializedSessionKey) {
-        onSessionMaterialized?.(materializedSessionKey);
-      }
-    } catch (error) {
-      if (queuedSubmission) {
-        clearSubmittingInput(queuedSubmission);
-      }
-      restoreComposer(draft.composerSnapshot);
-      setSendError(error instanceof Error ? error.message : String(error));
-      throw error;
+    const draft = buildSubmissionDraft({
+      agentIsSending: agent.isSending,
+      composerSnapshot: {
+        text,
+        nodes: createChatComposerNodesFromDraft(text),
+        selectedSkills: [],
+        skillRecords: [],
+        attachments: [],
+      },
+      inputSnapshot,
+      inputQuery,
+      isRuntimeBlocked,
+      materializationContext,
+      selectedAgentId,
+      sessionKey,
+    });
+    if (draft) {
+      await submitDraft(draft, 'preserve');
     }
   }, [
-    agent,
-    clearSubmittingInput,
-    continueRun,
+    agent.isSending,
     inputQuery,
     inputSnapshot,
     isRuntimeBlocked,
     materializationContext,
-    onSessionMaterialized,
-    resetComposer,
-    restoreComposer,
     selectedAgentId,
     sessionKey,
-    setSendError,
-    stageSubmittingInput,
-    primaryAction,
-    runQueue,
+    submitDraft,
   ]);
 
   const stop = useCallback(async () => {
@@ -426,6 +509,7 @@ export function useSessionConversationController(params: UseSessionConversationC
     isSending,
     queuedInputs,
     send,
+    sendPresetMessage,
     sendDisabled,
     primaryAction,
     stop,

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,