@nextclaw/ui 0.12.24 → 0.12.26

package/src/features/chat/hooks/use-ncp-agent-runtime.test.tsx

@@ -5,6 +5,8 @@ import {
   type NcpEndpointEvent,
   type NcpEndpointManifest,
   type NcpEndpointSubscriber,
+  type NcpMessage,
+  type NcpStreamRequestPayload,
   NcpEventType,
 } from "@nextclaw/ncp";
 import { beforeEach, describe, expect, it, vi } from "vitest";
@@ -31,9 +33,57 @@ class DeferredSendClient implements NcpAgentClientEndpoint {
   readonly stream = vi.fn(async () => {});
   readonly abort = vi.fn(async () => {});
   private listeners = new Set<NcpEndpointSubscriber>();
-  private releaseCompletion: (() => void) | null = null;
-  private completionGate = new Promise<void>((resolve) => {
-    this.releaseCompletion = resolve;
+
+  emit = async (event: NcpEndpointEvent): Promise<void> => {
+    this.publish(event);
+  };
+
+  subscribe = (listener: NcpEndpointSubscriber): (() => void) => {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  };
+
+  send = vi.fn(async (envelope: NcpAgentSendEnvelope) => ({
+    sessionId: "session-created",
+    userMessageId: envelope.message.id,
+    assistantMessageId: "assistant-1",
+    runId: "run-1",
+    ...(envelope.correlationId ? { correlationId: envelope.correlationId } : {}),
+  }));
+
+  private publish = (event: NcpEndpointEvent): void => {
+    for (const listener of this.listeners) {
+      listener(event);
+    }
+  };
+}
+
+class ExistingSessionLiveClient implements NcpAgentClientEndpoint {
+  readonly manifest: NcpEndpointManifest = {
+    endpointKind: "agent",
+    endpointId: "existing-session-live-client",
+    version: "0.1.0",
+    supportsStreaming: true,
+    supportsAbort: true,
+    supportsProactiveMessages: false,
+    supportsLiveSessionStream: true,
+    supportedPartTypes: ["text"],
+    expectedLatency: "seconds",
+  };
+
+  readonly start = vi.fn(async () => {});
+  readonly abort = vi.fn(async () => {});
+  private listeners = new Set<NcpEndpointSubscriber>();
+  private liveStreamActive = false;
+
+  stop = vi.fn(async () => {
+    this.liveStreamActive = false;
+  });
+
+  stream = vi.fn(async (_payload: NcpStreamRequestPayload) => {
+    this.liveStreamActive = true;
   });
 
   emit = async (event: NcpEndpointEvent): Promise<void> => {
@@ -47,78 +97,59 @@ class DeferredSendClient implements NcpAgentClientEndpoint {
     };
   };
 
-  send = vi.fn(async (_envelope: NcpAgentSendEnvelope): Promise<void> => {
-    this.publish({
-      type: NcpEventType.MessageSent,
-      payload: {
-        sessionId: "session-created",
-        message: {
-          id: "user-1",
-          sessionId: "session-created",
-          role: "user",
-          status: "final",
-          parts: [{ type: "text", text: "hello" }],
-          timestamp: now,
+  send = vi.fn(async (envelope: NcpAgentSendEnvelope) => {
+    const events: NcpEndpointEvent[] = [
+      {
+        type: NcpEventType.RunStarted,
+        payload: {
+          sessionId: "session-existing",
+          messageId: "assistant-1",
+          runId: "run-1",
         },
       },
-    });
-    this.publish({
-      type: NcpEventType.RunStarted,
-      payload: {
-        sessionId: "session-created",
-        messageId: "assistant-1",
-        runId: "run-1",
-      },
-    });
-    await this.completionGate;
-    this.publish({
-      type: NcpEventType.MessageTextStart,
-      payload: {
-        sessionId: "session-created",
-        messageId: "assistant-1",
-      },
-    });
-    this.publish({
-      type: NcpEventType.MessageTextDelta,
-      payload: {
-        sessionId: "session-created",
-        messageId: "assistant-1",
-        delta: "done",
+      {
+        type: NcpEventType.MessageTextStart,
+        payload: {
+          sessionId: "session-existing",
+          messageId: "assistant-1",
+        },
       },
-    });
-    this.publish({
-      type: NcpEventType.MessageTextEnd,
-      payload: {
-        sessionId: "session-created",
-        messageId: "assistant-1",
+      {
+        type: NcpEventType.MessageTextDelta,
+        payload: {
+          sessionId: "session-existing",
+          messageId: "assistant-1",
+          delta: "done",
+        },
       },
-    });
-    this.publish({
-      type: NcpEventType.MessageCompleted,
-      payload: {
-        sessionId: "session-created",
-        message: {
-          id: "assistant-1",
-          sessionId: "session-created",
-          role: "assistant",
-          status: "final",
-          parts: [{ type: "text", text: "done" }],
-          timestamp: now,
+      {
+        type: NcpEventType.MessageTextEnd,
+        payload: {
+          sessionId: "session-existing",
+          messageId: "assistant-1",
         },
       },
-    });
-    this.publish({
-      type: NcpEventType.RunFinished,
-      payload: {
-        sessionId: "session-created",
-        runId: "run-1",
+      {
+        type: NcpEventType.RunFinished,
+        payload: {
+          sessionId: "session-existing",
+          runId: "run-1",
+        },
       },
-    });
-  });
+    ];
 
-  release = (): void => {
-    this.releaseCompletion?.();
-  };
+    if (this.liveStreamActive) {
+      for (const event of events) {
+        this.publish(event);
+      }
+    }
+    return {
+      sessionId: "session-existing",
+      userMessageId: envelope.message.id,
+      assistantMessageId: "assistant-1",
+      runId: "run-1",
+    };
+  });
 
   private publish = (event: NcpEndpointEvent): void => {
     for (const listener of this.listeners) {
@@ -127,12 +158,20 @@ class DeferredSendClient implements NcpAgentClientEndpoint {
   };
 }
 
+function readAssistantText(messages: readonly NcpMessage[]): string {
+  const assistant = messages.find((message) => message.role === "assistant");
+  return assistant?.parts
+    .filter((part) => part.type === "text")
+    .map((part) => part.text ?? "")
+    .join("") ?? "";
+}
+
 describe("useNcpAgentRuntime", () => {
   beforeEach(() => {
     vi.clearAllMocks();
   });
 
-  it("keeps the active send stream alive when a new root chat materializes a session id", async () => {
+  it("returns a command handle when a new root chat materializes a session id", async () => {
     const client = new DeferredSendClient();
     const manager = new DefaultNcpAgentConversationStateManager();
     const envelope: NcpAgentSendEnvelope = {
@@ -150,30 +189,64 @@ describe("useNcpAgentRuntime", () => {
       { initialProps: { sessionId: undefined as string | undefined } },
     );
 
-    let sendPromise: Promise<void>;
-    act(() => {
-      sendPromise = result.current.send(envelope);
+    let handle: Awaited<ReturnType<typeof result.current.send>> | null = null;
+    await act(async () => {
+      handle = await result.current.send(envelope);
     });
 
-    await waitFor(() => {
-      expect(result.current.snapshot.activeRun?.sessionId).toBe("session-created");
+    expect(handle).toEqual({
+      sessionId: "session-created",
+      userMessageId: "user-1",
+      assistantMessageId: "assistant-1",
+      runId: "run-1",
     });
+    expect(result.current.visibleMessages).toEqual([]);
+    expect(client.stop).not.toHaveBeenCalled();
 
     rerender({ sessionId: "session-created" });
+  });
 
-    expect(client.stop).not.toHaveBeenCalled();
+  it("aborts by session id even before a hydrated active run reaches local state", async () => {
+    const client = new DeferredSendClient();
+    const manager = new DefaultNcpAgentConversationStateManager();
+    const { result } = renderHook(() =>
+      useNcpAgentRuntime({ sessionId: "session-running", client, manager: manager as never }),
+    );
+
+    await act(async () => {
+      await result.current.abort();
+    });
+
+    expect(client.abort).toHaveBeenCalledWith({ sessionId: "session-running" });
+  });
+
+  it("uses the hydrated live stream as the only event source while sending to an existing session", async () => {
+    const client = new ExistingSessionLiveClient();
+    const manager = new DefaultNcpAgentConversationStateManager();
+    await client.stream({ sessionId: "session-existing" });
+    const { result } = renderHook(() =>
+      useNcpAgentRuntime({ sessionId: "session-existing", client, manager: manager as never }),
+    );
 
     await act(async () => {
-      client.release();
-      await sendPromise;
+      await result.current.send({
+        sessionId: "session-existing",
+        message: {
+          id: "user-1",
+          sessionId: "session-existing",
+          role: "user",
+          status: "final",
+          parts: [{ type: "text", text: "hello" }],
+          timestamp: now,
+        },
+      });
     });
 
     await waitFor(() => {
       expect(result.current.snapshot.activeRun).toBeNull();
+      expect(readAssistantText(result.current.visibleMessages)).toBe("done");
     });
-    expect(result.current.visibleMessages.map((message) => message.id)).toEqual([
-      "user-1",
-      "assistant-1",
-    ]);
+    expect(client.stop).not.toHaveBeenCalled();
+    expect(client.stream).toHaveBeenCalledTimes(1);
   });
 });

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

@@ -0,0 +1,70 @@
+import { renderHook } from '@testing-library/react';
+import { describe, expect, it, vi } from 'vitest';
+import { useNcpChatPageData } from './use-ncp-chat-page-data';
+
+const useNcpSessionSkillsMock = vi.fn();
+
+vi.mock('@/shared/hooks/use-config', () => ({
+  useConfig: () => ({
+    data: {
+      agents: { defaults: {} },
+      providers: {}
+    },
+    isFetched: true,
+    isSuccess: true
+  }),
+  useConfigMeta: () => ({
+    data: { providers: [] },
+    isFetched: true,
+    isSuccess: true
+  }),
+  useNcpSessions: () => ({
+    data: { sessions: [] }
+  }),
+  useNcpSessionSkills: (params: unknown) => useNcpSessionSkillsMock(params)
+}));
+
+vi.mock('./use-ncp-chat-session-types', () => ({
+  useNcpChatSessionTypes: () => ({
+    data: {
+      defaultType: 'native',
+      options: [{ value: 'native', label: 'Native' }]
+    }
+  })
+}));
+
+function renderPageData(params: { sessionKey: string | null }) {
+  return renderHook(() =>
+    useNcpChatPageData({
+      sessionKey: params.sessionKey,
+      query: '',
+      currentSelectedModel: '',
+      pendingSessionType: '',
+      setPendingSessionType: vi.fn(),
+      setSelectedModel: vi.fn(),
+      setSelectedThinkingLevel: vi.fn()
+    })
+  );
+}
+
+describe('useNcpChatPageData skills query', () => {
+  it('loads draft-session skills before a new chat materializes', () => {
+    useNcpSessionSkillsMock.mockReturnValue({ data: { records: [] }, isLoading: false });
+
+    renderPageData({ sessionKey: null });
+
+    expect(useNcpSessionSkillsMock).toHaveBeenCalledWith({
+      sessionId: 'draft-session'
+    });
+  });
+
+  it('loads real session skills after materialization', () => {
+    useNcpSessionSkillsMock.mockReturnValue({ data: { records: [] }, isLoading: false });
+
+    renderPageData({ sessionKey: 'session-1' });
+
+    expect(useNcpSessionSkillsMock).toHaveBeenCalledWith({
+      sessionId: 'session-1'
+    });
+  });
+});

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

@@ -158,7 +158,7 @@ export function useNcpChatPageData(params: UseNcpChatPageDataParams) {
   const sessionsQuery = useNcpSessions({ limit: 200 });
   const sessionTypesQuery = useNcpChatSessionTypes();
   const sessionSkillsQuery = useNcpSessionSkills({
-    sessionId: sessionKey ?? null,
+    sessionId: sessionKey?.trim() || 'draft-session',
     ...(Object.prototype.hasOwnProperty.call(params, 'projectRootOverride')
       ? { projectRoot: projectRootOverride ?? null }
       : {})

package/src/features/chat/hooks/use-ncp-child-session-tabs-view.ts

@@ -49,16 +49,10 @@ export function useNcpChildSessionTabsView(
     return new Map(sessions.map((session) => [session.key, session]));
   }, [summaries]);
 
-  const summaryByKey = useMemo(
-    () => new Map(summaries.map((summary) => [summary.sessionId, summary])),
-    [summaries],
-  );
-
   return useMemo(
     () =>
       tabs.map((tab) => {
         const session = sessionByKey.get(tab.sessionKey) ?? null;
-        const summary = summaryByKey.get(tab.sessionKey) ?? null;
         const agentId = tab.agentId?.trim() || session?.agentId || null;
         return {
           sessionKey: tab.sessionKey,
@@ -68,7 +62,7 @@ export function useNcpChildSessionTabsView(
           updatedAt: session?.updatedAt ?? null,
           lastMessageAt: session?.lastMessageAt ?? null,
           readAt: session?.readAt ?? null,
-          runStatus: summary?.status === "running" ? "running" : undefined,
+          runStatus: session?.status === "running" ? "running" : undefined,
           sessionTypeLabel: session?.sessionType
             ? resolveSessionTypeLabel(session.sessionType)
             : null,
@@ -77,6 +71,6 @@ export function useNcpChildSessionTabsView(
           projectRoot: session?.projectRoot?.trim() || null,
         };
       }),
-    [sessionByKey, summaryByKey, tabs],
+    [sessionByKey, tabs],
   );
 }

package/src/features/chat/hooks/use-ncp-session-list-view.ts

@@ -32,11 +32,10 @@ export function useNcpSessionListView(params: { limit?: number } = {}) {
       shouldShowSessionInSidebar,
     );
     const filteredSessions = filterSessionsByQuery(sessions, query);
-    const summaryBySessionId = new Map(summaries.map((summary) => [summary.sessionId, summary]));
 
     return filteredSessions.map((session) => ({
       session,
-      runStatus: summaryBySessionId.get(session.key)?.status === 'running' ? 'running' : undefined
+      runStatus: session.status === 'running' ? 'running' : undefined
     }));
   }, [query, sessionsQuery.data?.sessions]);
 

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

@@ -35,7 +35,6 @@ describe('ChatSessionListManager', () => {
       snapshot: {
         ...useChatSessionListStore.getState().snapshot,
         selectedSessionKey: 'session-1',
-        draftSessionKey: 'draft-root-1',
         listMode: 'time-first'
       }
     });
@@ -65,8 +64,8 @@ describe('ChatSessionListManager', () => {
     expect(streamActionsManager.resetStreamState).toHaveBeenCalledTimes(1);
     expect(uiManager.goToChatRoot).toHaveBeenCalledTimes(1);
     expect(useChatSessionListStore.getState().snapshot.selectedSessionKey).toBeNull();
-    expect(useChatSessionListStore.getState().snapshot.draftSessionKey).toBeNull();
     expect(useChatThreadStore.getState().snapshot.sessionKey).toBeNull();
+    expect(useChatThreadStore.getState().snapshot.hasSubmittedDraftMessage).toBe(false);
     expect(useChatInputStore.getState().snapshot.pendingSessionType).toBe('codex');
     expect(useChatInputStore.getState().snapshot.pendingProjectRoot).toBeNull();
     expect(useChatInputStore.getState().snapshot.pendingProjectRootSessionKey).toBeNull();
@@ -89,8 +88,8 @@ describe('ChatSessionListManager', () => {
     expect(uiManager.goToChatRoot).toHaveBeenCalledTimes(1);
     expect(useChatSessionListStore.getState().snapshot.selectedAgentId).toBe('researcher');
     expect(useChatSessionListStore.getState().snapshot.selectedSessionKey).toBeNull();
-    expect(useChatSessionListStore.getState().snapshot.draftSessionKey).toBeNull();
     expect(useChatThreadStore.getState().snapshot.sessionKey).toBeNull();
+    expect(useChatThreadStore.getState().snapshot.hasSubmittedDraftMessage).toBe(false);
     expect(useChatInputStore.getState().snapshot.pendingSessionType).toBe('codex');
     expect(useChatInputStore.getState().snapshot.pendingProjectRoot).toBeNull();
     expect(useChatInputStore.getState().snapshot.pendingProjectRootSessionKey).toBeNull();
@@ -117,8 +116,7 @@ describe('ChatSessionListManager', () => {
     useChatSessionListStore.setState({
       snapshot: {
         ...useChatSessionListStore.getState().snapshot,
-        selectedSessionKey: null,
-        draftSessionKey: 'draft-root-2'
+        selectedSessionKey: null
       }
     });
     const uiManager = {
@@ -137,6 +135,7 @@ describe('ChatSessionListManager', () => {
     expect(uiManager.goToChatRoot).not.toHaveBeenCalled();
     expect(uiManager.goToSession).not.toHaveBeenCalled();
     expect(useChatSessionListStore.getState().snapshot.selectedSessionKey).toBeNull();
+    expect(useChatThreadStore.getState().snapshot.hasSubmittedDraftMessage).toBe(true);
   });
 
   it('does not eagerly replace the old selected session before the route finishes switching', () => {
@@ -225,12 +224,11 @@ describe('ChatSessionListManager', () => {
     expect(mocks.updateNcpSession).not.toHaveBeenCalled();
   });
 
-  it('routes to the backend-materialized root session after the first send starts', () => {
+  it('routes to the backend-materialized root session without duplicating route-owned selection state', () => {
     useChatSessionListStore.setState({
       snapshot: {
         ...useChatSessionListStore.getState().snapshot,
         selectedSessionKey: null,
-        draftSessionKey: 'draft-root-2',
       }
     });
     const uiManager = {
@@ -246,8 +244,8 @@ describe('ChatSessionListManager', () => {
     manager.ensureDraftSession('native');
     manager.materializeRootSessionRoute('ncp-materialized-session');
 
-    expect(useChatSessionListStore.getState().snapshot.selectedSessionKey).toBe('ncp-materialized-session');
-    expect(useChatThreadStore.getState().snapshot.sessionKey).toBe('ncp-materialized-session');
+    expect(useChatSessionListStore.getState().snapshot.selectedSessionKey).toBeNull();
+    expect(useChatThreadStore.getState().snapshot.sessionKey).toBeNull();
     expect(uiManager.goToSession).toHaveBeenCalledWith('ncp-materialized-session', { replace: true });
   });
 });

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

@@ -12,7 +12,7 @@ export class ChatSessionListManager {
     private streamActionsManager: ChatStreamActionsManager
   ) {}
 
-  private syncDraftThreadState = () => {
+  private syncDraftThreadState = (hasSubmittedDraftMessage = false) => {
     useChatThreadStore.getState().setSnapshot({
       sessionKey: null,
       sessionDisplayName: undefined,
@@ -21,9 +21,11 @@ export class ChatSessionListManager {
       messages: [],
       isSending: false,
       isAwaitingAssistantOutput: false,
+      hasSubmittedDraftMessage,
       parentSessionKey: null,
       parentSessionLabel: null,
       workspacePanelParentKey: null,
+      activeWorkspacePanelKind: null,
       childSessionTabs: [],
       activeChildSessionKey: null,
       activeWorkspaceFileKey: null,
@@ -108,7 +110,6 @@ export class ChatSessionListManager {
     this.streamActionsManager.resetStreamState();
     useChatSessionListStore.getState().setSnapshot({
       selectedSessionKey: null,
-      draftSessionKey: null
     });
     this.syncDraftThreadState();
     useChatInputStore.getState().setSnapshot({
@@ -134,7 +135,7 @@ export class ChatSessionListManager {
       typeof sessionType === 'string' && sessionType.trim().length > 0
         ? sessionType.trim()
         : null;
-    this.syncDraftThreadState();
+    this.syncDraftThreadState(true);
     if (normalizedSessionType) {
       useChatInputStore.getState().setSnapshot({ pendingSessionType: normalizedSessionType });
     }
@@ -149,19 +150,13 @@ export class ChatSessionListManager {
     if (!this.uiManager.isAtChatRoot()) {
       return;
     }
-    useChatSessionListStore.getState().setSnapshot({
-      selectedSessionKey: normalizedSessionKey,
-      draftSessionKey: null,
-    });
-    useChatThreadStore.getState().setSnapshot({
-      sessionKey: normalizedSessionKey,
-    });
     this.uiManager.goToSession(normalizedSessionKey, { replace: true });
   };
 
   selectSession = (sessionKey: string) => {
     useChatThreadStore.getState().setSnapshot({
       workspacePanelParentKey: null,
+      activeWorkspacePanelKind: null,
       activeChildSessionKey: null,
       activeWorkspaceFileKey: null,
     });

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

@@ -15,6 +15,7 @@ describe('NcpChatInputManager', () => {
         composerNodes: [createChatComposerTextNode('hello from current thread')],
         attachments: [],
         selectedSkills: [],
+        composerFocusRequest: null,
         selectedSessionType: 'native',
         selectedModel: 'gpt-5',
         selectedThinkingLevel: null,
@@ -58,7 +59,6 @@ describe('NcpChatInputManager', () => {
       snapshot: {
         ...useChatSessionListStore.getState().snapshot,
         selectedSessionKey: 'stale-selected-session',
-        draftSessionKey: 'draft-root-session',
         selectedAgentId: 'main',
       },
     });
@@ -109,7 +109,6 @@ describe('NcpChatInputManager', () => {
       snapshot: {
         ...useChatSessionListStore.getState().snapshot,
         selectedSessionKey: null,
-        draftSessionKey: null,
       },
     });
     const streamActionsManager = {
@@ -211,4 +210,23 @@ describe('NcpChatInputManager', () => {
     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-input.manager.ts

@@ -132,6 +132,24 @@ export class NcpChatInputManager {
     this.syncComposerSnapshot(createChatComposerNodesFromDraft(value));
   };
 
+  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);

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

@@ -18,4 +18,11 @@ export class NcpChatPresenter {
     this.chatSessionListManager,
     this.chatStreamActionsManager
   );
+
+  startAgentCreationDraft = (prompt: string) => {
+    this.chatSessionListManager.createSession();
+    this.chatSessionListManager.setSelectedAgentId('main');
+    this.chatInputManager.setDraft(prompt);
+    this.chatInputManager.requestComposerFocusAtEnd();
+  };
 }