@nextclaw/ui 0.15.21 → 0.15.23

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

@@ -171,7 +171,7 @@ describe("useNcpAgentRuntime", () => {
     vi.clearAllMocks();
   });
 
-  it("returns a command handle when a new root chat materializes a session id", async () => {
+  it("keeps an accepted run active while a new root chat materializes", async () => {
     const client = new DeferredSendClient();
     const manager = new DefaultNcpAgentConversationStateManager();
     const envelope: NcpAgentSendEnvelope = {
@@ -206,9 +206,102 @@ describe("useNcpAgentRuntime", () => {
         sessionId: "session-created",
       }),
     ]);
+    expect(result.current.isRunning).toBe(true);
     expect(client.stop).not.toHaveBeenCalled();
 
     rerender({ sessionId: "session-created" });
+    expect(result.current.isRunning).toBe(true);
+
+    await act(async () => {
+      await client.emit({
+        type: NcpEventType.RunStarted,
+        payload: {
+          sessionId: "session-created",
+          runId: "run-1",
+        },
+      });
+    });
+    await waitFor(() => {
+      expect(result.current.isRunning).toBe(true);
+    });
+
+    await act(async () => {
+      await client.emit({
+        type: NcpEventType.RunFinished,
+        payload: {
+          sessionId: "session-created",
+          runId: "run-1",
+        },
+      });
+    });
+    await waitFor(() => {
+      expect(result.current.isRunning).toBe(false);
+    });
+  });
+
+  it("shows a preallocated draft message before send returns and keeps it through materialization", async () => {
+    const client = new DeferredSendClient();
+    const manager = new DefaultNcpAgentConversationStateManager();
+    const envelope: NcpAgentSendEnvelope = {
+      sessionId: "session-preallocated",
+      message: {
+        id: "user-preallocated",
+        sessionId: "session-preallocated",
+        role: "user",
+        status: "final",
+        parts: [{ type: "text", text: "show immediately" }],
+        timestamp: now,
+      },
+    };
+    let releaseSend = () => {};
+    client.send.mockImplementationOnce(
+      (pendingEnvelope) =>
+        new Promise((resolve) => {
+          releaseSend = () => resolve({
+            sessionId: "session-preallocated",
+            userMessageId: pendingEnvelope.message.id,
+            assistantMessageId: "assistant-1",
+            runId: "run-1",
+          });
+        }),
+    );
+    const { result, rerender } = renderHook(
+      ({ sessionId }: { sessionId?: string }) =>
+        useNcpAgentRuntime({ sessionId, client, manager: manager as never }),
+      { initialProps: { sessionId: undefined as string | undefined } },
+    );
+
+    let sendPromise!: ReturnType<typeof result.current.send>;
+    act(() => {
+      sendPromise = result.current.send(envelope);
+    });
+
+    await waitFor(() => {
+      expect(result.current.visibleMessages).toEqual([envelope.message]);
+    });
+    expect(result.current.isSending).toBe(true);
+
+    await act(async () => {
+      releaseSend();
+      await sendPromise;
+    });
+    rerender({ sessionId: "session-preallocated" });
+
+    expect(result.current.visibleMessages).toEqual([envelope.message]);
+    expect(result.current.isRunning).toBe(true);
+
+    await act(async () => {
+      await client.emit({
+        type: NcpEventType.MessageSent,
+        payload: {
+          sessionId: "session-preallocated",
+          message: envelope.message as NcpMessage,
+        },
+      });
+    });
+    await waitFor(() => {
+      expect(result.current.visibleMessages).toEqual([envelope.message]);
+    });
   });
 
   it("shows an existing-session user message before send returns and deduplicates the server event", async () => {
@@ -275,6 +368,66 @@ describe("useNcpAgentRuntime", () => {
     expect(result.current.visibleMessages).toEqual([envelope.message]);
   });
 
+  it("keeps an earlier streaming assistant before a later optimistic user message", async () => {
+    const client = new DeferredSendClient();
+    const manager = new DefaultNcpAgentConversationStateManager();
+    manager.hydrate({
+      sessionId: "session-existing",
+      messages: [
+        {
+          id: "user-first",
+          sessionId: "session-existing",
+          role: "user",
+          status: "final",
+          parts: [{ type: "text", text: "start" }],
+          timestamp: "2026-05-14T00:00:00.000Z",
+        },
+        {
+          id: "assistant-old",
+          sessionId: "session-existing",
+          role: "assistant",
+          status: "streaming",
+          parts: [{ type: "text", text: "working" }],
+          timestamp: "2026-05-14T00:00:01.000Z",
+        },
+      ],
+    });
+    await manager.dispatch({
+      type: NcpEventType.MessageTextStart,
+      payload: { sessionId: "session-existing", messageId: "assistant-old" },
+    });
+    const { result } = renderHook(() =>
+      useNcpAgentRuntime({ sessionId: "session-existing", client, manager: manager as never }),
+    );
+
+    await act(async () => {
+      await result.current.send({
+        sessionId: "session-existing",
+        message: {
+          id: "user-later",
+          sessionId: "session-existing",
+          role: "user",
+          status: "final",
+          parts: [{ type: "text", text: "later" }],
+          timestamp: "2026-05-14T00:00:02.000Z",
+        },
+      });
+    });
+
+    expect(result.current.visibleMessages.map((message) => message.id)).toEqual([
+      "user-first",
+      "assistant-old",
+      "user-later",
+    ]);
+  });
+
+});
+
+describe("useNcpAgentRuntime commands and live stream", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
   it("marks an optimistic user message as failed when send fails", async () => {
     const client = new DeferredSendClient();
     const manager = new DefaultNcpAgentConversationStateManager();
@@ -334,6 +487,32 @@ describe("useNcpAgentRuntime", () => {
     });
   });
 
+  it("adopts an accepted run before persisted run.started arrives", 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.acceptRun({
+        assistantMessageId: null,
+        sessionId: "session-running",
+        userMessageId: "continuation-user-1",
+        runId: "run-accepted-1",
+      });
+    });
+
+    expect(result.current.activeRunId).toBe("run-accepted-1");
+    expect(result.current.isRunning).toBe(true);
+    await act(async () => {
+      await result.current.abort();
+    });
+    expect(client.abort).toHaveBeenCalledWith(expect.objectContaining({
+      runId: "run-accepted-1",
+    }));
+  });
+
   it("clears the local running state when the live stream publishes message.abort", async () => {
     const client = new DeferredSendClient();
     const manager = new DefaultNcpAgentConversationStateManager();

package/src/features/chat/features/ncp/hooks/__tests__/use-ncp-session-conversation.test.tsx

@@ -1,5 +1,6 @@
 import { act, renderHook, waitFor } from "@testing-library/react";
 import { beforeEach, describe, expect, it, vi } from "vitest";
+import type { NcpMessage } from "@nextclaw/ncp";
 import type * as SharedApi from "@/shared/lib/api";
 import {
   fetchNcpSessionConversationSeed,
@@ -7,13 +8,18 @@ import {
 } from "@/features/chat/features/ncp/hooks/use-ncp-session-conversation";
 
 const mocks = vi.hoisted(() => ({
+  acceptRun: vi.fn(),
+  continueRun: vi.fn(),
   fetchNcpSessionMessages: vi.fn(),
+  editMessage: vi.fn(),
   prependHistory: vi.fn(),
+  replaceHistory: vi.fn(),
   hydratedCalls: [] as Array<{ client: unknown; loadSeed: unknown }>,
   runtimeAvailability: {
     phase: "cold-starting" as "cold-starting" | "ready",
     lastReadyAt: null as number | null,
   },
+  visibleMessages: [] as NcpMessage[],
   useHydratedNcpAgent: vi.fn(() => ({
     snapshot: {
       messages: [],
@@ -21,14 +27,16 @@ const mocks = vi.hoisted(() => ({
       activeRun: null,
       error: null as Error | null,
     },
-    visibleMessages: [],
+    visibleMessages: mocks.visibleMessages,
     activeRunId: null,
     isRunning: false,
     isSending: false,
     send: vi.fn(),
+    acceptRun: mocks.acceptRun,
     abort: vi.fn(),
     streamRun: vi.fn(),
     prependHistory: mocks.prependHistory,
+    replaceHistory: mocks.replaceHistory,
     isHydrating: false,
     hydrateError: null,
   })),
@@ -40,6 +48,14 @@ vi.mock("@/shared/lib/api", async (importOriginal) => {
   return {
     ...actual,
     fetchNcpSessionMessages: mocks.fetchNcpSessionMessages,
+    nextclawClient: {
+      ...actual.nextclawClient,
+      agentRuns: {
+        ...actual.nextclawClient.agentRuns,
+        continue: mocks.continueRun,
+        editMessage: mocks.editMessage,
+      },
+    },
   };
 });
 
@@ -70,16 +86,23 @@ vi.mock("@/features/system-status", () => ({
   })),
 }));
 
+function resetConversationMocks(): void {
+  mocks.acceptRun.mockReset();
+  mocks.continueRun.mockReset();
+  mocks.fetchNcpSessionMessages.mockReset();
+  mocks.editMessage.mockReset();
+  mocks.prependHistory.mockReset();
+  mocks.replaceHistory.mockReset();
+  mocks.useHydratedNcpAgent.mockClear();
+  mocks.hydratedCalls.length = 0;
+  mocks.clientInstances.length = 0;
+  mocks.runtimeAvailability.phase = "cold-starting";
+  mocks.runtimeAvailability.lastReadyAt = null;
+  mocks.visibleMessages.length = 0;
+}
+
 describe("useNcpSessionConversation", () => {
-  beforeEach(() => {
-    mocks.fetchNcpSessionMessages.mockReset();
-    mocks.prependHistory.mockReset();
-    mocks.useHydratedNcpAgent.mockClear();
-    mocks.hydratedCalls.length = 0;
-    mocks.clientInstances.length = 0;
-    mocks.runtimeAvailability.phase = "cold-starting";
-    mocks.runtimeAvailability.lastReadyAt = null;
-  });
+  beforeEach(resetConversationMocks);
 
   it("hydrates seed from the shared session messages endpoint payload", async () => {
     mocks.fetchNcpSessionMessages.mockResolvedValue({
@@ -174,6 +197,155 @@ describe("useNcpSessionConversation", () => {
     expect(mocks.fetchNcpSessionMessages).not.toHaveBeenCalled();
   });
 
+  it("replaces the current session history after editing instead of creating a background session", async () => {
+    mocks.editMessage.mockResolvedValue({
+      sessionId: "session-1",
+      userMessageId: "edited-user-1",
+      assistantMessageId: null,
+      runId: "run-2",
+    });
+    const editedMessage = {
+      id: "edited-user-1",
+      sessionId: "session-1",
+      role: "user" as const,
+      status: "final" as const,
+      timestamp: "2026-08-08T10:00:00.000Z",
+      parts: [{ type: "text" as const, text: "edited request" }],
+    };
+    mocks.visibleMessages.push({
+      ...editedMessage,
+      id: "user-original",
+      parts: [{ type: "text", text: "original request" }],
+    });
+    const { result } = renderHook(() => useNcpSessionConversation("session-1"));
+
+    await act(async () => {
+      await result.current.editMessage({
+        sessionId: "session-1",
+        messageId: "user-original",
+        message: editedMessage,
+      });
+    });
+
+    expect(mocks.editMessage).toHaveBeenCalledWith({
+      sessionId: "session-1",
+      messageId: "user-original",
+      message: editedMessage,
+    });
+    expect(mocks.replaceHistory).toHaveBeenCalledWith({
+      status: "idle",
+      messages: [editedMessage],
+    });
+    expect(mocks.acceptRun).toHaveBeenCalledWith({
+      sessionId: "session-1",
+      userMessageId: "edited-user-1",
+      assistantMessageId: null,
+      runId: "run-2",
+    });
+    expect(mocks.fetchNcpSessionMessages).not.toHaveBeenCalled();
+  });
+
+  it("adopts an accepted continuation before persisted run.started arrives", async () => {
+    const handle = {
+      sessionId: "session-1",
+      userMessageId: "continuation-user-1",
+      runId: "run-continuation-1",
+    };
+    mocks.continueRun.mockResolvedValue(handle);
+    const { result } = renderHook(() => useNcpSessionConversation("session-1"));
+
+    await act(async () => {
+      await expect(result.current.continueRun({ sessionId: "session-1" })).resolves.toEqual(handle);
+    });
+
+    expect(mocks.acceptRun).toHaveBeenCalledWith(handle);
+  });
+
+  it("restores the previous current-session history when an edit is rejected", async () => {
+    const originalMessage = {
+      id: "user-original",
+      sessionId: "session-1",
+      role: "user" as const,
+      status: "final" as const,
+      timestamp: "2026-08-08T10:00:00.000Z",
+      parts: [{ type: "text" as const, text: "original request" }],
+    };
+    const editedMessage = {
+      ...originalMessage,
+      id: "edited-user-1",
+      parts: [{ type: "text" as const, text: "edited request" }],
+    };
+    mocks.visibleMessages.push(originalMessage);
+    mocks.editMessage.mockRejectedValue(new Error("session is running"));
+    mocks.fetchNcpSessionMessages.mockRejectedValue(new Error("recovery unavailable"));
+    const { result } = renderHook(() => useNcpSessionConversation("session-1"));
+
+    await act(async () => {
+      await expect(result.current.editMessage({
+        sessionId: "session-1",
+        messageId: originalMessage.id,
+        message: editedMessage,
+      })).rejects.toThrow("session is running");
+    });
+
+    expect(mocks.replaceHistory).toHaveBeenNthCalledWith(1, {
+      messages: [editedMessage],
+      status: "idle",
+    });
+    expect(mocks.replaceHistory).toHaveBeenNthCalledWith(2, {
+      messages: [originalMessage],
+      status: "idle",
+    });
+  });
+
+  it("rejects a second session command before React has time to rerender", async () => {
+    const originalMessage = {
+      id: "user-original",
+      sessionId: "session-1",
+      role: "user" as const,
+      status: "final" as const,
+      timestamp: "2026-08-08T10:00:00.000Z",
+      parts: [{ type: "text" as const, text: "original request" }],
+    };
+    const editedMessage = {
+      ...originalMessage,
+      id: "edited-user-1",
+      parts: [{ type: "text" as const, text: "edited request" }],
+    };
+    let finishEdit: ((value: unknown) => void) | null = null;
+    mocks.visibleMessages.push(originalMessage);
+    mocks.editMessage.mockImplementation(
+      () => new Promise((resolve) => {
+        finishEdit = resolve;
+      }),
+    );
+    const { result } = renderHook(() => useNcpSessionConversation("session-1"));
+    const payload = {
+      sessionId: "session-1",
+      messageId: originalMessage.id,
+      message: editedMessage,
+    };
+
+    await act(async () => {
+      const firstCommand = result.current.editMessage(payload);
+      await expect(result.current.editMessage(payload)).rejects.toThrow(
+        "A session command is already in progress.",
+      );
+      finishEdit?.({
+        sessionId: "session-1",
+        userMessageId: editedMessage.id,
+        runId: "run-2",
+      });
+      await firstCommand;
+    });
+
+    expect(mocks.editMessage).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe("useNcpSessionConversation history and hydration", () => {
+  beforeEach(resetConversationMocks);
+
   it("exposes the hydrated session context window without changing the generic ncp agent seed", async () => {
     const contextWindow = {
       usedContextTokens: 42,
@@ -340,10 +512,12 @@ describe("useNcpSessionConversation", () => {
       activeRunId: null,
       isRunning: false,
       isSending: false,
+      acceptRun: mocks.acceptRun,
       send: vi.fn(),
       abort: vi.fn(),
       streamRun: vi.fn(),
       prependHistory: mocks.prependHistory,
+      replaceHistory: mocks.replaceHistory,
       isHydrating: false,
       hydrateError: null,
     }));

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

@@ -0,0 +1,57 @@
+// @vitest-environment jsdom
+
+import { act, renderHook, waitFor } from '@testing-library/react';
+import type { NcpAgentClientEndpoint, NcpMessage } from '@nextclaw/ncp';
+import { useHydratedNcpAgent } from '@nextclaw/ncp-react';
+import { describe, expect, it, vi } from 'vitest';
+
+function message(id: string, text: string): NcpMessage {
+  return {
+    id,
+    sessionId: 'session-1',
+    role: 'user',
+    status: 'final',
+    timestamp: '2026-08-08T10:00:00.000Z',
+    parts: [{ type: 'text', text }],
+  };
+}
+
+describe('useHydratedNcpAgent history replacement', () => {
+  it('replaces the current session history and running state in one manager update', async () => {
+    let finishStream: (() => void) | null = null;
+    const client = {
+      abort: vi.fn(),
+      send: vi.fn(),
+      subscribe: vi.fn(() => () => undefined),
+      stop: vi.fn(async () => finishStream?.()),
+      stream: vi.fn(
+        async () =>
+          await new Promise<void>((resolve) => {
+            finishStream = resolve;
+          }),
+      ),
+    } as unknown as NcpAgentClientEndpoint;
+    const original = message('user-original', 'original');
+    const edited = message('user-edited', 'edited');
+    const loadSeed = async () => ({ messages: [original], status: 'idle' as const });
+    const { result, unmount } = renderHook(() =>
+      useHydratedNcpAgent({
+        client,
+        loadSeed,
+        sessionId: 'session-1',
+      }),
+    );
+    await waitFor(() => expect(result.current.isHydrating).toBe(false));
+
+    act(() => {
+      result.current.replaceHistory({
+        messages: [edited],
+        status: 'running',
+      });
+    });
+
+    expect(result.current.visibleMessages).toEqual([edited]);
+    expect(result.current.isRunning).toBe(true);
+    unmount();
+  });
+});

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

@@ -1,6 +1,13 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { NcpHttpAgentClientEndpoint } from "@nextclaw/ncp-http-agent-client";
 import { useHydratedNcpAgent } from "@nextclaw/ncp-react";
+import type {
+  NcpRunHandle,
+} from "@nextclaw/ncp";
+import type {
+  AgentRunContinueIngressPayload,
+  AgentRunEditMessageIngressPayload,
+} from "@nextclaw/shared";
 import { API_BASE } from "@/shared/lib/api";
 import { createNcpAppClientFetch } from "@/features/chat/features/runtime/utils/ncp-app-client-fetch.utils";
 import {
@@ -8,6 +15,7 @@ import {
   useNcpSessionMessageHistory,
 } from "@/features/chat/features/ncp/hooks/use-ncp-session-message-history";
 import { useSystemStatus } from "@/features/system-status";
+import { nextclawClient } from "@/shared/lib/api";
 
 const NCP_AGENT_UNAVAILABLE_DURING_STARTUP =
   "ncp agent unavailable during startup";
@@ -69,6 +77,8 @@ export function useNcpSessionConversation(
   const [client] = useState(() => createNcpSessionConversationClient());
   const systemStatus = useSystemStatus();
   const [hydrationRetryVersion, setHydrationRetryVersion] = useState(0);
+  const [pendingCommandSessionId, setPendingCommandSessionId] = useState<string | null>(null);
+  const pendingCommandSessionIdRef = useRef<string | null>(null);
   const {
     loadSeed,
     loadPreviousMessages: loadPreviousHistory,
@@ -83,6 +93,73 @@ export function useNcpSessionConversation(
     client,
     loadSeed,
   });
+  const { acceptRun } = agent;
+  const executeAcceptedRunCommand = useCallback(async (
+    commandSessionId: string,
+    command: () => Promise<NcpRunHandle>,
+  ): Promise<NcpRunHandle> => {
+    if (pendingCommandSessionIdRef.current) {
+      throw new Error("A session command is already in progress.");
+    }
+    pendingCommandSessionIdRef.current = commandSessionId;
+    setPendingCommandSessionId(commandSessionId);
+    try {
+      const handle = await command();
+      await acceptRun(handle);
+      return handle;
+    } finally {
+      if (pendingCommandSessionIdRef.current === commandSessionId) {
+        pendingCommandSessionIdRef.current = null;
+      }
+      setPendingCommandSessionId((current) =>
+        current === commandSessionId ? null : current,
+      );
+    }
+  }, [acceptRun]);
+  const editMessage = useCallback(
+    async (payload: AgentRunEditMessageIngressPayload) =>
+      await executeAcceptedRunCommand(payload.sessionId, async () => {
+        const previousSeed = {
+          messages: agent.visibleMessages,
+          status: agent.isRunning ? "running" as const : "idle" as const,
+        };
+        const anchorIndex = agent.visibleMessages.findIndex(
+          (message) => message.id === payload.messageId,
+        );
+        if (anchorIndex < 0) {
+          throw new Error("The message being edited is no longer in the current session history.");
+        }
+        agent.replaceHistory({
+          messages: [
+            ...agent.visibleMessages.slice(0, anchorIndex),
+            { ...payload.message, sessionId: payload.sessionId },
+          ],
+          status: "idle",
+        });
+        try {
+          return await nextclawClient.agentRuns.editMessage(payload);
+        } catch (error) {
+          agent.replaceHistory(previousSeed);
+          try {
+            const controller = new AbortController();
+            agent.replaceHistory(
+              await loadSeed(payload.sessionId, controller.signal),
+            );
+          } catch {
+            // The previous in-memory snapshot remains available when recovery hydration fails.
+          }
+          throw error;
+        }
+      }),
+    [agent, executeAcceptedRunCommand, loadSeed],
+  );
+  const continueRun = useCallback(
+    async (payload: AgentRunContinueIngressPayload) =>
+      await executeAcceptedRunCommand(payload.sessionId, () =>
+        nextclawClient.agentRuns.continue(payload),
+      ),
+    [executeAcceptedRunCommand],
+  );
   const loadPreviousMessages = useCallback(
     async (): Promise<void> =>
       await loadPreviousHistory(agent.prependHistory),
@@ -102,6 +179,10 @@ export function useNcpSessionConversation(
   return useMemo(
     () => ({
       ...agent,
+      isSending:
+        agent.isSending || pendingCommandSessionId === sessionId,
+      editMessage,
+      continueRun,
       snapshot: {
         ...agent.snapshot,
         contextWindow:
@@ -113,6 +194,14 @@ export function useNcpSessionConversation(
       loadPreviousMessages,
       messageTotal: visibleHistoryState.total,
     }),
-    [agent, loadPreviousMessages, visibleHistoryState],
+    [
+      agent,
+      continueRun,
+      editMessage,
+      loadPreviousMessages,
+      pendingCommandSessionId,
+      sessionId,
+      visibleHistoryState,
+    ],
   );
 }