@nextclaw/ui 0.9.1 → 0.9.3

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

package/src/components/chat/legacy/LegacyChatPage.tsx

@@ -18,14 +18,13 @@ export function LegacyChatPage({ view }: ChatPageProps) {
   const selectedSessionKey = useChatSessionListStore((state) => state.snapshot.selectedSessionKey);
   const selectedAgentId = useChatSessionListStore((state) => state.snapshot.selectedAgentId);
   const pendingSessionType = useChatInputStore((state) => state.snapshot.pendingSessionType);
+  const currentSelectedModel = useChatInputStore((state) => state.snapshot.selectedModel);
   const { confirm, ConfirmDialog } = useConfirmDialog();
   const location = useLocation();
   const navigate = useNavigate();
   const { sessionId: routeSessionIdParam } = useParams<{ sessionId?: string }>();
   const threadRef = useRef<HTMLDivElement | null>(null);
   const selectedSessionKeyRef = useRef<string | null>(selectedSessionKey);
-  const modelHydratedSessionKeyRef = useRef<string | null>(null);
-  const thinkingHydratedSessionKeyRef = useRef<string | null>(null);
   const routeSessionKey = useMemo(
     () => parseSessionKeyFromRoute(routeSessionIdParam),
     [routeSessionIdParam]
@@ -40,9 +39,7 @@ export function LegacyChatPage({ view }: ChatPageProps) {
     sessions,
     skillRecords,
     selectedSession,
-    hydratedSessionModel,
     historyMessages,
-    selectedSessionThinkingLevel,
     sessionTypeOptions,
     defaultSessionType,
     selectedSessionType,
@@ -53,9 +50,11 @@ export function LegacyChatPage({ view }: ChatPageProps) {
     query,
     selectedSessionKey,
     selectedAgentId,
+    currentSelectedModel,
     pendingSessionType,
     setPendingSessionType: presenter.chatInputManager.setPendingSessionType,
-    setSelectedModel: presenter.chatInputManager.setSelectedModel
+    setSelectedModel: presenter.chatInputManager.setSelectedModel,
+    setSelectedThinkingLevel: presenter.chatInputManager.setSelectedThinkingLevel
   });
   const {
     uiMessages,
@@ -140,21 +139,6 @@ export function LegacyChatPage({ view }: ChatPageProps) {
   }, [presenter, sessionsQuery.refetch]);
 
   useEffect(() => {
-    const shouldHydrateModelFromSession =
-      !isSending &&
-      !isAwaitingAssistantOutput &&
-      !sessionsQuery.isLoading &&
-      isProviderStateResolved &&
-      modelOptions.length > 0 &&
-      selectedSessionKey !== modelHydratedSessionKeyRef.current;
-    const shouldHydrateThinkingFromHistory =
-      !isSending &&
-      !isAwaitingAssistantOutput &&
-      !historyQuery.isLoading &&
-      isProviderStateResolved &&
-      modelOptions.length > 0 &&
-      selectedSessionKey !== thinkingHydratedSessionKeyRef.current;
-
     presenter.chatInputManager.syncSnapshot({
       isProviderStateResolved,
       defaultSessionType,
@@ -165,25 +149,13 @@ export function LegacyChatPage({ view }: ChatPageProps) {
       sendError: lastSendError,
       isSending,
       modelOptions,
-      ...(shouldHydrateModelFromSession ? { selectedModel: hydratedSessionModel } : {}),
       sessionTypeOptions,
       selectedSessionType,
-      ...(shouldHydrateThinkingFromHistory ? { selectedThinkingLevel: selectedSessionThinkingLevel } : {}),
       canEditSessionType,
       sessionTypeUnavailable,
       skillRecords,
       isSkillsLoading: installedSkillsQuery.isLoading
     });
-    if (shouldHydrateModelFromSession) {
-      modelHydratedSessionKeyRef.current = selectedSessionKey;
-    }
-    if (shouldHydrateThinkingFromHistory) {
-      thinkingHydratedSessionKeyRef.current = selectedSessionKey;
-    }
-    if (!selectedSessionKey) {
-      modelHydratedSessionKeyRef.current = null;
-      thinkingHydratedSessionKeyRef.current = null;
-    }
     presenter.chatSessionListManager.syncSnapshot({
       sessions,
       query,
@@ -221,7 +193,6 @@ export function LegacyChatPage({ view }: ChatPageProps) {
     historyQuery.isLoading,
     installedSkillsQuery.isLoading,
     isAwaitingAssistantOutput,
-    hydratedSessionModel,
     isProviderStateResolved,
     isSending,
     lastSendError,
@@ -231,7 +202,6 @@ export function LegacyChatPage({ view }: ChatPageProps) {
     query,
     selectedSession,
     selectedSessionKey,
-    selectedSessionThinkingLevel,
     selectedSessionType,
     sessionRunStatusByKey,
     sessionTypeOptions,

package/src/components/chat/ncp/NcpChatPage.tsx

@@ -65,14 +65,13 @@ export function NcpChatPage({ view }: ChatPageProps) {
   const selectedSessionKey = useChatSessionListStore((state) => state.snapshot.selectedSessionKey);
   const selectedAgentId = useChatSessionListStore((state) => state.snapshot.selectedAgentId);
   const pendingSessionType = useChatInputStore((state) => state.snapshot.pendingSessionType);
+  const currentSelectedModel = useChatInputStore((state) => state.snapshot.selectedModel);
   const { confirm, ConfirmDialog } = useConfirmDialog();
   const location = useLocation();
   const navigate = useNavigate();
   const { sessionId: routeSessionIdParam } = useParams<{ sessionId?: string }>();
   const threadRef = useRef<HTMLDivElement | null>(null);
   const selectedSessionKeyRef = useRef<string | null>(selectedSessionKey);
-  const modelHydratedSessionKeyRef = useRef<string | null>(null);
-  const thinkingHydratedSessionKeyRef = useRef<string | null>(null);
   const routeSessionKey = useMemo(
     () => parseSessionKeyFromRoute(routeSessionIdParam),
     [routeSessionIdParam]
@@ -86,8 +85,6 @@ export function NcpChatPage({ view }: ChatPageProps) {
     sessions,
     skillRecords,
     selectedSession,
-    hydratedSessionModel,
-    selectedSessionThinkingLevel,
     sessionTypeOptions,
     defaultSessionType,
     selectedSessionType,
@@ -97,9 +94,11 @@ export function NcpChatPage({ view }: ChatPageProps) {
   } = useNcpChatPageData({
     query,
     selectedSessionKey,
+    currentSelectedModel,
     pendingSessionType,
     setPendingSessionType: presenter.chatInputManager.setPendingSessionType,
-    setSelectedModel: presenter.chatInputManager.setSelectedModel
+    setSelectedModel: presenter.chatInputManager.setSelectedModel,
+    setSelectedThinkingLevel: presenter.chatInputManager.setSelectedThinkingLevel
   });
   const refetchSessions = sessionsQuery.refetch;
 
@@ -278,21 +277,6 @@ export function NcpChatPage({ view }: ChatPageProps) {
   }, [presenter, sessionsQuery.refetch]);
 
   useEffect(() => {
-    const shouldHydrateModelFromSession =
-      !isSending &&
-      !isAwaitingAssistantOutput &&
-      !sessionsQuery.isLoading &&
-      isProviderStateResolved &&
-      modelOptions.length > 0 &&
-      selectedSessionKey !== modelHydratedSessionKeyRef.current;
-    const shouldHydrateThinkingFromSession =
-      !isSending &&
-      !isAwaitingAssistantOutput &&
-      !agent.isHydrating &&
-      isProviderStateResolved &&
-      modelOptions.length > 0 &&
-      selectedSessionKey !== thinkingHydratedSessionKeyRef.current;
-
     presenter.chatInputManager.syncSnapshot({
       isProviderStateResolved,
       defaultSessionType,
@@ -303,25 +287,13 @@ export function NcpChatPage({ view }: ChatPageProps) {
       sendError: lastSendError,
       isSending,
       modelOptions,
-      ...(shouldHydrateModelFromSession ? { selectedModel: hydratedSessionModel } : {}),
       sessionTypeOptions,
       selectedSessionType,
-      ...(shouldHydrateThinkingFromSession ? { selectedThinkingLevel: selectedSessionThinkingLevel } : {}),
       canEditSessionType,
       sessionTypeUnavailable,
       skillRecords,
       isSkillsLoading: installedSkillsQuery.isLoading
     });
-    if (shouldHydrateModelFromSession) {
-      modelHydratedSessionKeyRef.current = selectedSessionKey;
-    }
-    if (shouldHydrateThinkingFromSession) {
-      thinkingHydratedSessionKeyRef.current = selectedSessionKey;
-    }
-    if (!selectedSessionKey) {
-      modelHydratedSessionKeyRef.current = null;
-      thinkingHydratedSessionKeyRef.current = null;
-    }
     presenter.chatSessionListManager.syncSnapshot({
       sessions,
       query,
@@ -357,7 +329,6 @@ export function NcpChatPage({ view }: ChatPageProps) {
     defaultSessionType,
     installedSkillsQuery.isLoading,
     isAwaitingAssistantOutput,
-    hydratedSessionModel,
     isProviderStateResolved,
     isSending,
     lastSendError,
@@ -367,7 +338,6 @@ export function NcpChatPage({ view }: ChatPageProps) {
     query,
     selectedSession,
     selectedSessionKey,
-    selectedSessionThinkingLevel,
     selectedSessionType,
     sessionRunStatusByKey,
     sessionTypeOptions,

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

@@ -0,0 +1,36 @@
+import { describe, expect, it } from 'vitest';
+import { filterModelOptionsBySessionType } from '@/components/chat/ncp/ncp-chat-page-data';
+import type { ChatModelOption } from '@/components/chat/chat-input.types';
+
+const modelOptions: ChatModelOption[] = [
+  {
+    value: 'dashscope/qwen3-coder-next',
+    modelLabel: 'qwen3-coder-next',
+    providerLabel: 'DashScope'
+  },
+  {
+    value: 'anthropic/claude-sonnet-4-5',
+    modelLabel: 'claude-sonnet-4-5',
+    providerLabel: 'Anthropic'
+  }
+];
+
+describe('filterModelOptionsBySessionType', () => {
+  it('keeps only session-type-supported models when the runtime publishes a filtered list', () => {
+    expect(
+      filterModelOptionsBySessionType({
+        modelOptions,
+        supportedModels: ['dashscope/qwen3-coder-next']
+      })
+    ).toEqual([modelOptions[0]]);
+  });
+
+  it('falls back to the full model catalog when the advertised models do not match the current catalog', () => {
+    expect(
+      filterModelOptionsBySessionType({
+        modelOptions,
+        supportedModels: ['unknown/model']
+      })
+    ).toEqual(modelOptions);
+  });
+});