@assistant-ui/eve 0.0.23 → 0.0.25

package/src/useEveAgentRuntime.ts

@@ -33,12 +33,9 @@ import { invokeUserCallback } from "@assistant-ui/core/internal";
 import { useReplaySafeEffect } from "@assistant-ui/store/internal";
 import { useAui } from "@assistant-ui/store";
 import type { AssistantCloud } from "assistant-cloud";
-import {
-  useEveAgent,
-  type EveMessageData,
-  type UseEveAgentOptions,
-  type UseEveAgentStatus,
-} from "eve/react";
+import { useEveAgent, type UseEveAgentOptions } from "eve/react";
+import { activeTurn, idle, type JsonObject } from "eve/events";
+import type { Delivery } from "eve/sessions";
 import {
   collectInterruptedTurnEvents,
   convertEveMessages,
@@ -79,23 +76,6 @@ const hasRunConfig = (
 ): runConfig is NonNullable<AppendMessage["runConfig"]> =>
   runConfig?.custom !== undefined && Object.keys(runConfig.custom).length > 0;
 
-type EveJsonValue =
-  | string
-  | number
-  | boolean
-  | null
-  | readonly EveJsonValue[]
-  | { readonly [key: string]: EveJsonValue };
-
-/**
- * Structural equivalent of eve's `JsonObject`. Eve demoted its public send
- * payload type once already (`SendTurnPayload`, public through 0.30, internal
- * from 0.31), so the helpers declare the shapes they forward instead of
- * re-exporting eve's option types, and assignability is checked at the send
- * call sites against the installed version.
- */
-type EveClientContext = { readonly [key: string]: EveJsonValue };
-
 /**
  * Only the `custom` bag crosses the wire. Eve reads `clientContext` as its own
  * namespace and serializes it into a model-visible context message, so sending
@@ -104,14 +84,12 @@ type EveClientContext = { readonly [key: string]: EveJsonValue };
  */
 const toEveSendOptions = (
   runConfig: AppendMessage["runConfig"],
-): { readonly clientContext: EveClientContext } | undefined =>
+): { readonly clientContext: JsonObject } | undefined =>
   hasRunConfig(runConfig)
-    ? { clientContext: runConfig.custom as EveClientContext }
+    ? { clientContext: runConfig.custom as JsonObject }
     : undefined;
 
