@assistant-ui/eve 0.0.14 → 0.0.15

package/src/useEveAgentRuntime.refetch.test.tsx

@@ -0,0 +1,89 @@
+// @vitest-environment jsdom
+
+import { act, renderHook } from "@testing-library/react";
+import { describe, expect, it, vi } from "vitest";
+import type { HandleMessageStreamEvent } from "eve/client";
+
+import { useEveAgentRuntime } from "./useEveAgentRuntime";
+
+const completedTurn = (
+  turnId: string,
+  text: string,
+  reply: string,
+  sequence: number,
+) =>
+  [
+    {
+      type: "turn.started",
+      data: { sequence, turnId },
+      meta: { at: "2026-01-02T10:00:00.000Z", id: `${turnId}-1` },
+    },
+    {
+      type: "message.received",
+      data: { message: text, sequence: sequence + 1, turnId },
+      meta: { at: "2026-01-02T10:00:01.000Z", id: `${turnId}-2` },
+    },
+    {
+      type: "step.started",
+      data: { modelId: "m", sequence: sequence + 2, stepIndex: 0, turnId },
+      meta: { at: "2026-01-02T10:00:02.000Z", id: `${turnId}-3` },
+    },
+    {
+      type: "message.completed",
+      data: {
+        finishReason: "stop",
+        message: reply,
+        sequence: sequence + 3,
+        stepIndex: 0,
+        turnId,
+      },
+      meta: { at: "2026-01-02T10:00:03.000Z", id: `${turnId}-4` },
+    },
+    {
+      type: "turn.completed",
+      data: { sequence: sequence + 4, turnId },
+      meta: { at: "2026-01-02T10:00:04.000Z", id: `${turnId}-5` },
+    },
+  ] as const satisfies readonly HandleMessageStreamEvent[];
+
+const knownTurn = completedTurn("t1", "hi", "hello", 1);
+const outOfBandTurn = completedTurn("t2", "answered elsewhere", "done", 6);
+
+describe("useEveAgentRuntime against a durable eve session", () => {
+  it("surfaces a turn the server appended out of band after reloadMainThread", async () => {
+    const stream = vi.fn(async function* () {
+      yield* [...knownTurn, ...outOfBandTurn];
+    });
+    const session = {
+      state: { sessionId: "s1" },
+      stream,
+      send: () => {
+        throw new Error("the refetch test must not send");
+      },
+    } as never;
+
+    const { result } = renderHook(() =>
+      useEveAgentRuntime({ initialEvents: knownTurn as never, session }),
+    );
+    expect(
+      result.current.thread.getState().messages.map((m) => m.role),
+    ).toEqual(["user", "assistant"]);
+
+    await act(async () => {
+      await result.current.threads.reloadMainThread();
+    });
+
+    expect(stream).toHaveBeenCalled();
+    const messages = result.current.thread.getState().messages;
+    expect(messages.map((m) => m.role)).toEqual([
+      "user",
+      "assistant",
+      "user",
+      "assistant",
+    ]);
+    expect(messages[3]?.content).toMatchObject([
+      { type: "text", text: "done" },
+    ]);
+    expect(result.current.thread.getState().isRunning).toBe(false);
+  });
+});

package/src/useEveAgentRuntime.test.tsx

@@ -328,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" }] },
@@ -1580,3 +1737,285 @@ describe("useEveAgentRuntime concurrent sends", () => {
     ]);
   });
 });
+
+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();
+    });
+  });
+});

package/src/useEveAgentRuntime.ts

@@ -28,6 +28,7 @@ import {
 } from "eve/react";
 import {
   convertEveMessages,
+  findEveInputRequest,
   getEveMessageContent,
   toEveInputResponse,
 } from "./convertEveMessages";
