@nextclaw/ui 0.14.1 → 0.14.2

package/src/features/chat/managers/chat-input.manager.ts

@@ -1,430 +0,0 @@
-import type { ChatComposerNode } from '@nextclaw/agent-chat-ui';
-import { isRuntimeDefaultModelValue } from '@nextclaw/shared';
-import type { NcpDraftAttachment } from '@nextclaw/ncp-react';
-import type { SetStateAction } from 'react';
-import type { ThinkingLevel } from '@/shared/lib/api';
-import { updateNcpSession } from '@/shared/lib/api';
-import {
-  createChatComposerNodesFromDraft,
-  createInitialChatComposerNodes,
-  deriveChatComposerDraft,
-  deriveNcpMessagePartsFromComposer,
-  deriveSelectedSkillsFromComposer,
-  pruneComposerAttachments,
-  syncComposerAttachments,
-  syncComposerSkills
-} from '@/features/chat/features/input/utils/chat-composer-state.utils';
-import { useChatInputStore } from '@/features/chat/stores/chat-input.store';
-import { useChatSessionListStore } from '@/features/chat/stores/chat-session-list.store';
-import { useChatThreadStore } from '@/features/chat/stores/chat-thread.store';
-import type { ChatInputSnapshot } from '@/features/chat/stores/chat-input.store';
-import type { ChatRunManager } from '@/features/chat/managers/chat-run.manager';
-import type { ChatSessionListManager } from '@/features/chat/managers/chat-session-list.manager';
-import { ChatSessionPreferenceSync } from '@/features/chat/managers/chat-session-preference-sync.manager';
-import { isNcpChatSendDisabled } from '@/features/chat/features/input/utils/ncp-chat-input-availability.utils';
-import { isNcpChatRuntimeBlocked } from '@/features/chat/features/runtime/utils/ncp-chat-runtime-availability.utils';
-import { chatRecentModelsManager } from '@/features/chat/managers/chat-recent-models.manager';
-import { chatRecentSkillsManager } from '@/features/chat/managers/chat-recent-skills.manager';
-import type { ChatModelOption } from '@/features/chat/types/chat-input.types';
-import { normalizeSessionType } from '@/features/chat/features/session-type/utils/chat-session-type.utils';
-import { systemStatusManager } from '@/features/system-status';
-import { shouldClearPendingProjectRootOverride } from '@/features/chat/features/session/utils/chat-run-metadata.utils';
-import { normalizeSessionProjectRootValue } from '@/shared/lib/session-project';
-
-function resolveModelForSend(value: string): string | undefined {
-  return value || undefined;
-}
-
-export class ChatInputManager {
-  private readonly sessionPreferenceSync = new ChatSessionPreferenceSync(updateNcpSession);
-
-  private buildAttachmentSignature = (attachment: NcpDraftAttachment): string =>
-    [
-      attachment.assetUri ?? '',
-      attachment.url ?? '',
-      attachment.name,
-      attachment.mimeType,
-      String(attachment.sizeBytes),
-      attachment.contentBase64 ?? '',
-    ].join(':');
-
-  constructor(
-    private chatRunManager: ChatRunManager,
-    private sessionListManager: ChatSessionListManager
-  ) {}
-
-  private resolveUpdateValue = <T>(prev: T, next: SetStateAction<T>): T => {
-    if (typeof next === 'function') {
-      return (next as (value: T) => T)(prev);
-    }
-    return next;
-  };
-
-  private isSameStringArray = (left: string[], right: string[]): boolean =>
-    left.length === right.length && left.every((value, index) => value === right[index]);
-
-  private hasSnapshotChanges = (patch: Partial<ChatInputSnapshot>): boolean => {
-    const current = useChatInputStore.getState().snapshot;
-    for (const [key, value] of Object.entries(patch) as Array<[keyof ChatInputSnapshot, ChatInputSnapshot[keyof ChatInputSnapshot]]>) {
-      if (!Object.is(current[key], value)) {
-        return true;
-      }
-    }
-    return false;
-  };
-
-  private isRuntimeBlockedForSend = (): boolean =>
-    isNcpChatRuntimeBlocked(systemStatusManager.getStatusView());
-
-  private syncComposerSnapshot = (nodes: ChatComposerNode[]) => {
-    const currentAttachments = useChatInputStore.getState().snapshot.attachments;
-    const attachments = pruneComposerAttachments(nodes, currentAttachments);
-    useChatInputStore.getState().setSnapshot({
-      composerNodes: nodes,
-      attachments,
-      draft: deriveChatComposerDraft(nodes),
-      selectedSkills: deriveSelectedSkillsFromComposer(nodes)
-    });
-  };
-
-  private syncComposerSnapshotWithAttachments = (
-    nodes: ChatComposerNode[],
-    attachments: NcpDraftAttachment[]
-  ) => {
-    useChatInputStore.getState().setSnapshot({
-      composerNodes: nodes,
-      attachments,
-      draft: deriveChatComposerDraft(nodes),
-      selectedSkills: deriveSelectedSkillsFromComposer(nodes)
-    });
-  };
-
-  private dedupeAttachments = (attachments: NcpDraftAttachment[]): NcpDraftAttachment[] => {
-    const seen = new Set<string>();
-    const output: NcpDraftAttachment[] = [];
-    for (const attachment of attachments) {
-      const signature = this.buildAttachmentSignature(attachment);
-      if (seen.has(signature)) {
-        continue;
-      }
-      seen.add(signature);
-      output.push(attachment);
-    }
-    return output;
-  };
-
-  syncSnapshot = (patch: Partial<ChatInputSnapshot>) => {
-    const current = useChatInputStore.getState().snapshot;
-    let resolvedPatch = patch;
-    if (
-      patch.defaultSessionType &&
-      current.selectedSessionType === undefined &&
-      patch.selectedSessionType === undefined
-    ) {
-      resolvedPatch = Object.assign({}, patch, {
-        selectedSessionType: patch.defaultSessionType,
-      });
-    }
-    if (!this.hasSnapshotChanges(resolvedPatch)) {
-      return;
-    }
-    useChatInputStore.getState().setSnapshot(resolvedPatch);
-    if (
-      Object.prototype.hasOwnProperty.call(resolvedPatch, 'modelOptions') ||
-      Object.prototype.hasOwnProperty.call(resolvedPatch, 'selectedModel') ||
-      Object.prototype.hasOwnProperty.call(resolvedPatch, 'selectedThinkingLevel')
-    ) {
-      const { selectedModel } = useChatInputStore.getState().snapshot;
-      this.reconcileThinkingForModel(selectedModel);
-    }
-  };
-
-  resolveProjectRootForSend = (params: {
-    sessionKey: string | null | undefined;
-    selectedSessionProjectRoot: string | null | undefined;
-  }): string | null => {
-    const { sessionKey, selectedSessionProjectRoot } = params;
-    const { pendingProjectRoot, pendingProjectRootSessionKey } =
-      useChatInputStore.getState().snapshot;
-    if (
-      pendingProjectRoot !== null &&
-      (!sessionKey || sessionKey === pendingProjectRootSessionKey)
-    ) {
-      return pendingProjectRoot;
-    }
-    if (!sessionKey) {
-      return useChatInputStore.getState().snapshot.defaultProjectRoot;
-    }
-    return selectedSessionProjectRoot ?? null;
-  };
-
-  clearPendingProjectRootOverrideForSession = (params: {
-    sessionKey: string | null | undefined;
-    selectedSessionProjectRoot: string | null | undefined;
-  }) => {
-    const { pendingProjectRoot, pendingProjectRootSessionKey } =
-      useChatInputStore.getState().snapshot;
-    if (
-      !shouldClearPendingProjectRootOverride({
-        pendingProjectRoot,
-        pendingProjectRootSessionKey,
-        sessionKey: params.sessionKey,
-        selectedSessionProjectRoot: params.selectedSessionProjectRoot,
-      })
-    ) {
-      return;
-    }
-    useChatInputStore.getState().setSnapshot({
-      pendingProjectRoot: null,
-      pendingProjectRootSessionKey: null,
-    });
-  };
-
-  clearPendingProjectRootOverrideForCurrentThread = () => {
-    const { sessionKey, sessionProjectRoot } = useChatThreadStore.getState().snapshot;
-    this.clearPendingProjectRootOverrideForSession({
-      sessionKey,
-      selectedSessionProjectRoot: sessionProjectRoot,
-    });
-  };
-
-  syncSessionPreferences = this.sessionPreferenceSync.syncInputSelection;
-
-  setDraft = (next: SetStateAction<string>) => {
-    const prev = useChatInputStore.getState().snapshot.draft;
-    const value = this.resolveUpdateValue(prev, next);
-    if (value === prev) {
-      return;
-    }
-    this.syncComposerSnapshot(createChatComposerNodesFromDraft(value));
-  };
-
-  applyPromptSuggestion = (prompt: string) => {
-    const normalizedPrompt = prompt.trim();
-    if (!normalizedPrompt) {
-      return;
-    }
-    this.setDraft(normalizedPrompt);
-    this.requestComposerFocusAtEnd();
-  };
-
-  requestComposerFocusAtEnd = () => {
-    const currentRequest = useChatInputStore.getState().snapshot.composerFocusRequest;
-    useChatInputStore.getState().setSnapshot({
-      composerFocusRequest: {
-        id: (currentRequest?.id ?? 0) + 1,
-        placement: 'end',
-      },
-    });
-  };
-
-  consumeComposerFocusRequest = (requestId: number) => {
-    const currentRequest = useChatInputStore.getState().snapshot.composerFocusRequest;
-    if (currentRequest?.id !== requestId) {
-      return;
-    }
-    useChatInputStore.getState().setSnapshot({ composerFocusRequest: null });
-  };
-
-  setComposerNodes = (next: SetStateAction<ChatComposerNode[]>) => {
-    const prev = useChatInputStore.getState().snapshot.composerNodes;
-    const value = this.resolveUpdateValue(prev, next);
-    if (Object.is(value, prev)) {
-      return;
-    }
-    this.syncComposerSnapshot(value);
-  };
-
-  addAttachments = (attachments: NcpDraftAttachment[]): NcpDraftAttachment[] => {
-    if (attachments.length === 0) {
-      return [];
-    }
-    const { snapshot } = useChatInputStore.getState();
-    const existingSignatures = new Set(snapshot.attachments.map(this.buildAttachmentSignature));
-    const nextAttachments = this.dedupeAttachments([...snapshot.attachments, ...attachments]);
-    const insertedAttachments = nextAttachments.filter(
-      (attachment) => !existingSignatures.has(this.buildAttachmentSignature(attachment))
-    );
-    if (insertedAttachments.length === 0) {
-      return [];
-    }
-    const nextNodes = syncComposerAttachments(snapshot.composerNodes, nextAttachments);
-    this.syncComposerSnapshotWithAttachments(nextNodes, nextAttachments);
-    return insertedAttachments;
-  };
-
-  restoreComposerState = (nodes: ChatComposerNode[], attachments: NcpDraftAttachment[]) => {
-    const nextAttachments = this.dedupeAttachments(attachments);
-    const nextNodes = syncComposerAttachments(nodes, nextAttachments);
-    this.syncComposerSnapshotWithAttachments(nextNodes, nextAttachments);
-  };
-
-  setPendingSessionType = (next: SetStateAction<string>) => {
-    const prev = useChatInputStore.getState().snapshot.pendingSessionType;
-    const value = this.resolveUpdateValue(prev, next);
-    if (value === prev) {
-      return;
-    }
-    useChatInputStore.getState().setSnapshot({
-      pendingSessionType: value,
-      selectedSessionType: value,
-    });
-  };
-
-  setPendingProjectRoot = (projectRoot: string | null) => {
-    const normalizedProjectRoot = normalizeSessionProjectRootValue(projectRoot);
-    useChatInputStore.getState().setSnapshot({
-      pendingProjectRoot: normalizedProjectRoot,
-      pendingProjectRootSessionKey: null,
-    });
-  };
-
-  send = async () => {
-    const inputSnapshot = useChatInputStore.getState().snapshot;
-    const sessionSnapshot = useChatSessionListStore.getState().snapshot;
-    const threadSnapshot = useChatThreadStore.getState().snapshot;
-    const message = inputSnapshot.draft.trim();
-    const { attachments } = inputSnapshot;
-    const parts = deriveNcpMessagePartsFromComposer(inputSnapshot.composerNodes, attachments);
-    const hasSendableContent = parts.some(
-      (part) => part.type !== 'text' || part.text.trim().length > 0
-    );
-    if (
-      isNcpChatSendDisabled({
-        snapshot: inputSnapshot,
-        hasSendableDraft: hasSendableContent,
-        isRuntimeBlocked: this.isRuntimeBlockedForSend(),
-      })
-    ) {
-      return;
-    }
-    const { selectedSkills: requestedSkills, composerNodes } = inputSnapshot;
-    const sessionKey =
-      threadSnapshot.sessionKey ??
-      sessionSnapshot.selectedSessionKey ??
-      null;
-    if (!sessionKey && inputSnapshot.selectedSessionType?.trim()) {
-      this.sessionListManager.ensureDraftSession(inputSnapshot.selectedSessionType);
-    }
-    this.setComposerNodes(createInitialChatComposerNodes());
-    try {
-      await this.chatRunManager.sendMessage({
-        message,
-        sessionKey: sessionKey ?? undefined,
-        agentId: sessionSnapshot.selectedAgentId,
-        sessionType: inputSnapshot.selectedSessionType,
-        model: resolveModelForSend(inputSnapshot.selectedModel),
-        thinkingLevel: inputSnapshot.selectedThinkingLevel ?? undefined,
-        projectRoot: this.resolveProjectRootForSend({
-          sessionKey,
-          selectedSessionProjectRoot: threadSnapshot.sessionProjectRoot,
-        }),
-        requestedSkills,
-        attachments,
-        parts,
-        composerNodes,
-      });
-    } catch (error) {
-      this.restoreComposerState(composerNodes, attachments);
-      throw error;
-    }
-  };
-
-  stop = async () => {
-    await this.chatRunManager.stopCurrentRun();
-  };
-
-  setSelectedModel = (next: SetStateAction<string>) => {
-    const prev = useChatInputStore.getState().snapshot.selectedModel;
-    const value = this.resolveUpdateValue(prev, next);
-    if (value === prev) {
-      return;
-    }
-    useChatInputStore.getState().setSnapshot({ selectedModel: value });
-    this.reconcileThinkingForModel(value);
-  };
-
-  setSelectedThinkingLevel = (next: SetStateAction<ThinkingLevel | null>) => {
-    const prev = useChatInputStore.getState().snapshot.selectedThinkingLevel;
-    const value = this.resolveUpdateValue(prev, next);
-    if (value === prev) {
-      return;
-    }
-    useChatInputStore.getState().setSnapshot({ selectedThinkingLevel: value });
-  };
-
-  selectSessionType = (value: string) => {
-    const normalized = normalizeSessionType(value);
-    useChatInputStore.getState().setSnapshot({ selectedSessionType: normalized, pendingSessionType: normalized });
-  };
-
-  setSelectedSkills = (next: SetStateAction<string[]>) => {
-    const { snapshot } = useChatInputStore.getState();
-    const { selectedSkills: prev } = snapshot;
-    const value = this.resolveUpdateValue(prev, next);
-    if (this.isSameStringArray(value, prev)) {
-      return;
-    }
-    this.syncComposerSnapshot(syncComposerSkills(snapshot.composerNodes, value, snapshot.skillRecords));
-  };
-
-  selectModel = (value: string) => {
-    this.setSelectedModel(value);
-    chatRecentModelsManager.remember(value, {
-      namespace: useChatInputStore.getState().snapshot.selectedSessionType,
-    });
-    if (!isRuntimeDefaultModelValue(value)) {
-      chatRecentModelsManager.remember(value);
-    }
-    this.sessionPreferenceSync.syncSelectedSessionPreferences();
-  };
-
-  selectThinkingLevel = (value: ThinkingLevel) => {
-    this.setSelectedThinkingLevel(value);
-    this.sessionPreferenceSync.syncSelectedSessionPreferences();
-  };
-
-  rememberSkillSelection = (value: string) => {
-    chatRecentSkillsManager.remember(value);
-  };
-
-  selectSkills = (next: string[]) => {
-    const prev = useChatInputStore.getState().snapshot.selectedSkills;
-    for (const value of next) {
-      if (!prev.includes(value)) {
-        this.rememberSkillSelection(value);
-      }
-    }
-    this.setSelectedSkills(next);
-  };
-
-  private resolveThinkingForModel = (
-    modelOption: ChatModelOption | undefined,
-    current: ThinkingLevel | null
-  ): ThinkingLevel | null => {
-    const capability = modelOption?.thinkingCapability;
-    if (!capability || capability.supported.length === 0) {
-      return null;
-    }
-    if (current === 'off') {
-      return 'off';
-    }
-    if (current && capability.supported.includes(current)) {
-      return current;
-    }
-    if (capability.default && capability.supported.includes(capability.default)) {
-      return capability.default;
-    }
-    return 'off';
-  };
-
-  private reconcileThinkingForModel = (model: string): void => {
-    const { snapshot } = useChatInputStore.getState();
-    const modelOption = snapshot.modelOptions.find((option) => option.value === model);
-    const { selectedThinkingLevel } = snapshot;
-    const nextThinking = this.resolveThinkingForModel(modelOption, selectedThinkingLevel);
-    if (nextThinking !== selectedThinkingLevel) {
-      useChatInputStore.getState().setSnapshot({ selectedThinkingLevel: nextThinking });
-    }
-  };
-}

