@assistant-ui/eve 0.0.13 → 0.0.15

package/src/useEveAgentRuntime.test.tsx

@@ -14,6 +14,7 @@ vi.mock("eve/react", async (importOriginal) => ({
 
 import type { EveMessageData } from "eve/react";
 import { useEveAgentRuntime } from "./useEveAgentRuntime";
+import { eveExtras } from "./eveExtras";
 
 const stuckStreamingData: EveMessageData = {
   messages: [
@@ -34,6 +35,7 @@ const createAgent = (overrides: Record<string, unknown>) => ({
   session: undefined,
   status: "ready",
   send: vi.fn(),
+  respond: vi.fn(),
   stop: vi.fn(),
   reset: vi.fn(),
   ...overrides,
@@ -160,8 +162,7 @@ describe("useEveAgentRuntime status forwarding", () => {
     });
 
     await waitFor(() => {
-      expect(agent.send).toHaveBeenCalledWith({
-        message: "hello",
+      expect(agent.send).toHaveBeenCalledWith("hello", {
         clientContext: { page: "/pricing" },
       });
     });
@@ -183,7 +184,7 @@ describe("useEveAgentRuntime status forwarding", () => {
     });
 
     await waitFor(() => {
-      expect(agent.send).toHaveBeenCalledWith({ message: "hello" });
+      expect(agent.send).toHaveBeenCalledWith("hello", undefined);
     });
   });
 
@@ -204,7 +205,7 @@ describe("useEveAgentRuntime status forwarding", () => {
     });
 
     await waitFor(() => {
-      expect(agent.send).toHaveBeenCalledWith({ message: "hello" });
+      expect(agent.send).toHaveBeenCalledWith("hello", undefined);
     });
   });
 
@@ -238,8 +239,7 @@ describe("useEveAgentRuntime status forwarding", () => {
     });
 
     await waitFor(() => {
-      expect(agent.send).toHaveBeenCalledWith({
-        message: "hello",
+      expect(agent.send).toHaveBeenCalledWith("hello", {
         clientContext: { page: "/reload" },
       });
     });
@@ -272,8 +272,7 @@ describe("useEveAgentRuntime status forwarding", () => {
     });
 
     await waitFor(() => {
-      expect(agent.send).toHaveBeenCalledWith({
-        message: "hello",
+      expect(agent.send).toHaveBeenCalledWith("hello", {
         clientContext: { page: "/staged" },
       });
     });
@@ -310,8 +309,7 @@ describe("useEveAgentRuntime status forwarding", () => {
     });
 
     await waitFor(() => {
-      expect(agent.send).toHaveBeenCalledWith({
-        message: "hello",
+      expect(agent.send).toHaveBeenCalledWith("hello", {
         clientContext: { page: "/staged" },
       });
     });
@@ -330,6 +328,163 @@ describe("useEveAgentRuntime status forwarding", () => {
   });
 });
 
+describe("useEveAgentRuntime tool approval responses", () => {
+  const textRequestData: EveMessageData = {
+    messages: [
+      { id: "u1", role: "user", parts: [{ type: "text", text: "hi" }] },
+      {
+        id: "a1",
+        role: "assistant",
+        parts: [
+          {
+            type: "dynamic-tool",
+            state: "approval-requested",
+            toolCallId: "call_1",
+            toolName: "ask_question",
+            input: {},
+            approval: { id: "req_1" },
+            toolMetadata: {
+              eve: {
+                kind: "tool-call",
+                name: "ask_question",
+                inputRequest: {
+                  requestId: "req_1",
+                  prompt: "What should the subject line be?",
+                  kind: "question",
+                  display: "text",
+                },
+              },
+            },
+          },
+        ],
+      },
+    ],
+  };
+
+  const flushMicrotasks = () =>
+    new Promise((resolve) => setTimeout(resolve, 0));
+
+  const processEvents = process as unknown as {
+    on(event: "unhandledRejection", listener: (reason: unknown) => void): void;
+    off(event: "unhandledRejection", listener: (reason: unknown) => void): void;
+  };
+
+  const respondToTextRequest = (
+    result: { current: ReturnType<typeof useEveAgentRuntime> },
+    response: { approved: boolean; reason?: string; optionId?: string },
+  ) =>
+    result.current.thread
+      .getMessageById("a1")
+      .getMessagePartByToolCallId("call_1")
+      .respondToToolApproval(response);
+
+  it("keeps an unanswered free-form request pending through the default controls", async () => {
+    const rejections: unknown[] = [];
+    const onUnhandledRejection = (reason: unknown) => rejections.push(reason);
+    processEvents.on("unhandledRejection", onUnhandledRejection);
+    const agent = createAgent({ data: textRequestData });
+    mockUseEveAgent.mockReturnValue(agent as never);
+
+    try {
+      const { result } = renderHook(() => useEveAgentRuntime());
+
+      expect(() => respondToTextRequest(result, { approved: true })).toThrow(
+        /was not answered by this response/,
+      );
+
+      await flushMicrotasks();
+      await flushMicrotasks();
+
+      expect(agent.send).not.toHaveBeenCalled();
+      expect(agent.respond).not.toHaveBeenCalled();
+      expect(rejections).toEqual([]);
+    } finally {
+      processEvents.off("unhandledRejection", onUnhandledRejection);
+    }
+  });
+
+  const bareApprovalData = (toolMetadata?: {
+    eve: { kind: "tool-call"; name: string };
+  }): EveMessageData => ({
+    messages: [
+      { id: "u1", role: "user", parts: [{ type: "text", text: "hi" }] },
+      {
+        id: "a1",
+        role: "assistant",
+        parts: [
+          {
+            type: "dynamic-tool",
+            state: "approval-requested",
+            toolCallId: "call_1",
+            toolName: "delete_file",
+            input: {},
+            approval: { id: "req_1" },
+            ...(toolMetadata && { toolMetadata }),
+          },
+        ],
+      },
+    ],
+  });
+
+  it.each([
+    ["no eve tool metadata at all", undefined],
+    [
+      "eve metadata carrying no input request",
+      { eve: { kind: "tool-call", name: "delete_file" } },
+    ],
+  ])(
+    "still answers an ordinary approval when the part has %s",
+    async (_label, toolMetadata) => {
+      const agent = createAgent({
+        data: bareApprovalData(toolMetadata as never),
+      });
+      mockUseEveAgent.mockReturnValue(agent as never);
+
+      const { result } = renderHook(() => useEveAgentRuntime());
+      expect(() =>
+        respondToTextRequest(result, { approved: true }),
+      ).not.toThrow();
+
+      await flushMicrotasks();
+
+      expect(agent.respond).toHaveBeenCalledWith([
+        { requestId: "req_1", optionId: "approve" },
+      ]);
+    },
+  );
+
+  it("maps a refusal on a request the data does not carry", async () => {
+    const agent = createAgent({ data: bareApprovalData(undefined) });
+    mockUseEveAgent.mockReturnValue(agent as never);
+
+    const { result } = renderHook(() => useEveAgentRuntime());
+    respondToTextRequest(result, { approved: false, reason: "not safe" });
+
+    await flushMicrotasks();
+
+    expect(agent.respond).toHaveBeenCalledWith([
+      { requestId: "req_1", optionId: "cancel", text: "not safe" },
+    ]);
+  });
+
+  it("submits a free-form answer as text without an option id", async () => {
+    const agent = createAgent({ data: textRequestData });
+    mockUseEveAgent.mockReturnValue(agent as never);
+
+    const { result } = renderHook(() => useEveAgentRuntime());
+    respondToTextRequest(result, {
+      approved: true,
+      reason: "Quarterly results",
+    });
+
+    await flushMicrotasks();
+
+    expect(agent.respond).toHaveBeenCalledWith([
+      { requestId: "req_1", text: "Quarterly results" },
+    ]);
+  });
+});
+
 const settledData: EveMessageData = {
   messages: [
     { id: "u1", role: "user", parts: [{ type: "text", text: "earlier" }] },
@@ -341,6 +496,51 @@ const settledData: EveMessageData = {
   ],
 };
 
+const executingToolData: EveMessageData = {
+  messages: [
+    { id: "u1", role: "user", parts: [{ type: "text", text: "run it" }] },
+    {
+      id: "a1",
+      role: "assistant",
+      parts: [
+        {
+          type: "dynamic-tool",
+          state: "input-available",
+          toolCallId: "call_slow",
+          toolName: "slow_tool",
+          input: {},
+        },
+      ],
+    },
+  ],
+};
+
+const twoExecutingToolsData: EveMessageData = {
+  messages: [
+    { id: "u1", role: "user", parts: [{ type: "text", text: "run them" }] },
+    {
+      id: "a1",
+      role: "assistant",
+      parts: [
+        {
+          type: "dynamic-tool",
+          state: "input-available",
+          toolCallId: "call_slow_a",
+          toolName: "slow_tool",
+          input: {},
+        },
+        {
+          type: "dynamic-tool",
+          state: "input-available",
+          toolCallId: "call_slow_b",
+          toolName: "slow_tool",
+          input: {},
+        },
+      ],
+    },
+  ],
+};
+
 const getText = (runtime: ReturnType<typeof useEveAgentRuntime>) =>
   runtime.thread
     .getState()
@@ -394,9 +594,7 @@ describe("useEveAgentRuntime staged messages", () => {
         content: [{ type: "text", text: "hello" }],
       });
     });
-    expect(agent.send).toHaveBeenCalledWith({
-      message: "hello",
-    });
+    expect(agent.send).toHaveBeenCalledWith("hello", undefined);
 
     mockUseEveAgent.mockReturnValue(
       createAgent({
@@ -504,8 +702,8 @@ describe("useEveAgentRuntime staged messages", () => {
     });
 
     expect(send).toHaveBeenCalledTimes(3);
-    expect(send).toHaveBeenNthCalledWith(2, { message: "first staged" });
-    expect(send).toHaveBeenNthCalledWith(3, { message: "second staged" });
+    expect(send).toHaveBeenNthCalledWith(2, "first staged", undefined);
+    expect(send).toHaveBeenNthCalledWith(3, "second staged", undefined);
     await waitFor(() => {
       expect(getText(result.current)).toEqual(["earlier", "earlier answer"]);
     });
@@ -541,12 +739,10 @@ describe("useEveAgentRuntime staged messages", () => {
 
     // the earlier draft keeps the context it was staged with; only the
     // reloaded message takes the reload-time config
-    expect(agent.send).toHaveBeenNthCalledWith(1, {
-      message: "first staged",
+    expect(agent.send).toHaveBeenNthCalledWith(1, "first staged", {
       clientContext: { page: "/first" },
     });
-    expect(agent.send).toHaveBeenNthCalledWith(2, {
-      message: "second staged",
+    expect(agent.send).toHaveBeenNthCalledWith(2, "second staged", {
       clientContext: { page: "/reloaded" },
     });
   });
@@ -569,9 +765,7 @@ describe("useEveAgentRuntime staged messages", () => {
     });
 
     expect(agent.send).toHaveBeenCalledTimes(1);
-    expect(agent.send).toHaveBeenCalledWith({
-      message: "first staged",
-    });
+    expect(agent.send).toHaveBeenCalledWith("first staged", undefined);
     await waitFor(() => {
       expect(getText(result.current)).toEqual([
         "earlier",
@@ -609,17 +803,13 @@ describe("useEveAgentRuntime staged messages", () => {
     });
 
     await waitFor(() => expect(send).toHaveBeenCalledTimes(1));
-    expect(send).toHaveBeenNthCalledWith(1, {
-      message: "first staged",
-    });
+    expect(send).toHaveBeenNthCalledWith(1, "first staged", undefined);
 
     await act(async () => {
       resolveFirstSend();
     });
     await waitFor(() => expect(send).toHaveBeenCalledTimes(2));
-    expect(send).toHaveBeenNthCalledWith(2, {
-      message: "second staged",
-    });
+    expect(send).toHaveBeenNthCalledWith(2, "second staged", undefined);
 
     await waitFor(() => {
       expect(getText(result.current)).toEqual(["earlier", "earlier answer"]);
@@ -681,7 +871,7 @@ describe("useEveAgentRuntime staged messages", () => {
     });
 
     expect(send).toHaveBeenCalledTimes(1);
-    expect(send).toHaveBeenCalledWith({ message: "first staged" });
+    expect(send).toHaveBeenCalledWith("first staged", undefined);
     await waitFor(() => {
       expect(getText(result.current)).toEqual([
         "earlier",
@@ -756,129 +946,101 @@ describe("useEveAgentRuntime staged messages", () => {
   });
 });
 
-const approvalData: EveMessageData = {
-  messages: [
-    { id: "u1", role: "user", parts: [{ type: "text", text: "send it" }] },
-    {
-      id: "a1",
-      role: "assistant",
-      parts: [
-        {
-          type: "dynamic-tool",
-          state: "approval-requested",
-          toolCallId: "call_1",
-          toolName: "send_email",
-          input: { to: "dev@example.com" },
-          approval: { id: "req_1" },
-          toolMetadata: {
-            eve: {
-              kind: "tool-call",
-              name: "send_email",
-              inputRequest: {
-                requestId: "req_1",
-                prompt: "Send the email?",
-                display: "confirmation",
-                options: [
-                  { id: "approve", label: "Approve" },
-                  { id: "deny", label: "Deny" },
-                ],
-              },
-            },
-          },
-        },
-      ],
-    },
-  ],
-};
+describe("useEveAgentRuntime extras wiring", () => {
+  it("provides error, events, and session through the runtime extras", () => {
+    const error = new Error("boom");
+    const events = [{ type: "session.started" }];
+    const session = { sessionId: "s1" };
+    mockUseEveAgent.mockReturnValue(
+      createAgent({ status: "error", error, events, session }) as never,
+    );
 
-describe("useEveAgentRuntime concurrent sends", () => {
-  it("defers an approval clicked while a turn is in flight until the turn parks", async () => {
-    let resolveFirstSend!: () => void;
-    const send = vi
-      .fn()
-      .mockImplementationOnce(
-        () =>
-          new Promise<void>((resolve) => {
-            resolveFirstSend = resolve;
-          }),
-      )
-      .mockResolvedValue(undefined);
-    const agent = createAgent({ data: approvalData, send });
+    const { result } = renderHook(() => useEveAgentRuntime());
+
+    expect(
+      eveExtras.tryGet(result.current.thread.getState().extras),
+    ).toMatchObject({ error, events, session });
+  });
+
+  it("discards staged inputs when reset is invoked", async () => {
+    const agent = createAgent({ data: settledData });
     mockUseEveAgent.mockReturnValue(agent as never);
     const { result } = renderHook(() => useEveAgentRuntime());
 
-    await act(async () => {
-      result.current.thread.append({
-        role: "user",
-        content: [{ type: "text", text: "go" }],
-      });
-    });
-    await waitFor(() => expect(send).toHaveBeenCalledTimes(1));
+    await stageMessage(result.current, "discarded draft");
+    const discardedId = result.current.thread.getState().messages[2]!.id;
 
     act(() => {
-      result.current.thread
-        .getMessageByIndex(1)
-        .getMessagePartByToolCallId("call_1")
-        .respondToToolApproval({ optionId: "approve" });
-    });
-    expect(send).toHaveBeenCalledTimes(1);
-
-    await act(async () => {
-      resolveFirstSend();
+      eveExtras.tryGet(result.current.thread.getState().extras)!.reset();
     });
-    await waitFor(() => expect(send).toHaveBeenCalledTimes(2));
-    expect(send).toHaveBeenNthCalledWith(2, {
-      inputResponses: [{ requestId: "req_1", optionId: "approve" }],
+    await waitFor(() => {
+      expect(getText(result.current)).toEqual(["earlier", "earlier answer"]);
     });
+
+    // `onReload` is only wired while staged messages exist, so a fresh draft
+    // is needed to reach the staged-run lookup that reads `stagedInputsRef`.
+    await stageMessage(result.current, "fresh draft");
+
+    await expect(
+      Promise.resolve(
+        result.current.thread.startRun({
+          parentId: discardedId,
+          sourceId: null,
+          runConfig: {},
+        }),
+      ),
+    ).rejects.toThrow("Runtime does not support reloading messages.");
+    expect(agent.send).not.toHaveBeenCalled();
+    expect(agent.reset).toHaveBeenCalledTimes(1);
   });
 
-  it("queues a send issued while a turn is in flight and preserves order", async () => {
-    let resolveFirstSend!: () => void;
-    const send = vi
-      .fn()
-      .mockImplementationOnce(
-        () =>
-          new Promise<void>((resolve) => {
-            resolveFirstSend = resolve;
-          }),
-      )
-      .mockResolvedValue(undefined);
-    const agent = createAgent({ data: settledData, send });
+  it("clears executing tool state when reset is invoked", async () => {
+    const agent = createAgent({ data: settledData });
     mockUseEveAgent.mockReturnValue(agent as never);
-    const { result } = renderHook(() => useEveAgentRuntime());
+    const { result, rerender } = renderHook(() => useEveAgentRuntime());
 
-    await act(async () => {
-      result.current.thread.append({
-        role: "user",
-        content: [{ type: "text", text: "first" }],
+    act(() => {
+      result.current.registerModelContextProvider({
+        getModelContext: () => ({
+          tools: {
+            slow_tool: {
+              parameters: { type: "object", properties: {} },
+              execute: () => new Promise<never>(() => {}),
+            },
+          },
+        }),
       });
     });
-    await waitFor(() => expect(send).toHaveBeenCalledTimes(1));
 
-    await act(async () => {
-      result.current.thread.append({
-        role: "user",
-        content: [{ type: "text", text: "second" }],
-      });
+    // The tracker treats its first snapshot as historical, so the tool call
+    // has to arrive on a later one to actually execute.
+    mockUseEveAgent.mockReturnValue(
+      createAgent({ data: executingToolData, reset: agent.reset }) as never,
+    );
+    rerender();
+
+    await waitFor(() => {
+      expect(result.current.thread.getState().isRunning).toBe(true);
     });
-    expect(send).toHaveBeenCalledTimes(1);
 
-    await act(async () => {
-      resolveFirstSend();
+    act(() => {
+      eveExtras.tryGet(result.current.thread.getState().extras)!.reset();
     });
-    await waitFor(() => expect(send).toHaveBeenCalledTimes(2));
-    expect(send).toHaveBeenNthCalledWith(1, { message: "first" });
-    expect(send).toHaveBeenNthCalledWith(2, { message: "second" });
+
+    await waitFor(() => {
+      expect(result.current.thread.getState().isRunning).toBe(false);
+    });
+    expect(agent.reset).toHaveBeenCalledTimes(1);
   });
 
-  it("drops a queued send when the run is cancelled before it dispatches", async () => {
-    let resolveFirstSend!: () => void;
+  it("drops a send queued behind an active turn when reset is invoked", async () => {
+    let releaseFirstSend: (() => void) | undefined;
     const send = vi
       .fn()
       .mockImplementationOnce(
         () =>
           new Promise<void>((resolve) => {
-            resolveFirstSend = resolve;
+            releaseFirstSend = resolve;
           }),
       )
       .mockResolvedValue(undefined);
@@ -886,39 +1048,52 @@ describe("useEveAgentRuntime concurrent sends", () => {
     mockUseEveAgent.mockReturnValue(agent as never);
     const { result } = renderHook(() => useEveAgentRuntime());
 
-    await act(async () => {
+    await stageMessage(result.current, "queued draft");
+    const queuedDraftId = result.current.thread.getState().messages[2]!.id;
+
+    act(() => {
       result.current.thread.append({
         role: "user",
         content: [{ type: "text", text: "first" }],
       });
     });
-    await waitFor(() => expect(send).toHaveBeenCalledTimes(1));
-
-    await act(async () => {
-      result.current.thread.append({
-        role: "user",
-        content: [{ type: "text", text: "queued" }],
-      });
+    await waitFor(() => {
+      expect(send).toHaveBeenCalledTimes(1);
     });
+
+    const queuedReload = Promise.resolve(
+      result.current.thread.startRun({
+        parentId: queuedDraftId,
+        sourceId: null,
+        runConfig: {},
+      }),
+    );
+    // Let the reload reach `enqueueSend` and park behind the active turn.
+    await act(async () => {});
+
     act(() => {
-      result.current.thread.cancelRun();
+      eveExtras.tryGet(result.current.thread.getState().extras)!.reset();
     });
-    expect(agent.stop).toHaveBeenCalledTimes(1);
 
     await act(async () => {
-      resolveFirstSend();
+      releaseFirstSend?.();
+      await queuedReload;
     });
+
     expect(send).toHaveBeenCalledTimes(1);
+    await waitFor(() => {
+      expect(getText(result.current)).toEqual(["earlier", "earlier answer"]);
+    });
   });
 
-  it("returns a cancelled queued send to the composer", async () => {
-    let resolveFirstSend!: () => void;
+  it("keeps a staged draft when a queued send is cancelled instead of reset", async () => {
+    let releaseFirstSend: (() => void) | undefined;
     const send = vi
       .fn()
       .mockImplementationOnce(
         () =>
           new Promise<void>((resolve) => {
-            resolveFirstSend = resolve;
+            releaseFirstSend = resolve;
           }),
       )
       .mockResolvedValue(undefined);
@@ -926,35 +1101,449 @@ describe("useEveAgentRuntime concurrent sends", () => {
     mockUseEveAgent.mockReturnValue(agent as never);
     const { result } = renderHook(() => useEveAgentRuntime());
 
-    await act(async () => {
+    await stageMessage(result.current, "queued draft");
+    const queuedDraftId = result.current.thread.getState().messages[2]!.id;
+
+    act(() => {
       result.current.thread.append({
         role: "user",
         content: [{ type: "text", text: "first" }],
       });
     });
-    await waitFor(() => expect(send).toHaveBeenCalledTimes(1));
-
-    await act(async () => {
-      result.current.thread.composer.setText("queued");
-      result.current.thread.composer.send();
+    await waitFor(() => {
+      expect(send).toHaveBeenCalledTimes(1);
     });
-    expect(result.current.thread.composer.getState().text).toBe("");
+
+    const queuedReload = Promise.resolve(
+      result.current.thread.startRun({
+        parentId: queuedDraftId,
+        sourceId: null,
+        runConfig: {},
+      }),
+    );
+    await act(async () => {});
 
     act(() => {
       result.current.thread.cancelRun();
     });
+
     await act(async () => {
-      resolveFirstSend();
+      releaseFirstSend?.();
+      await queuedReload;
     });
 
+    expect(send).toHaveBeenCalledTimes(1);
+    expect(agent.stop).toHaveBeenCalledTimes(1);
     await waitFor(() => {
-      expect(result.current.thread.composer.getState().text).toBe("queued");
+      expect(getText(result.current)).toEqual([
+        "earlier",
+        "earlier answer",
+        "queued draft",
+      ]);
     });
-    expect(send).toHaveBeenCalledTimes(1);
-    expect(getText(result.current)).toEqual(["earlier", "earlier answer"]);
   });
 
-  it("returns the queued send when cancel keeps the trailing message", async () => {
+  it("aborts client tool executions when reset is invoked", async () => {
+    const agentReset = vi.fn(() => {
+      mockUseEveAgent.mockReturnValue(
+        createAgent({ data: { messages: [] }, reset: agentReset }) as never,
+      );
+    });
+    const agent = createAgent({ data: settledData, reset: agentReset });
+    mockUseEveAgent.mockReturnValue(agent as never);
+    const { result, rerender } = renderHook(() => useEveAgentRuntime());
+
+    const abortReasons: string[] = [];
+    act(() => {
+      result.current.registerModelContextProvider({
+        getModelContext: () => ({
+          tools: {
+            slow_tool: {
+              parameters: { type: "object", properties: {} },
+              execute: (
+                _args: unknown,
+                context: { toolCallId: string; abortSignal: AbortSignal },
+              ) =>
+                new Promise<never>(() => {
+                  context.abortSignal.addEventListener("abort", () => {
+                    abortReasons.push(context.toolCallId);
+                  });
+                }),
+            },
+          },
+        }),
+      });
+    });
+
+    mockUseEveAgent.mockReturnValue(
+      createAgent({ data: twoExecutingToolsData, reset: agentReset }) as never,
+    );
+    rerender();
+
+    await waitFor(() => {
+      expect(result.current.thread.getState().isRunning).toBe(true);
+    });
+
+    act(() => {
+      eveExtras.tryGet(result.current.thread.getState().extras)!.reset();
+    });
+    rerender();
+
+    await waitFor(() => {
+      expect(abortReasons.sort()).toEqual(["call_slow_a", "call_slow_b"]);
+    });
+    expect(result.current.thread.getState().isRunning).toBe(false);
+  });
+
+  it("rejects a pending human-input request when reset is invoked", async () => {
+    const agentReset = vi.fn(() => {
+      mockUseEveAgent.mockReturnValue(
+        createAgent({ data: { messages: [] }, reset: agentReset }) as never,
+      );
+    });
+    const agent = createAgent({ data: settledData, reset: agentReset });
+    mockUseEveAgent.mockReturnValue(agent as never);
+    const { result, rerender } = renderHook(() => useEveAgentRuntime());
+
+    const humanRejections: unknown[] = [];
+    act(() => {
+      result.current.registerModelContextProvider({
+        getModelContext: () => ({
+          tools: {
+            slow_tool: {
+              parameters: { type: "object", properties: {} },
+              execute: async (
+                _args: unknown,
+                context: { human: (payload: unknown) => Promise<unknown> },
+              ) => {
+                try {
+                  return await context.human({ request: "approve" });
+                } catch (error) {
+                  humanRejections.push(error);
+                  throw error;
+                }
+              },
+            },
+          },
+        }),
+      });
+    });
+
+    mockUseEveAgent.mockReturnValue(
+      createAgent({ data: twoExecutingToolsData, reset: agentReset }) as never,
+    );
+    rerender();
+
+    await waitFor(() => {
+      expect(result.current.thread.getState().isRunning).toBe(true);
+    });
+
+    act(() => {
+      eveExtras.tryGet(result.current.thread.getState().extras)!.reset();
+    });
+    rerender();
+
+    await waitFor(() => {
+      expect(humanRejections).toHaveLength(2);
+    });
+    expect((humanRejections[0] as Error).message).toBe(
+      "Tool execution aborted",
+    );
+  });
+
+  it("ignores tool statuses left over from a discarded session", async () => {
+    const releases: Record<string, () => void> = {};
+    const agentReset = vi.fn(() => {
+      mockUseEveAgent.mockReturnValue(
+        createAgent({ data: { messages: [] }, reset: agentReset }) as never,
+      );
+    });
+    const agent = createAgent({ data: settledData, reset: agentReset });
+    mockUseEveAgent.mockReturnValue(agent as never);
+    const { result, rerender } = renderHook(() => useEveAgentRuntime());
+
+    act(() => {
+      result.current.registerModelContextProvider({
+        getModelContext: () => ({
+          tools: {
+            slow_tool: {
+              parameters: { type: "object", properties: {} },
+              execute: (_args: unknown, context: { toolCallId: string }) =>
+                new Promise<never>((_resolve, reject) => {
+                  releases[context.toolCallId] = () =>
+                    reject(new Error("aborted"));
+                }),
+            },
+          },
+        }),
+      });
+    });
+
+    mockUseEveAgent.mockReturnValue(
+      createAgent({
+        data: twoExecutingToolsData,
+        reset: agentReset,
+      }) as never,
+    );
+    rerender();
+
+    await waitFor(() => {
+      expect(result.current.thread.getState().isRunning).toBe(true);
+    });
+
+    act(() => {
+      eveExtras.tryGet(result.current.thread.getState().extras)!.reset();
+    });
+    rerender();
+
+    await waitFor(() => {
+      expect(result.current.thread.getState().isRunning).toBe(false);
+    });
+
+    await act(async () => {
+      releases["call_slow_a"]?.();
+      await Promise.resolve();
+    });
+
+    await waitFor(() => {
+      expect(result.current.thread.getState().isRunning).toBe(false);
+    });
+    expect(agentReset).toHaveBeenCalledTimes(1);
+  });
+
+  it("promotes every staged draft after reset when the discarded run failed", async () => {
+    const send = vi.fn().mockResolvedValue(undefined);
+    const agent = createAgent({ data: settledData, send });
+    let capturedOptions: { onFinish?: (snapshot: unknown) => void } = {};
+    mockUseEveAgent.mockImplementation((options) => {
+      capturedOptions = options as typeof capturedOptions;
+      return agent as never;
+    });
+    const { result } = renderHook(() => useEveAgentRuntime());
+
+    act(() => {
+      capturedOptions.onFinish?.({ status: "error" });
+    });
+    act(() => {
+      eveExtras.tryGet(result.current.thread.getState().extras)!.reset();
+    });
+
+    await stageMessage(result.current, "first staged");
+    await stageMessage(result.current, "second staged");
+
+    const secondStagedId = result.current.thread.getState().messages[3]!.id;
+    await act(async () => {
+      await result.current.thread.startRun({
+        parentId: secondStagedId,
+        sourceId: null,
+        runConfig: {},
+      });
+    });
+
+    expect(send).toHaveBeenCalledTimes(2);
+    expect(send).toHaveBeenNthCalledWith(1, "first staged", undefined);
+    expect(send).toHaveBeenNthCalledWith(2, "second staged", undefined);
+  });
+});
+
+const approvalData: EveMessageData = {
+  messages: [
+    { id: "u1", role: "user", parts: [{ type: "text", text: "send it" }] },
+    {
+      id: "a1",
+      role: "assistant",
+      parts: [
+        {
+          type: "dynamic-tool",
+          state: "approval-requested",
+          toolCallId: "call_1",
+          toolName: "send_email",
+          input: { to: "dev@example.com" },
+          approval: { id: "req_1" },
+          toolMetadata: {
+            eve: {
+              kind: "tool-call",
+              name: "send_email",
+              inputRequest: {
+                requestId: "req_1",
+                kind: "tool-approval",
+                prompt: "Send the email?",
+                display: "confirmation",
+                options: [
+                  { id: "approve", label: "Approve" },
+                  { id: "cancel", label: "Cancel" },
+                ],
+              },
+            },
+          },
+        },
+      ],
+    },
+  ],
+};
+
+describe("useEveAgentRuntime concurrent sends", () => {
+  it("defers an approval clicked while a turn is in flight until the turn parks", async () => {
+    let resolveFirstSend!: () => void;
+    const send = vi.fn().mockImplementationOnce(
+      () =>
+        new Promise<void>((resolve) => {
+          resolveFirstSend = resolve;
+        }),
+    );
+    const respond = vi.fn().mockResolvedValue(undefined);
+    const agent = createAgent({ data: approvalData, send, respond });
+    mockUseEveAgent.mockReturnValue(agent as never);
+    const { result } = renderHook(() => useEveAgentRuntime());
+
+    await act(async () => {
+      result.current.thread.append({
+        role: "user",
+        content: [{ type: "text", text: "go" }],
+      });
+    });
+    await waitFor(() => expect(send).toHaveBeenCalledTimes(1));
+
+    act(() => {
+      result.current.thread
+        .getMessageByIndex(1)
+        .getMessagePartByToolCallId("call_1")
+        .respondToToolApproval({ optionId: "approve" });
+    });
+    expect(respond).not.toHaveBeenCalled();
+
+    await act(async () => {
+      resolveFirstSend();
+    });
+    await waitFor(() => expect(respond).toHaveBeenCalledTimes(1));
+    expect(respond).toHaveBeenCalledWith([
+      { requestId: "req_1", optionId: "approve" },
+    ]);
+  });
+
+  it("queues a send issued while a turn is in flight and preserves order", async () => {
+    let resolveFirstSend!: () => void;
+    const send = vi
+      .fn()
+      .mockImplementationOnce(
+        () =>
+          new Promise<void>((resolve) => {
+            resolveFirstSend = resolve;
+          }),
+      )
+      .mockResolvedValue(undefined);
+    const agent = createAgent({ data: settledData, send });
+    mockUseEveAgent.mockReturnValue(agent as never);
+    const { result } = renderHook(() => useEveAgentRuntime());
+
+    await act(async () => {
+      result.current.thread.append({
+        role: "user",
+        content: [{ type: "text", text: "first" }],
+      });
+    });
+    await waitFor(() => expect(send).toHaveBeenCalledTimes(1));
+
+    await act(async () => {
+      result.current.thread.append({
+        role: "user",
+        content: [{ type: "text", text: "second" }],
+      });
+    });
+    expect(send).toHaveBeenCalledTimes(1);
+
+    await act(async () => {
+      resolveFirstSend();
+    });
+    await waitFor(() => expect(send).toHaveBeenCalledTimes(2));
+    expect(send).toHaveBeenNthCalledWith(1, "first", undefined);
+    expect(send).toHaveBeenNthCalledWith(2, "second", undefined);
+  });
+
+  it("drops a queued send when the run is cancelled before it dispatches", async () => {
+    let resolveFirstSend!: () => void;
+    const send = vi
+      .fn()
+      .mockImplementationOnce(
+        () =>
+          new Promise<void>((resolve) => {
+            resolveFirstSend = resolve;
+          }),
+      )
+      .mockResolvedValue(undefined);
+    const agent = createAgent({ data: settledData, send });
+    mockUseEveAgent.mockReturnValue(agent as never);
+    const { result } = renderHook(() => useEveAgentRuntime());
+
+    await act(async () => {
+      result.current.thread.append({
+        role: "user",
+        content: [{ type: "text", text: "first" }],
+      });
+    });
+    await waitFor(() => expect(send).toHaveBeenCalledTimes(1));
+
+    await act(async () => {
+      result.current.thread.append({
+        role: "user",
+        content: [{ type: "text", text: "queued" }],
+      });
+    });
+    act(() => {
+      result.current.thread.cancelRun();
+    });
+    expect(agent.stop).toHaveBeenCalledTimes(1);
+
+    await act(async () => {
+      resolveFirstSend();
+    });
+    expect(send).toHaveBeenCalledTimes(1);
+  });
+
+  it("returns a cancelled queued send to the composer", async () => {
+    let resolveFirstSend!: () => void;
+    const send = vi
+      .fn()
+      .mockImplementationOnce(
+        () =>
+          new Promise<void>((resolve) => {
+            resolveFirstSend = resolve;
+          }),
+      )
+      .mockResolvedValue(undefined);
+    const agent = createAgent({ data: settledData, send });
+    mockUseEveAgent.mockReturnValue(agent as never);
+    const { result } = renderHook(() => useEveAgentRuntime());
+
+    await act(async () => {
+      result.current.thread.append({
+        role: "user",
+        content: [{ type: "text", text: "first" }],
+      });
+    });
+    await waitFor(() => expect(send).toHaveBeenCalledTimes(1));
+
+    await act(async () => {
+      result.current.thread.composer.setText("queued");
+      result.current.thread.composer.send();
+    });
+    expect(result.current.thread.composer.getState().text).toBe("");
+
+    act(() => {
+      result.current.thread.cancelRun();
+    });
+    await act(async () => {
+      resolveFirstSend();
+    });
+
+    await waitFor(() => {
+      expect(result.current.thread.composer.getState().text).toBe("queued");
+    });
+    expect(send).toHaveBeenCalledTimes(1);
+    expect(getText(result.current)).toEqual(["earlier", "earlier answer"]);
+  });
+
+  it("returns the queued send when cancel keeps the trailing message", async () => {
     let resolveFirstSend!: () => void;
     const send = vi
       .fn()
@@ -1007,16 +1596,14 @@ describe("useEveAgentRuntime concurrent sends", () => {
 
   it("keeps a cancelled tool approval discarded", async () => {
     let resolveFirstSend!: () => void;
-    const send = vi
-      .fn()
-      .mockImplementationOnce(
-        () =>
-          new Promise<void>((resolve) => {
-            resolveFirstSend = resolve;
-          }),
-      )
-      .mockResolvedValue(undefined);
-    const agent = createAgent({ data: approvalData, send });
+    const send = vi.fn().mockImplementationOnce(
+      () =>
+        new Promise<void>((resolve) => {
+          resolveFirstSend = resolve;
+        }),
+    );
+    const respond = vi.fn().mockResolvedValue(undefined);
+    const agent = createAgent({ data: approvalData, send, respond });
     mockUseEveAgent.mockReturnValue(agent as never);
     const { result } = renderHook(() => useEveAgentRuntime());
     const before = getText(result.current);
@@ -1043,6 +1630,7 @@ describe("useEveAgentRuntime concurrent sends", () => {
     });
 
     expect(send).toHaveBeenCalledTimes(1);
+    expect(respond).not.toHaveBeenCalled();
     expect(result.current.thread.composer.getState().text).toBe("");
     expect(getText(result.current)).toEqual(before);
   });
@@ -1142,10 +1730,292 @@ describe("useEveAgentRuntime concurrent sends", () => {
     });
     await waitFor(() => expect(send).toHaveBeenCalledTimes(3));
 
-    expect(send.mock.calls.map(([payload]) => payload)).toEqual([
-      { message: "first staged" },
-      { message: "interleaved" },
-      { message: "second staged" },
+    expect(send.mock.calls.map(([message]) => message)).toEqual([
+      "first staged",
+      "interleaved",
+      "second staged",
     ]);
   });
 });
+
+describe("useEveAgentRuntime cancel binding", () => {
+  it("cancels through the eve 0.38+ cancel binding when the agent provides it", async () => {
+    const cancel = vi.fn().mockResolvedValue({ status: "cancelled" });
+    const agent = createAgent({ status: "streaming", cancel });
+    mockUseEveAgent.mockReturnValue(agent as never);
+    const { result } = renderHook(() => useEveAgentRuntime());
+
+    await act(async () => {
+      result.current.thread.cancelRun();
+    });
+
+    expect(cancel).toHaveBeenCalledTimes(1);
+    expect(agent.stop).not.toHaveBeenCalled();
+  });
+
+  it("falls back to the pre-0.38 stop binding when cancel is absent", async () => {
+    const agent = createAgent({ status: "streaming" });
+    mockUseEveAgent.mockReturnValue(agent as never);
+    const { result } = renderHook(() => useEveAgentRuntime());
+
+    await act(async () => {
+      result.current.thread.cancelRun();
+    });
+
+    expect(agent.stop).toHaveBeenCalledTimes(1);
+  });
+
+  it("drops a queued send when the durable cancel settles late", async () => {
+    let resolveFirstSend!: () => void;
+    const send = vi
+      .fn()
+      .mockImplementationOnce(
+        () =>
+          new Promise<void>((resolve) => {
+            resolveFirstSend = resolve;
+          }),
+      )
+      .mockResolvedValue(undefined);
+    let resolveCancel!: () => void;
+    const cancel = vi.fn(
+      () =>
+        new Promise<{ status: string }>((resolve) => {
+          resolveCancel = () => resolve({ status: "cancelled" });
+        }),
+    );
+    const agent = createAgent({ data: settledData, send, cancel });
+    mockUseEveAgent.mockReturnValue(agent as never);
+    const { result } = renderHook(() => useEveAgentRuntime());
+
+    await act(async () => {
+      result.current.thread.append({
+        role: "user",
+        content: [{ type: "text", text: "first" }],
+      });
+    });
+    await waitFor(() => expect(send).toHaveBeenCalledTimes(1));
+
+    await act(async () => {
+      result.current.thread.append({
+        role: "user",
+        content: [{ type: "text", text: "queued" }],
+      });
+    });
+    act(() => {
+      result.current.thread.cancelRun();
+    });
+    expect(cancel).toHaveBeenCalledTimes(1);
+
+    await act(async () => {
+      resolveFirstSend();
+      resolveCancel();
+    });
+    expect(send).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe("useEveAgentRuntime thread refetch", () => {
+  const session = { sessionId: "s1" };
+
+  it("replays the session through eve resume when the thread is refetched", async () => {
+    const resume = vi.fn().mockResolvedValue(undefined);
+    const agent = createAgent({ session, resume });
+    mockUseEveAgent.mockReturnValue(agent as never);
+    const { result } = renderHook(() => useEveAgentRuntime());
+    expect(result.current.thread.getState().capabilities.refetchThread).toBe(
+      true,
+    );
+
+    await act(async () => {
+      await result.current.threads.reloadMainThread();
+    });
+
+    expect(resume).toHaveBeenCalledTimes(1);
+  });
+
+  it("propagates a failed replay to the refetch caller", async () => {
+    const resume = vi.fn().mockRejectedValue(new Error("replay failed"));
+    const agent = createAgent({ session, resume });
+    mockUseEveAgent.mockReturnValue(agent as never);
+    const { result } = renderHook(() => useEveAgentRuntime());
+
+    await act(async () => {
+      await expect(result.current.threads.reloadMainThread()).rejects.toThrow(
+        "replay failed",
+      );
+    });
+  });
+
+  it("resolves without replaying when no session exists yet", async () => {
+    const resume = vi.fn();
+    const agent = createAgent({ session: undefined, resume });
+    mockUseEveAgent.mockReturnValue(agent as never);
+    const { result } = renderHook(() => useEveAgentRuntime());
+
+    await act(async () => {
+      await result.current.threads.reloadMainThread();
+    });
+
+    expect(resume).not.toHaveBeenCalled();
+  });
+
+  it("waits for a turn dispatched before it to park, then replays", async () => {
+    let resolveSend!: () => void;
+    const send = vi.fn(
+      () =>
+        new Promise<void>((resolve) => {
+          resolveSend = resolve;
+        }),
+    );
+    const resume = vi.fn().mockResolvedValue(undefined);
+    const agent = createAgent({ session, resume, send });
+    mockUseEveAgent.mockReturnValue(agent as never);
+    const { result } = renderHook(() => useEveAgentRuntime());
+
+    await act(async () => {
+      result.current.thread.append({
+        role: "user",
+        content: [{ type: "text", text: "hi" }],
+      });
+    });
+    await waitFor(() => expect(send).toHaveBeenCalledTimes(1));
+
+    let settled = false;
+    await act(async () => {
+      void result.current.threads.reloadMainThread().then(() => {
+        settled = true;
+      });
+    });
+    expect(resume).not.toHaveBeenCalled();
+    expect(settled).toBe(false);
+
+    await act(async () => {
+      resolveSend();
+    });
+    await waitFor(() => expect(settled).toBe(true));
+    expect(resume).toHaveBeenCalledTimes(1);
+  });
+
+  it("reads the session at dispatch time, after the first send created it", async () => {
+    let resolveSend!: () => void;
+    const send = vi.fn(
+      () =>
+        new Promise<void>((resolve) => {
+          resolveSend = resolve;
+        }),
+    );
+    const resume = vi.fn().mockResolvedValue(undefined);
+    const agent = createAgent({ session: undefined, resume, send });
+    mockUseEveAgent.mockReturnValue(agent as never);
+    const { result, rerender } = renderHook(() => useEveAgentRuntime());
+
+    await act(async () => {
+      result.current.thread.append({
+        role: "user",
+        content: [{ type: "text", text: "hi" }],
+      });
+    });
+    await waitFor(() => expect(send).toHaveBeenCalledTimes(1));
+
+    let settled = false;
+    await act(async () => {
+      void result.current.threads.reloadMainThread().then(() => {
+        settled = true;
+      });
+    });
+
+    mockUseEveAgent.mockReturnValue({ ...agent, session } as never);
+    rerender();
+    await act(async () => {
+      resolveSend();
+    });
+    await waitFor(() => expect(settled).toBe(true));
+    expect(resume).toHaveBeenCalledTimes(1);
+  });
+
+  it("still replays a queued refetch when the run it waited on is cancelled", async () => {
+    let resolveSend!: () => void;
+    const send = vi.fn(
+      () =>
+        new Promise<void>((resolve) => {
+          resolveSend = resolve;
+        }),
+    );
+    const resume = vi.fn().mockResolvedValue(undefined);
+    const cancel = vi.fn().mockResolvedValue({ status: "cancelled" });
+    const agent = createAgent({ session, resume, send, cancel });
+    mockUseEveAgent.mockReturnValue(agent as never);
+    const { result } = renderHook(() => useEveAgentRuntime());
+
+    await act(async () => {
+      result.current.thread.append({
+        role: "user",
+        content: [{ type: "text", text: "hi" }],
+      });
+    });
+    await waitFor(() => expect(send).toHaveBeenCalledTimes(1));
+
+    let settled = false;
+    await act(async () => {
+      void result.current.threads.reloadMainThread().then(() => {
+        settled = true;
+      });
+      result.current.thread.cancelRun();
+    });
+    await act(async () => {
+      resolveSend();
+    });
+
+    await waitFor(() => expect(settled).toBe(true));
+    expect(resume).toHaveBeenCalledTimes(1);
+  });
+
+  it("drops a queued refetch when the session is reset before it dispatches", async () => {
+    let resolveSend!: () => void;
+    const send = vi.fn(
+      () =>
+        new Promise<void>((resolve) => {
+          resolveSend = resolve;
+        }),
+    );
+    const resume = vi.fn();
+    const agent = createAgent({ session, resume, send });
+    mockUseEveAgent.mockReturnValue(agent as never);
+    const { result } = renderHook(() => useEveAgentRuntime());
+
+    await act(async () => {
+      result.current.thread.append({
+        role: "user",
+        content: [{ type: "text", text: "hi" }],
+      });
+    });
+    await waitFor(() => expect(send).toHaveBeenCalledTimes(1));
+
+    let settled = false;
+    await act(async () => {
+      void result.current.threads.reloadMainThread().then(() => {
+        settled = true;
+      });
+      eveExtras.tryGet(result.current.thread.getState().extras)!.reset();
+    });
+    await act(async () => {
+      resolveSend();
+    });
+
+    await waitFor(() => expect(settled).toBe(true));
+    expect(resume).not.toHaveBeenCalled();
+  });
+
+  it("leaves the capability absent when the installed eve has no resume", async () => {
+    const agent = createAgent({ session });
+    mockUseEveAgent.mockReturnValue(agent as never);
+    const { result } = renderHook(() => useEveAgentRuntime());
+
+    expect(result.current.thread.getState().capabilities.refetchThread).toBe(
+      false,
+    );
+    await act(async () => {
+      await result.current.threads.reloadMainThread();
+    });
+  });
+});