@nextclaw/ui 0.13.13 → 0.14.1-beta.0

package/src/features/chat/hooks/use-ncp-chat-page-data.ts

@@ -1,260 +0,0 @@
-import { useMemo } 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';
-import { sessionMatchesQuery } from '@/features/chat/utils/chat-session-display.utils';
-import { adaptNcpSessionSummaries } from '@/features/chat/utils/ncp-session-adapter.utils';
-import { useChatSessionTypeState } from '@/features/chat/hooks/use-chat-session-type-state';
-import {
-  resolveRecentSessionPreferredValue,
-  useSyncSelectedModel,
-  useSyncSelectedThinking
-} from '@/features/chat/utils/chat-session-preference-governance.utils';
-import {
-  useConfig,
-  useNcpSessionSkills,
-  useNcpSessions,
-  useProviders,
-  useProviderTemplates
-} from '@/shared/hooks/use-config';
-import { useNcpChatSessionTypes } from './use-ncp-chat-session-types';
-import { buildProviderModelCatalog, composeProviderModel, resolveModelThinkingCapability } from '@/shared/lib/provider-models';
-
-export type { ChatModelOption } from '@/features/chat/types/chat-input.types';
-
-type UseNcpChatPageDataParams = {
-  query: string;
-  sessionKey: string | null;
-  projectRootOverride?: string | null;
-  currentSelectedModel: string;
-  pendingSessionType: string;
-  setPendingSessionType: Dispatch<SetStateAction<string>>;
-  setSelectedModel: Dispatch<SetStateAction<string>>;
-  setSelectedThinkingLevel: Dispatch<SetStateAction<ThinkingLevel | null>>;
-};
-
-function filterSessionsByQuery(sessions: SessionEntryView[], query: string): SessionEntryView[] {
-  return sessions.filter((session) => sessionMatchesQuery(session, query));
-}
-
-function useNcpChatModelOptions(params: {
-  config: ReturnType<typeof useConfig>['data'];
-  providersView: ReturnType<typeof useProviders>['data'];
-  templatesView: ReturnType<typeof useProviderTemplates>['data'];
-}) {
-  const { config, providersView, templatesView } = params;
-  return useMemo<ChatModelOption[]>(() => {
-    const providers = buildProviderModelCatalog({
-      providersView,
-      templatesView,
-      config,
-      onlyConfigured: true
-    });
-    const seen = new Set<string>();
-    const options: ChatModelOption[] = [];
-    for (const provider of providers) {
-      for (const localModel of provider.models) {
-        const value = composeProviderModel(provider.prefix, localModel);
-        if (!value || seen.has(value)) {
-          continue;
-        }
-        seen.add(value);
-        options.push({
-          value,
-          modelLabel: localModel,
-          providerLabel: provider.displayName,
-          thinkingCapability: resolveModelThinkingCapability(provider.modelThinking, localModel, provider.aliases)
-        });
-      }
-    }
-    return options.sort((left, right) => {
-      const providerCompare = left.providerLabel.localeCompare(right.providerLabel);
-      if (providerCompare !== 0) {
-        return providerCompare;
-      }
-      return left.modelLabel.localeCompare(right.modelLabel);
-    });
-  }, [config, providersView, templatesView]);
-}
-
-function useRecentSessionPreferences(params: {
-  sessions: SessionEntryView[];
-  sessionKey: string | null;
-  sessionType: string;
-}) {
-  const { sessions, sessionKey, sessionType } = params;
-  const recentSessionPreferredModel = useMemo(
-    () =>
-      resolveRecentSessionPreferredValue<string>({
-        sessions,
-        selectedSessionKey: sessionKey ?? '',
-        sessionType,
-        readPreference: (session) => session.preferredModel?.trim() || undefined
-      }),
-    [sessionKey, sessionType, sessions]
-  );
-  const recentSessionPreferredThinking = useMemo(
-    () =>
-      resolveRecentSessionPreferredValue<ThinkingLevel>({
-        sessions,
-        selectedSessionKey: sessionKey ?? '',
-        sessionType,
-        readPreference: (session) => session.preferredThinking ?? undefined
-      }),
-    [sessionKey, sessionType, sessions]
-  );
-  return {
-    recentSessionPreferredModel,
-    recentSessionPreferredThinking
-  };
-}
-
-function useCurrentModelThinkingState(params: {
-  currentSelectedModel: string;
-  modelOptions: ChatModelOption[];
-}) {
-  const { currentSelectedModel, modelOptions } = params;
-  const currentModelOption = useMemo(
-    () => modelOptions.find((option) => option.value === currentSelectedModel),
-    [currentSelectedModel, modelOptions]
-  );
-  const supportedThinkingLevels = useMemo(
-    () => (currentModelOption?.thinkingCapability?.supported as ThinkingLevel[] | undefined) ?? [],
-    [currentModelOption?.thinkingCapability?.supported]
-  );
-  const defaultThinkingLevel = useMemo(
-    () => (currentModelOption?.thinkingCapability?.default as ThinkingLevel | null | undefined) ?? null,
-    [currentModelOption?.thinkingCapability?.default]
-  );
-  return {
-    supportedThinkingLevels,
-    defaultThinkingLevel
-  };
-}
-
-export function filterModelOptionsBySessionType(params: {
-  modelOptions: ChatModelOption[];
-  supportedModels?: string[];
-}): ChatModelOption[] {
-  const { modelOptions, supportedModels } = params;
-  if (!supportedModels || supportedModels.length === 0) {
-    return modelOptions;
-  }
-  const supportedModelSet = new Set(supportedModels);
-  const filtered = modelOptions.filter((option) => supportedModelSet.has(option.value));
-  return filtered.length > 0 ? filtered : modelOptions;
-}
-
-export function useNcpChatPageData(params: UseNcpChatPageDataParams) {
-  const {
-    currentSelectedModel,
-    pendingSessionType,
-    projectRootOverride,
-    query,
-    sessionKey,
-    setPendingSessionType,
-    setSelectedModel,
-    setSelectedThinkingLevel,
-  } = params;
-  const configQuery = useConfig();
-  const providersQuery = useProviders();
-  const templatesQuery = useProviderTemplates();
-  const sessionsQuery = useNcpSessions({ limit: 200 });
-  const sessionTypesQuery = useNcpChatSessionTypes();
-  const sessionSkillsQuery = useNcpSessionSkills({
-    sessionId: sessionKey?.trim() || 'draft-session',
-    ...(Object.prototype.hasOwnProperty.call(params, 'projectRootOverride')
-      ? { projectRoot: projectRootOverride ?? null }
-      : {})
-  });
-  const isProviderStateResolved =
-    (configQuery.isFetched || configQuery.isSuccess) &&
-    (providersQuery.isFetched || providersQuery.isSuccess) &&
-    (templatesQuery.isFetched || templatesQuery.isSuccess);
-  const modelOptions = useNcpChatModelOptions({
-    config: configQuery.data,
-    providersView: providersQuery.data,
-    templatesView: templatesQuery.data
-  });
-
-  const sessionSummaries = useMemo(
-    () => sessionsQuery.data?.sessions ?? [],
-    [sessionsQuery.data?.sessions]
-  );
-  const allSessions = useMemo(
-    () => adaptNcpSessionSummaries(sessionSummaries),
-    [sessionSummaries]
-  );
-  const sessions = useMemo(
-    () => filterSessionsByQuery(allSessions, query),
-    [allSessions, query]
-  );
-  const selectedSession = useMemo(
-    () => allSessions.find((session) => session.key === sessionKey) ?? null,
-    [allSessions, sessionKey]
-  );
-  const skillRecords = useMemo(
-    () => sessionSkillsQuery.data?.records ?? [],
-    [sessionSkillsQuery.data?.records]
-  );
-  const sessionTypeState = useChatSessionTypeState({
-    selectedSession,
-    pendingSessionType,
-    setPendingSessionType,
-    sessionTypesData: sessionTypesQuery.data
-  });
-  const filteredModelOptions = useMemo(
-    () =>
-      filterModelOptionsBySessionType({
-        modelOptions,
-        supportedModels: sessionTypeState.selectedSessionTypeOption?.supportedModels
-      }),
-    [modelOptions, sessionTypeState.selectedSessionTypeOption?.supportedModels]
-  );
-  const { recentSessionPreferredModel, recentSessionPreferredThinking } =
-    useRecentSessionPreferences({
-      sessions: allSessions,
-      sessionKey,
-      sessionType: sessionTypeState.selectedSessionType
-    });
-  const { supportedThinkingLevels, defaultThinkingLevel } =
-    useCurrentModelThinkingState({
-      currentSelectedModel,
-      modelOptions: filteredModelOptions
-    });
-
-  useSyncSelectedModel({
-    modelOptions: filteredModelOptions,
-    selectedSessionKey: sessionKey ?? '',
-    selectedSessionExists: Boolean(selectedSession),
-    selectedSessionPreferredModel: selectedSession?.preferredModel,
-    fallbackPreferredModel: sessionTypeState.selectedSessionTypeOption?.recommendedModel ?? recentSessionPreferredModel,
-    defaultModel: sessionTypeState.selectedSessionTypeOption?.recommendedModel ?? configQuery.data?.agents.defaults.model,
-    setSelectedModel
-  });
-  useSyncSelectedThinking({
-    supportedThinkingLevels,
-    selectedSessionKey: sessionKey ?? '',
-    selectedSessionExists: Boolean(selectedSession),
-    selectedSessionPreferredThinking: selectedSession?.preferredThinking ?? null,
-    fallbackPreferredThinking: recentSessionPreferredThinking ?? null,
-    defaultThinkingLevel,
-    setSelectedThinkingLevel
-  });
-
-  return {
-    configQuery,
-    providersQuery,
-    templatesQuery,
-    sessionsQuery,
-    sessionTypesQuery,
-    sessionSkillsQuery,
-    isProviderStateResolved,
-    modelOptions: filteredModelOptions,
-    sessionSummaries,
-    sessions,
-    skillRecords,
-    selectedSession,
-    ...sessionTypeState
-  };
-}

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

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

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