package/src/features/chat/managers/chat-run.manager.ts

@@ -1,110 +0,0 @@
-import { buildNcpRequestEnvelope } from '@nextclaw/ncp-react';
-import { useChatInputStore } from '@/features/chat/stores/chat-input.store';
-import { useChatThreadStore } from '@/features/chat/stores/chat-thread.store';
-import type { ChatUiManager } from '@/features/chat/managers/chat-ui.manager';
-import type {
-  ChatRunRuntime,
-  ChatRunSnapshot,
-  SendMessageParams,
-} from '@/features/chat/types/chat-run.types';
-import { buildChatRunMetadata } from '@/features/chat/features/session/utils/chat-run-metadata.utils';
-
-export class ChatRunManager {
-  private activeRuntime: ChatRunRuntime | null = null;
-
-  constructor(private uiManager: ChatUiManager) {}
-
-  setActiveRuntime = (runtime: ChatRunRuntime | null) => {
-    this.activeRuntime = runtime;
-  };
-
-  sendMessage = async (payload: SendMessageParams) => {
-    const runtime = this.activeRuntime;
-    if (!runtime || runtime.sessionKey !== (payload.sessionKey ?? null)) {
-      return;
-    }
-    const metadata = buildChatRunMetadata({
-      agentId: payload.agentId,
-      model: payload.model,
-      thinkingLevel: payload.thinkingLevel,
-      sessionType: payload.sessionType,
-      projectRoot: payload.projectRoot,
-      requestedSkills: payload.requestedSkills,
-      composerNodes: payload.composerNodes,
-    });
-    const envelope = buildNcpRequestEnvelope({
-      sessionId: payload.sessionKey,
-      text: payload.message,
-      attachments: payload.attachments,
-      parts: payload.parts,
-      metadata,
-    });
-    if (!envelope) {
-      return;
-    }
-    const handle = await runtime.sendEnvelope(envelope);
-    if (!payload.sessionKey && handle?.sessionId) {
-      this.materializeRootSessionRoute(handle.sessionId);
-    }
-  };
-
-  stopCurrentRun = async () => {
-    await this.activeRuntime?.abortCurrentRun();
-  };
-
-  resumeRun = async (run: { sessionKey: string }) => {
-    if (this.activeRuntime?.sessionKey !== run.sessionKey) {
-      return;
-    }
-    await this.activeRuntime.resumeCurrentSessionRun();
-  };
-
-  applyRunSnapshot = (snapshot: ChatRunSnapshot) => {
-    const isSending = snapshot.isSending || snapshot.isRunning;
-    const sessionKey =
-      snapshot.routeSessionKey ?? snapshot.materializedSessionKey ?? null;
-    useChatInputStore.getState().setSnapshot({
-      canStopGeneration: snapshot.isRunning,
-      stopDisabledReason: snapshot.isRunning ? null : '__preparing__',
-      stopSupported: true,
-      stopReason: undefined,
-      sendError: snapshot.sendErrorMessage,
-      isSending,
-    });
-    useChatThreadStore.getState().setSnapshot({
-      sessionKey,
-      isHistoryLoading: snapshot.isHydrating,
-      messages: snapshot.visibleMessages,
-      isSending,
-      isAwaitingAssistantOutput: snapshot.isRunning,
-      contextWindow: snapshot.contextWindow,
-    });
-    if (!snapshot.routeSessionKey && snapshot.materializedSessionKey) {
-      this.materializeRootSessionRoute(snapshot.materializedSessionKey);
-    }
-  };
-
-  clearRunState = () => {
-    useChatInputStore.getState().setSnapshot({
-      canStopGeneration: false,
-      stopDisabledReason: '__preparing__',
-      sendError: null,
-      isSending: false,
-    });
-    useChatThreadStore.getState().setSnapshot({
-      isHistoryLoading: false,
-      messages: [],
-      isSending: false,
-      isAwaitingAssistantOutput: false,
-      contextWindow: null,
-    });
-  };
-
-  private materializeRootSessionRoute = (sessionKey: string) => {
-    const normalizedSessionKey = sessionKey.trim();
-    if (!normalizedSessionKey || !this.uiManager.isAtChatRoot()) {
-      return;
-    }
-    this.uiManager.goToSession(normalizedSessionKey, { replace: true });
-  };
-}

