@assistant-ui/eve 0.0.12 → 0.0.14

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" },
       });
     });
@@ -341,6 +339,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 +437,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 +545,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 +582,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 +608,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 +646,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 +714,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,6 +789,406 @@ describe("useEveAgentRuntime staged messages", () => {
   });
 });
 
+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,
+    );
+
+    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 stageMessage(result.current, "discarded draft");
+    const discardedId = result.current.thread.getState().messages[2]!.id;
+
+    act(() => {
+      eveExtras.tryGet(result.current.thread.getState().extras)!.reset();
+    });
+    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("clears executing tool state when reset is invoked", async () => {
+    const agent = createAgent({ data: settledData });
+    mockUseEveAgent.mockReturnValue(agent as never);
+    const { result, rerender } = renderHook(() => useEveAgentRuntime());
+
+    act(() => {
+      result.current.registerModelContextProvider({
+        getModelContext: () => ({
+          tools: {
+            slow_tool: {
+              parameters: { type: "object", properties: {} },
+              execute: () => new Promise<never>(() => {}),
+            },
+          },
+        }),
+      });
+    });
+
+    // 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);
+    });
+
+    act(() => {
+      eveExtras.tryGet(result.current.thread.getState().extras)!.reset();
+    });
+
+    await waitFor(() => {
+      expect(result.current.thread.getState().isRunning).toBe(false);
+    });
+    expect(agent.reset).toHaveBeenCalledTimes(1);
+  });
+
+  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) => {
+            releaseFirstSend = resolve;
+          }),
+      )
+      .mockResolvedValue(undefined);
+    const agent = createAgent({ data: settledData, send });
+    mockUseEveAgent.mockReturnValue(agent as never);
+    const { result } = renderHook(() => useEveAgentRuntime());
+
+    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);
+    });
+
+    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(() => {
+      eveExtras.tryGet(result.current.thread.getState().extras)!.reset();
+    });
+
+    await act(async () => {
+      releaseFirstSend?.();
+      await queuedReload;
+    });
+
+    expect(send).toHaveBeenCalledTimes(1);
+    await waitFor(() => {
+      expect(getText(result.current)).toEqual(["earlier", "earlier answer"]);
+    });
+  });
+
+  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) => {
+            releaseFirstSend = resolve;
+          }),
+      )
+      .mockResolvedValue(undefined);
+    const agent = createAgent({ data: settledData, send });
+    mockUseEveAgent.mockReturnValue(agent as never);
+    const { result } = renderHook(() => useEveAgentRuntime());
+
+    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);
+    });
+
+    const queuedReload = Promise.resolve(
+      result.current.thread.startRun({
+        parentId: queuedDraftId,
+        sourceId: null,
+        runConfig: {},
+      }),
+    );
+    await act(async () => {});
+
+    act(() => {
+      result.current.thread.cancelRun();
+    });
+
+    await act(async () => {
+      releaseFirstSend?.();
+      await queuedReload;
+    });
+
+    expect(send).toHaveBeenCalledTimes(1);
+    expect(agent.stop).toHaveBeenCalledTimes(1);
+    await waitFor(() => {
+      expect(getText(result.current)).toEqual([
+        "earlier",
+        "earlier answer",
+        "queued draft",
+      ]);
+    });
+  });
+
+  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" }] },
@@ -776,11 +1209,12 @@ const approvalData: EveMessageData = {
               name: "send_email",
               inputRequest: {
                 requestId: "req_1",
+                kind: "tool-approval",
                 prompt: "Send the email?",
                 display: "confirmation",
                 options: [
                   { id: "approve", label: "Approve" },
-                  { id: "deny", label: "Deny" },
+                  { id: "cancel", label: "Cancel" },
                 ],
               },
             },
@@ -794,16 +1228,14 @@ const approvalData: EveMessageData = {
 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 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());
 
@@ -821,15 +1253,15 @@ describe("useEveAgentRuntime concurrent sends", () => {
         .getMessagePartByToolCallId("call_1")
         .respondToToolApproval({ optionId: "approve" });
     });
-    expect(send).toHaveBeenCalledTimes(1);
+    expect(respond).not.toHaveBeenCalled();
 
     await act(async () => {
       resolveFirstSend();
     });
-    await waitFor(() => expect(send).toHaveBeenCalledTimes(2));
-    expect(send).toHaveBeenNthCalledWith(2, {
-      inputResponses: [{ requestId: "req_1", optionId: "approve" }],
-    });
+    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 () => {
@@ -867,8 +1299,8 @@ describe("useEveAgentRuntime concurrent sends", () => {
       resolveFirstSend();
     });
     await waitFor(() => expect(send).toHaveBeenCalledTimes(2));
-    expect(send).toHaveBeenNthCalledWith(1, { message: "first" });
-    expect(send).toHaveBeenNthCalledWith(2, { message: "second" });
+    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 () => {
@@ -911,6 +1343,141 @@ describe("useEveAgentRuntime concurrent sends", () => {
     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()
+      .mockImplementationOnce(
+        () =>
+          new Promise<void>((resolve) => {
+            resolveFirstSend = resolve;
+          }),
+      )
+      .mockResolvedValue(undefined);
+    // Before the turn streams, the dispatched message is the thread's trailing
+    // user leaf. Eve owns that message and cannot remove it on cancel.
+    const agent = createAgent({
+      data: {
+        messages: [
+          ...settledData.messages,
+          { id: "u2", role: "user", parts: [{ type: "text", text: "first" }] },
+        ],
+      } satisfies EveMessageData,
+      status: "submitted",
+      send,
+    });
+    mockUseEveAgent.mockReturnValue(agent as never);
+    const { result } = renderHook(() => useEveAgentRuntime());
+
+    await act(async () => {
+      result.current.thread.composer.setText("first");
+      result.current.thread.composer.send();
+    });
+    await waitFor(() => expect(send).toHaveBeenCalledTimes(1));
+
+    await act(async () => {
+      result.current.thread.composer.setText("queued");
+      result.current.thread.composer.send();
+    });
+    act(() => {
+      result.current.thread.cancelRun();
+    });
+    expect(result.current.thread.composer.getState().text).toBe("");
+
+    await act(async () => {
+      resolveFirstSend();
+    });
+
+    await waitFor(() => {
+      expect(result.current.thread.composer.getState().text).toBe("queued");
+    });
+    expect(send).toHaveBeenCalledTimes(1);
+  });
+
+  it("keeps a cancelled tool approval discarded", 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());
+    const before = getText(result.current);
+
+    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" });
+    });
+    act(() => {
+      result.current.thread.cancelRun();
+    });
+    await act(async () => {
+      resolveFirstSend();
+    });
+
+    expect(send).toHaveBeenCalledTimes(1);
+    expect(respond).not.toHaveBeenCalled();
+    expect(result.current.thread.composer.getState().text).toBe("");
+    expect(getText(result.current)).toEqual(before);
+  });
+
   it("drops a queued send when the hook unmounts before it dispatches", async () => {
     let resolveFirstSend!: () => void;
     const send = vi
@@ -1006,10 +1573,10 @@ 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",
     ]);
   });
 });