@assistant-ui/eve 0.0.14 → 0.0.16

package/src/useEveAgentRuntime.ts

@@ -1,6 +1,13 @@
 "use client";
 
-import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import {
+  useCallback,
+  useEffect,
+  useInsertionEffect,
+  useMemo,
+  useRef,
+  useState,
+} from "react";
 import {
   fromThreadMessageLike,
   generateId,
@@ -28,6 +35,7 @@ import {
 } from "eve/react";
 import {
   convertEveMessages,
+  findEveInputRequest,
   getEveMessageContent,
   toEveInputResponse,
 } from "./convertEveMessages";
@@ -199,10 +207,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;
@@ -229,7 +236,13 @@ export const useEveAgentRuntime = (options: UseEveAgentRuntimeOptions = {}) => {
 
   const messages = stagedMessages ?? convertedMessages;
   const messagesRef = useRef(messages);
-  messagesRef.current = messages;
+  const agentRef = useRef(agent);
+  // Descendant layout effects can dispatch against these refs synchronously;
+  // this matches useA2ARuntime's commit-scoped ref publication.
+  useInsertionEffect(() => {
+    messagesRef.current = messages;
+    agentRef.current = agent;
+  }, [agent, messages]);
 
   // 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 +252,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 +356,7 @@ export const useEveAgentRuntime = (options: UseEveAgentRuntimeOptions = {}) => {
   const runtime = useExternalStoreRuntime({
     ...pickExternalStoreSharedOptions(options),
     messages,
-    isRunning,
+    isRunning: providerIsRunning,
     extras,
     unstable_enableToolInvocations: true,
     setToolStatuses,
@@ -419,18 +436,60 @@ 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 resolves a request the moment any response for it arrives, and an
+      // empty one is recorded as an answer with no content. Mapping before the
+      // send is enqueued keeps an unmappable response unsent, so the request
+      // stays answerable; the mapper's error reaches the caller as the seam's
+      // rejection.
+      const inputResponse = toEveInputResponse(
+        response,
+        findEveInputRequest(agent.data, response.approvalId),
+      );
+      return enqueueSend(() => agent.respond([inputResponse])).catch(
+        (error) => {
+          if (!isDroppedSend(error)) throw error;
+        },
+      );
+    },
   });
   runtimeRef.current = runtime;