@nextclaw/ui 0.10.5 → 0.11.1

package/src/components/chat/chat-stream/transport.ts

@@ -1,253 +0,0 @@
-import { fetchChatRuns, stopChatTurn } from '@/api/config';
-import { appClient } from '@/transport';
-import type { ActiveRunState, SendMessageParams, StreamDeltaEvent, StreamReadyEvent, StreamSessionEvent } from './types';
-
-function buildSendTurnPayload(item: SendMessageParams, requestedSkills: string[]) {
-  const metadata: Record<string, unknown> = {};
-  if (item.sessionType) {
-    metadata.session_type = item.sessionType;
-  }
-  if (item.thinkingLevel) {
-    metadata.thinking = item.thinkingLevel;
-  }
-  if (requestedSkills.length > 0) {
-    metadata.requested_skills = requestedSkills;
-  }
-  return {
-    message: item.message,
-    ...(item.runId ? { runId: item.runId } : {}),
-    sessionKey: item.sessionKey,
-    agentId: item.agentId,
-    ...(item.model ? { model: item.model } : {}),
-    ...(Object.keys(metadata).length > 0 ? { metadata } : {}),
-    channel: 'ui',
-    chatId: 'web-ui'
-  };
-}
-
-export async function openSendTurnStream(params: {
-  item: SendMessageParams;
-  requestedSkills: string[];
-  signal: AbortSignal;
-  onReady: (event: StreamReadyEvent) => void;
-  onDelta: (event: StreamDeltaEvent) => void;
-  onSessionEvent: (event: StreamSessionEvent) => void;
-}) {
-  let readySessionKey = '';
-  let finalResult: { sessionKey: string; reply: string } | null = null;
-  const session = appClient.openStream<{ reply?: string; sessionKey?: string }>({
-    method: 'POST',
-    path: '/api/chat/turn/stream',
-    body: buildSendTurnPayload(params.item, params.requestedSkills),
-    signal: params.signal,
-    onEvent: (event) => {
-      if (event.name === 'ready') {
-        const payload = (event.payload ?? {}) as StreamReadyEvent;
-        if (typeof payload.sessionKey === 'string' && payload.sessionKey.trim()) {
-          readySessionKey = payload.sessionKey;
-        }
-        params.onReady(payload);
-        return;
-      }
-      if (event.name === 'delta') {
-        params.onDelta((event.payload ?? { delta: '' }) as StreamDeltaEvent);
-        return;
-      }
-      if (event.name === 'session_event') {
-        params.onSessionEvent({ data: event.payload as StreamSessionEvent['data'] });
-        return;
-      }
-      if (event.name === 'final') {
-        const payload = (event.payload ?? {}) as { sessionKey?: string; reply?: string };
-        finalResult = {
-          sessionKey:
-            typeof payload.sessionKey === 'string' && payload.sessionKey.trim()
-              ? payload.sessionKey
-              : readySessionKey,
-          reply: typeof payload.reply === 'string' ? payload.reply : ''
-        };
-        return;
-      }
-      if (event.name === 'error') {
-        const payload = (event.payload ?? {}) as { message?: string };
-        throw new Error(payload.message?.trim() || 'chat stream failed');
-      }
-    }
-  });
-  const result = await session.finished as { reply?: string; sessionKey?: string } | undefined;
-  if (finalResult !== null) {
-    return finalResult;
-  }
-  return {
-    sessionKey: typeof result?.sessionKey === 'string' && result.sessionKey.trim()
-      ? result.sessionKey
-      : readySessionKey,
-    reply: typeof result?.reply === 'string' ? result.reply : ''
-  };
-}
-
-export async function openResumeRunStream(params: {
-  runId: string;
-  fromEventIndex?: number;
-  signal: AbortSignal;
-  onReady: (event: StreamReadyEvent) => void;
-  onDelta: (event: StreamDeltaEvent) => void;
-  onSessionEvent: (event: StreamSessionEvent) => void;
-}) {
-  let readySessionKey = '';
-  let finalResult: { sessionKey: string; reply: string } | null = null;
-  const query = new URLSearchParams();
-  if (typeof params.fromEventIndex === 'number') {
-    query.set('fromEventIndex', String(Math.max(0, Math.trunc(params.fromEventIndex))));
-  }
-  const path =
-    `/api/chat/runs/${encodeURIComponent(params.runId)}/stream`
-    + (query.size > 0 ? `?${query.toString()}` : '');
-  const session = appClient.openStream<{ reply?: string; sessionKey?: string }>({
-    method: 'GET',
-    path,
-    signal: params.signal,
-    onEvent: (event) => {
-      if (event.name === 'ready') {
-        const payload = (event.payload ?? {}) as StreamReadyEvent;
-        if (typeof payload.sessionKey === 'string' && payload.sessionKey.trim()) {
-          readySessionKey = payload.sessionKey;
-        }
-        params.onReady(payload);
-        return;
-      }
-      if (event.name === 'delta') {
-        params.onDelta((event.payload ?? { delta: '' }) as StreamDeltaEvent);
-        return;
-      }
-      if (event.name === 'session_event') {
-        params.onSessionEvent({ data: event.payload as StreamSessionEvent['data'] });
-        return;
-      }
-      if (event.name === 'final') {
-        const payload = (event.payload ?? {}) as { sessionKey?: string; reply?: string };
-        finalResult = {
-          sessionKey:
-            typeof payload.sessionKey === 'string' && payload.sessionKey.trim()
-              ? payload.sessionKey
-              : readySessionKey,
-          reply: typeof payload.reply === 'string' ? payload.reply : ''
-        };
-        return;
-      }
-      if (event.name === 'error') {
-        const payload = (event.payload ?? {}) as { message?: string };
-        throw new Error(payload.message?.trim() || 'chat stream failed');
-      }
-    }
-  });
-  const result = await session.finished as { reply?: string; sessionKey?: string } | undefined;
-  if (finalResult !== null) {
-    return finalResult;
-  }
-  return {
-    sessionKey: typeof result?.sessionKey === 'string' && result.sessionKey.trim()
-      ? result.sessionKey
-      : readySessionKey,
-    reply: typeof result?.reply === 'string' ? result.reply : ''
-  };
-}
-
-export async function requestStopRun(activeRun: ActiveRunState): Promise<void> {
-  if (!activeRun.backendStopSupported) {
-    return;
-  }
-
-  try {
-    const attemptedRunIds = new Set<string>();
-    const knownRunId = activeRun.backendRunId?.trim();
-    if (knownRunId) {
-      attemptedRunIds.add(knownRunId);
-      const stopped = await stopRunById(knownRunId);
-      if (stopped) {
-        return;
-      }
-    }
-
-    const candidateRunIds = await resolveStopCandidateRunIds(activeRun);
-    for (const runId of candidateRunIds) {
-      if (attemptedRunIds.has(runId)) {
-        continue;
-      }
-      attemptedRunIds.add(runId);
-      const stopped = await stopRunById(runId);
-      if (stopped) {
-        return;
-      }
-    }
-    if (knownRunId) {
-      const stopped = await stopRunById(knownRunId);
-      if (stopped) {
-        return;
-      }
-    }
-  } catch {
-    // Keep local abort as fallback even if stop API fails.
-  }
-}
-
-async function stopRunById(runId: string): Promise<boolean> {
-  const normalizedRunId = runId.trim();
-  if (!normalizedRunId) {
-    return false;
-  }
-  try {
-    const result = await stopChatTurn({
-      runId: normalizedRunId
-    });
-    return result.stopped === true;
-  } catch {
-    return false;
-  }
-}
-
-async function resolveStopCandidateRunIds(activeRun: ActiveRunState): Promise<string[]> {
-  const sessionKey = activeRun.sessionKey?.trim();
-  if (!sessionKey) {
-    return [];
-  }
-  const attempts = 8;
-  const delayMs = 120;
-  for (let attempt = 0; attempt < attempts; attempt += 1) {
-    const runIds = await listActiveRunIdsBySession(activeRun, sessionKey);
-    if (runIds.length > 0) {
-      return runIds;
-    }
-    if (attempt < attempts - 1) {
-      await sleep(delayMs);
-    }
-  }
-  return [];
-}
-
-async function listActiveRunIdsBySession(activeRun: ActiveRunState, sessionKey: string): Promise<string[]> {
-  try {
-    const response = await fetchChatRuns({
-      sessionKey,
-      states: ['queued', 'running'],
-      limit: 50
-    });
-    const primary = response.runs
-      .filter((run) => run.runId?.trim() && run.sessionKey === sessionKey && run.agentId === activeRun.agentId)
-      .map((run) => run.runId.trim());
-    if (primary.length > 0) {
-      return primary;
-    }
-    return response.runs
-      .filter((run) => run.runId?.trim() && run.sessionKey === sessionKey)
-      .map((run) => run.runId.trim());
-  } catch {
-    return [];
-  }
-}
-
-function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => {
-    window.setTimeout(resolve, ms);
-  });
-}

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

