@nextclaw/ui 0.13.13 → 0.14.1-beta.0

package/src/features/chat/{components/conversation/session-header → features/session/components/session-header/__tests__}/chat-session-project-badge.test.tsx

@@ -1,17 +1,17 @@
 import { render, screen, waitFor } from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { ChatSessionProjectBadge } from './chat-session-project-badge';
+import { ChatSessionProjectBadge } from '@/features/chat/features/session/components/session-header/chat-session-project-badge';
 
 const mocks = vi.hoisted(() => ({
   updateSessionProject: vi.fn(),
 }));
 
-vi.mock('@/features/chat/hooks/use-chat-session-project', () => ({
+vi.mock('@/features/chat/features/session/hooks/use-chat-session-project', () => ({
   useChatSessionProject: () => mocks.updateSessionProject,
 }));
 
-vi.mock('./chat-session-project-dialog', () => ({
+vi.mock('@/features/chat/features/session/components/session-header/chat-session-project-dialog', () => ({
   ChatSessionProjectDialog: () => null,
 }));
 

package/src/features/chat/{components/conversation → features/session/components}/session-header/chat-session-header-actions.tsx

@@ -1,9 +1,10 @@
 import { useState } from 'react';
-import { AlarmClock, FolderOpen, GitBranch, MoreVertical, Trash2 } from 'lucide-react';
-import { Button } from '@/shared/components/ui/button';
+import { AlarmClock, Braces, FolderOpen, GitBranch, MoreVertical, Trash2 } from 'lucide-react';
+import { IconActionButton } from '@/shared/components/ui/actions/icon-action-button';
 import { Popover, PopoverContent, PopoverTrigger } from '@/shared/components/ui/popover';
-import { useChatSessionProject } from '@/features/chat/hooks/use-chat-session-project';
+import { useChatSessionProject } from '@/features/chat/features/session/hooks/use-chat-session-project';
 import { ChatSessionHeaderMenuItem } from './chat-session-header-menu-item';
+import { ChatSessionMetadataDialog } from './chat-session-metadata-dialog';
 import { ChatSessionProjectDialog } from './chat-session-project-dialog';
 import { t } from '@/shared/lib/i18n';
 
@@ -15,6 +16,7 @@ type ChatSessionHeaderActionsProps = {
   canDeleteSession: boolean;
   isDeletePending: boolean;
   projectRoot?: string | null;
+  metadata?: Record<string, unknown> | null;
   childSessionCount?: number;
   sessionCronJobCount?: number;
   onOpenChildSessions?: () => void;
@@ -27,6 +29,7 @@ export function ChatSessionHeaderActions({
   canDeleteSession,
   isDeletePending,
   projectRoot,
+  metadata,
   childSessionCount = 0,
   sessionCronJobCount = 0,
   onOpenChildSessions,
@@ -36,6 +39,7 @@ export function ChatSessionHeaderActions({
   const updateSessionProject = useChatSessionProject();
   const [isMenuOpen, setIsMenuOpen] = useState(false);
   const [isDialogOpen, setIsDialogOpen] = useState(false);
+  const [isMetadataDialogOpen, setIsMetadataDialogOpen] = useState(false);
   const [isProjectPending, setIsProjectPending] = useState(false);
   const isBusy = isDeletePending || isProjectPending;
 
@@ -58,44 +62,32 @@ export function ChatSessionHeaderActions({
   return (
     <div className={SESSION_HEADER_ACTION_GROUP_CLASS}>
       {childSessionCount > 0 && onOpenChildSessions ? (
-        <Button
-          type="button"
-          variant="ghost"
-          size="icon"
+        <IconActionButton
+          icon={<GitBranch className="h-4 w-4" />}
+          label={t('chatSessionOpenChildSessions')}
           className={SESSION_HEADER_ACTION_BUTTON_CLASS}
-          aria-label={t('chatSessionOpenChildSessions')}
-          title={t('chatSessionOpenChildSessions')}
           onClick={onOpenChildSessions}
           disabled={isBusy}
-        >
-          <GitBranch className="h-4 w-4" />
-        </Button>
+        />
       ) : null}
       {sessionCronJobCount > 0 && onOpenSessionCronJobs ? (
-        <Button
-          type="button"
-          variant="ghost"
-          size="icon"
+        <IconActionButton
+          icon={<AlarmClock className="h-4 w-4" />}
+          label={t('chatSessionOpenCronJobs')}
           className={SESSION_HEADER_ACTION_BUTTON_CLASS}
-          aria-label={t('chatSessionOpenCronJobs')}
-          title={t('chatSessionOpenCronJobs')}
           onClick={onOpenSessionCronJobs}
           disabled={isBusy}
-        >
-          <AlarmClock className="h-4 w-4" />
-        </Button>
+        />
       ) : null}
       <Popover open={isMenuOpen} onOpenChange={setIsMenuOpen}>
         <PopoverTrigger asChild>
-          <Button
-            variant="ghost"
-            size="icon"
+          <IconActionButton
+            icon={<MoreVertical className="h-4 w-4" />}
+            label={t('chatSessionMoreActions')}
+            tooltip={false}
             className={SESSION_HEADER_ACTION_BUTTON_CLASS}
-            aria-label={t('chatSessionMoreActions')}
             disabled={isBusy}
-          >
-            <MoreVertical className="h-4 w-4" />
-          </Button>
+          />
         </PopoverTrigger>
         <PopoverContent align="end" className="w-56 p-2">
           <div className="space-y-1">
@@ -108,6 +100,15 @@ export function ChatSessionHeaderActions({
               }}
               disabled={isBusy}
             />
+            <ChatSessionHeaderMenuItem
+              icon={Braces}
+              label={t('chatSessionViewMetadata')}
+              onClick={() => {
+                setIsMenuOpen(false);
+                setIsMetadataDialogOpen(true);
+              }}
+              disabled={isBusy}
+            />
             <ChatSessionHeaderMenuItem
               icon={Trash2}
               label={t('chatDeleteSession')}
@@ -129,6 +130,11 @@ export function ChatSessionHeaderActions({
         onOpenChange={setIsDialogOpen}
         onSave={runProjectUpdate}
       />
+      <ChatSessionMetadataDialog
+        open={isMetadataDialogOpen}
+        metadata={metadata}
+        onOpenChange={setIsMetadataDialogOpen}
+      />
     </div>
   );
 }

package/src/features/chat/features/session/components/session-header/chat-session-metadata-dialog.tsx

@@ -0,0 +1,46 @@
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogHeader,
+  DialogTitle,
+} from '@/shared/components/ui/dialog';
+import { t } from '@/shared/lib/i18n';
+
+type ChatSessionMetadataDialogProps = {
+  open: boolean;
+  metadata?: Record<string, unknown> | null;
+  onOpenChange: (open: boolean) => void;
+};
+
+function formatSessionMetadata(metadata?: Record<string, unknown> | null): string {
+  try {
+    return JSON.stringify(metadata ?? {}, null, 2);
+  } catch {
+    return '{}';
+  }
+}
+
+export function ChatSessionMetadataDialog({
+  open,
+  metadata,
+  onOpenChange,
+}: ChatSessionMetadataDialogProps) {
+  return (
+    <Dialog open={open} onOpenChange={onOpenChange}>
+      <DialogContent className="max-w-2xl gap-0 overflow-hidden p-0">
+        <DialogHeader className="border-b border-gray-200 px-5 py-4 pr-12">
+          <DialogTitle className="text-base">{t('chatSessionMetadataDialogTitle')}</DialogTitle>
+          <DialogDescription className="sr-only">
+            {t('chatSessionMetadataDialogDescription')}
+          </DialogDescription>
+        </DialogHeader>
+        <div className="px-5 pb-5 pt-4">
+          <pre className="max-h-[60vh] overflow-auto rounded-lg border border-gray-200 bg-gray-950 p-4 text-xs leading-relaxed text-gray-100">
+            {formatSessionMetadata(metadata)}
+          </pre>
+        </div>
+      </DialogContent>
+    </Dialog>
+  );
+}

package/src/features/chat/{components/conversation → features/session/components}/session-header/chat-session-project-badge.tsx

@@ -1,6 +1,6 @@
 import { useState } from 'react';
 import { ChevronDown, FolderOpen, FolderX, Pencil } from 'lucide-react';
-import { useChatSessionProject } from '@/features/chat/hooks/use-chat-session-project';
+import { useChatSessionProject } from '@/features/chat/features/session/hooks/use-chat-session-project';
 import { ChatSessionHeaderMenuItem } from './chat-session-header-menu-item';
 import { ChatSessionProjectDialog } from './chat-session-project-dialog';
 import { Popover, PopoverContent, PopoverTrigger } from '@/shared/components/ui/popover';

package/src/features/chat/{hooks → features/session/hooks/__tests__}/use-chat-session-project.test.tsx

@@ -2,7 +2,7 @@ import { act, renderHook } from '@testing-library/react';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { toast } from 'sonner';
 import { useChatInputStore } from '@/features/chat/stores/chat-input.store';
-import { useChatSessionProject } from '@/features/chat/hooks/use-chat-session-project';
+import { useChatSessionProject } from '@/features/chat/features/session/hooks/use-chat-session-project';
 
 const mocks = vi.hoisted(() => ({
   updateSession: vi.fn()
@@ -14,7 +14,7 @@ vi.mock('sonner', () => ({
   }
 }));
 
-vi.mock('@/features/chat/hooks/use-chat-session-update', () => ({
+vi.mock('@/features/chat/features/session/hooks/use-chat-session-update', () => ({
   useChatSessionUpdate: () => mocks.updateSession
 }));
 

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

@@ -3,7 +3,7 @@ import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
 import type { ReactNode } from 'react';
 import { afterEach, describe, expect, it, vi } from 'vitest';
 import { toast } from 'sonner';
-import { useChatSessionUpdate } from '@/features/chat/hooks/use-chat-session-update';
+import { useChatSessionUpdate } from '@/features/chat/features/session/hooks/use-chat-session-update';
 import type * as SharedApiModule from '@/shared/lib/api';
 
 const mocks = vi.hoisted(() => ({

package/src/features/chat/features/session/hooks/__tests__/use-selected-session-context-window-indicator.test.tsx

@@ -0,0 +1,63 @@
+import { renderHook } from '@testing-library/react';
+import { beforeEach, describe, expect, it } from 'vitest';
+import { useSelectedSessionContextWindowIndicator } from '@/features/chat/features/session/hooks/use-selected-session-context-window-indicator';
+import { useChatSessionListStore } from '@/features/chat/stores/chat-session-list.store';
+import { useChatThreadStore } from '@/features/chat/stores/chat-thread.store';
+
+describe('useSelectedSessionContextWindowIndicator', () => {
+  beforeEach(() => {
+    useChatSessionListStore.getState().setSnapshot({
+      selectedSessionKey: null,
+    });
+    useChatThreadStore.getState().setSnapshot({
+      sessionKey: null,
+      contextWindow: null,
+    });
+  });
+
+  it('shows the current thread context window once the thread snapshot has it', () => {
+    useChatSessionListStore.getState().setSnapshot({
+      selectedSessionKey: 'session-other',
+    });
+    useChatThreadStore.getState().setSnapshot({
+      sessionKey: 'session-current',
+      contextWindow: {
+        usedContextTokens: 25,
+        totalContextTokens: 100,
+        availableContextTokens: 75,
+        prunedUsedContextTokens: 25,
+        droppedHistoryCount: 0,
+        truncatedToolResultCount: 0,
+        truncatedSystemPrompt: false,
+        truncatedUserMessage: false,
+        compacted: false,
+        compactedUsedContextTokens: 25,
+        compactedMessageCount: 0,
+        updatedAt: '2026-06-10T00:00:00.000Z',
+      },
+    });
+
+    const { result } = renderHook(() =>
+      useSelectedSessionContextWindowIndicator(),
+    );
+
+    expect(result.current).toMatchObject({
+      percentLabel: '25%',
+      ratio: 0.25,
+      tone: 'neutral',
+    });
+  });
+
+  it('hides the indicator when the current thread snapshot has no context window', () => {
+    useChatThreadStore.getState().setSnapshot({
+      sessionKey: 'session-current',
+      contextWindow: null,
+    });
+
+    const { result } = renderHook(() =>
+      useSelectedSessionContextWindowIndicator(),
+    );
+
+    expect(result.current).toBeNull();
+  });
+});

package/src/features/chat/{hooks → features/session/hooks}/use-chat-session-project.ts

@@ -1,7 +1,7 @@
 import { toast } from 'sonner';
 import { t } from '@/shared/lib/i18n';
 import { useChatInputStore } from '@/features/chat/stores/chat-input.store';
-import { useChatSessionUpdate } from '@/features/chat/hooks/use-chat-session-update';
+import { useChatSessionUpdate } from '@/features/chat/features/session/hooks/use-chat-session-update';
 
 type UpdateChatSessionProjectParams = {
   sessionKey: string;

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

@@ -11,6 +11,11 @@ type UpdateChatSessionParams = {
   successMessage?: string;
 };
 
+type UpdateChatSessionLabelParams = {
+  sessionKey: string;
+  label: string | null;
+};
+
 export function useChatSessionUpdate() {
   const queryClient = useQueryClient();
 
@@ -27,3 +32,15 @@ export function useChatSessionUpdate() {
     }
   };
 }
+
+export function useChatSessionLabel() {
+  const updateSession = useChatSessionUpdate();
+
+  return async (params: UpdateChatSessionLabelParams): Promise<void> => {
+    await updateSession({
+      sessionKey: params.sessionKey,
+      patch: { label: params.label },
+      successMessage: t('configSavedApplied')
+    });
+  };
+}

package/src/features/chat/{hooks → features/session/hooks}/use-chat-sidebar-session-label-editor.ts

@@ -1,6 +1,6 @@
 import { useState } from 'react';
 import type { SessionEntryView } from '@/shared/lib/api';
-import { useChatSessionLabel } from '@/features/chat/hooks/use-chat-session-label';
+import { useChatSessionLabel } from '@/features/chat/features/session/hooks/use-chat-session-update';
 
 export function useChatSidebarSessionLabelEditor() {
   const updateSessionLabel = useChatSessionLabel();

package/src/features/chat/features/session/hooks/use-selected-session-context-window-indicator.ts

@@ -0,0 +1,15 @@
+import { useMemo } from 'react';
+import type { ChatContextWindowIndicator } from '@nextclaw/agent-chat-ui';
+import { useChatThreadStore } from '@/features/chat/stores/chat-thread.store';
+import { buildChatContextWindowIndicator } from '@/features/chat/features/session/utils/chat-context-window-indicator.utils';
+
+export function useSelectedSessionContextWindowIndicator(): ChatContextWindowIndicator | null {
+  const liveContextWindow = useChatThreadStore(
+    (state) => state.snapshot.contextWindow,
+  );
+
+  return useMemo(
+    () => buildChatContextWindowIndicator(liveContextWindow),
+    [liveContextWindow],
+  );
+}

package/src/features/chat/{utils → features/session/utils/__tests__}/chat-session-display.utils.test.ts

@@ -5,7 +5,7 @@ import {
   sessionActivityPreviewText,
   sessionDisplayName,
   sessionMatchesQuery
-} from './chat-session-display.utils';
+} from '../chat-session-display.utils';
 
 function createSession(overrides: Partial<SessionEntryView> = {}): SessionEntryView {
   return {

package/src/features/chat/{utils → features/session/utils/__tests__}/chat-session-route.utils.test.ts

@@ -3,7 +3,7 @@ import {
   CHAT_DRAFT_SESSION_PATH,
   buildSessionPath,
   parseSessionKeyFromRoute,
-} from '@/features/chat/utils/chat-session-route.utils';
+} from '@/features/chat/features/session/utils/chat-session-route.utils';
 
 describe('chat session route utils', () => {
   it('keeps the draft route separate from real session keys', () => {

package/src/features/chat/{utils → features/session/utils/__tests__}/ncp-session-adapter.utils.cancelled-tool.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest';
-import { adaptChatMessage } from '@/features/chat/utils/chat-message.utils';
-import { adaptNcpMessageToUiMessage } from './ncp-session-adapter.utils';
+import { adaptChatMessage } from '@/features/chat/features/message/utils/chat-message.utils';
+import { adaptNcpMessageToUiMessage } from '../ncp-session-adapter.utils';
 
 const texts = {
   roleLabels: {

package/src/features/chat/{utils → features/session/utils/__tests__}/ncp-session-adapter.utils.test.ts

@@ -2,8 +2,8 @@ import {
   adaptNcpMessageToUiMessage,
   adaptNcpSessionSummary,
   readNcpSessionPreferredThinking
-} from '@/features/chat/utils/ncp-session-adapter.utils';
-import { adaptChatMessage } from '@/features/chat/utils/chat-message.utils';
+} from '@/features/chat/features/session/utils/ncp-session-adapter.utils';
+import { adaptChatMessage } from '@/features/chat/features/message/utils/chat-message.utils';
 import type { NcpSessionSummaryView } from '@/shared/lib/api';
 
 function createSummary(partial: Partial<NcpSessionSummaryView> = {}): NcpSessionSummaryView {
@@ -43,6 +43,14 @@ describe('adaptNcpSessionSummary', () => {
       projectRoot: '/Users/demo/workspace/project-alpha',
       workingDir: '/Users/demo/workspace/project-alpha',
       projectName: 'project-alpha',
+      metadata: {
+        label: 'NCP Planning Thread',
+        model: 'openai/gpt-5',
+        preferred_thinking: 'medium',
+        project_root: '/Users/demo/workspace/project-alpha',
+        session_type: 'native',
+        ui_last_read_at: '2026-03-17T23:59:00.000Z'
+      },
       lastMessageAt: '2026-03-18T00:00:00.000Z',
       readAt: '2026-03-17T23:59:00.000Z',
       sessionType: 'native',

package/src/features/chat/{utils → features/session/utils/__tests__}/session-context.utils.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it, vi } from "vitest";
-import { resolveSessionContextView } from "./session-context.utils";
+import { resolveSessionContextView } from "../session-context.utils";
 
 vi.mock("@/shared/lib/logos", () => ({
   getChannelLogo: vi.fn(() => null),

package/src/features/chat/features/session/utils/chat-run-metadata.utils.ts

@@ -0,0 +1,60 @@
+import { buildInlineSkillTokensFromComposer, CHAT_UI_INLINE_TOKENS_METADATA_KEY } from "@/features/chat/features/input/utils/chat-inline-token.utils";
+import { normalizeRequestedSkills } from "@/features/chat/features/runtime/utils/chat-runtime.utils";
+import { normalizeSessionProjectRootValue } from "@/shared/lib/session-project";
+
+function createMetadataFields(
+  value: string | undefined,
+  fields: readonly string[],
+): Record<string, string> {
+  return value ? Object.fromEntries(fields.map((field) => [field, value])) : {};
+}
+
+export function buildChatRunMetadata(payload: {
+  agentId?: string;
+  model?: string;
+  thinkingLevel?: string;
+  sessionType?: string;
+  projectRoot?: string | null;
+  requestedSkills?: string[];
+  composerNodes?: Parameters<typeof buildInlineSkillTokensFromComposer>[0];
+}): Record<string, unknown> {
+  const projectRoot = normalizeSessionProjectRootValue(payload.projectRoot);
+  const metadata: Record<string, unknown> = {
+    ...createMetadataFields(payload.model?.trim(), ["model", "preferred_model"]),
+    ...createMetadataFields(payload.thinkingLevel?.trim(), ["thinkingEffort", "thinking", "preferred_thinking"]),
+    ...createMetadataFields(payload.sessionType?.trim(), ["agentRuntimeId", "session_type", "runtime"]),
+    ...createMetadataFields(payload.agentId?.trim(), ["agentId", "agent_id"]),
+    ...createMetadataFields(projectRoot ?? undefined, ["projectRoot", "project_root"]),
+  };
+  const requestedSkills = normalizeRequestedSkills(payload.requestedSkills);
+  if (requestedSkills.length > 0) {
+    metadata.requested_skill_refs = requestedSkills;
+  }
+  const inlineSkillTokens = payload.composerNodes
+    ? buildInlineSkillTokensFromComposer(payload.composerNodes)
+    : [];
+  if (inlineSkillTokens.length > 0) {
+    metadata[CHAT_UI_INLINE_TOKENS_METADATA_KEY] = inlineSkillTokens;
+  }
+  return metadata;
+}
+
+export function shouldClearPendingProjectRootOverride(params: {
+  pendingProjectRoot: string | null;
+  pendingProjectRootSessionKey: string | null;
+  sessionKey: string | null | undefined;
+  selectedSessionProjectRoot: string | null | undefined;
+}): boolean {
+  const {
+    pendingProjectRoot,
+    pendingProjectRootSessionKey,
+    selectedSessionProjectRoot,
+    sessionKey,
+  } = params;
+  return (
+    pendingProjectRoot !== null &&
+    pendingProjectRootSessionKey !== null &&
+    sessionKey === pendingProjectRootSessionKey &&
+    (selectedSessionProjectRoot ?? null) === pendingProjectRoot
+  );
+}

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

@@ -1,5 +1,3 @@
-import { useEffect, useRef } from 'react';
-import type { Dispatch, SetStateAction } from 'react';
 import type { SessionEntryView, ThinkingLevel } from '@/shared/lib/api';
 import type { ChatModelOption } from '@/features/chat/types/chat-input.types';
 
@@ -159,129 +157,3 @@ export function resolveRecentSessionPreferredValue<T>(params: {
   }
   return bestValue;
 }
-
-function buildSyncKey(parts: unknown[]): string {
-  return parts.map((part) => (part == null ? '' : String(part))).join('\u0002');
-}
-
-type UseSyncSessionPreferenceParams<T> = {
-  isPreferenceAvailable: boolean;
-  emptyValue: T;
-  syncKey: string;
-  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,
-    syncKey,
-    selectedSessionKey,
-    selectedSessionExists = false,
-    setValue,
-    resolveValue
-  } = params;
-  const previousSessionKeyRef = useRef<string | null | undefined>(undefined);
-  const resolveValueRef = useRef(resolveValue);
-  const lastSyncedValueRef = useRef<T>(emptyValue);
-
-  useEffect(() => {
-    resolveValueRef.current = resolveValue;
-  }, [resolveValue]);
-
-  useEffect(() => {
-    const sessionChanged = previousSessionKeyRef.current !== selectedSessionKey;
-    if (!isPreferenceAvailable) {
-      setValue(emptyValue);
-      lastSyncedValueRef.current = emptyValue;
-      previousSessionKeyRef.current = selectedSessionKey;
-      return;
-    }
-    setValue((prev) => {
-      const next = resolveValueRef.current({
-        currentValue:
-          !sessionChanged && Object.is(prev, lastSyncedValueRef.current)
-            ? emptyValue
-            : prev,
-        sessionChanged,
-        preserveCurrentValueOnSessionChange: sessionChanged && Boolean(selectedSessionKey) && !selectedSessionExists
-      });
-      lastSyncedValueRef.current = next;
-      return next;
-    });
-    previousSessionKeyRef.current = selectedSessionKey;
-  }, [emptyValue, isPreferenceAvailable, selectedSessionExists, selectedSessionKey, setValue, syncKey]);
-}
-
-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: '',
-    syncKey: buildSyncKey([
-      modelOptions.map((option) => option.value).join('\u0001'),
-      selectedSessionPreferredModel,
-      fallbackPreferredModel,
-      defaultModel
-    ]),
-    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,
-    syncKey: buildSyncKey([
-      supportedThinkingLevels.join('\u0001'),
-      selectedSessionPreferredThinking,
-      fallbackPreferredThinking,
-      defaultThinkingLevel
-    ]),
-    selectedSessionKey,
-    selectedSessionExists,
-    setValue: setSelectedThinkingLevel,
-    resolveValue: ({ currentValue, sessionChanged, preserveCurrentValueOnSessionChange }) =>
-      resolveSelectedThinkingLevelValue({
-        currentSelectedThinkingLevel: currentValue,
-        supportedThinkingLevels,
-        selectedSessionPreferredThinking,
-        fallbackPreferredThinking,
-        defaultThinkingLevel,
-        preferSessionPreferredThinking: sessionChanged,
-        preserveCurrentSelectedThinkingOnSessionChange: preserveCurrentValueOnSessionChange
-      })
-  });
-}