@assistant-ui/eve 0.0.13 → 0.0.15

package/src/useEveAgentRuntime.ts

@@ -1,6 +1,6 @@
 "use client";
 
-import { useEffect, useMemo, useRef, useState } from "react";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import {
   fromThreadMessageLike,
   generateId,
@@ -26,12 +26,13 @@ import {
   type UseEveAgentOptions,
   type UseEveAgentStatus,
 } from "eve/react";
-import type { SendTurnPayload } from "eve/client";
 import {
   convertEveMessages,
+  findEveInputRequest,
   getEveMessageContent,
   toEveInputResponse,
 } from "./convertEveMessages";
+import { eveExtras } from "./eveExtras";
 
 const USER_STAGED_STATUS = {
   type: "complete",
@@ -83,22 +84,35 @@ 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
  * the assistant-ui envelope would surface a literal `"custom"` key in the
  * prompt and to every eve-side handler.
  */
-const toEveClientContext = (
+const toEveSendOptions = (
   runConfig: AppendMessage["runConfig"],
-): Pick<SendTurnPayload, "clientContext"> =>
+): { readonly clientContext: EveClientContext } | undefined =>
   hasRunConfig(runConfig)
-    ? {
-        clientContext: runConfig.custom as NonNullable<
-          SendTurnPayload["clientContext"]
-        >,
-      }
-    : {};
+    ? { clientContext: runConfig.custom as EveClientContext }
+    : undefined;
 
 export type UseEveAgentRuntimeOptions = Omit<
   UseEveAgentOptions<EveMessageData>,
@@ -186,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;
@@ -217,21 +230,34 @@ 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` rejects while a turn is in flight and only
-  // resolves once the turn's stream parks, so a pending chain link is exactly
-  // an active turn; chaining every send serializes them without watching
-  // status.
+  // 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.
   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;
+  // only a reset discards the draft with the session, so the two need separate
+  // 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 = (payload: Parameters<typeof agent.send>[0]) => {
-    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;
-      return agent.send(payload);
+      if (!isMountedRef.current) throw sendAbandonedError;
+      if (epoch !== epochRef.current) throw sendCancelledError;
+      return dispatch();
     });
     sendChainRef.current = next.catch(() => {});
     return next;
@@ -290,10 +316,37 @@ export const useEveAgentRuntime = (options: UseEveAgentRuntimeOptions = {}) => {
     setStagedMessages(nextMessages);
   };
 
-  return useExternalStoreRuntime({
+  const reset = useCallback(() => {
+    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.
+    sendEpochRef.current += 1;
+    resetEpochRef.current += 1;
+    lastFinishStatusRef.current = null;
+    setStagedMessages(null);
+    stagedInputsRef.current.clear();
+    setToolStatuses({});
+    agent.reset();
+  }, [agent]);
+
+  const extras = useMemo(
+    () =>
+      eveExtras.provide({
+        error: agent.error,
+        events: agent.events,
+        session: agent.session,
+        reset,
+      }),
+    [agent.error, agent.events, agent.session, reset],
+  );
+
+  const runtime = useExternalStoreRuntime({
     ...pickExternalStoreSharedOptions(options),
     messages,
-    isRunning,
+    isRunning: providerIsRunning,
+    extras,
     unstable_enableToolInvocations: true,
     setToolStatuses,
     adapters: {
@@ -309,10 +362,12 @@ export const useEveAgentRuntime = (options: UseEveAgentRuntimeOptions = {}) => {
         return;
       }
       try {
-        await enqueueSend({
-          message: getEveMessageContent(message),
-          ...toEveClientContext(message.runConfig),
-        });
+        await enqueueSend(() =>
+          agent.send(
+            getEveMessageContent(message),
+            toEveSendOptions(message.runConfig),
+          ),
+        );
       } catch (error) {
         // A cancelled send never reached the session, so it rethrows for the
         // composer to take the draft back; an unmounted one has no composer
@@ -328,6 +383,7 @@ export const useEveAgentRuntime = (options: UseEveAgentRuntimeOptions = {}) => {
             if (!stagedRun)
               throw new Error("Runtime does not support reloading messages.");
             const epoch = sendEpochRef.current;
+            const resetEpoch = resetEpochRef.current;
             for (const { message: stagedMessage, input } of stagedRun) {
               if (epoch !== sendEpochRef.current) return;
               const previousMessages = messagesRef.current;
@@ -347,11 +403,17 @@ export const useEveAgentRuntime = (options: UseEveAgentRuntimeOptions = {}) => {
                   ? config.runConfig
                   : input.runConfig;
               try {
-                await enqueueSend({
-                  message: getEveMessageContent(input.message),
-                  ...toEveClientContext(runConfig),
-                });
+                await enqueueSend(() =>
+                  agent.send(
+                    getEveMessageContent(input.message),
+                    toEveSendOptions(runConfig),
+                  ),
+                );
               } catch (error) {
+                // A reset discarded the draft along with the session, so
+                // restoring it here would refloat a message the thread no
+                // longer has. A cancel still restores.
+                if (resetEpoch !== resetEpochRef.current) return;
                 stagedInputsRef.current.set(stagedMessage.id, input);
                 messagesRef.current = previousMessages;
                 setStagedMessages(previousMessages);
@@ -363,17 +425,61 @@ export const useEveAgentRuntime = (options: UseEveAgentRuntimeOptions = {}) => {
           },
         }
       : {}),
-    onCancel: () => {
+    onCancel: async () => {
       sendEpochRef.current += 1;
-      agent.stop();
-      return Promise.resolve();
-    },
-    onRespondToToolApproval: async (response) => {
-      try {
-        await enqueueSend({ inputResponses: [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;
+
+  return runtime;
 };