@@ -1,77 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vitest';
-import { updateNcpSession } from '@/shared/lib/api';
-import { ChatSessionPreferenceSync } from './chat-session-preference-sync.manager';
-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 * as SharedApiModule from '@/shared/lib/api';
-
-vi.mock('@/shared/lib/api', async (importOriginal) => {
-  const actual = await importOriginal<typeof SharedApiModule>();
-  return {
-    ...actual,
-    updateNcpSession: vi.fn(async () => ({
-      sessionId: 'session-1',
-      messageCount: 0,
-      updatedAt: new Date().toISOString(),
-      status: 'idle',
-      metadata: {}
-    }))
-  };
-});
-
-describe('ChatSessionPreferenceSync', () => {
-  afterEach(() => {
-    useChatInputStore.setState((state) => ({
-      snapshot: {
-        ...state.snapshot,
-        selectedModel: '',
-        selectedThinkingLevel: null
-      }
-    }));
-    useChatSessionListStore.setState((state) => ({
-      snapshot: {
-        ...state.snapshot,
-        selectedSessionKey: null
-      }
-    }));
-    useChatThreadStore.setState((state) => ({
-      snapshot: {
-        ...state.snapshot,
-        canDeleteSession: false
-      }
-    }));
-    vi.clearAllMocks();
-  });
-
-  it('persists the selected model and thinking to the current session metadata', async () => {
-    useChatInputStore.setState((state) => ({
-      snapshot: {
-        ...state.snapshot,
-        selectedModel: 'openai/gpt-5',
-        selectedThinkingLevel: 'high'
-      }
-    }));
-    useChatSessionListStore.setState((state) => ({
-      snapshot: {
-        ...state.snapshot,
-        selectedSessionKey: 'session-1'
-      }
-    }));
-    useChatThreadStore.setState((state) => ({
-      snapshot: {
-        ...state.snapshot,
-        canDeleteSession: true
-      }
-    }));
-
-    const sync = new ChatSessionPreferenceSync(updateNcpSession);
-    sync.syncSelectedSessionPreferences();
-    await vi.waitFor(() => {
-      expect(updateNcpSession).toHaveBeenCalledWith('session-1', {
-        preferredModel: 'openai/gpt-5',
-        preferredThinking: 'high'
-      });
-    });
-  });
-});