@@ -1,223 +0,0 @@
-import { useEffect, useMemo, useRef, useState } from 'react';
-import { useLocation, useNavigate, useParams } from 'react-router-dom';
-import { useConfirmDialog } from '@/hooks/useConfirmDialog';
-import { useSessionRunStatus } from '@/components/chat/chat-page-runtime';
-import { useChatPageData, sessionDisplayName } from '@/components/chat/chat-page-data';
-import { ChatPageLayout, type ChatPageProps, useChatSessionSync } from '@/components/chat/chat-page-shell';
-import { parseSessionKeyFromRoute, resolveAgentIdFromSessionKey } from '@/components/chat/chat-session-route';
-import { ChatPresenterProvider } from '@/components/chat/presenter/chat-presenter-context';
-import { ChatPresenter } from '@/components/chat/presenter/chat.presenter';
-import { useChatRuntimeController } from '@/components/chat/useChatRuntimeController';
-import { resolveSessionTypeLabel } from '@/components/chat/useChatSessionTypeState';
-import { useChatInputStore } from '@/components/chat/stores/chat-input.store';
-import { useChatSessionListStore } from '@/components/chat/stores/chat-session-list.store';
-
-export function LegacyChatPage({ view }: ChatPageProps) {
-  const [presenter] = useState(() => new ChatPresenter());
-  const query = useChatSessionListStore((state) => state.snapshot.query);
-  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 routeSessionKey = useMemo(
-    () => parseSessionKeyFromRoute(routeSessionIdParam),
-    [routeSessionIdParam]
-  );
-  const {
-    sessionsQuery,
-    installedSkillsQuery,
-    chatCapabilitiesQuery,
-    historyQuery,
-    isProviderStateResolved,
-    modelOptions,
-    sessions,
-    skillRecords,
-    selectedSession,
-    historyMessages,
-    sessionTypeOptions,
-    defaultSessionType,
-    selectedSessionType,
-    canEditSessionType,
-    sessionTypeUnavailable,
-    sessionTypeUnavailableMessage
-  } = useChatPageData({
-    query,
-    selectedSessionKey,
-    selectedAgentId,
-    currentSelectedModel,
-    pendingSessionType,
-    setPendingSessionType: presenter.chatInputManager.setPendingSessionType,
-    setSelectedModel: presenter.chatInputManager.setSelectedModel,
-    setSelectedThinkingLevel: presenter.chatInputManager.setSelectedThinkingLevel
-  });
-  const {
-    uiMessages,
-    isSending,
-    isAwaitingAssistantOutput,
-    canStopCurrentRun,
-    stopDisabledReason,
-    lastSendError,
-    activeBackendRunId,
-    sendMessage,
-    stopCurrentRun,
-    resumeRun,
-    resetStreamState,
-    applyHistoryMessages
-  } = useChatRuntimeController(
-    {
-      selectedSessionKeyRef,
-      setSelectedSessionKey: presenter.chatSessionListManager.setSelectedSessionKey,
-      setDraft: presenter.chatInputManager.setDraft,
-      setComposerNodes: presenter.chatInputManager.setComposerNodes,
-      refetchSessions: sessionsQuery.refetch,
-      refetchHistory: historyQuery.refetch
-    },
-    presenter.chatController
-  );
-
-  useEffect(() => {
-    presenter.chatStreamActionsManager.bind({
-      sendMessage,
-      stopCurrentRun,
-      resumeRun,
-      resetStreamState,
-      applyHistoryMessages
-    });
-  }, [applyHistoryMessages, presenter, resetStreamState, resumeRun, sendMessage, stopCurrentRun]);
-
-  const { sessionRunStatusByKey } = useSessionRunStatus({
-    view,
-    selectedSessionKey,
-    activeBackendRunId,
-    isLocallyRunning: isSending || Boolean(activeBackendRunId),
-    resumeRun: presenter.chatStreamActionsManager.resumeRun
-  });
-
-  useChatSessionSync({
-    view,
-    routeSessionKey,
-    selectedSessionKey,
-    selectedAgentId,
-    setSelectedSessionKey: presenter.chatSessionListManager.setSelectedSessionKey,
-    setSelectedAgentId: presenter.chatSessionListManager.setSelectedAgentId,
-    selectedSessionKeyRef,
-    resetStreamState: presenter.chatStreamActionsManager.resetStreamState,
-    resolveAgentIdFromSessionKey
-  });
-
-  useEffect(() => {
-    presenter.chatStreamActionsManager.applyHistoryMessages(historyMessages, {
-      isLoading: historyQuery.isLoading
-    });
-  }, [historyMessages, historyQuery.isLoading, presenter]);
-
-  useEffect(() => {
-    presenter.chatUiManager.syncState({
-      pathname: location.pathname
-    });
-    presenter.chatUiManager.bindActions({
-      navigate,
-      confirm
-    });
-  }, [confirm, location.pathname, navigate, presenter]);
-
-  const currentSessionDisplayName = selectedSession ? sessionDisplayName(selectedSession) : undefined;
-  const currentSessionTypeLabel =
-    sessionTypeOptions.find((option) => option.value === selectedSessionType)?.label ??
-    resolveSessionTypeLabel(selectedSessionType);
-
-  useEffect(() => {
-    presenter.chatThreadManager.bindActions({
-      refetchSessions: sessionsQuery.refetch
-    });
-  }, [presenter, sessionsQuery.refetch]);
-
-  useEffect(() => {
-    presenter.chatInputManager.syncSnapshot({
-      isProviderStateResolved,
-      defaultSessionType,
-      canStopGeneration: canStopCurrentRun,
-      stopDisabledReason,
-      stopSupported: chatCapabilitiesQuery.data?.stopSupported ?? false,
-      stopReason: chatCapabilitiesQuery.data?.stopReason,
-      sendError: lastSendError,
-      isSending,
-      modelOptions,
-      sessionTypeOptions,
-      selectedSessionType,
-      canEditSessionType,
-      sessionTypeUnavailable,
-      skillRecords,
-      isSkillsLoading: installedSkillsQuery.isLoading
-    });
-    presenter.chatSessionListManager.syncSnapshot({
-      sessions,
-      query,
-      isLoading: sessionsQuery.isLoading
-    });
-    presenter.chatRunStatusManager.syncSnapshot({
-      sessionRunStatusByKey,
-      isLocallyRunning: isSending || Boolean(activeBackendRunId),
-      activeBackendRunId
-    });
-    presenter.chatThreadManager.syncSnapshot({
-      isProviderStateResolved,
-      modelOptions,
-      sessionTypeUnavailable,
-      sessionTypeUnavailableMessage,
-      sessionTypeLabel: currentSessionTypeLabel,
-      selectedSessionKey,
-      sessionDisplayName: currentSessionDisplayName,
-      canDeleteSession: Boolean(selectedSession),
-      threadRef,
-      isHistoryLoading: historyQuery.isLoading,
-      uiMessages,
-      isSending,
-      isAwaitingAssistantOutput
-    });
-  }, [
-    activeBackendRunId,
-    canEditSessionType,
-    canStopCurrentRun,
-    currentSessionDisplayName,
-    currentSessionTypeLabel,
-    chatCapabilitiesQuery.data?.stopReason,
-    chatCapabilitiesQuery.data?.stopSupported,
-    defaultSessionType,
-    historyQuery.isLoading,
-    installedSkillsQuery.isLoading,
-    isAwaitingAssistantOutput,
-    isProviderStateResolved,
-    isSending,
-    lastSendError,
-    modelOptions.length,
-    modelOptions,
-    presenter,
-    query,
-    selectedSession,
-    selectedSessionKey,
-    selectedSessionType,
-    sessionRunStatusByKey,
-    sessionTypeOptions,
-    sessionTypeUnavailable,
-    sessionTypeUnavailableMessage,
-    sessions,
-    sessionsQuery.isLoading,
-    skillRecords,
-    stopDisabledReason,
-    threadRef,
-    uiMessages
-  ]);
-
-  return (
-    <ChatPresenterProvider presenter={presenter}>
-      <ChatPageLayout view={view} confirmDialog={<ConfirmDialog />} />
-    </ChatPresenterProvider>
-  );
-}

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

