@nextclaw/ui 0.9.2 → 0.9.4

package/src/components/chat/chat-page-data.ts

@@ -4,9 +4,11 @@ import type { SessionEntryView, ThinkingLevel } from '@/api/types';
 import type { ChatModelOption } from '@/components/chat/chat-input.types';
 import { useChatSessionTypeState } from '@/components/chat/useChatSessionTypeState';
 import {
+  resolveRecentSessionPreferredThinking,
   resolveRecentSessionPreferredModel,
-  useSyncSelectedModel
-} from '@/components/chat/chat-page-runtime';
+  useSyncSelectedModel,
+  useSyncSelectedThinking
+} from '@/components/chat/chat-session-preference-governance';
 import {
   useChatCapabilities,
   useChatSessionTypes,
@@ -22,24 +24,13 @@ type UseChatPageDataParams = {
   query: string;
   selectedSessionKey: string | null;
   selectedAgentId: string;
+  currentSelectedModel: string;
   pendingSessionType: string;
   setPendingSessionType: Dispatch<SetStateAction<string>>;
   setSelectedModel: Dispatch<SetStateAction<string>>;
+  setSelectedThinkingLevel: Dispatch<SetStateAction<ThinkingLevel | null>>;
 };
 
-const THINKING_LEVEL_SET = new Set<string>(['off', 'minimal', 'low', 'medium', 'high', 'adaptive', 'xhigh']);
-
-function parseThinkingLevel(value: unknown): ThinkingLevel | null {
-  if (typeof value !== 'string') {
-    return null;
-  }
-  const normalized = value.trim().toLowerCase();
-  if (!normalized) {
-    return null;
-  }
-  return THINKING_LEVEL_SET.has(normalized) ? (normalized as ThinkingLevel) : null;
-}
-
 export function useChatPageData(params: UseChatPageDataParams) {
   const configQuery = useConfig();
   const configMetaQuery = useConfigMeta();
@@ -110,6 +101,27 @@ export function useChatPageData(params: UseChatPageDataParams) {
       }),
     [params.selectedSessionKey, sessionTypeState.selectedSessionType, sessions]
   );
