@assistant-ui/eve 0.0.8 → 0.0.10

package/dist/useEveAgentRuntime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useEveAgentRuntime.d.ts","names":[],"sources":["../src/useEveAgentRuntime.ts"],"mappings":";;;KAqCY,4BAA4B,KACtC,mBAAmB,8BAGnB;WACW;aAEM,cAAc;aACd,SAAS;aACT,YAAY;aACZ,QAAQ;aACR,WAAW;;;;;;;;;;cAYjB,qBAAsB,UAAS,2DAA8B"}
+{"version":3,"file":"useEveAgentRuntime.d.ts","names":[],"sources":["../src/useEveAgentRuntime.ts"],"mappings":";;;KAiEY,4BAA4B,KACtC,mBAAmB,8BAGnB;WACW;aAEM,cAAc;aACd,SAAS;aACT,YAAY;aACZ,QAAQ;aACR,WAAW;;;;;;;;;;cAYjB,qBAAsB,UAAS,2DAA8B"}

package/dist/useEveAgentRuntime.js

@@ -9,6 +9,15 @@ const USER_STAGED_STATUS = {
 	type: "complete",
 	reason: "unknown"
 };
+const sendCancelledError = /* @__PURE__ */ new Error("eve send was dropped because the run was cancelled.");
+const hasRunConfig = (runConfig) => runConfig?.custom !== void 0 && Object.keys(runConfig.custom).length > 0;
+/**
+* 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 = (runConfig) => hasRunConfig(runConfig) ? { clientContext: runConfig.custom } : {};
 /**
 * Connects Eve's `useEveAgent` hook to assistant-ui's runtime contract.
 *
@@ -18,7 +27,15 @@ const USER_STAGED_STATUS = {
 */
 const useEveAgentRuntime = (options = {}) => {
 	const { adapters, isDisabled: _isDisabled, isSendDisabled: _isSendDisabled, suggestions: _suggestions, unstable_capabilities: _unstable_capabilities, ...agentOptions } = options;
-	const agent = useEveAgent(agentOptions);
+	const { onFinish } = agentOptions;
+	const lastFinishStatusRef = useRef(null);
+	const agent = useEveAgent({
+		...agentOptions,
+		onFinish: (snapshot) => {
+			lastFinishStatusRef.current = snapshot.status;
+			onFinish?.(snapshot);
+		}
+	});
 	const runtimeAdapters = useRuntimeAdapters();
 	const [toolStatuses, setToolStatuses] = useState({});
 	const [stagedMessages, setStagedMessages] = useState(null);
@@ -49,6 +66,22 @@ const useEveAgentRuntime = (options = {}) => {
 	const messages = stagedMessages ?? convertedMessages;
 	const messagesRef = useRef(messages);
 	messagesRef.current = messages;
+	const sendChainRef = useRef(Promise.resolve());
+	const sendEpochRef = useRef(0);
+	const enqueueSend = (payload) => {
+		const epoch = sendEpochRef.current;
+		const next = sendChainRef.current.then(() => {
+			if (epoch !== sendEpochRef.current) throw sendCancelledError;
+			return agent.send(payload);
+		});
+		sendChainRef.current = next.catch(() => {});
+		return next;
+	};
+	useEffect(() => {
+		return () => {
+			sendEpochRef.current += 1;
+		};
+	}, []);
 	useEffect(() => {
 		if (stagedInputsRef.current.size === 0) return;
 		const baseIds = new Set(convertedMessages.map((message) => message.id));
@@ -96,33 +129,53 @@ const useEveAgentRuntime = (options = {}) => {
 				stageUserMessage(message);
 				return;
 			}
-			await agent.send({ message: getEveMessageContent(message) });
+			try {
+				await enqueueSend({
+					message: getEveMessageContent(message),
+					...toEveClientContext(message.runConfig)
+				});
+			} catch (error) {
+				if (error !== sendCancelledError) throw error;
+			}
 		},
-		...stagedMessages ? { onReload: async (parentId) => {
+		...stagedMessages ? { onReload: async (parentId, config) => {
 			const stagedRun = getStagedRun(parentId);
 			if (!stagedRun) throw new Error("Runtime does not support reloading messages.");
+			const epoch = sendEpochRef.current;
 			for (const { message: stagedMessage, input } of stagedRun) {
+				if (epoch !== sendEpochRef.current) return;
 				const previousMessages = messagesRef.current;
 				stagedInputsRef.current.delete(stagedMessage.id);
 				const nextMessages = previousMessages.filter((message) => message.id !== stagedMessage.id);
 				messagesRef.current = nextMessages;
 				setStagedMessages(stagedInputsRef.current.size > 0 ? nextMessages : null);
+				const runConfig = stagedMessage.id === parentId && hasRunConfig(config.runConfig) ? config.runConfig : input.runConfig;
 				try {
-					await agent.send({ message: getEveMessageContent(input.message) });
+					await enqueueSend({
+						message: getEveMessageContent(input.message),
+						...toEveClientContext(runConfig)
+					});
 				} catch (error) {
 					stagedInputsRef.current.set(stagedMessage.id, input);
 					messagesRef.current = previousMessages;
 					setStagedMessages(previousMessages);
+					if (error === sendCancelledError) return;
 					throw error;
 				}
+				if (lastFinishStatusRef.current === "error") return;
 			}
 		} } : {},
 		onCancel: () => {
+			sendEpochRef.current += 1;
 			agent.stop();
 			return Promise.resolve();
 		},
 		onRespondToToolApproval: async (response) => {
-			await agent.send({ inputResponses: [toEveInputResponse(response)] });
+			try {
+				await enqueueSend({ inputResponses: [toEveInputResponse(response)] });
+			} catch (error) {
+				if (error !== sendCancelledError) throw error;
+			}
 		}
 	});
 };

package/dist/useEveAgentRuntime.js.map

@@ -1 +1 @@
-{"version":3,"file":"useEveAgentRuntime.js","names":[],"sources":["../src/useEveAgentRuntime.ts"],"sourcesContent":["\"use client\";\n\nimport { useEffect, useMemo, useRef, useState } from \"react\";\nimport {\n  fromThreadMessageLike,\n  generateId,\n  pickExternalStoreSharedOptions,\n  type AppendMessage,\n  type AttachmentAdapter,\n  type DictationAdapter,\n  type ExternalStoreSharedOptions,\n  type FeedbackAdapter,\n  type RealtimeVoiceAdapter,\n  type SpeechSynthesisAdapter,\n  type ThreadMessage,\n  type ToolExecutionStatus,\n} from \"@assistant-ui/core\";\nimport {\n  useExternalStoreRuntime,\n  useRuntimeAdapters,\n} from \"@assistant-ui/core/react\";\nimport {\n  useEveAgent,\n  type EveMessageData,\n  type UseEveAgentOptions,\n} from \"eve/react\";\nimport {\n  convertEveMessages,\n  getEveMessageContent,\n  toEveInputResponse,\n} from \"./convertEveMessages\";\n\nconst USER_STAGED_STATUS = {\n  type: \"complete\",\n  reason: \"unknown\",\n} as const;\n\nexport type UseEveAgentRuntimeOptions = Omit<\n  UseEveAgentOptions<EveMessageData>,\n  \"reducer\"\n> &\n  ExternalStoreSharedOptions & {\n    readonly adapters?:\n      | {\n          readonly attachments?: AttachmentAdapter | undefined;\n          readonly speech?: SpeechSynthesisAdapter | undefined;\n          readonly dictation?: DictationAdapter | undefined;\n          readonly voice?: RealtimeVoiceAdapter | undefined;\n          readonly feedback?: FeedbackAdapter | undefined;\n        }\n      | undefined;\n  };\n\n/**\n * Connects Eve's `useEveAgent` hook to assistant-ui's runtime contract.\n *\n * The runtime renders Eve messages, forwards new user messages to the Eve\n * session, supports cancellation, and maps Eve input requests to assistant-ui\n * tool approval UI.\n */\nexport const useEveAgentRuntime = (options: UseEveAgentRuntimeOptions = {}) => {\n  const {\n    adapters,\n    isDisabled: _isDisabled,\n    isSendDisabled: _isSendDisabled,\n    suggestions: _suggestions,\n    unstable_capabilities: _unstable_capabilities,\n    ...agentOptions\n  } = options;\n  true satisfies keyof typeof agentOptions &\n    keyof ExternalStoreSharedOptions extends never\n    ? true\n    : never;\n\n  const agent = useEveAgent(agentOptions);\n  const runtimeAdapters = useRuntimeAdapters();\n  const [toolStatuses, setToolStatuses] = useState<\n    Record<string, ToolExecutionStatus>\n  >({});\n  const [stagedMessages, setStagedMessages] = useState<ThreadMessage[] | null>(\n    null,\n  );\n  const createdAtByMessageIdRef = useRef(new Map<string, Date>());\n  const stagedInputsRef = useRef(\n    new Map<\n      string,\n      { message: AppendMessage; runConfig: AppendMessage[\"runConfig\"] }\n    >(),\n  );\n\n  const hasExecutingTools = Object.values(toolStatuses).some(\n    (status) => status?.type === \"executing\",\n  );\n  const isRunning =\n    agent.status === \"submitted\" ||\n    agent.status === \"streaming\" ||\n    hasExecutingTools;\n\n  const convertedMessages = useMemo(() => {\n    const createdAtByMessageId = createdAtByMessageIdRef.current;\n    const messageIds = new Set(\n      agent.data.messages.map((message) => message.id),\n    );\n    for (const messageId of createdAtByMessageId.keys()) {\n      if (!messageIds.has(messageId)) createdAtByMessageId.delete(messageId);\n    }\n\n    return convertEveMessages(agent.data, {\n      isRunning,\n      error: agent.error,\n      getCreatedAt: (message) => {\n        const existing = createdAtByMessageId.get(message.id);\n        if (existing) return existing;\n\n        const createdAt = new Date();\n        createdAtByMessageId.set(message.id, createdAt);\n        return createdAt;\n      },\n    });\n  }, [agent.data, agent.error, isRunning]);\n\n  const messages = stagedMessages ?? convertedMessages;\n  const messagesRef = useRef(messages);\n  messagesRef.current = messages;\n\n  useEffect(() => {\n    if (stagedInputsRef.current.size === 0) return;\n    const baseIds = new Set(convertedMessages.map((message) => message.id));\n    const remaining = messagesRef.current.filter(\n      (message) =>\n        stagedInputsRef.current.has(message.id) && !baseIds.has(message.id),\n    );\n    setStagedMessages(\n      remaining.length > 0 ? [...convertedMessages, ...remaining] : null,\n    );\n  }, [convertedMessages]);\n\n  const getStagedRun = (parentId: string | null) => {\n    if (!parentId || !stagedInputsRef.current.has(parentId)) return null;\n    const staged: {\n      message: ThreadMessage;\n      input: { message: AppendMessage; runConfig: AppendMessage[\"runConfig\"] };\n    }[] = [];\n    for (const message of messagesRef.current) {\n      const input = stagedInputsRef.current.get(message.id);\n      if (input) staged.push({ message, input });\n      if (message.id === parentId) break;\n    }\n    return staged;\n  };\n\n  const stageUserMessage = (message: AppendMessage) => {\n    const threadMessage = fromThreadMessageLike(\n      message,\n      generateId(),\n      USER_STAGED_STATUS,\n    );\n    stagedInputsRef.current.set(threadMessage.id, {\n      message,\n      runConfig: message.runConfig,\n    });\n    const nextMessages = [...messagesRef.current, threadMessage];\n    messagesRef.current = nextMessages;\n    setStagedMessages(nextMessages);\n  };\n\n  return useExternalStoreRuntime({\n    ...pickExternalStoreSharedOptions(options),\n    messages,\n    isRunning,\n    unstable_enableToolInvocations: true,\n    setToolStatuses,\n    adapters: {\n      attachments: adapters?.attachments ?? runtimeAdapters?.attachments,\n      speech: adapters?.speech,\n      dictation: adapters?.dictation,\n      voice: adapters?.voice,\n      feedback: adapters?.feedback,\n    },\n    onNew: async (message) => {\n      if (!(message.startRun ?? message.role === \"user\")) {\n        stageUserMessage(message);\n        return;\n      }\n      await agent.send({ message: getEveMessageContent(message) });\n    },\n    ...(stagedMessages\n      ? {\n          onReload: async (parentId: string | null) => {\n            const stagedRun = getStagedRun(parentId);\n            if (!stagedRun)\n              throw new Error(\"Runtime does not support reloading messages.\");\n            for (const { message: stagedMessage, input } of stagedRun) {\n              const previousMessages = messagesRef.current;\n              stagedInputsRef.current.delete(stagedMessage.id);\n              const nextMessages = previousMessages.filter(\n                (message) => message.id !== stagedMessage.id,\n              );\n              messagesRef.current = nextMessages;\n              setStagedMessages(\n                stagedInputsRef.current.size > 0 ? nextMessages : null,\n              );\n              try {\n                await agent.send({\n                  message: getEveMessageContent(input.message),\n                });\n              } catch (error) {\n                stagedInputsRef.current.set(stagedMessage.id, input);\n                messagesRef.current = previousMessages;\n                setStagedMessages(previousMessages);\n                throw error;\n              }\n            }\n          },\n        }\n      : {}),\n    onCancel: () => {\n      agent.stop();\n      return Promise.resolve();\n    },\n    onRespondToToolApproval: async (response) => {\n      await agent.send({ inputResponses: [toEveInputResponse(response)] });\n    },\n  });\n};\n"],"mappings":"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"}
+{"version":3,"file":"useEveAgentRuntime.js","names":[],"sources":["../src/useEveAgentRuntime.ts"],"sourcesContent":["\"use client\";\n\nimport { useEffect, useMemo, useRef, useState } from \"react\";\nimport {\n  fromThreadMessageLike,\n  generateId,\n  pickExternalStoreSharedOptions,\n  type AppendMessage,\n  type AttachmentAdapter,\n  type DictationAdapter,\n  type ExternalStoreSharedOptions,\n  type FeedbackAdapter,\n  type RealtimeVoiceAdapter,\n  type SpeechSynthesisAdapter,\n  type ThreadMessage,\n  type ToolExecutionStatus,\n} from \"@assistant-ui/core\";\nimport {\n  useExternalStoreRuntime,\n  useRuntimeAdapters,\n} from \"@assistant-ui/core/react\";\nimport {\n  useEveAgent,\n  type EveMessageData,\n  type UseEveAgentOptions,\n  type UseEveAgentStatus,\n} from \"eve/react\";\nimport type { SendTurnPayload } from \"eve/client\";\nimport {\n  convertEveMessages,\n  getEveMessageContent,\n  toEveInputResponse,\n} from \"./convertEveMessages\";\n\nconst USER_STAGED_STATUS = {\n  type: \"complete\",\n  reason: \"unknown\",\n} as const;\n\nconst sendCancelledError = new Error(\n  \"eve send was dropped because the run was cancelled.\",\n);\n\nconst hasRunConfig = (\n  runConfig: AppendMessage[\"runConfig\"],\n): runConfig is NonNullable<AppendMessage[\"runConfig\"]> =>\n  runConfig?.custom !== undefined && Object.keys(runConfig.custom).length > 0;\n\n/**\n * Only the `custom` bag crosses the wire. Eve reads `clientContext` as its own\n * namespace and serializes it into a model-visible context message, so sending\n * the assistant-ui envelope would surface a literal `\"custom\"` key in the\n * prompt and to every eve-side handler.\n */\nconst toEveClientContext = (\n  runConfig: AppendMessage[\"runConfig\"],\n): Pick<SendTurnPayload, \"clientContext\"> =>\n  hasRunConfig(runConfig)\n    ? {\n        clientContext: runConfig.custom as NonNullable<\n          SendTurnPayload[\"clientContext\"]\n        >,\n      }\n    : {};\n\nexport type UseEveAgentRuntimeOptions = Omit<\n  UseEveAgentOptions<EveMessageData>,\n  \"reducer\"\n> &\n  ExternalStoreSharedOptions & {\n    readonly adapters?:\n      | {\n          readonly attachments?: AttachmentAdapter | undefined;\n          readonly speech?: SpeechSynthesisAdapter | undefined;\n          readonly dictation?: DictationAdapter | undefined;\n          readonly voice?: RealtimeVoiceAdapter | undefined;\n          readonly feedback?: FeedbackAdapter | undefined;\n        }\n      | undefined;\n  };\n\n/**\n * Connects Eve's `useEveAgent` hook to assistant-ui's runtime contract.\n *\n * The runtime renders Eve messages, forwards new user messages to the Eve\n * session, supports cancellation, and maps Eve input requests to assistant-ui\n * tool approval UI.\n */\nexport const useEveAgentRuntime = (options: UseEveAgentRuntimeOptions = {}) => {\n  const {\n    adapters,\n    isDisabled: _isDisabled,\n    isSendDisabled: _isSendDisabled,\n    suggestions: _suggestions,\n    unstable_capabilities: _unstable_capabilities,\n    ...agentOptions\n  } = options;\n  true satisfies keyof typeof agentOptions &\n    keyof ExternalStoreSharedOptions extends never\n    ? true\n    : never;\n\n  const { onFinish } = agentOptions;\n  const lastFinishStatusRef = useRef<UseEveAgentStatus | null>(null);\n  const agent = useEveAgent({\n    ...agentOptions,\n    onFinish: (snapshot) => {\n      lastFinishStatusRef.current = snapshot.status;\n      onFinish?.(snapshot);\n    },\n  });\n  const runtimeAdapters = useRuntimeAdapters();\n  const [toolStatuses, setToolStatuses] = useState<\n    Record<string, ToolExecutionStatus>\n  >({});\n  const [stagedMessages, setStagedMessages] = useState<ThreadMessage[] | null>(\n    null,\n  );\n  const createdAtByMessageIdRef = useRef(new Map<string, Date>());\n  const stagedInputsRef = useRef(\n    new Map<\n      string,\n      { message: AppendMessage; runConfig: AppendMessage[\"runConfig\"] }\n    >(),\n  );\n\n  const hasExecutingTools = Object.values(toolStatuses).some(\n    (status) => status?.type === \"executing\",\n  );\n  const isRunning =\n    agent.status === \"submitted\" ||\n    agent.status === \"streaming\" ||\n    hasExecutingTools;\n\n  const convertedMessages = useMemo(() => {\n    const createdAtByMessageId = createdAtByMessageIdRef.current;\n    const messageIds = new Set(\n      agent.data.messages.map((message) => message.id),\n    );\n    for (const messageId of createdAtByMessageId.keys()) {\n      if (!messageIds.has(messageId)) createdAtByMessageId.delete(messageId);\n    }\n\n    return convertEveMessages(agent.data, {\n      isRunning,\n      error: agent.error,\n      getCreatedAt: (message) => {\n        const existing = createdAtByMessageId.get(message.id);\n        if (existing) return existing;\n\n        const createdAt = new Date();\n        createdAtByMessageId.set(message.id, createdAt);\n        return createdAt;\n      },\n    });\n  }, [agent.data, agent.error, isRunning]);\n\n  const messages = stagedMessages ?? convertedMessages;\n  const messagesRef = useRef(messages);\n  messagesRef.current = messages;\n\n  // Upstream `EveAgentStore.send` rejects while a turn is in flight and only\n  // resolves once the turn's stream parks, so a pending chain link is exactly\n  // an active turn; chaining every send serializes them without watching\n  // status.\n  const sendChainRef = useRef<Promise<void>>(Promise.resolve());\n  const sendEpochRef = useRef(0);\n\n  const enqueueSend = (payload: Parameters<typeof agent.send>[0]) => {\n    const epoch = sendEpochRef.current;\n    const next = sendChainRef.current.then(() => {\n      if (epoch !== sendEpochRef.current) throw sendCancelledError;\n      return agent.send(payload);\n    });\n    sendChainRef.current = next.catch(() => {});\n    return next;\n  };\n\n  // The store outlives the component (useEveAgent holds it in a ref with no\n  // cleanup), so queued sends must not fire server turns after unmount.\n  useEffect(() => {\n    return () => {\n      sendEpochRef.current += 1;\n    };\n  }, []);\n\n  useEffect(() => {\n    if (stagedInputsRef.current.size === 0) return;\n    const baseIds = new Set(convertedMessages.map((message) => message.id));\n    const remaining = messagesRef.current.filter(\n      (message) =>\n        stagedInputsRef.current.has(message.id) && !baseIds.has(message.id),\n    );\n    setStagedMessages(\n      remaining.length > 0 ? [...convertedMessages, ...remaining] : null,\n    );\n  }, [convertedMessages]);\n\n  const getStagedRun = (parentId: string | null) => {\n    if (!parentId || !stagedInputsRef.current.has(parentId)) return null;\n    const staged: {\n      message: ThreadMessage;\n      input: { message: AppendMessage; runConfig: AppendMessage[\"runConfig\"] };\n    }[] = [];\n    for (const message of messagesRef.current) {\n      const input = stagedInputsRef.current.get(message.id);\n      if (input) staged.push({ message, input });\n      if (message.id === parentId) break;\n    }\n    return staged;\n  };\n\n  const stageUserMessage = (message: AppendMessage) => {\n    const threadMessage = fromThreadMessageLike(\n      message,\n      generateId(),\n      USER_STAGED_STATUS,\n    );\n    stagedInputsRef.current.set(threadMessage.id, {\n      message,\n      runConfig: message.runConfig,\n    });\n    const nextMessages = [...messagesRef.current, threadMessage];\n    messagesRef.current = nextMessages;\n    setStagedMessages(nextMessages);\n  };\n\n  return useExternalStoreRuntime({\n    ...pickExternalStoreSharedOptions(options),\n    messages,\n    isRunning,\n    unstable_enableToolInvocations: true,\n    setToolStatuses,\n    adapters: {\n      attachments: adapters?.attachments ?? runtimeAdapters?.attachments,\n      speech: adapters?.speech,\n      dictation: adapters?.dictation,\n      voice: adapters?.voice,\n      feedback: adapters?.feedback,\n    },\n    onNew: async (message) => {\n      if (!(message.startRun ?? message.role === \"user\")) {\n        stageUserMessage(message);\n        return;\n      }\n      try {\n        await enqueueSend({\n          message: getEveMessageContent(message),\n          ...toEveClientContext(message.runConfig),\n        });\n      } catch (error) {\n        if (error !== sendCancelledError) throw error;\n      }\n    },\n    ...(stagedMessages\n      ? {\n          onReload: async (parentId: string | null, config) => {\n            const stagedRun = getStagedRun(parentId);\n            if (!stagedRun)\n              throw new Error(\"Runtime does not support reloading messages.\");\n            const epoch = sendEpochRef.current;\n            for (const { message: stagedMessage, input } of stagedRun) {\n              if (epoch !== sendEpochRef.current) return;\n              const previousMessages = messagesRef.current;\n              stagedInputsRef.current.delete(stagedMessage.id);\n              const nextMessages = previousMessages.filter(\n                (message) => message.id !== stagedMessage.id,\n              );\n              messagesRef.current = nextMessages;\n              setStagedMessages(\n                stagedInputsRef.current.size > 0 ? nextMessages : null,\n              );\n              // The reload config belongs to the message being reloaded; the\n              // drafts promoted ahead of it keep the config they were staged\n              // with, or reloading the tail would rewrite their context too.\n              const runConfig =\n                stagedMessage.id === parentId && hasRunConfig(config.runConfig)\n                  ? config.runConfig\n                  : input.runConfig;\n              try {\n                await enqueueSend({\n                  message: getEveMessageContent(input.message),\n                  ...toEveClientContext(runConfig),\n                });\n              } catch (error) {\n                stagedInputsRef.current.set(stagedMessage.id, input);\n                messagesRef.current = previousMessages;\n                setStagedMessages(previousMessages);\n                if (error === sendCancelledError) return;\n                throw error;\n              }\n              if (lastFinishStatusRef.current === \"error\") return;\n            }\n          },\n        }\n      : {}),\n    onCancel: () => {\n      sendEpochRef.current += 1;\n      agent.stop();\n      return Promise.resolve();\n    },\n    onRespondToToolApproval: async (response) => {\n      try {\n        await enqueueSend({ inputResponses: [toEveInputResponse(response)] });\n      } catch (error) {\n        if (error !== sendCancelledError) throw error;\n      }\n    },\n  });\n};\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@assistant-ui/eve",
-  "version": "0.0.8",
+  "version": "0.0.10",
   "description": "Eve runtime adapter for assistant-ui",
   "keywords": [
     "eve",
@@ -28,7 +28,7 @@
   ],
   "sideEffects": false,
   "dependencies": {
-    "@assistant-ui/core": "^0.3.6"
+    "@assistant-ui/core": "^0.3.8"
   },
   "peerDependencies": {
     "@types/react": "*",

package/src/useEveAgentRuntime.test.tsx

@@ -90,6 +90,180 @@ describe("useEveAgentRuntime status forwarding", () => {
     });
   });
 
+  it("forwards runConfig to eve as one-turn client context when sending", async () => {
+    const agent = createAgent({
+      data: { messages: [] } satisfies EveMessageData,
+    });
+    mockUseEveAgent.mockReturnValue(agent as never);
+
+    const { result } = renderHook(() => useEveAgentRuntime());
+
+    act(() => {
+      result.current.thread.append({
+        role: "user",
+        content: [{ type: "text", text: "hello" }],
+        runConfig: { custom: { page: "/pricing" } },
+      });
+    });
+
+    await waitFor(() => {
+      expect(agent.send).toHaveBeenCalledWith({
+        message: "hello",
+        clientContext: { page: "/pricing" },
+      });
+    });
+  });
+
+  it("omits clientContext when no runConfig is provided", async () => {
+    const agent = createAgent({
+      data: { messages: [] } satisfies EveMessageData,
+    });
+    mockUseEveAgent.mockReturnValue(agent as never);
+
+    const { result } = renderHook(() => useEveAgentRuntime());
+
+    act(() => {
+      result.current.thread.append({
+        role: "user",
+        content: [{ type: "text", text: "hello" }],
+      });
+    });
+
+    await waitFor(() => {
+      expect(agent.send).toHaveBeenCalledWith({ message: "hello" });
+    });
+  });
+
+  it("omits clientContext when runConfig.custom is empty", async () => {
+    const agent = createAgent({
+      data: { messages: [] } satisfies EveMessageData,
+    });
+    mockUseEveAgent.mockReturnValue(agent as never);
+
+    const { result } = renderHook(() => useEveAgentRuntime());
+
+    act(() => {
+      result.current.thread.append({
+        role: "user",
+        content: [{ type: "text", text: "hello" }],
+        runConfig: { custom: {} },
+      });
+    });
+
+    await waitFor(() => {
+      expect(agent.send).toHaveBeenCalledWith({ message: "hello" });
+    });
+  });
+
+  it("prefers the reload-time runConfig over the staged one", async () => {
+    const agent = createAgent({
+      data: { messages: [] } satisfies EveMessageData,
+    });
+    mockUseEveAgent.mockReturnValue(agent as never);
+
+    const { result } = renderHook(() => useEveAgentRuntime());
+
+    act(() => {
+      result.current.thread.append({
+        role: "user",
+        content: [{ type: "text", text: "hello" }],
+        startRun: false,
+        runConfig: { custom: { page: "/staged" } },
+      });
+    });
+
+    await waitFor(() => {
+      expect(result.current.thread.getState().messages.length).toBe(1);
+    });
+    const stagedId = result.current.thread.getState().messages[0]!.id;
+
+    act(() => {
+      result.current.thread.startRun({
+        parentId: stagedId,
+        runConfig: { custom: { page: "/reload" } },
+      });
+    });
+
+    await waitFor(() => {
+      expect(agent.send).toHaveBeenCalledWith({
+        message: "hello",
+        clientContext: { page: "/reload" },
+      });
+    });
+  });
+
+  it("falls back to the staged runConfig when reload passes none", async () => {
+    const agent = createAgent({
+      data: { messages: [] } satisfies EveMessageData,
+    });
+    mockUseEveAgent.mockReturnValue(agent as never);
+
+    const { result } = renderHook(() => useEveAgentRuntime());
+
+    act(() => {
+      result.current.thread.append({
+        role: "user",
+        content: [{ type: "text", text: "hello" }],
+        startRun: false,
+        runConfig: { custom: { page: "/staged" } },
+      });
+    });
+
+    await waitFor(() => {
+      expect(result.current.thread.getState().messages.length).toBe(1);
+    });
+    const stagedId = result.current.thread.getState().messages[0]!.id;
+
+    act(() => {
+      result.current.thread.startRun({ parentId: stagedId });
+    });
+
+    await waitFor(() => {
+      expect(agent.send).toHaveBeenCalledWith({
+        message: "hello",
+        clientContext: { page: "/staged" },
+      });
+    });
+  });
+
+  // Known limitation: core normalizes an omitted reload runConfig to {}
+  // (toStartRunConfig in core/src/runtime/api/thread-runtime.ts), so an
+  // explicit empty reload config is indistinguishable from an omitted one at
+  // the adapter and cannot clear the staged context.
+  it("cannot clear the staged runConfig with an explicit empty reload config", async () => {
+    const agent = createAgent({
+      data: { messages: [] } satisfies EveMessageData,
+    });
+    mockUseEveAgent.mockReturnValue(agent as never);
+
+    const { result } = renderHook(() => useEveAgentRuntime());
+
+    act(() => {
+      result.current.thread.append({
+        role: "user",
+        content: [{ type: "text", text: "hello" }],
+        startRun: false,
+        runConfig: { custom: { page: "/staged" } },
+      });
+    });
+
+    await waitFor(() => {
+      expect(result.current.thread.getState().messages.length).toBe(1);
+    });
+    const stagedId = result.current.thread.getState().messages[0]!.id;
+
+    act(() => {
+      result.current.thread.startRun({ parentId: stagedId, runConfig: {} });
+    });
+
+    await waitFor(() => {
+      expect(agent.send).toHaveBeenCalledWith({
+        message: "hello",
+        clientContext: { page: "/staged" },
+      });
+    });
+  });
+
   it("keeps the last assistant message running while streaming", () => {
     mockUseEveAgent.mockReturnValue(
       createAgent({ status: "streaming" }) as never,
@@ -284,6 +458,46 @@ describe("useEveAgentRuntime staged messages", () => {
     });
   });
 
+  it("applies the reload runConfig only to the message being reloaded", async () => {
+    const agent = createAgent({ data: settledData });
+    mockUseEveAgent.mockReturnValue(agent as never);
+    const { result } = renderHook(() => useEveAgentRuntime());
+
+    const stageWithConfig = async (text: string, page: string) => {
+      await act(async () => {
+        result.current.thread.append({
+          role: "user",
+          content: [{ type: "text", text }],
+          startRun: false,
+          runConfig: { custom: { page } },
+        });
+      });
+    };
+
+    await stageWithConfig("first staged", "/first");
+    await stageWithConfig("second staged", "/second");
+
+    const secondStagedId = result.current.thread.getState().messages[3]!.id;
+    await act(async () => {
+      await result.current.thread.startRun({
+        parentId: secondStagedId,
+        sourceId: null,
+        runConfig: { custom: { page: "/reloaded" } },
+      });
+    });
+
+    // 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",
+      clientContext: { page: "/first" },
+    });
+    expect(agent.send).toHaveBeenNthCalledWith(2, {
+      message: "second staged",
+      clientContext: { page: "/reloaded" },
+    });
+  });
+
   it("keeps later staged messages visible after promoting one staged parent", async () => {
     const agent = createAgent({ data: settledData });
     mockUseEveAgent.mockReturnValue(agent as never);
@@ -387,6 +601,88 @@ describe("useEveAgentRuntime staged messages", () => {
     });
   });
 
+  it("stops promoting once a promoted turn parks with an error status", async () => {
+    let capturedOptions: {
+      onFinish?: (snapshot: { status: string }) => void;
+    } = {};
+    const send = vi.fn().mockImplementation(async () => {
+      capturedOptions.onFinish?.({ status: "error" });
+    });
+    const agent = createAgent({ data: settledData, send });
+    mockUseEveAgent.mockImplementation((options) => {
+      capturedOptions = options as typeof capturedOptions;
+      return agent as never;
+    });
+    const { result } = renderHook(() => useEveAgentRuntime());
+
+    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(1);
+    expect(send).toHaveBeenCalledWith({ message: "first staged" });
+    await waitFor(() => {
+      expect(getText(result.current)).toEqual([
+        "earlier",
+        "earlier answer",
+        "second staged",
+      ]);
+    });
+  });
+
+  it("stops promoting when the run is cancelled mid-prefix", 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 stageMessage(result.current, "first staged");
+    await stageMessage(result.current, "second staged");
+
+    const secondStagedId = result.current.thread.getState().messages[3]!.id;
+    act(() => {
+      void result.current.thread.startRun({
+        parentId: secondStagedId,
+        sourceId: null,
+        runConfig: {},
+      });
+    });
+    await waitFor(() => expect(send).toHaveBeenCalledTimes(1));
+
+    act(() => {
+      result.current.thread.cancelRun();
+    });
+    await act(async () => {
+      resolveFirstSend();
+    });
+
+    expect(send).toHaveBeenCalledTimes(1);
+    await waitFor(() => {
+      expect(getText(result.current)).toEqual([
+        "earlier",
+        "earlier answer",
+        "second staged",
+      ]);
+    });
+  });
+
   it("still rejects reloading a non-staged message", async () => {
     const agent = createAgent({ data: settledData });
     mockUseEveAgent.mockReturnValue(agent as never);
@@ -406,3 +702,261 @@ describe("useEveAgentRuntime staged messages", () => {
     expect(agent.send).not.toHaveBeenCalled();
   });
 });
+
+const approvalData: EveMessageData = {
+  messages: [
+    { id: "u1", role: "user", parts: [{ type: "text", text: "send it" }] },
+    {
+      id: "a1",
+      role: "assistant",
+      parts: [
+        {
+          type: "dynamic-tool",
+          state: "approval-requested",
+          toolCallId: "call_1",
+          toolName: "send_email",
+          input: { to: "dev@example.com" },
+          approval: { id: "req_1" },
+          toolMetadata: {
+            eve: {
+              kind: "tool-call",
+              name: "send_email",
+              inputRequest: {
+                requestId: "req_1",
+                prompt: "Send the email?",
+                display: "confirmation",
+                options: [
+                  { id: "approve", label: "Approve" },
+                  { id: "deny", label: "Deny" },
+                ],
+              },
+            },
+          },
+        },
+      ],
+    },
+  ],
+};
+
+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 });
+    mockUseEveAgent.mockReturnValue(agent as never);
+    const { result } = renderHook(() => useEveAgentRuntime());
+
+    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" });
+    });
+    expect(send).toHaveBeenCalledTimes(1);
+
+    await act(async () => {
+      resolveFirstSend();
+    });
+    await waitFor(() => expect(send).toHaveBeenCalledTimes(2));
+    expect(send).toHaveBeenNthCalledWith(2, {
+      inputResponses: [{ requestId: "req_1", optionId: "approve" }],
+    });
+  });
+
+  it("queues a send issued while a turn is in flight and preserves order", 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.append({
+        role: "user",
+        content: [{ type: "text", text: "second" }],
+      });
+    });
+    expect(send).toHaveBeenCalledTimes(1);
+
+    await act(async () => {
+      resolveFirstSend();
+    });
+    await waitFor(() => expect(send).toHaveBeenCalledTimes(2));
+    expect(send).toHaveBeenNthCalledWith(1, { message: "first" });
+    expect(send).toHaveBeenNthCalledWith(2, { message: "second" });
+  });
+
+  it("drops a queued send when the run is cancelled before it dispatches", 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.append({
+        role: "user",
+        content: [{ type: "text", text: "queued" }],
+      });
+    });
+    act(() => {
+      result.current.thread.cancelRun();
+    });
+    expect(agent.stop).toHaveBeenCalledTimes(1);
+
+    await act(async () => {
+      resolveFirstSend();
+    });
+    expect(send).toHaveBeenCalledTimes(1);
+  });
+
+  it("drops a queued send when the hook unmounts before it dispatches", 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, unmount } = 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" }],
+      });
+    });
+    unmount();
+
+    resolveFirstSend();
+    await Promise.resolve();
+    await Promise.resolve();
+    expect(send).toHaveBeenCalledTimes(1);
+  });
+
+  it("forwards onFinish snapshots to the caller's onFinish", () => {
+    let capturedOptions: {
+      onFinish?: (snapshot: { status: string }) => void;
+    } = {};
+    const agent = createAgent({ data: settledData });
+    mockUseEveAgent.mockImplementation((options) => {
+      capturedOptions = options as typeof capturedOptions;
+      return agent as never;
+    });
+    const onFinish = vi.fn();
+    renderHook(() => useEveAgentRuntime({ onFinish }));
+
+    capturedOptions.onFinish?.({ status: "ready" });
+
+    expect(onFinish).toHaveBeenCalledWith({ status: "ready" });
+  });
+
+  it("orders a send issued mid-promotion after the in-flight staged draft", 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 stageMessage(result.current, "first staged");
+    await stageMessage(result.current, "second staged");
+
+    const secondStagedId = result.current.thread.getState().messages[3]!.id;
+    act(() => {
+      void result.current.thread.startRun({
+        parentId: secondStagedId,
+        sourceId: null,
+        runConfig: {},
+      });
+    });
+    await waitFor(() => expect(send).toHaveBeenCalledTimes(1));
+
+    await act(async () => {
+      result.current.thread.append({
+        role: "user",
+        content: [{ type: "text", text: "interleaved" }],
+      });
+    });
+    expect(send).toHaveBeenCalledTimes(1);
+
+    await act(async () => {
+      resolveFirstSend();
+    });
+    await waitFor(() => expect(send).toHaveBeenCalledTimes(3));
+
+    expect(send.mock.calls.map(([payload]) => payload)).toEqual([
+      { message: "first staged" },
+      { message: "interleaved" },
+      { message: "second staged" },
+    ]);
+  });
+});