@@ -199,10 +200,9 @@ export const useEveAgentRuntime = (options: UseEveAgentRuntimeOptions = {}) => {
   const hasExecutingTools = Object.values(toolStatuses).some(
     (status) => status?.type === "executing",
   );
-  const isRunning =
-    agent.status === "submitted" ||
-    agent.status === "streaming" ||
-    hasExecutingTools;
+  const providerIsRunning =
+    agent.status === "submitted" || agent.status === "streaming";
+  const isRunning = providerIsRunning || hasExecutingTools;
 
   const convertedMessages = useMemo(() => {
     const createdAtByMessageId = createdAtByMessageIdRef.current;
@@ -230,6 +230,8 @@ export const useEveAgentRuntime = (options: UseEveAgentRuntimeOptions = {}) => {
   const messages = stagedMessages ?? convertedMessages;
   const messagesRef = useRef(messages);
   messagesRef.current = messages;
+  const agentRef = useRef(agent);
+  agentRef.current = agent;
 
   // Upstream `EveAgentStore` `send` and `respond` reject while a turn is in
   // flight and only resolve once the turn's stream parks, so a pending chain
@@ -239,18 +241,22 @@ export const useEveAgentRuntime = (options: UseEveAgentRuntimeOptions = {}) => {
   const sendEpochRef = useRef(0);
   // A cancel drops the queued send but keeps its draft for a later promotion;
   // only a reset discards the draft with the session, so the two need separate
-  // counters.
+  // counters. A queued read has no draft and outlives a cancel, so it waits on
+  // the reset counter instead.
   const resetEpochRef = useRef(0);
   const isMountedRef = useRef(true);
   const runtimeRef = useRef<ReturnType<typeof useExternalStoreRuntime> | null>(
     null,
   );
 
-  const enqueueSend = (dispatch: () => Promise<void>) => {
-    const epoch = sendEpochRef.current;
+  const enqueueSend = (
+    dispatch: () => Promise<void>,
+    epochRef: { current: number } = sendEpochRef,
+  ) => {
+    const epoch = epochRef.current;
     const next = sendChainRef.current.then(() => {
-      if (epoch !== sendEpochRef.current)
-        throw isMountedRef.current ? sendCancelledError : sendAbandonedError;
+      if (!isMountedRef.current) throw sendAbandonedError;
+      if (epoch !== epochRef.current) throw sendCancelledError;
       return dispatch();
     });
     sendChainRef.current = next.catch(() => {});
@@ -339,7 +345,7 @@ export const useEveAgentRuntime = (options: UseEveAgentRuntimeOptions = {}) => {
   const runtime = useExternalStoreRuntime({
     ...pickExternalStoreSharedOptions(options),
     messages,
-    isRunning,
+    isRunning: providerIsRunning,
     extras,
     unstable_enableToolInvocations: true,
     setToolStatuses,
@@ -419,18 +425,59 @@ export const useEveAgentRuntime = (options: UseEveAgentRuntimeOptions = {}) => {
           },
         }
       : {}),
-    onCancel: () => {
+    onCancel: async () => {
       sendEpochRef.current += 1;
-      agent.stop();
-      return Promise.resolve();
-    },
-    onRespondToToolApproval: async (response) => {
-      try {
-        await enqueueSend(() => agent.respond([toEveInputResponse(response)]));
-      } catch (error) {
-        if (!isDroppedSend(error)) throw error;
+      // Eve 0.38 replaced the binding's local-abort `stop()` with the durable
+      // `cancel()`, so the adapter detects which side of that break the host's
+      // eve provides instead of pinning the peer range to one of them.
+      const controls = agent as
+        | { readonly cancel: () => Promise<unknown> }
+        | { readonly stop: () => void };
+      if ("cancel" in controls) {
+        await controls.cancel();
+      } else {
+        controls.stop();
       }
     },
+    // Hosts below eve 0.44.1 expose no `resume`; leaving the capability absent
+    // keeps `threads.reloadMainThread()` on core's no-capability no-op.
+    ...("resume" in agent
+      ? {
+          onRefetchThread: () =>
+            // `resume()` rejects during a turn, so the replay rides the send
+            // chain like every other dispatch and runs once the turn parks; a
+            // cancel of that turn does not drop it, or the caller would be told
+            // the thread was refetched when it was not. Upstream shares one
+            // replay across concurrent `resume()` calls, so a refetch
+            // dispatched while `resume: true` is replaying on mount joins that
+            // read instead of taking a fresh one. The session is read at
+            // dispatch time because nothing durable exists before the first
+            // send lands.
+            enqueueSend(async () => {
+              const live = agentRef.current;
+              if (live.session === undefined) return;
+              await live.resume();
+            }, resetEpochRef).catch((error) => {
+              if (isDroppedSend(error)) return;
+              throw error;
+            }),
+        }
+      : {}),
+    onRespondToToolApproval: (response) => {
+      // Eve leaves an unanswered request pending, so an unmappable response
+      // must stay answerable. Mapping before the first await lets the mapper's
+      // own error surface synchronously to the caller that rendered the
+      // controls, the only signal the void `respondToApproval` seam carries.
+      const inputResponse = toEveInputResponse(
+        response,
+        findEveInputRequest(agent.data, response.approvalId),
+      );
+      return enqueueSend(() => agent.respond([inputResponse])).catch(
+        (error) => {
+          if (!isDroppedSend(error)) throw error;
+        },
+      );
+    },
   });
   runtimeRef.current = runtime;