package/src/features/chat/managers/chat-stream-actions.manager.ts

@@ -1,35 +0,0 @@
-import type { ChatStreamActions } from '@/features/chat/types/chat-stream.types';
-
-const noopAsync = async () => {};
-const noop = () => {};
-
-export class ChatStreamActionsManager {
-  private actions: ChatStreamActions = {
-    sendMessage: noopAsync,
-    stopCurrentRun: noopAsync,
-    resumeRun: noopAsync,
-    resetStreamState: noop,
-    applyHistoryMessages: noop
-  };
-
-  bind = (patch: Partial<ChatStreamActions>) => {
-    this.actions = {
-      ...this.actions,
-      ...patch
-    };
-  };
-
-  sendMessage = (payload: Parameters<ChatStreamActions['sendMessage']>[0]) =>
-    this.actions.sendMessage(payload);
-
-  stopCurrentRun = () => this.actions.stopCurrentRun();
-
-  resumeRun = (run: Parameters<ChatStreamActions['resumeRun']>[0]) => this.actions.resumeRun(run);
-
-  resetStreamState = () => this.actions.resetStreamState();
-
-  applyHistoryMessages = (
-    messages: Parameters<ChatStreamActions['applyHistoryMessages']>[0],
-    options?: Parameters<ChatStreamActions['applyHistoryMessages']>[1]
-  ) => this.actions.applyHistoryMessages(messages, options);
-}

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