package/src/features/chat/managers/chat-session-preference-sync.manager.ts

@@ -1,142 +0,0 @@
-import { isRuntimeDefaultModelValue } from '@nextclaw/shared';
-import type { SessionPatchUpdate, ThinkingLevel } from '@/shared/lib/api';
-import { useChatInputStore } from '@/features/chat/stores/chat-input.store';
-import { useChatSessionListStore } from '@/features/chat/stores/chat-session-list.store';
-import { useChatThreadStore } from '@/features/chat/stores/chat-thread.store';
-import {
-  resolveSelectedModelValue,
-  resolveSelectedThinkingLevelValue,
-} from '@/features/chat/features/session/utils/chat-session-preference-governance.utils';
-
-type QueuedSessionPreferenceSync = { sessionKey: string; patch: SessionPatchUpdate };
-
-function normalizeOptionalModel(value: string): string | null {
-  if (isRuntimeDefaultModelValue(value)) {
-    return null;
-  }
-  const normalized = value.trim(); return normalized.length > 0 ? normalized : null;
-}
-
-export class ChatSessionPreferenceSync {
-  private inFlight: Promise<void> | null = null;
-  private queued: QueuedSessionPreferenceSync | null = null;
-  private previousPreferenceSessionKey: string | null | undefined = undefined;
-
-  constructor(
-    private readonly updateSession: (sessionKey: string, patch: SessionPatchUpdate) => Promise<unknown>
-  ) {}
-
-  syncSelectedSessionPreferences = (): void => {
-    const inputSnapshot = useChatInputStore.getState().snapshot;
-    const sessionSnapshot = useChatSessionListStore.getState().snapshot;
-    const threadSnapshot = useChatThreadStore.getState().snapshot;
-    const sessionKey = sessionSnapshot.selectedSessionKey;
-    if (!sessionKey || !threadSnapshot.canDeleteSession) {
-      return;
-    }
-
-    this.enqueue({
-      sessionKey,
-      patch: {
-        preferredModel: normalizeOptionalModel(inputSnapshot.selectedModel),
-        preferredThinking: inputSnapshot.selectedThinkingLevel ?? null
-      }
-    });
-  };
-
-  syncInputSelection = (params: {
-    selectedSessionKey?: string | null;
-    selectedSessionExists: boolean;
-    selectedSessionPreferredModel?: string;
-    fallbackPreferredModel?: string;
-    defaultModel?: string;
-    selectedSessionPreferredThinking?: ThinkingLevel | null;
-    fallbackPreferredThinking?: ThinkingLevel | null;
-  }) => {
-    const {
-      defaultModel,
-      fallbackPreferredModel,
-      fallbackPreferredThinking,
-      selectedSessionKey = null,
-      selectedSessionExists,
-      selectedSessionPreferredModel,
-      selectedSessionPreferredThinking,
-    } = params;
-    const { snapshot } = useChatInputStore.getState();
-    const { modelOptions } = snapshot;
-    const sessionChanged = this.previousPreferenceSessionKey !== selectedSessionKey;
-    const preserveCurrentPreference = sessionChanged && Boolean(selectedSessionKey) && !selectedSessionExists;
-    const selectedModel = resolveSelectedModelValue({
-      currentSelectedModel: snapshot.selectedModel,
-      modelOptions,
-      selectedSessionPreferredModel,
-      fallbackPreferredModel,
-      defaultModel,
-      preferSessionPreferredModel: sessionChanged,
-      preserveCurrentSelectedModelOnSessionChange: preserveCurrentPreference,
-    });
-    const modelOption = modelOptions.find((option) => option.value === selectedModel);
-    const supportedThinkingLevels =
-      (modelOption?.thinkingCapability?.supported as ThinkingLevel[] | undefined) ?? [];
-    const selectedThinking = resolveSelectedThinkingLevelValue({
-      currentSelectedThinkingLevel: snapshot.selectedThinkingLevel,
-      supportedThinkingLevels,
-      selectedSessionPreferredThinking,
-      fallbackPreferredThinking,
-      defaultThinkingLevel:
-        (modelOption?.thinkingCapability?.default as ThinkingLevel | null | undefined) ?? null,
-      preferSessionPreferredThinking: sessionChanged,
-      preserveCurrentSelectedThinkingOnSessionChange: preserveCurrentPreference,
-    });
-    if (
-      snapshot.selectedModel === selectedModel &&
-      snapshot.selectedThinkingLevel === selectedThinking
-    ) {
-      this.recordSyncedPreferenceSessionKey(selectedSessionKey, selectedSessionExists);
-      return;
-    }
-    useChatInputStore.getState().setSnapshot({
-      selectedModel,
-      selectedThinkingLevel: selectedThinking,
-    });
-    this.recordSyncedPreferenceSessionKey(selectedSessionKey, selectedSessionExists);
-  };
-
-  private recordSyncedPreferenceSessionKey = (
-    selectedSessionKey: string | null,
-    selectedSessionExists: boolean,
-  ): void => {
-    if (!selectedSessionKey || selectedSessionExists) {
-      this.previousPreferenceSessionKey = selectedSessionKey;
-    }
-  };
-
-  private enqueue = (next: QueuedSessionPreferenceSync): void => {
-    this.queued = next;
-    if (this.inFlight) {
-      return;
-    }
-    this.startFlush();
-  };
-
-  private startFlush = (): void => {
-    this.inFlight = this.flush()
-      .catch((error) => {
-        console.error(`Failed to sync chat session preferences: ${String(error)}`);
-      })
-      .finally(() => {
-        this.inFlight = null;
-        if (this.queued) {
-          this.startFlush();
-        }
-      });
-  };
-
-  private flush = async (): Promise<void> => {
-    while (this.queued) {
-      const current = this.queued;
-      this.queued = null;
-      await this.updateSession(current.sessionKey, current.patch);
-    }
-  };
-}