+  const currentModelOption = useMemo(
+    () => modelOptions.find((option) => option.value === params.currentSelectedModel),
+    [modelOptions, params.currentSelectedModel]
+  );
+  const supportedThinkingLevels = useMemo(
+    () => (currentModelOption?.thinkingCapability?.supported as ThinkingLevel[] | undefined) ?? [],
+    [currentModelOption?.thinkingCapability?.supported]
+  );
+  const defaultThinkingLevel = useMemo(
+    () => (currentModelOption?.thinkingCapability?.default as ThinkingLevel | null | undefined) ?? null,
+    [currentModelOption?.thinkingCapability?.default]
+  );
+  const recentSessionPreferredThinking = useMemo(
+    () =>
+      resolveRecentSessionPreferredThinking({
+        sessions,
+        selectedSessionKey: params.selectedSessionKey,
+        sessionType: sessionTypeState.selectedSessionType
+      }),
+    [params.selectedSessionKey, sessionTypeState.selectedSessionType, sessions]
+  );
 
   useSyncSelectedModel({
     modelOptions,
@@ -120,30 +132,17 @@ export function useChatPageData(params: UseChatPageDataParams) {
     defaultModel: configQuery.data?.agents.defaults.model,
     setSelectedModel: params.setSelectedModel
   });
+  useSyncSelectedThinking({
+    supportedThinkingLevels,
+    selectedSessionKey: params.selectedSessionKey,
+    selectedSessionExists: Boolean(selectedSession),
+    selectedSessionPreferredThinking: selectedSession?.preferredThinking ?? null,
+    fallbackPreferredThinking: recentSessionPreferredThinking ?? null,
+    defaultThinkingLevel,
+    setSelectedThinkingLevel: params.setSelectedThinkingLevel
+  });
 
   const historyMessages = useMemo(() => historyQuery.data?.messages ?? [], [historyQuery.data?.messages]);
-  const selectedSessionThinkingLevel = useMemo(() => {
-    if (!params.selectedSessionKey) {
-      return null;
-    }
-    const metadata = historyQuery.data?.metadata;
-    if (!metadata || typeof metadata !== 'object') {
-      return null;
-    }
-    const candidates = [
-      metadata.preferred_thinking,
-      metadata.thinking,
-      metadata.thinking_level,
-      metadata.thinkingLevel
-    ];
-    for (const value of candidates) {
-      const level = parseThinkingLevel(value);
-      if (level) {
-        return level;
-      }
-    }
-    return null;
-  }, [historyQuery.data?.metadata, params.selectedSessionKey]);
 
   return {
     configQuery,
@@ -159,7 +158,6 @@ export function useChatPageData(params: UseChatPageDataParams) {
     skillRecords,
     selectedSession,
     historyMessages,
-    selectedSessionThinkingLevel,
     ...sessionTypeState
   };
 }

package/src/components/chat/chat-page-runtime.test.ts

@@ -1,6 +1,11 @@
 import { describe, expect, it } from 'vitest';
-import type { SessionEntryView } from '@/api/types';
-import { resolveRecentSessionPreferredModel, resolveSelectedModelValue } from '@/components/chat/chat-page-runtime';
+import type { SessionEntryView, ThinkingLevel } from '@/api/types';
+import {
+  resolveRecentSessionPreferredModel,
+  resolveRecentSessionPreferredThinking,
+  resolveSelectedModelValue,
+  resolveSelectedThinkingLevelValue
+} from '@/components/chat/chat-session-preference-governance';
 
 const modelOptions = [
   {
@@ -27,11 +32,16 @@ function createSession(overrides: Partial<SessionEntryView> & Pick<SessionEntryV
     messageCount: overrides.messageCount ?? 0,
     ...(overrides.label ? { label: overrides.label } : {}),
     ...(overrides.preferredModel ? { preferredModel: overrides.preferredModel } : {}),
+    ...(Object.prototype.hasOwnProperty.call(overrides, 'preferredThinking')
+      ? { preferredThinking: overrides.preferredThinking ?? null }
+      : {}),
     ...(overrides.lastRole ? { lastRole: overrides.lastRole } : {}),
     ...(overrides.lastTimestamp ? { lastTimestamp: overrides.lastTimestamp } : {})
   };
 }
 
+const thinkingLevels: ThinkingLevel[] = ['off', 'minimal', 'medium', 'high'];
+
 describe('resolveSelectedModelValue', () => {
   it('keeps the current selected model when it is still available', () => {
     expect(
@@ -205,3 +215,87 @@ describe('resolveRecentSessionPreferredModel', () => {
     ).toBe('anthropic/claude-sonnet-4');
   });
 });
+
+describe('resolveSelectedThinkingLevelValue', () => {
+  it('keeps the current selected thinking when it is still valid', () => {
+    expect(
+      resolveSelectedThinkingLevelValue({
+        currentSelectedThinkingLevel: 'high',
+        supportedThinkingLevels: thinkingLevels,
+        selectedSessionPreferredThinking: 'medium',
+        fallbackPreferredThinking: 'minimal',
+        defaultThinkingLevel: 'off'
+      })
+    ).toBe('high');
+  });
+
+  it('prefers the persisted session thinking after switching sessions', () => {
+    expect(
+      resolveSelectedThinkingLevelValue({
+        currentSelectedThinkingLevel: 'high',
+        supportedThinkingLevels: thinkingLevels,
+        selectedSessionPreferredThinking: 'medium',
+        fallbackPreferredThinking: 'minimal',
+        defaultThinkingLevel: 'off',
+        preferSessionPreferredThinking: true
+      })
+    ).toBe('medium');
+  });
+
+  it('preserves the current valid thinking when a draft session materializes before metadata exists', () => {
+    expect(
+      resolveSelectedThinkingLevelValue({
+        currentSelectedThinkingLevel: 'high',
+        supportedThinkingLevels: thinkingLevels,
+        fallbackPreferredThinking: 'minimal',
+        defaultThinkingLevel: 'off',
+        preferSessionPreferredThinking: true,
+        preserveCurrentSelectedThinkingOnSessionChange: true
+      })
+    ).toBe('high');
+  });
+
+  it('falls back to the model default when no current or persisted thinking is valid', () => {
+    expect(
+      resolveSelectedThinkingLevelValue({
+        currentSelectedThinkingLevel: null,
+        supportedThinkingLevels: thinkingLevels,
+        fallbackPreferredThinking: null,
+        defaultThinkingLevel: 'medium'
+      })
+    ).toBe('medium');
+  });
+});
+
+describe('resolveRecentSessionPreferredThinking', () => {
+  it('returns the most recent preferred thinking from the same runtime', () => {
+    const sessions = [
+      createSession({
+        key: 'native-1',
+        sessionType: 'native',
+        preferredThinking: 'low',
+        updatedAt: '2026-03-18T01:00:00.000Z'
+      }),
+      createSession({
+        key: 'codex-1',
+        sessionType: 'codex',
+        preferredThinking: 'high',
+        updatedAt: '2026-03-18T03:00:00.000Z'
+      }),
+      createSession({
+        key: 'codex-2',
+        sessionType: 'codex',
+        preferredThinking: 'medium',
+        updatedAt: '2026-03-18T02:00:00.000Z'
+      })
+    ];
+
+    expect(
+      resolveRecentSessionPreferredThinking({
+        sessions,
+        selectedSessionKey: 'draft',
+        sessionType: 'codex'
+      })
+    ).toBe('high');
+  });
+});

package/src/components/chat/chat-page-runtime.ts

@@ -1,144 +1,10 @@
 import { useEffect, useMemo, useRef, useState } from 'react';
-import type { Dispatch, SetStateAction } from 'react';
-import type { ChatRunView, SessionEntryView } from '@/api/types';
-import type { ChatModelOption } from '@/components/chat/chat-input.types';
+import type { ChatRunView } from '@/api/types';
 import { useChatRuns } from '@/hooks/useConfig';
 import { buildActiveRunBySessionKey, buildSessionRunStatusByKey } from '@/lib/session-run-status';
 
 export type ChatMainPanelView = 'chat' | 'cron' | 'skills';
 
-function normalizeSessionType(value: string | null | undefined): string {
-  const normalized = value?.trim().toLowerCase();
-  return normalized || 'native';
-}
-
-function hasModelOption(modelOptions: ChatModelOption[], value: string | null | undefined): value is string {
-  const normalized = value?.trim();
-  if (!normalized) {
-    return false;
-  }
-  return modelOptions.some((option) => option.value === normalized);
-}
-
-export function resolveSelectedModelValue(params: {
-  currentSelectedModel?: string;
-  modelOptions: ChatModelOption[];
-  selectedSessionPreferredModel?: string;
-  fallbackPreferredModel?: string;
-  defaultModel?: string;
-  preferSessionPreferredModel?: boolean;
-  preserveCurrentSelectedModelOnSessionChange?: boolean;
-}): string {
-  const {
-    currentSelectedModel,
-    modelOptions,
-    selectedSessionPreferredModel,
-    fallbackPreferredModel,
-    defaultModel,
-    preferSessionPreferredModel = false,
-    preserveCurrentSelectedModelOnSessionChange = false
-  } = params;
-  if (modelOptions.length === 0) {
-    return '';
-  }
-  if (
-    hasModelOption(modelOptions, currentSelectedModel) &&
-    (!preferSessionPreferredModel || preserveCurrentSelectedModelOnSessionChange)
-  ) {
-    return currentSelectedModel.trim();
-  }
-  if (hasModelOption(modelOptions, selectedSessionPreferredModel)) {
-    return selectedSessionPreferredModel.trim();
-  }
-  if (hasModelOption(modelOptions, fallbackPreferredModel)) {
-    return fallbackPreferredModel.trim();
-  }
-  if (hasModelOption(modelOptions, defaultModel)) {
-    return defaultModel.trim();
-  }
-  return modelOptions[0]?.value ?? '';
-}
-
-export function resolveRecentSessionPreferredModel(params: {
-  sessions: readonly SessionEntryView[];
-  selectedSessionKey?: string | null;
-  sessionType?: string | null;
-}): string | undefined {
-  const targetSessionType = normalizeSessionType(params.sessionType);
-  let bestSession: SessionEntryView | null = null;
-  let bestTimestamp = Number.NEGATIVE_INFINITY;
-  for (const session of params.sessions) {
-    if (session.key === params.selectedSessionKey) {
-      continue;
-    }
-    if (normalizeSessionType(session.sessionType) !== targetSessionType) {
-      continue;
-    }
-    const preferredModel = session.preferredModel?.trim();
-    if (!preferredModel) {
-      continue;
-    }
-    const updatedAtTimestamp = Date.parse(session.updatedAt);
-    const comparableTimestamp = Number.isFinite(updatedAtTimestamp) ? updatedAtTimestamp : Number.NEGATIVE_INFINITY;
-    if (!bestSession || comparableTimestamp > bestTimestamp) {
-      bestSession = session;
-      bestTimestamp = comparableTimestamp;
-    }
-  }
-  return bestSession?.preferredModel?.trim();
-}
-
-export function useSyncSelectedModel(params: {
-  modelOptions: ChatModelOption[];
-  selectedSessionKey?: string | null;
-  selectedSessionExists?: boolean;
-  selectedSessionPreferredModel?: string;
-  fallbackPreferredModel?: string;
-  defaultModel?: string;
-  setSelectedModel: Dispatch<SetStateAction<string>>;
-}) {
-  const {
-    modelOptions,
-    selectedSessionKey,
-    selectedSessionExists = false,
-    selectedSessionPreferredModel,
-    fallbackPreferredModel,
-    defaultModel,
-    setSelectedModel
-  } = params;
-  const previousSessionKeyRef = useRef<string | null | undefined>(undefined);
-
-  useEffect(() => {
-    const sessionChanged = previousSessionKeyRef.current !== selectedSessionKey;
-    if (modelOptions.length === 0) {
-      setSelectedModel('');
-      previousSessionKeyRef.current = selectedSessionKey;
-      return;
-    }
-    setSelectedModel((prev) => {
-      return resolveSelectedModelValue({
-        currentSelectedModel: prev,
-        modelOptions,
-        selectedSessionPreferredModel,
-        fallbackPreferredModel,
-        defaultModel,
-        preferSessionPreferredModel: sessionChanged,
-        preserveCurrentSelectedModelOnSessionChange:
-          sessionChanged && Boolean(selectedSessionKey) && !selectedSessionExists
-      });
-    });
-    previousSessionKeyRef.current = selectedSessionKey;
-  }, [
-    defaultModel,
-    fallbackPreferredModel,
-    modelOptions,
-    selectedSessionExists,
-    selectedSessionKey,
-    selectedSessionPreferredModel,
-    setSelectedModel
-  ]);
-}
-
 export function useSessionRunStatus(params: {
   view: ChatMainPanelView;
   selectedSessionKey: string | null;

package/src/components/chat/chat-session-preference-governance.ts

@@ -0,0 +1,303 @@
+import { useEffect, useRef } from 'react';
+import type { Dispatch, SetStateAction } from 'react';
+import type { SessionEntryView, ThinkingLevel } from '@/api/types';
+import type { ChatModelOption } from '@/components/chat/chat-input.types';
+
+function normalizeSessionType(value: string | null | undefined): string {
+  const normalized = value?.trim().toLowerCase();
+  return normalized || 'native';
+}
+
+function hasModelOption(modelOptions: ChatModelOption[], value: unknown): value is string {
+  if (typeof value !== 'string') {
+    return false;
+  }
+  const normalized = value.trim();
+  if (!normalized) {
+    return false;
+  }
+  return modelOptions.some((option) => option.value === normalized);
+}
+
+function hasThinkingLevelOption(levels: readonly ThinkingLevel[], value: unknown): value is ThinkingLevel {
+  return typeof value === 'string' && levels.includes(value as ThinkingLevel);
+}
+
+function resolveFallbackThinkingLevel(levels: readonly ThinkingLevel[]): ThinkingLevel | null {
+  if (levels.length === 0) {
+    return null;
+  }
+  if (levels.includes('off')) {
+    return 'off';
+  }
+  return levels[0] ?? null;
+}
+
+type ResolveSessionPreferenceValueParams<T> = {
+  currentValue: unknown;
+  selectedSessionPreferredValue?: unknown;
+  fallbackPreferredValue?: unknown;
+  defaultValue?: unknown;
+  isValueSupported: (value: unknown) => value is T;
+  firstAvailableValue: T;
+  preferSessionPreferredValue?: boolean;
+  preserveCurrentValueOnSessionChange?: boolean;
+};
+
+export function resolveSessionPreferenceValue<T>(params: ResolveSessionPreferenceValueParams<T>): T {
+  const {
+    currentValue,
+    selectedSessionPreferredValue,
+    fallbackPreferredValue,
+    defaultValue,
+    isValueSupported,
+    firstAvailableValue,
+    preferSessionPreferredValue = false,
+    preserveCurrentValueOnSessionChange = false
+  } = params;
+  if (isValueSupported(currentValue) && (!preferSessionPreferredValue || preserveCurrentValueOnSessionChange)) {
+    return currentValue;
+  }
+  if (isValueSupported(selectedSessionPreferredValue)) {
+    return selectedSessionPreferredValue;
+  }
+  if (isValueSupported(fallbackPreferredValue)) {
+    return fallbackPreferredValue;
+  }
+  if (isValueSupported(defaultValue)) {
+    return defaultValue;
+  }
+  return firstAvailableValue;
+}
+
+export function resolveSelectedModelValue(params: {
+  currentSelectedModel?: string;
+  modelOptions: ChatModelOption[];
+  selectedSessionPreferredModel?: string;
+  fallbackPreferredModel?: string;
+  defaultModel?: string;
+  preferSessionPreferredModel?: boolean;
+  preserveCurrentSelectedModelOnSessionChange?: boolean;
+}): string {
+  const { modelOptions } = params;
+  if (modelOptions.length === 0) {
+    return '';
+  }
+  return resolveSessionPreferenceValue<string>({
+    currentValue: params.currentSelectedModel,
+    selectedSessionPreferredValue: params.selectedSessionPreferredModel,
+    fallbackPreferredValue: params.fallbackPreferredModel,
+    defaultValue: params.defaultModel,
+    isValueSupported: (value): value is string => hasModelOption(modelOptions, value),
+    firstAvailableValue: modelOptions[0]?.value ?? '',
+    preferSessionPreferredValue: params.preferSessionPreferredModel,
+    preserveCurrentValueOnSessionChange: params.preserveCurrentSelectedModelOnSessionChange
+  });
+}
+
+export function resolveSelectedThinkingLevelValue(params: {
+  currentSelectedThinkingLevel?: ThinkingLevel | null;
+  supportedThinkingLevels: readonly ThinkingLevel[];
+  selectedSessionPreferredThinking?: ThinkingLevel | null;
+  fallbackPreferredThinking?: ThinkingLevel | null;
+  defaultThinkingLevel?: ThinkingLevel | null;
+  preferSessionPreferredThinking?: boolean;
+  preserveCurrentSelectedThinkingOnSessionChange?: boolean;
+}): ThinkingLevel | null {
+  const { supportedThinkingLevels } = params;
+  if (supportedThinkingLevels.length === 0) {
+    return null;
+  }
+  return resolveSessionPreferenceValue<ThinkingLevel>({
+    currentValue: params.currentSelectedThinkingLevel,
+    selectedSessionPreferredValue: params.selectedSessionPreferredThinking,
+    fallbackPreferredValue: params.fallbackPreferredThinking,
+    defaultValue: params.defaultThinkingLevel,
+    isValueSupported: (value): value is ThinkingLevel => hasThinkingLevelOption(supportedThinkingLevels, value),
+    firstAvailableValue: resolveFallbackThinkingLevel(supportedThinkingLevels) ?? 'off',
+    preferSessionPreferredValue: params.preferSessionPreferredThinking,
+    preserveCurrentValueOnSessionChange: params.preserveCurrentSelectedThinkingOnSessionChange
+  });
+}
+
+export function resolveRecentSessionPreferredValue<T>(params: {
+  sessions: readonly SessionEntryView[];
+  selectedSessionKey?: string | null;
+  sessionType?: string | null;
+  readPreference: (session: SessionEntryView) => T | null | undefined;
+}): T | undefined {
+  const targetSessionType = normalizeSessionType(params.sessionType);
+  let bestValue: T | undefined;
+  let bestTimestamp = Number.NEGATIVE_INFINITY;
+  for (const session of params.sessions) {
+    if (session.key === params.selectedSessionKey) {
+      continue;
+    }
+    if (normalizeSessionType(session.sessionType) !== targetSessionType) {
+      continue;
+    }
+    const value = params.readPreference(session);
+    if (value === null || value === undefined) {
+      continue;
+    }
+    const updatedAtTimestamp = Date.parse(session.updatedAt);
+    const comparableTimestamp = Number.isFinite(updatedAtTimestamp) ? updatedAtTimestamp : Number.NEGATIVE_INFINITY;
+    if (bestValue === undefined || comparableTimestamp > bestTimestamp) {
+      bestValue = value;
+      bestTimestamp = comparableTimestamp;
+    }
+  }
+  return bestValue;
+}
+
+export function resolveRecentSessionPreferredModel(params: {
+  sessions: readonly SessionEntryView[];
+  selectedSessionKey?: string | null;
+  sessionType?: string | null;
+}): string | undefined {
+  return resolveRecentSessionPreferredValue<string>({
+    sessions: params.sessions,
+    selectedSessionKey: params.selectedSessionKey,
+    sessionType: params.sessionType,
+    readPreference: (session) => {
+      const preferredModel = session.preferredModel?.trim();
+      return preferredModel || undefined;
+    }
+  });
+}
+
+export function resolveRecentSessionPreferredThinking(params: {
+  sessions: readonly SessionEntryView[];
+  selectedSessionKey?: string | null;
+  sessionType?: string | null;
+}): ThinkingLevel | undefined {
+  return resolveRecentSessionPreferredValue<ThinkingLevel>({
+    sessions: params.sessions,
+    selectedSessionKey: params.selectedSessionKey,
+    sessionType: params.sessionType,
+    readPreference: (session) => session.preferredThinking ?? undefined
+  });
+}
+
+type UseSyncSessionPreferenceParams<T> = {
+  isPreferenceAvailable: boolean;
+  emptyValue: T;
+  selectedSessionKey?: string | null;
+  selectedSessionExists?: boolean;
+  setValue: Dispatch<SetStateAction<T>>;
+  resolveValue: (params: {
+    currentValue: T;
+    sessionChanged: boolean;
+    preserveCurrentValueOnSessionChange: boolean;
+  }) => T;
+};
+
+function useSyncSessionPreference<T>(params: UseSyncSessionPreferenceParams<T>) {
+  const {
+    isPreferenceAvailable,
+    emptyValue,
+    selectedSessionKey,
+    selectedSessionExists = false,
+    setValue,
+    resolveValue
+  } = params;
+  const previousSessionKeyRef = useRef<string | null | undefined>(undefined);
+  const resolveValueRef = useRef(resolveValue);
+
+  useEffect(() => {
+    resolveValueRef.current = resolveValue;
+  }, [resolveValue]);
+
+  useEffect(() => {
+    const sessionChanged = previousSessionKeyRef.current !== selectedSessionKey;
+    if (!isPreferenceAvailable) {
+      setValue(emptyValue);
+      previousSessionKeyRef.current = selectedSessionKey;
+      return;
+    }
+    setValue((prev) =>
+      resolveValueRef.current({
+        currentValue: prev,
+        sessionChanged,
+        preserveCurrentValueOnSessionChange: sessionChanged && Boolean(selectedSessionKey) && !selectedSessionExists
+      })
+    );
+    previousSessionKeyRef.current = selectedSessionKey;
+  }, [emptyValue, isPreferenceAvailable, selectedSessionExists, selectedSessionKey, setValue]);
+}
+
+export function useSyncSelectedModel(params: {
+  modelOptions: ChatModelOption[];
+  selectedSessionKey?: string | null;
+  selectedSessionExists?: boolean;
+  selectedSessionPreferredModel?: string;
+  fallbackPreferredModel?: string;
+  defaultModel?: string;
+  setSelectedModel: Dispatch<SetStateAction<string>>;
+}) {
+  const {
+    modelOptions,
+    selectedSessionKey,
+    selectedSessionExists = false,
+    selectedSessionPreferredModel,
+    fallbackPreferredModel,
+    defaultModel,
+    setSelectedModel
+  } = params;
+
+  useSyncSessionPreference<string>({
+    isPreferenceAvailable: modelOptions.length > 0,
+    emptyValue: '',
+    selectedSessionKey,
+    selectedSessionExists,
+    setValue: setSelectedModel,
+    resolveValue: ({ currentValue, sessionChanged, preserveCurrentValueOnSessionChange }) =>
+      resolveSelectedModelValue({
+        currentSelectedModel: currentValue,
+        modelOptions,
+        selectedSessionPreferredModel,
+        fallbackPreferredModel,
+        defaultModel,
+        preferSessionPreferredModel: sessionChanged,
+        preserveCurrentSelectedModelOnSessionChange: preserveCurrentValueOnSessionChange
+      })
+  });
+}
+
+export function useSyncSelectedThinking(params: {
+  supportedThinkingLevels: readonly ThinkingLevel[];
+  selectedSessionKey?: string | null;
+  selectedSessionExists?: boolean;
+  selectedSessionPreferredThinking?: ThinkingLevel | null;
+  fallbackPreferredThinking?: ThinkingLevel | null;
+  defaultThinkingLevel?: ThinkingLevel | null;
+  setSelectedThinkingLevel: Dispatch<SetStateAction<ThinkingLevel | null>>;
+}) {
+  const {
+    supportedThinkingLevels,
+    selectedSessionKey,
+    selectedSessionExists = false,
+    selectedSessionPreferredThinking,
+    fallbackPreferredThinking,
+    defaultThinkingLevel,
+    setSelectedThinkingLevel
+  } = params;
+
+  useSyncSessionPreference<ThinkingLevel | null>({
+    isPreferenceAvailable: supportedThinkingLevels.length > 0,
+    emptyValue: null,
+    selectedSessionKey,
+    selectedSessionExists,
+    setValue: setSelectedThinkingLevel,
+    resolveValue: ({ currentValue, sessionChanged, preserveCurrentValueOnSessionChange }) =>
+      resolveSelectedThinkingLevelValue({
+        currentSelectedThinkingLevel: currentValue,
+        supportedThinkingLevels,
+        selectedSessionPreferredThinking,
+        fallbackPreferredThinking,
+        defaultThinkingLevel,
+        preferSessionPreferredThinking: sessionChanged,
+        preserveCurrentSelectedThinkingOnSessionChange: preserveCurrentValueOnSessionChange
+      })
+  });
+}