@@ -1,232 +0,0 @@
-import { createChatComposerTextNode } from '@nextclaw/agent-chat-ui';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { NcpChatInputManager } from '@/features/chat/managers/ncp-chat-input.manager';
-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 { useSystemStatusStore } from '@/features/system-status';
-
-describe('NcpChatInputManager', () => {
-  beforeEach(() => {
-    useChatInputStore.setState({
-      snapshot: {
-        ...useChatInputStore.getState().snapshot,
-        draft: 'hello from current thread',
-        composerNodes: [createChatComposerTextNode('hello from current thread')],
-        attachments: [],
-        selectedSkills: [],
-        composerFocusRequest: null,
-        selectedSessionType: 'native',
-        selectedModel: 'gpt-5',
-        selectedThinkingLevel: null,
-        isProviderStateResolved: true,
-        modelOptions: [
-          {
-            value: 'gpt-5',
-            modelLabel: 'GPT-5',
-            providerLabel: 'OpenAI',
-            thinkingCapability: null,
-          },
-        ],
-      },
-    });
-    useSystemStatusStore.setState({
-      state: {
-        ...useSystemStatusStore.getState().state,
-        lifecyclePhase: 'ready',
-        bootstrapStatus: {
-          phase: 'ready',
-          ncpAgent: {
-            state: 'ready',
-          },
-          extensionLoading: {
-            state: 'ready',
-            loadedExtensionCount: 1,
-            totalExtensionCount: 1,
-          },
-          channels: {
-            state: 'ready',
-            enabled: [],
-          },
-          remote: {
-            state: 'pending',
-          },
-        },
-      },
-    });
-    useChatSessionListStore.setState({
-      optimisticReadAtBySessionKey: {},
-      snapshot: {
-        ...useChatSessionListStore.getState().snapshot,
-        selectedSessionKey: 'stale-selected-session',
-        selectedAgentId: 'main',
-      },
-    });
-    useChatThreadStore.setState({
-      snapshot: {
-        ...useChatThreadStore.getState().snapshot,
-        sessionKey: 'current-route-session',
-      },
-    });
-  });
-
-  it('sends through the current thread session when selected session state is stale', async () => {
-    const streamActionsManager = {
-      sendMessage: vi.fn().mockResolvedValue(undefined),
-      stopCurrentRun: vi.fn().mockResolvedValue(undefined),
-    } as unknown as ConstructorParameters<typeof NcpChatInputManager>[1];
-    const sessionListManager = {
-      ensureDraftSession: vi.fn(() => 'draft-session'),
-      materializeRootSessionRoute: vi.fn(),
-    } as unknown as ConstructorParameters<typeof NcpChatInputManager>[2];
-    const manager = new NcpChatInputManager(
-      {} as ConstructorParameters<typeof NcpChatInputManager>[0],
-      streamActionsManager,
-      sessionListManager,
-    );
-
-    await manager.send();
-
-    expect(streamActionsManager.sendMessage).toHaveBeenCalledTimes(1);
-    expect(streamActionsManager.sendMessage).toHaveBeenCalledWith(
-      expect.objectContaining({
-        sessionKey: 'current-route-session',
-        message: 'hello from current thread',
-      }),
-    );
-    expect(sessionListManager.ensureDraftSession).not.toHaveBeenCalled();
-    expect(sessionListManager.materializeRootSessionRoute).not.toHaveBeenCalled();
-  });
-
-  it('sends without a session key while /chat is still in blank-draft mode', async () => {
-    useChatThreadStore.setState({
-      snapshot: {
-        ...useChatThreadStore.getState().snapshot,
-        sessionKey: null,
-      },
-    });
-    useChatSessionListStore.setState({
-      snapshot: {
-        ...useChatSessionListStore.getState().snapshot,
-        selectedSessionKey: null,
-      },
-    });
-    const streamActionsManager = {
-      sendMessage: vi.fn().mockResolvedValue(undefined),
-      stopCurrentRun: vi.fn().mockResolvedValue(undefined),
-    } as unknown as ConstructorParameters<typeof NcpChatInputManager>[1];
-    const sessionListManager = {
-      ensureDraftSession: vi.fn(() => 'materialized-draft-session'),
-      materializeRootSessionRoute: vi.fn(),
-    } as unknown as ConstructorParameters<typeof NcpChatInputManager>[2];
-    const manager = new NcpChatInputManager(
-      {} as ConstructorParameters<typeof NcpChatInputManager>[0],
-      streamActionsManager,
-      sessionListManager,
-    );
-
-    await manager.send();
-
-    expect(sessionListManager.ensureDraftSession).toHaveBeenCalledWith('native');
-    expect(streamActionsManager.sendMessage).toHaveBeenCalledWith(
-      expect.not.objectContaining({
-        sessionKey: expect.any(String),
-      }),
-    );
-    expect(streamActionsManager.sendMessage).toHaveBeenCalledWith(
-      expect.objectContaining({
-        message: 'hello from current thread',
-      }),
-    );
-    expect(sessionListManager.materializeRootSessionRoute).not.toHaveBeenCalled();
-  });
-
-  it('does not send while the runtime is still blocked during startup', async () => {
-    useChatInputStore.setState({
-      snapshot: {
-        ...useChatInputStore.getState().snapshot,
-        isProviderStateResolved: false,
-        modelOptions: [],
-      },
-    });
-    useSystemStatusStore.setState({
-      state: {
-        ...useSystemStatusStore.getState().state,
-        lifecyclePhase: 'cold-starting',
-        bootstrapStatus: {
-          ...useSystemStatusStore.getState().state.bootstrapStatus!,
-          phase: 'kernel-starting',
-          ncpAgent: {
-            state: 'pending',
-          },
-        },
-      },
-    });
-    const streamActionsManager = {
-      sendMessage: vi.fn().mockResolvedValue(undefined),
-      stopCurrentRun: vi.fn().mockResolvedValue(undefined),
-    } as unknown as ConstructorParameters<typeof NcpChatInputManager>[1];
-    const sessionListManager = {
-      ensureDraftSession: vi.fn(() => 'draft-session'),
-      materializeRootSessionRoute: vi.fn(),
-    } as unknown as ConstructorParameters<typeof NcpChatInputManager>[2];
-    const manager = new NcpChatInputManager(
-      {} as ConstructorParameters<typeof NcpChatInputManager>[0],
-      streamActionsManager,
-      sessionListManager,
-    );
-
-    await manager.send();
-
-    expect(streamActionsManager.sendMessage).not.toHaveBeenCalled();
-    expect(sessionListManager.materializeRootSessionRoute).not.toHaveBeenCalled();
-  });
-
-  it('still attempts to send when provider metadata is stale or the session type is marked unavailable', async () => {
-    useChatInputStore.setState({
-      snapshot: {
-        ...useChatInputStore.getState().snapshot,
-        isProviderStateResolved: true,
-        modelOptions: [],
-        sessionTypeUnavailable: true,
-      },
-    });
-    const streamActionsManager = {
-      sendMessage: vi.fn().mockResolvedValue(undefined),
-      stopCurrentRun: vi.fn().mockResolvedValue(undefined),
-    } as unknown as ConstructorParameters<typeof NcpChatInputManager>[1];
-    const sessionListManager = {
-      ensureDraftSession: vi.fn(() => 'draft-session'),
-      materializeRootSessionRoute: vi.fn(),
-    } as unknown as ConstructorParameters<typeof NcpChatInputManager>[2];
-    const manager = new NcpChatInputManager(
-      {} as ConstructorParameters<typeof NcpChatInputManager>[0],
-      streamActionsManager,
-      sessionListManager,
-    );
-
-    await manager.send();
-
-    expect(streamActionsManager.sendMessage).toHaveBeenCalledTimes(1);
-    expect(sessionListManager.materializeRootSessionRoute).not.toHaveBeenCalled();
-  });
-
-  it('creates and consumes one-shot composer focus requests', () => {
-    const manager = new NcpChatInputManager(
-      {} as ConstructorParameters<typeof NcpChatInputManager>[0],
-      {} as ConstructorParameters<typeof NcpChatInputManager>[1],
-      {} as ConstructorParameters<typeof NcpChatInputManager>[2],
-    );
-
-    manager.requestComposerFocusAtEnd();
-
-    const request = useChatInputStore.getState().snapshot.composerFocusRequest;
-    expect(request).toEqual({ id: 1, placement: 'end' });
-
-    manager.consumeComposerFocusRequest(999);
-    expect(useChatInputStore.getState().snapshot.composerFocusRequest).toEqual(request);
-
-    manager.consumeComposerFocusRequest(request!.id);
-    expect(useChatInputStore.getState().snapshot.composerFocusRequest).toBeNull();
-  });
-});