@@ -1,228 +0,0 @@
-import type { ChatComposerNode } from '@nextclaw/agent-chat-ui';
-import {
-  createInitialChatComposerNodes,
-  createChatComposerNodesFromDraft,
-  deriveChatComposerDraft,
-  deriveSelectedSkillsFromComposer,
-  syncComposerSkills
-} from '@/components/chat/chat-composer-state';
-import { updateSession } from '@/api/config';
-import { useChatInputStore } from '@/components/chat/stores/chat-input.store';
-import { buildNewSessionKey } from '@/components/chat/chat-session-route';
-import type { ChatUiManager } from '@/components/chat/managers/chat-ui.manager';
-import { useChatSessionListStore } from '@/components/chat/stores/chat-session-list.store';
-import { normalizeSessionType } from '@/components/chat/useChatSessionTypeState';
-import type { ChatInputSnapshot } from '@/components/chat/stores/chat-input.store';
-import { ChatSessionPreferenceSync } from '@/components/chat/chat-session-preference-sync';
-import type { SetStateAction } from 'react';
-import type { ChatStreamActionsManager } from '@/components/chat/managers/chat-stream-actions.manager';
-import type { ThinkingLevel } from '@/api/types';
-import type { ChatModelOption } from '@/components/chat/chat-input.types';
-
-export class ChatInputManager {
-  private readonly sessionPreferenceSync = new ChatSessionPreferenceSync(updateSession);
-
-  constructor(
-    private uiManager: ChatUiManager,
-    private streamActionsManager: ChatStreamActionsManager
-  ) {}
-
-  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 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 syncComposerSnapshot = (nodes: ChatComposerNode[]) => {
-    useChatInputStore.getState().setSnapshot({
-      composerNodes: nodes,
-      draft: deriveChatComposerDraft(nodes),
-      selectedSkills: deriveSelectedSkillsFromComposer(nodes)
-    });
-  };
-
-  syncSnapshot = (patch: Partial<ChatInputSnapshot>) => {
-    if (!this.hasSnapshotChanges(patch)) {
-      return;
-    }
-    useChatInputStore.getState().setSnapshot(patch);
-    if (
-      Object.prototype.hasOwnProperty.call(patch, 'modelOptions') ||
-      Object.prototype.hasOwnProperty.call(patch, 'selectedModel') ||
-      Object.prototype.hasOwnProperty.call(patch, 'selectedThinkingLevel')
-    ) {
-      const { selectedModel } = useChatInputStore.getState().snapshot;
-      this.reconcileThinkingForModel(selectedModel);
-    }
-  };
-
-  setDraft = (next: SetStateAction<string>) => {
-    const prev = useChatInputStore.getState().snapshot.draft;
-    const value = this.resolveUpdateValue(prev, next);
-    if (value === prev) {
-      return;
-    }
-    this.syncComposerSnapshot(createChatComposerNodesFromDraft(value));
-  };
-
-  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);
-  };
-
-  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 });
-  };
-
-  send = async () => {
-    const inputSnapshot = useChatInputStore.getState().snapshot;
-    const sessionSnapshot = useChatSessionListStore.getState().snapshot;
-    const message = inputSnapshot.draft.trim();
-    if (!message) {
-      return;
-    }
-    const { selectedSkills: requestedSkills, composerNodes } = inputSnapshot;
-    const hasSelectedSession = Boolean(sessionSnapshot.selectedSessionKey);
-    const sessionKey = sessionSnapshot.selectedSessionKey ?? buildNewSessionKey(sessionSnapshot.selectedAgentId);
-    if (!hasSelectedSession) {
-      this.uiManager.goToSession(sessionKey, { replace: true });
-    }
-    this.setComposerNodes(createInitialChatComposerNodes());
-    await this.streamActionsManager.sendMessage({
-      message,
-      sessionKey,
-      agentId: sessionSnapshot.selectedAgentId,
-      sessionType: inputSnapshot.selectedSessionType,
-      model: inputSnapshot.selectedModel || undefined,
-      thinkingLevel: inputSnapshot.selectedThinkingLevel ?? undefined,
-      stopSupported: inputSnapshot.stopSupported,
-      stopReason: inputSnapshot.stopReason,
-      requestedSkills,
-      restoreDraftOnError: true,
-      composerNodes
-    });
-  };
-
-  stop = async () => {
-    await this.streamActionsManager.stopCurrentRun();
-  };
-
-  goToProviders = () => {
-    this.uiManager.goToProviders();
-  };
-
-  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 });
-    void this.syncRemoteSessionType(normalized);
-  };
-
-  setSelectedSkills = (next: SetStateAction<string[]>) => {
-    const snapshot = useChatInputStore.getState().snapshot;
-    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);
-    this.sessionPreferenceSync.syncSelectedSessionPreferences();
-  };
-
-  selectThinkingLevel = (value: ThinkingLevel) => {
-    this.setSelectedThinkingLevel(value);
-    this.sessionPreferenceSync.syncSelectedSessionPreferences();
-  };
-
-  selectSkills = (next: string[]) => {
-    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().snapshot;
-    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 });
-    }
-  }
-
-  private syncRemoteSessionType = async (normalizedType: string) => {
-    const sessionSnapshot = useChatSessionListStore.getState().snapshot;
-    const { selectedSessionKey } = sessionSnapshot;
-    if (!selectedSessionKey) {
-      return;
-    }
-    const selectedSession = sessionSnapshot.sessions.find((session) => session.key === selectedSessionKey);
-    if (!selectedSession?.sessionTypeMutable) {
-      return;
-    }
-    if (normalizeSessionType(selectedSession.sessionType) === normalizedType) {
-      return;
-    }
-    await updateSession(selectedSessionKey, { sessionType: normalizedType });
-  };
-}