-type EveAgentOptions = Omit<UseEveAgentOptions<EveMessageData>, "reducer">;
-
-export type UseEveAgentRuntimeOptions = EveAgentOptions &
+export type UseEveAgentRuntimeOptions = UseEveAgentOptions &
   ExternalStoreSharedOptions & {
     readonly adapters?:
       | {
@@ -142,9 +120,9 @@ const withCloudThreadSession = (
     resume: _resume,
     session: _session,
     ...options
-  }: EveAgentOptions,
+  }: UseEveAgentOptions,
   sessionId: string | undefined,
-): EveAgentOptions =>
+): UseEveAgentOptions =>
   sessionId === undefined
     ? options
     : {
@@ -193,7 +171,6 @@ const useEveThreadRuntime = (
     cloudThread.sessionId === undefined;
 
   const { onError, onEvent, onFinish, onSessionChange } = agentOptions;
-  const lastFinishStatusRef = useRef<UseEveAgentStatus | null>(null);
   const agent = useEveAgent({
     ...(cloudThread
       ? withCloudThreadSession(agentOptions, cloudThread.sessionId)
@@ -221,7 +198,6 @@ const useEveThreadRuntime = (
         }
       : {}),
     onFinish: (snapshot) => {
-      lastFinishStatusRef.current = snapshot.status;
       void invokeUserCallback(
         "assistant-ui/eve",
         "onFinish",
@@ -253,11 +229,6 @@ const useEveThreadRuntime = (
         }
       : {}),
   });
-  if (cloudThread && !("resume" in agent)) {
-    throw new Error(
-      "useEveAgentRuntime needs eve 0.44.1 or later for `cloud`, because opening a cloud thread resumes its session.",
-    );
-  }
   const runtimeAdapters = useRuntimeAdapters();
   const [toolStatuses, setToolStatuses] = useState<
     Record<string, ToolExecutionStatus>
@@ -277,7 +248,10 @@ const useEveThreadRuntime = (
     (status) => status?.type === "executing",
   );
   const providerIsRunning =
-    agent.status === "submitted" || agent.status === "streaming";
+    agent.status === "busy" ||
+    (agent.status !== "resuming" &&
+      activeTurn(agent.view) !== undefined &&
+      !idle(agent.view));
   const isRunning = providerIsRunning || hasExecutingTools;
 
   // Kept apart from the message memo so events that teach no timestamp keep
@@ -299,34 +273,41 @@ const useEveThreadRuntime = (
 
   const convertedMessages = useMemo(() => {
     const createdAtByMessageId = createdAtByMessageIdRef.current;
-    const messageIds = new Set(
-      agent.data.messages.map((message) => message.id),
-    );
+    const messageIds = new Set(agent.messages.map((message) => message.id));
     for (const messageId of createdAtByMessageId.keys()) {
       if (!messageIds.has(messageId)) createdAtByMessageId.delete(messageId);
     }
 
-    return convertEveMessages(agent.data, {
-      isRunning,
-      error: agent.error,
-      events: interruptionEvents,
-      getCreatedAt: (message) => {
-        const turnId = message.metadata?.turnId;
-        const durable =
-          turnId === undefined
-            ? undefined
-            : turnTimestamps.get(turnId)?.[message.role];
-        if (durable !== undefined) return durable;
-
-        const existing = createdAtByMessageId.get(message.id);
-        if (existing) return existing;
-
-        const createdAt = new Date();
-        createdAtByMessageId.set(message.id, createdAt);
-        return createdAt;
+    return convertEveMessages(
+      { messages: agent.messages },
+      {
+        isRunning,
+        error: agent.error,
+        events: interruptionEvents,
+        getCreatedAt: (message) => {
+          const turnId = message.metadata?.turnId;
+          const durable =
+            turnId === undefined
+              ? undefined
+              : turnTimestamps.get(turnId)?.[message.role];
+          if (durable !== undefined) return durable;
+
+          const existing = createdAtByMessageId.get(message.id);
+          if (existing) return existing;
+
+          const createdAt = new Date();
+          createdAtByMessageId.set(message.id, createdAt);
+          return createdAt;
+        },
       },
-    });
-  }, [agent.data, agent.error, interruptionEvents, isRunning, turnTimestamps]);
+    );
+  }, [
+    agent.messages,
+    agent.error,
+    interruptionEvents,
+    isRunning,
+    turnTimestamps,
+  ]);
 
   const messages = stagedMessages ?? convertedMessages;
   const messagesRef = useRef(messages);
@@ -338,10 +319,11 @@ const useEveThreadRuntime = (
     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
-  // link is exactly an active turn; chaining every dispatch serializes them
-  // without watching status.
+  // Eve commands resolve on acceptance, so each dispatch also waits for its
+  // delivery to settle; a pending chain link is exactly an unsettled turn, and
+  // chaining every dispatch serializes them without watching status.
+  const deliveryReadsRef = useRef(new AbortController());
+  const lastDeliveryFailedRef = useRef(false);
   const sendChainRef = useRef<Promise<void>>(Promise.resolve());
   const sendEpochRef = useRef(0);
   // A cancel drops the queued send but keeps its draft for a later promotion;
@@ -354,6 +336,22 @@ const useEveThreadRuntime = (
     null,
   );
 
+  const settleDelivery = async (pending: Promise<Delivery>) => {
+    const signal = deliveryReadsRef.current.signal;
+    const receipt = await pending;
+    try {
+      const result = await receipt.result({ signal });
+      if (!signal.aborted) {
+        lastDeliveryFailedRef.current = result.status === "failed";
+      }
+    } catch (error) {
+      // Only a reset aborts these reads, and the delivery already reached the
+      // old session, so it settles instead of handing its draft back.
+      if (signal.aborted) return;
+      throw error;
+    }
+  };
+
   const enqueueSend = useCallback(
     (
       dispatch: () => Promise<void>,
@@ -371,10 +369,9 @@ const useEveThreadRuntime = (
     [],
   );
 
-  // The store outlives the component (useEveAgent holds it in a ref with no
-  // cleanup), so queued sends must not fire server turns after unmount. The
-  // flag separates that teardown from a user cancel, and is re-armed in setup
-  // for a remounted tree.
+  // Queued sends must not fire server turns after unmount. The flag separates
+  // that teardown from a user cancel, and is re-armed in setup for a remounted
+  // tree.
   useEffect(() => {
     isMountedRef.current = true;
     return () => {
@@ -390,12 +387,12 @@ const useEveThreadRuntime = (
     [],
   );
 
-  // A replay rides the send chain because `resume()` rejects during a turn and upstream refuses sends while it runs; the reset counter keeps a cancel from dropping a refetch, and the hook's own replay on mount joins this one since upstream shares concurrent `resume()` calls.
+  // A replay rides the send chain so it waits for the active turn to settle; the reset counter keeps a cancel from dropping a refetch, and the hook's own replay on mount joins this one since upstream shares concurrent `resume()` calls.
   const enqueueResume = useCallback(
     () =>
       enqueueSend(async () => {
         const live = agentRef.current;
-        if (live.session === undefined || !("resume" in live)) return;
+        if (live.session === undefined) return;
         await live.resume();
       }, resetEpochRef),
     [enqueueSend],
@@ -468,15 +465,17 @@ const useEveThreadRuntime = (
     runtimeRef.current?.thread.unstable_notifySessionReset();
     // Sends parked behind an active turn captured the pre-reset epoch, so the
     // epoch has to advance before the session is torn down or they dispatch
-    // into the new one; `lastFinishStatusRef` is run-scoped for the same
-    // reason.
+    // into the new one.
     sendEpochRef.current += 1;
     resetEpochRef.current += 1;
-    lastFinishStatusRef.current = null;
+    lastDeliveryFailedRef.current = false;
+    deliveryReadsRef.current.abort();
+    deliveryReadsRef.current = new AbortController();
+    sendChainRef.current = Promise.resolve();
     setStagedMessages(null);
     stagedInputsRef.current.clear();
     setToolStatuses({});
-    agent.reset();
+    agent.newSession();
   }, [agent, aui, cloudThread]);
 
   const extras = useMemo(
@@ -522,9 +521,11 @@ const useEveThreadRuntime = (
       }
       try {
         await enqueueSend(() =>
-          agent.send(
-            getEveMessageContent(message),
-            toEveSendOptions(message.runConfig),
+          settleDelivery(
+            agent.send(
+              getEveMessageContent(message),
+              toEveSendOptions(message.runConfig),
+            ),
           ),
         );
       } catch (error) {
@@ -563,9 +564,11 @@ const useEveThreadRuntime = (
                   : input.runConfig;
               try {
                 await enqueueSend(() =>
-                  agent.send(
-                    getEveMessageContent(input.message),
-                    toEveSendOptions(runConfig),
+                  settleDelivery(
+                    agent.send(
+                      getEveMessageContent(input.message),
+                      toEveSendOptions(runConfig),
+                    ),
                   ),
                 );
               } catch (error) {
@@ -579,47 +582,31 @@ const useEveThreadRuntime = (
                 if (isDroppedSend(error)) return;
                 throw error;
               }
-              if (lastFinishStatusRef.current === "error") return;
+              if (lastDeliveryFailedRef.current) return;
             }
           },
         }
       : {}),
     onCancel: async () => {
       sendEpochRef.current += 1;
-      // 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();
-      }
+      await agent.cancel();
     },
-    // 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: () =>
-            enqueueResume().catch((error) => {
-              if (isDroppedSend(error)) return;
-              throw error;
-            }),
-        }
-      : {}),
+    onRefetchThread: () =>
+      enqueueResume().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(
+      // Eve resolves an interaction the moment any answer 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
+      // interaction stays answerable; the mapper's error reaches the caller as
+      // the seam's rejection.
+      const answer = toEveInputResponse(
         response,
-        findEveInputRequest(agent.data, response.approvalId),
+        findEveInputRequest(agent, response.approvalId),
       );
-      return enqueueSend(() => agent.respond([inputResponse])).catch(
+      return enqueueSend(() => settleDelivery(agent.respond([answer]))).catch(
         (error) => {
           if (!isDroppedSend(error)) throw error;
         },
@@ -655,7 +642,7 @@ const useEveCloudRuntime = (
  * Connects Eve's `useEveAgent` hook to assistant-ui's runtime contract.
  *
  * The runtime renders Eve messages, forwards new user messages to the Eve
- * session, supports cancellation, and maps Eve input requests to assistant-ui
+ * session, supports cancellation, and maps Eve interactions to assistant-ui
  * tool approval UI.
  */
 export const useEveAgentRuntime = (options: UseEveAgentRuntimeOptions = {}) => {