package/src/useEveAgentRuntime.ts

@@ -23,7 +23,9 @@ import {
   useEveAgent,
   type EveMessageData,
   type UseEveAgentOptions,
+  type UseEveAgentStatus,
 } from "eve/react";
+import type { SendTurnPayload } from "eve/client";
 import {
   convertEveMessages,
   getEveMessageContent,
@@ -35,6 +37,32 @@ const USER_STAGED_STATUS = {
   reason: "unknown",
 } as const;
 
+const sendCancelledError = new Error(
+  "eve send was dropped because the run was cancelled.",
+);
+
+const hasRunConfig = (
+  runConfig: AppendMessage["runConfig"],
+): runConfig is NonNullable<AppendMessage["runConfig"]> =>
+  runConfig?.custom !== undefined && Object.keys(runConfig.custom).length > 0;
+
+/**
+ * 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 = (
+  runConfig: AppendMessage["runConfig"],
+): Pick<SendTurnPayload, "clientContext"> =>
+  hasRunConfig(runConfig)
+    ? {
+        clientContext: runConfig.custom as NonNullable<
+          SendTurnPayload["clientContext"]
+        >,
+      }
+    : {};
+
 export type UseEveAgentRuntimeOptions = Omit<
   UseEveAgentOptions<EveMessageData>,
   "reducer"
@@ -72,7 +100,15 @@ export const useEveAgentRuntime = (options: UseEveAgentRuntimeOptions = {}) => {
     ? true
     : never;
 
-  const agent = useEveAgent(agentOptions);
+  const { onFinish } = agentOptions;
+  const lastFinishStatusRef = useRef<UseEveAgentStatus | null>(null);
+  const agent = useEveAgent({
+    ...agentOptions,
+    onFinish: (snapshot) => {
+      lastFinishStatusRef.current = snapshot.status;
+      onFinish?.(snapshot);
+    },
+  });
   const runtimeAdapters = useRuntimeAdapters();
   const [toolStatuses, setToolStatuses] = useState<
     Record<string, ToolExecutionStatus>
@@ -123,6 +159,31 @@ export const useEveAgentRuntime = (options: UseEveAgentRuntimeOptions = {}) => {
   const messagesRef = useRef(messages);
   messagesRef.current = messages;
 
+  // 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.
+  const sendChainRef = useRef<Promise<void>>(Promise.resolve());
+  const sendEpochRef = useRef(0);
+
+  const enqueueSend = (payload: Parameters<typeof agent.send>[0]) => {
+    const epoch = sendEpochRef.current;
+    const next = sendChainRef.current.then(() => {
+      if (epoch !== sendEpochRef.current) throw sendCancelledError;
+      return agent.send(payload);
+    });
+    sendChainRef.current = next.catch(() => {});
+    return next;
+  };
+
+  // The store outlives the component (useEveAgent holds it in a ref with no
+  // cleanup), so queued sends must not fire server turns after unmount.
+  useEffect(() => {
+    return () => {
+      sendEpochRef.current += 1;
+    };
+  }, []);
+
   useEffect(() => {
     if (stagedInputsRef.current.size === 0) return;
     const baseIds = new Set(convertedMessages.map((message) => message.id));
@@ -182,15 +243,24 @@ export const useEveAgentRuntime = (options: UseEveAgentRuntimeOptions = {}) => {
         stageUserMessage(message);
         return;
       }
-      await agent.send({ message: getEveMessageContent(message) });
+      try {
+        await enqueueSend({
+          message: getEveMessageContent(message),
+          ...toEveClientContext(message.runConfig),
+        });
+      } catch (error) {
+        if (error !== sendCancelledError) throw error;
+      }
     },
     ...(stagedMessages
       ? {
-          onReload: async (parentId: string | null) => {
+          onReload: async (parentId: string | null, config) => {
             const stagedRun = getStagedRun(parentId);
             if (!stagedRun)
               throw new Error("Runtime does not support reloading messages.");
+            const epoch = sendEpochRef.current;
             for (const { message: stagedMessage, input } of stagedRun) {
+              if (epoch !== sendEpochRef.current) return;
               const previousMessages = messagesRef.current;
               stagedInputsRef.current.delete(stagedMessage.id);
               const nextMessages = previousMessages.filter(
@@ -200,26 +270,41 @@ export const useEveAgentRuntime = (options: UseEveAgentRuntimeOptions = {}) => {
               setStagedMessages(
                 stagedInputsRef.current.size > 0 ? nextMessages : null,
               );
+              // The reload config belongs to the message being reloaded; the
+              // drafts promoted ahead of it keep the config they were staged
+              // with, or reloading the tail would rewrite their context too.
+              const runConfig =
+                stagedMessage.id === parentId && hasRunConfig(config.runConfig)
+                  ? config.runConfig
+                  : input.runConfig;
               try {
-                await agent.send({
+                await enqueueSend({
                   message: getEveMessageContent(input.message),
+                  ...toEveClientContext(runConfig),
                 });
               } catch (error) {
                 stagedInputsRef.current.set(stagedMessage.id, input);
                 messagesRef.current = previousMessages;
                 setStagedMessages(previousMessages);
+                if (error === sendCancelledError) return;
                 throw error;
               }
+              if (lastFinishStatusRef.current === "error") return;
             }
           },
         }
       : {}),
     onCancel: () => {
+      sendEpochRef.current += 1;
       agent.stop();
       return Promise.resolve();
     },
     onRespondToToolApproval: async (response) => {
-      await agent.send({ inputResponses: [toEveInputResponse(response)] });
+      try {
+        await enqueueSend({ inputResponses: [toEveInputResponse(response)] });
+      } catch (error) {
+        if (error !== sendCancelledError) throw error;
+      }
     },
   });
 };