@nextclaw/ui 0.15.22 → 0.15.24

package/src/features/chat/managers/__tests__/chat-thread-workspace.manager.test.ts

@@ -3,9 +3,11 @@ import { ChatThreadManager } from '@/features/chat/managers/chat-thread.manager'
 import { useChatSessionListStore } from '@/features/chat/stores/chat-session-list.store';
 import { useChatThreadStore } from '@/features/chat/stores/chat-thread.store';
 
-function createUiManager(): ConstructorParameters<typeof ChatThreadManager>[0] {
+function createUiManager(overrides: Record<string, unknown> = {}): ConstructorParameters<typeof ChatThreadManager>[0] {
   return {
     goToSession: vi.fn(),
+    isAtChatRoot: vi.fn(() => true),
+    ...overrides,
   } as unknown as ConstructorParameters<typeof ChatThreadManager>[0];
 }
 
@@ -24,6 +26,8 @@ describe('ChatThreadManager workspace pages', () => {
         activeWorkspacePanelKind: null,
         activeChildSessionKey: null,
         activeWorkspaceFileKey: null,
+        draftProjectRoot: null,
+        workspaceFileTabs: [],
         closedWorkspaceTabEntries: [],
         workspaceNavigationHistory: [],
         workspaceNavigationHistoryIndex: 0,
@@ -75,6 +79,94 @@ describe('ChatThreadManager workspace pages', () => {
     });
   });
 
+  it('opens project files for a draft without exposing session-only pages', () => {
+    const manager = new ChatThreadManager(
+      createUiManager(),
+      {} as ConstructorParameters<typeof ChatThreadManager>[1],
+    );
+
+    manager.toggleWorkspacePanel(null);
+
+    expect(useChatThreadStore.getState().snapshot).toMatchObject({
+      workspacePanelParentKey: null,
+      activeWorkspacePanelKind: 'project-files',
+      workspaceNavigationHistory: [{ kind: 'project-files' }],
+    });
+  });
+
+  it('materializes the draft selection, workspace, and route as one owner action', () => {
+    useChatThreadStore.setState({
+      snapshot: {
+        ...useChatThreadStore.getState().snapshot,
+        draftProjectRoot: '/tmp/project-alpha',
+        workspacePanelParentKey: null,
+        activeWorkspacePanelKind: 'file',
+        activeWorkspaceFileKey: 'draft::preview::README.md',
+        workspaceFileTabs: [
+          {
+            key: 'draft::preview::README.md',
+            parentSessionKey: null,
+            path: 'README.md',
+            viewMode: 'preview',
+          },
+        ],
+        workspaceNavigationHistory: [
+          { kind: 'project-files' },
+          { kind: 'file', key: 'draft::preview::README.md' },
+        ],
+        workspaceNavigationHistoryIndex: 1,
+      },
+    });
+    const uiManager = createUiManager();
+    const syncRouteSessionSelection = vi.fn((sessionKey: string) => {
+      useChatSessionListStore.getState().setSnapshot({ selectedSessionKey: sessionKey });
+      useChatThreadStore.getState().setSnapshot({ draftProjectRoot: null });
+    });
+    const manager = new ChatThreadManager(uiManager, {
+      syncRouteSessionSelection,
+    } as unknown as ConstructorParameters<typeof ChatThreadManager>[1]);
+
+    manager.materializeRootDraftSession('materialized-session');
+
+    expect(syncRouteSessionSelection).toHaveBeenCalledWith('materialized-session');
+    expect(useChatThreadStore.getState().snapshot).toMatchObject({
+      draftProjectRoot: null,
+      workspacePanelParentKey: 'materialized-session',
+      activeWorkspacePanelKind: 'file',
+      activeWorkspaceFileKey:
+        'materialized-session::preview::README.md',
+      workspaceFileTabs: [
+        expect.objectContaining({
+          key: 'materialized-session::preview::README.md',
+          parentSessionKey: 'materialized-session',
+        }),
+      ],
+      workspaceNavigationHistory: [
+        { kind: 'project-files' },
+        {
+          kind: 'file',
+          key: 'materialized-session::preview::README.md',
+        },
+      ],
+    });
+    expect(uiManager.goToSession).toHaveBeenCalledWith('materialized-session', {
+      replace: true,
+    });
+  });
+
+  it('ignores draft materialization after leaving the root route', () => {
+    const uiManager = createUiManager({ isAtChatRoot: vi.fn(() => false) });
+    const syncRouteSessionSelection = vi.fn();
+    const manager = new ChatThreadManager(uiManager, {
+      syncRouteSessionSelection,
+    } as unknown as ConstructorParameters<typeof ChatThreadManager>[1]);
+
+    manager.materializeRootDraftSession('materialized-session');
+
+    expect(syncRouteSessionSelection).not.toHaveBeenCalled();
+    expect(uiManager.goToSession).not.toHaveBeenCalled();
+  });
+
   it('does not close fixed workspace pages', () => {
     const manager = new ChatThreadManager(
       createUiManager(),

package/src/features/chat/managers/__tests__/provider-model-catalog-notice.manager.test.ts

@@ -0,0 +1,57 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import {
+  LARGE_PROVIDER_MODEL_CATALOG_THRESHOLD,
+  ProviderModelCatalogNoticeManager,
+} from '@/features/chat/managers/provider-model-catalog-notice.manager';
+
+function buildOptions(providerId: string, count: number) {
+  return Array.from({ length: count }, (_, index) => ({
+    providerId,
+    value: `${providerId}/model-${index + 1}`,
+  }));
+}
+
+describe('ProviderModelCatalogNoticeManager', () => {
+  beforeEach(() => {
+    window.localStorage.clear();
+  });
+
+  it('treats a first large catalog as a browseable baseline and only surfaces later additions', () => {
+    const manager = new ProviderModelCatalogNoticeManager();
+    const initial = buildOptions('openrouter', LARGE_PROVIDER_MODEL_CATALOG_THRESHOLD + 1);
+
+    expect(manager.filterUnseen(initial)).toEqual([]);
+    expect(manager.initializeLargeCatalogs(initial)).toBe(true);
+    expect(manager.filterUnseen([...initial, {
+      providerId: 'openrouter',
+      value: 'openrouter/new-after-baseline',
+    }])).toEqual([{
+      providerId: 'openrouter',
+      value: 'openrouter/new-after-baseline',
+    }]);
+  });
+
+  it('keeps small-catalog additions visible until the user marks the batch as seen', () => {
+    const manager = new ProviderModelCatalogNoticeManager();
+    const initial = buildOptions('opencode', 2);
+
+    expect(manager.filterUnseen(initial)).toEqual(initial);
+    expect(manager.acknowledge(initial)).toBe(true);
+    expect(manager.filterUnseen(initial)).toEqual([]);
+    expect(manager.filterUnseen([...initial, {
+      providerId: 'opencode',
+      value: 'opencode/new-after-seen',
+    }])).toEqual([{
+      providerId: 'opencode',
+      value: 'opencode/new-after-seen',
+    }]);
+  });
+
+  it('recovers from invalid persisted data without suppressing a small catalog', () => {
+    window.localStorage.setItem('nextclaw.chat.provider-model-catalog-notices', '{broken-json');
+    const manager = new ProviderModelCatalogNoticeManager();
+    const options = buildOptions('opencode', 1);
+
+    expect(manager.filterUnseen(options)).toEqual(options);
+  });
+});

package/src/features/chat/managers/chat-composer-intent.manager.ts

@@ -0,0 +1,190 @@
+import {
+  CHAT_CONVERSATION_EXCERPT_TOKEN_KIND,
+  CHAT_WORKSPACE_EXCERPT_TOKEN_KIND,
+  CHAT_WORKSPACE_FILE_TOKEN_KIND,
+} from "@nextclaw/shared";
+
+type ChatComposerReferenceIntentBase = {
+  id: number;
+  targetSessionKey: string | null;
+  tokenKey: string;
+  label: string;
+};
+
+export type ChatComposerFileReferenceIntent = ChatComposerReferenceIntentBase & {
+  kind: typeof CHAT_WORKSPACE_FILE_TOKEN_KIND;
+};
+
+export type ChatComposerExcerptReferenceIntent = ChatComposerReferenceIntentBase & {
+  kind: typeof CHAT_WORKSPACE_EXCERPT_TOKEN_KIND;
+  path: string;
+  excerpt: string;
+  startLine: number | null;
+  endLine: number | null;
+};
+
+export type ChatComposerConversationExcerptIntent = ChatComposerReferenceIntentBase & {
+  kind: typeof CHAT_CONVERSATION_EXCERPT_TOKEN_KIND;
+  messageId: string;
+  role: "assistant" | "user";
+  excerpt: string;
+};
+
+export type ChatComposerReferenceIntent =
+  | ChatComposerFileReferenceIntent
+  | ChatComposerExcerptReferenceIntent
+  | ChatComposerConversationExcerptIntent;
+
+type ChatComposerReferenceRequest =
+  | Omit<ChatComposerFileReferenceIntent, "id">
+  | Omit<ChatComposerExcerptReferenceIntent, "id">
+  | Omit<ChatComposerConversationExcerptIntent, "id">;
+
+function createExcerptTokenKey(prefix: string, identity: string): string {
+  let hash = 2166136261;
+  for (let index = 0; index < identity.length; index += 1) {
+    hash ^= identity.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return `${prefix}#excerpt-${(hash >>> 0).toString(36)}`;
+}
+
+type ChatComposerIntentListener = (intent: ChatComposerReferenceIntent) => void;
+
+type ChatComposerIntentSubscription = {
+  targetSessionKey: string | null;
+  listener: ChatComposerIntentListener;
+};
+
+export class ChatComposerIntentManager {
+  private nextId = 0;
+  private pendingIntent: ChatComposerReferenceIntent | null = null;
+  private readonly subscriptions = new Set<ChatComposerIntentSubscription>();
+
+  private publish = (intent: ChatComposerReferenceRequest) => {
+    const id = this.nextId + 1;
+    const targetSessionKey = intent.targetSessionKey?.trim() || null;
+    const nextIntent: ChatComposerReferenceIntent = intent.kind === CHAT_WORKSPACE_FILE_TOKEN_KIND
+      ? { ...intent, id, targetSessionKey }
+      : { ...intent, id, targetSessionKey };
+    this.nextId = nextIntent.id;
+    this.pendingIntent = nextIntent;
+    this.subscriptions.forEach((subscription) => {
+      if (subscription.targetSessionKey === nextIntent.targetSessionKey) {
+        subscription.listener(nextIntent);
+      }
+    });
+  };
+
+  requestFileReference = (params: {
+    targetSessionKey: string | null;
+    tokenKey: string;
+    label: string;
+  }) => {
+    const tokenKey = params.tokenKey.trim();
+    const label = params.label.trim();
+    if (!tokenKey || !label) {
+      return;
+    }
+    this.publish({
+      kind: CHAT_WORKSPACE_FILE_TOKEN_KIND,
+      targetSessionKey: params.targetSessionKey?.trim() || null,
+      tokenKey,
+      label,
+    });
+  };
+
+  requestExcerptReference = (params: {
+    targetSessionKey: string | null;
+    path: string;
+    label: string;
+    excerpt: string;
+    startLine: number | null;
+    endLine: number | null;
+  }) => {
+    const {
+      endLine,
+      excerpt: rawExcerpt,
+      label: rawLabel,
+      path: rawPath,
+      startLine,
+      targetSessionKey,
+    } = params;
+    const path = rawPath.trim();
+    const label = rawLabel.trim();
+    const excerpt = rawExcerpt.trim();
+    if (!path || !label || !excerpt) {
+      return;
+    }
+    this.publish({
+      kind: CHAT_WORKSPACE_EXCERPT_TOKEN_KIND,
+      targetSessionKey,
+      tokenKey: createExcerptTokenKey(
+        path,
+        `${path}:${startLine ?? "x"}:${endLine ?? "x"}:${excerpt}`,
+      ),
+      path,
+      label,
+      excerpt,
+      startLine,
+      endLine,
+    });
+  };
+
+  requestConversationExcerptReference = (params: {
+    targetSessionKey: string | null;
+    messageId: string;
+    role: "assistant" | "user";
+    label: string;
+    excerpt: string;
+  }) => {
+    const {
+      targetSessionKey,
+      messageId: requestedMessageId,
+      role,
+      label: requestedLabel,
+      excerpt: requestedExcerpt,
+    } = params;
+    const messageId = requestedMessageId.trim();
+    const label = requestedLabel.trim();
+    const excerpt = requestedExcerpt.trim();
+    if (!messageId || !label || !excerpt) return;
+    this.publish({
+      kind: CHAT_CONVERSATION_EXCERPT_TOKEN_KIND,
+      targetSessionKey,
+      tokenKey: createExcerptTokenKey(messageId, `${messageId}:${excerpt}`),
+      messageId,
+      role,
+      label,
+      excerpt,
+    });
+  };
+
+  consumePending = (
+    targetSessionKey: string | null,
+  ): ChatComposerReferenceIntent | null => {
+    if (this.pendingIntent?.targetSessionKey !== targetSessionKey) {
+      return null;
+    }
+    const intent = this.pendingIntent;
+    this.pendingIntent = null;
+    return intent;
+  };
+
+  markConsumed = (intentId: number) => {
+    if (this.pendingIntent?.id === intentId) {
+      this.pendingIntent = null;
+    }
+  };
+
+  subscribe = (
+    targetSessionKey: string | null,
+    listener: ChatComposerIntentListener,
+  ) => {
+    const subscription = { targetSessionKey, listener };
+    this.subscriptions.add(subscription);
+    return () => {
+      this.subscriptions.delete(subscription);
+    };
+  };
+}

package/src/features/chat/managers/chat-session-list.manager.ts

@@ -36,10 +36,14 @@ function toggleListValue(values: string[], value: string): string[] {
 export class ChatSessionListManager {
   constructor(private uiManager: ChatUiManager) {}
 
-  private syncDraftThreadState = () => {
+  private syncDraftThreadState = (draftProjectRoot: string | null) => {
+    const workspaceFileTabs = useChatThreadStore
+      .getState()
+      .snapshot.workspaceFileTabs.filter((tab) => tab.parentSessionKey !== null);
     useChatThreadStore.getState().setSnapshot({
       sessionKey: null,
       sessionDisplayName: undefined,
+      draftProjectRoot,
       canDeleteSession: false,
       parentSessionKey: null,
       parentSessionLabel: null,
@@ -47,7 +51,9 @@ export class ChatSessionListManager {
       activeWorkspacePanelKind: null,
       childSessionTabs: [],
       activeChildSessionKey: null,
+      activeSideChatDraft: null,
       activeWorkspaceFileKey: null,
+      workspaceFileTabs,
       closedWorkspaceTabEntries: [],
       workspaceNavigationHistory: [],
       workspaceNavigationHistoryIndex: 0,
@@ -112,6 +118,9 @@ export class ChatSessionListManager {
 
   syncRouteSessionSelection = (routeSessionKey: string | null) => {
     this.setSelectedSessionKey(routeSessionKey);
+    if (routeSessionKey) {
+      useChatThreadStore.getState().setSnapshot({ draftProjectRoot: null });
+    }
   };
 
   setListMode = (next: SetStateAction<"time-first" | "project-first">) => {
@@ -190,7 +199,7 @@ export class ChatSessionListManager {
     );
     const normalizedProjectRoot = normalizeSessionProjectRootValue(projectRoot);
     const normalizedPrompt = prompt?.trim() || null;
-    this.syncDraftThreadState();
+    this.syncDraftThreadState(normalizedProjectRoot);
     this.uiManager.navigateTo(CHAT_DRAFT_SESSION_PATH, {
       replace: this.uiManager.isAtChatRoot(),
       state: {
@@ -203,9 +212,9 @@ export class ChatSessionListManager {
     });
   };
 
-  startAgentDraftChat = (agentId: string, sessionType: string): void => {
+  startAgentDraftChat = (agentId: string, sessionType: string, prompt?: string): void => {
     const normalizedAgentId = agentId.trim() || "main";
-    this.createSession({ sessionType });
+    this.createSession({ prompt, sessionType });
     this.setSelectedAgentId(normalizedAgentId);
   };
 

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

@@ -27,6 +27,7 @@ import {
   closeWorkspaceTabSnapshot,
   createWorkspaceSelectionPatch,
   createSideChatDraft,
+  materializeDraftWorkspaceSnapshot,
   materializeSideChatDraftSnapshot,
   upsertChildSessionTab,
 } from '@/features/chat/features/workspace/utils/chat-thread-workspace-session.utils';
@@ -81,7 +82,7 @@ export class ChatThreadManager {
       sessionTypeLabel: null,
       agentId: null,
       sessionDisplayName: undefined,
-      sessionProjectRoot: null,
+      draftProjectRoot: null,
       sessionProjectName: null,
       canDeleteSession: false,
       parentSessionKey: null,
@@ -177,11 +178,11 @@ export class ChatThreadManager {
   };
 
   private openWorkspacePage = (
-    rawParentSessionKey: string,
+    rawParentSessionKey: string | null,
     kind: 'overview' | 'child-sessions' | 'project-files' | 'cron',
   ) => {
-    const parentSessionKey = rawParentSessionKey.trim();
-    if (!parentSessionKey) {
+    const parentSessionKey = rawParentSessionKey?.trim() || null;
+    if (!parentSessionKey && kind !== 'project-files') {
       return;
     }
     this.setWorkspaceSelection({
@@ -199,11 +200,8 @@ export class ChatThreadManager {
     this.openWorkspacePage(sessionKey, 'overview');
   };
 
-  toggleWorkspacePanel = (sessionKey: string) => {
-    const normalizedSessionKey = sessionKey.trim();
-    if (!normalizedSessionKey) {
-      return;
-    }
+  toggleWorkspacePanel = (sessionKey: string | null) => {
+    const normalizedSessionKey = sessionKey?.trim() || null;
     const { snapshot } = useChatThreadStore.getState();
     if (
       snapshot.workspacePanelParentKey === normalizedSessionKey &&
@@ -212,7 +210,11 @@ export class ChatThreadManager {
       this.closeWorkspacePanel();
       return;
     }
-    this.openWorkspaceOverview(normalizedSessionKey);
+    if (normalizedSessionKey) {
+      this.openWorkspaceOverview(normalizedSessionKey);
+      return;
+    }
+    this.openProjectFiles(null);
   };
 
   setWorkspacePanelWidth = (width: number) => {
@@ -225,10 +227,27 @@ export class ChatThreadManager {
     this.openWorkspacePage(sessionKey, 'child-sessions');
   };
 
-  openProjectFiles = (sessionKey: string) => {
+  openProjectFiles = (sessionKey: string | null) => {
     this.openWorkspacePage(sessionKey, 'project-files');
   };
 
+  materializeRootDraftSession = (rawSessionKey: string) => {
+    const sessionKey = rawSessionKey.trim();
+    if (!sessionKey || !this.uiManager.isAtChatRoot()) {
+      return;
+    }
+    const patch = materializeDraftWorkspaceSnapshot(
+      useChatThreadStore.getState().snapshot,
+      sessionKey,
+    );
+    if (!patch) {
+      return;
+    }
+    this.sessionListManager.syncRouteSessionSelection(sessionKey);
+    useChatThreadStore.getState().setSnapshot(patch);
+    this.uiManager.goToSession(sessionKey, { replace: true });
+  };
+
   openChildSessionPanel = (params: {
     parentSessionKey: string;
     activeChildSessionKey?: string | null;

package/src/features/chat/managers/provider-model-catalog-notice.manager.ts

@@ -0,0 +1,121 @@
+const STORAGE_KEY = 'nextclaw.chat.provider-model-catalog-notices';
+const STORAGE_VERSION = 1;
+
+export const LARGE_PROVIDER_MODEL_CATALOG_THRESHOLD = 50;
+
+type CatalogNoticeOption = {
+  readonly providerId: string;
+  readonly value: string;
+};
+
+type CatalogNoticeState = {
+  readonly version: typeof STORAGE_VERSION;
+  readonly acknowledgedModelsByProvider: Record<string, string[]>;
+};
+
+const EMPTY_STATE: CatalogNoticeState = {
+  version: STORAGE_VERSION,
+  acknowledgedModelsByProvider: {},
+};
+
+function readStorage(): Storage | null {
+  return typeof window === 'undefined' ? null : window.localStorage;
+}
+
+function groupOptions(options: readonly CatalogNoticeOption[]): Map<string, string[]> {
+  const grouped = new Map<string, string[]>();
+  for (const option of options) {
+    const values = grouped.get(option.providerId) ?? [];
+    if (!values.includes(option.value)) {
+      values.push(option.value);
+      grouped.set(option.providerId, values);
+    }
+  }
+  return grouped;
+}
+
+export class ProviderModelCatalogNoticeManager {
+  read = (): CatalogNoticeState => {
+    const storage = readStorage();
+    if (!storage) {
+      return EMPTY_STATE;
+    }
+    try {
+      const value = JSON.parse(storage.getItem(STORAGE_KEY) ?? 'null') as Partial<CatalogNoticeState> | null;
+      return value?.version === STORAGE_VERSION && value.acknowledgedModelsByProvider
+        ? {
+            version: STORAGE_VERSION,
+            acknowledgedModelsByProvider: value.acknowledgedModelsByProvider,
+          }
+        : EMPTY_STATE;
+    } catch {
+      return EMPTY_STATE;
+    }
+  };
+
+  write = (state: CatalogNoticeState): boolean => {
+    const storage = readStorage();
+    if (!storage) {
+      return false;
+    }
+    try {
+      storage.setItem(STORAGE_KEY, JSON.stringify(state));
+      return true;
+    } catch {
+      return false;
+    }
+  };
+
+  initializeLargeCatalogs = (options: readonly CatalogNoticeOption[]): boolean => {
+    const state = this.read();
+    const nextAcknowledged = { ...state.acknowledgedModelsByProvider };
+    let changed = false;
+    for (const [providerId, values] of groupOptions(options)) {
+      if (
+        values.length > LARGE_PROVIDER_MODEL_CATALOG_THRESHOLD &&
+        !Object.prototype.hasOwnProperty.call(nextAcknowledged, providerId)
+      ) {
+        nextAcknowledged[providerId] = values;
+        changed = true;
+      }
+    }
+    return changed && this.write({ version: STORAGE_VERSION, acknowledgedModelsByProvider: nextAcknowledged });
+  };
+
+  filterUnseen = <T extends CatalogNoticeOption>(options: readonly T[]): T[] => {
+    const acknowledged = this.read().acknowledgedModelsByProvider;
+    const grouped = groupOptions(options);
+    return options.filter((option) => {
+      const providerAcknowledged = acknowledged[option.providerId];
+      if (!providerAcknowledged) {
+        return (grouped.get(option.providerId)?.length ?? 0) <= LARGE_PROVIDER_MODEL_CATALOG_THRESHOLD;
+      }
+      return !providerAcknowledged.includes(option.value);
+    });
+  };
+
+  acknowledge = (options: readonly CatalogNoticeOption[]): boolean => {
+    if (options.length === 0) {
+      return false;
+    }
+    const state = this.read();
+    const nextAcknowledged = { ...state.acknowledgedModelsByProvider };
+    let changed = false;
+    for (const [providerId, values] of groupOptions(options)) {
+      const currentValues = nextAcknowledged[providerId] ?? [];
+      const currentSet = new Set(currentValues);
+      const merged = [...currentValues];
+      for (const value of values) {
+        if (!currentSet.has(value)) {
+          currentSet.add(value);
+          merged.push(value);
+          changed = true;
+        }
+      }
+      nextAcknowledged[providerId] = merged;
+    }
+    return changed && this.write({ version: STORAGE_VERSION, acknowledgedModelsByProvider: nextAcknowledged });
+  };
+}
+
+export const providerModelCatalogNoticeManager = new ProviderModelCatalogNoticeManager();

package/src/features/chat/presenters/chat.presenter.ts

@@ -2,6 +2,7 @@ import { ChatSessionListManager } from '@/features/chat/managers/chat-session-li
 import { ChatUiManager } from '@/features/chat/managers/chat-ui.manager';
 import { ChatQueryManager } from '@/features/chat/managers/chat-query.manager';
 import { ChatThreadManager } from '@/features/chat/managers/chat-thread.manager';
+import { ChatComposerIntentManager } from '@/features/chat/managers/chat-composer-intent.manager';
 import type { AppPresenter } from '@/app/presenters/app.presenter';
 
 export class ChatPresenter {
@@ -9,11 +10,13 @@ export class ChatPresenter {
   readonly chatSessionListManager: ChatSessionListManager;
   readonly chatQueryManager: ChatQueryManager;
   readonly chatThreadManager: ChatThreadManager;
+  readonly chatComposerIntentManager: ChatComposerIntentManager;
 
   constructor(appPresenter: AppPresenter) {
     this.chatUiManager = new ChatUiManager(appPresenter.docBrowserManager);
     this.chatSessionListManager = new ChatSessionListManager(this.chatUiManager);
     this.chatQueryManager = new ChatQueryManager();
+    this.chatComposerIntentManager = new ChatComposerIntentManager();
     this.chatThreadManager = new ChatThreadManager(
       this.chatUiManager,
       this.chatSessionListManager,