@nextclaw/ui 0.11.22 → 0.11.23

package/src/components/chat/ncp/ncp-session-adapter.test.ts

@@ -39,9 +39,30 @@ describe('adaptNcpSessionSummary', () => {
       projectName: 'project-alpha',
       sessionType: 'native',
       sessionTypeMutable: false,
+      isChildSession: false,
       messageCount: 3
     });
   });
+
+  it('marks child sessions from parent_session_id metadata and keeps the request link', () => {
+    const adapted = adaptNcpSessionSummary(
+      createSummary({
+        metadata: {
+          label: 'Verifier',
+          session_type: 'native',
+          parent_session_id: 'parent-session-1',
+          spawned_by_request_id: 'request-1',
+        },
+      }),
+    );
+
+    expect(adapted).toMatchObject({
+      key: 'ncp-session-1',
+      isChildSession: true,
+      parentSessionId: 'parent-session-1',
+      spawnedByRequestId: 'request-1',
+    });
+  });
 });
 
 describe('adaptNcpMessageToUiMessage', () => {

package/src/components/chat/ncp/ncp-session-adapter.ts

@@ -88,6 +88,30 @@ function readNcpSessionType(summary: NcpSessionSummaryView): string {
   return readOptionalString(metadata.session_type) ?? readOptionalString(metadata.sessionType) ?? 'native';
 }
 
+function readNcpParentSessionId(summary: NcpSessionSummaryView): string | null {
+  const metadata = readMetadata(summary);
+  if (!metadata) {
+    return null;
+  }
+  return readOptionalString(metadata.parent_session_id) ?? readOptionalString(metadata.parentSessionId);
+}
+
+function readNcpSpawnedByRequestId(summary: NcpSessionSummaryView): string | null {
+  const metadata = readMetadata(summary);
+  if (!metadata) {
+    return null;
+  }
+  return readOptionalString(metadata.spawned_by_request_id) ?? readOptionalString(metadata.spawnedByRequestId);
+}
+
+function readPromotedChildSession(summary: NcpSessionSummaryView): boolean {
+  const metadata = readMetadata(summary);
+  if (!metadata) {
+    return false;
+  }
+  return metadata.child_session_promoted === true;
+}
+
 function parseSessionContext(sessionKey: string): { channel?: string; type?: string } {
   if (sessionKey === 'heartbeat') {
     return { type: 'heartbeat' };
@@ -222,6 +246,9 @@ export function adaptNcpSessionSummary(summary: NcpSessionSummaryView): SessionE
   const projectRoot = readNcpSessionProjectRoot(summary);
   const projectName = getSessionProjectName(projectRoot);
   const context = parseSessionContext(summary.sessionId);
+  const parentSessionId = readNcpParentSessionId(summary);
+  const spawnedByRequestId = readNcpSpawnedByRequestId(summary);
+  const isPromotedChildSession = readPromotedChildSession(summary);
   return {
     key: summary.sessionId,
     createdAt: summary.updatedAt,
@@ -234,6 +261,10 @@ export function adaptNcpSessionSummary(summary: NcpSessionSummaryView): SessionE
     ...(projectName ? { projectName } : {}),
     sessionType: readNcpSessionType(summary),
     sessionTypeMutable: false,
+    isChildSession: Boolean(parentSessionId),
+    ...(isPromotedChildSession ? { isPromotedChildSession } : {}),
+    ...(parentSessionId ? { parentSessionId } : {}),
+    ...(spawnedByRequestId ? { spawnedByRequestId } : {}),
     messageCount: summary.messageCount
   };
 }

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

@@ -15,13 +15,22 @@ function filterSessionsByQuery(sessions: readonly SessionEntryView[], query: str
   return sessions.filter((session) => sessionMatchesQuery(session, query));
 }
 
+function shouldShowSessionInSidebar(session: SessionEntryView): boolean {
+  if (!session.isChildSession) {
+    return true;
+  }
+  return session.isPromotedChildSession === true;
+}
+
 export function useNcpSessionListView(params: { limit?: number } = {}) {
   const query = useChatSessionListStore((state) => state.snapshot.query);
   const sessionsQuery = useNcpSessions({ limit: params.limit ?? 200 });
 
   const items = useMemo<NcpSessionListItemView[]>(() => {
     const summaries = sessionsQuery.data?.sessions ?? [];
-    const sessions = adaptNcpSessionSummaries(summaries);
+    const sessions = adaptNcpSessionSummaries(summaries).filter(
+      shouldShowSessionInSidebar,
+    );
     const filteredSessions = filterSessionsByQuery(sessions, query);
     const summaryBySessionId = new Map(summaries.map((summary) => [summary.sessionId, summary]));
 

package/src/components/chat/presenter/chat-presenter-context.tsx

@@ -1,4 +1,4 @@
-import type { ChatComposerNode } from '@nextclaw/agent-chat-ui';
+import type { ChatComposerNode, ChatToolActionViewModel } from '@nextclaw/agent-chat-ui';
 import type { NcpDraftAttachment } from '@nextclaw/ncp-react';
 import { createContext, useContext } from 'react';
 import type { ReactNode } from 'react';
@@ -37,6 +37,9 @@ export type ChatThreadManagerLike = {
   deleteSession: () => void;
   createSession: () => void;
   goToProviders: () => void;
+  openSessionFromToolAction: (action: ChatToolActionViewModel) => void;
+  closeChildSessionDetail: () => void;
+  goToParentSession: () => void;
 };
 
 export type ChatPresenterLike = {

package/src/components/chat/stores/chat-thread.store.ts

@@ -20,6 +20,11 @@ export type ChatThreadSnapshot = {
   messages: readonly NcpMessage[];
   isSending: boolean;
   isAwaitingAssistantOutput: boolean;
+  parentSessionKey?: string | null;
+  parentSessionLabel?: string | null;
+  childSessionDetailSessionKey?: string | null;
+  childSessionDetailParentSessionKey?: string | null;
+  childSessionDetailLabel?: string | null;
 };
 
 type ChatThreadStore = {
@@ -43,7 +48,12 @@ const initialSnapshot: ChatThreadSnapshot = {
   isHistoryLoading: false,
   messages: [],
   isSending: false,
-  isAwaitingAssistantOutput: false
+  isAwaitingAssistantOutput: false,
+  parentSessionKey: null,
+  parentSessionLabel: null,
+  childSessionDetailSessionKey: null,
+  childSessionDetailParentSessionKey: null,
+  childSessionDetailLabel: null,
 };
 
 export const useChatThreadStore = create<ChatThreadStore>((set) => ({

package/src/components/chat/useHydratedNcpAgent.test.tsx

@@ -1,18 +1,19 @@
-import { renderHook, waitFor } from '@testing-library/react';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { useHydratedNcpAgent } from '../../../../ncp-packages/nextclaw-ncp-react/src/hooks/use-hydrated-ncp-agent.ts';
+import { renderHook, waitFor } from "@testing-library/react";
+import type { NcpAgentClientEndpoint } from "@nextclaw/ncp";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { useHydratedNcpAgent } from "../../../../ncp-packages/nextclaw-ncp-react/src/hooks/use-hydrated-ncp-agent.ts";
 
 const mocks = vi.hoisted(() => ({
   manager: {
     reset: vi.fn(),
-    hydrate: vi.fn()
+    hydrate: vi.fn(),
   },
   runtime: {
     snapshot: {
       messages: [],
       streamingMessage: null,
       activeRun: null,
-      error: null
+      error: null,
     },
     visibleMessages: [],
     activeRunId: null,
@@ -20,16 +21,19 @@ const mocks = vi.hoisted(() => ({
     isSending: false,
     send: vi.fn(),
     abort: vi.fn(),
-    streamRun: vi.fn()
-  }
+    streamRun: vi.fn(),
+  },
 }));
 
-vi.mock('../../../../ncp-packages/nextclaw-ncp-react/src/hooks/use-ncp-agent-runtime.js', () => ({
-  useScopedAgentManager: () => mocks.manager,
-  useNcpAgentRuntime: () => mocks.runtime
-}));
+vi.mock(
+  "../../../../ncp-packages/nextclaw-ncp-react/src/hooks/use-ncp-agent-runtime.js",
+  () => ({
+    useScopedAgentManager: () => mocks.manager,
+    useNcpAgentRuntime: () => mocks.runtime,
+  }),
+);
 
-describe('useHydratedNcpAgent', () => {
+describe("useHydratedNcpAgent", () => {
   beforeEach(() => {
     mocks.manager.reset.mockReset();
     mocks.manager.hydrate.mockReset();
@@ -38,40 +42,43 @@ describe('useHydratedNcpAgent', () => {
     mocks.runtime.streamRun.mockReset();
   });
 
-  it('treats a newly selected session as hydrating immediately on rerender', async () => {
+  it("treats a newly selected session as hydrating immediately on rerender", async () => {
     const client = {
       stop: vi.fn().mockResolvedValue(undefined),
-      stream: vi.fn().mockResolvedValue(undefined)
-    } as never;
+      stream: vi.fn().mockResolvedValue(undefined),
+    } satisfies Pick<NcpAgentClientEndpoint, "stop" | "stream">;
     const loadSeed = vi
       .fn()
-      .mockResolvedValueOnce({ messages: [], status: 'idle' })
-      .mockResolvedValueOnce({ messages: [], status: 'idle' });
+      .mockResolvedValueOnce({ messages: [], status: "idle" })
+      .mockResolvedValueOnce({ messages: [], status: "idle" });
 
     const { result, rerender } = renderHook(
       ({ sessionId }: { sessionId: string }) =>
         useHydratedNcpAgent({
           sessionId,
-          client,
-          loadSeed
+          client: client as never,
+          loadSeed,
         }),
       {
         initialProps: {
-          sessionId: 'session-a'
-        }
-      }
+          sessionId: "session-a",
+        },
+      },
     );
 
     await waitFor(() => {
       expect(result.current.isHydrating).toBe(false);
     });
+    expect(client.stream).toHaveBeenCalledWith({ sessionId: "session-a" });
 
-    rerender({ sessionId: 'session-b' });
+    rerender({ sessionId: "session-b" });
 
     expect(result.current.isHydrating).toBe(true);
 
     await waitFor(() => {
       expect(result.current.isHydrating).toBe(false);
     });
+    expect(client.stream).toHaveBeenCalledWith({ sessionId: "session-b" });
+    expect(client.stream).toHaveBeenCalledTimes(2);
   });
 });