package/src/features/chat/managers/ncp-chat-presenter.manager.ts

@@ -1,28 +0,0 @@
-import { ChatSessionListManager } from '@/features/chat/managers/chat-session-list.manager';
-import { ChatStreamActionsManager } from '@/features/chat/managers/chat-stream-actions.manager';
-import { ChatUiManager } from '@/features/chat/managers/chat-ui.manager';
-import { NcpChatInputManager } from '@/features/chat/managers/ncp-chat-input.manager';
-import { NcpChatThreadManager } from '@/features/chat/managers/ncp-chat-thread.manager';
-
-export class NcpChatPresenter {
-  chatUiManager = new ChatUiManager();
-  chatStreamActionsManager = new ChatStreamActionsManager();
-  chatSessionListManager = new ChatSessionListManager(this.chatUiManager, this.chatStreamActionsManager);
-  chatInputManager = new NcpChatInputManager(
-    this.chatUiManager,
-    this.chatStreamActionsManager,
-    this.chatSessionListManager
-  );
-  chatThreadManager = new NcpChatThreadManager(
-    this.chatUiManager,
-    this.chatSessionListManager,
-    this.chatStreamActionsManager
-  );
-
-  startAgentCreationDraft = (prompt: string) => {
-    this.chatSessionListManager.createSession();
-    this.chatSessionListManager.setSelectedAgentId('main');
-    this.chatInputManager.setDraft(prompt);
-    this.chatInputManager.requestComposerFocusAtEnd();
-  };
-}