agents 0.0.0-2cc0f02 → 0.0.0-2e73791

package/dist/ai-react.js

@@ -1,10 +1,28 @@
-import { MessageType } from "./ai-types-B0GBFDwi.js";
-import { nanoid } from "nanoid";
+import { t as MessageType } from "./ai-types-DEtF_8Km.js";
 import { DefaultChatTransport, getToolName, isToolUIPart } from "ai";
+import { nanoid } from "nanoid";
 import { useChat } from "@ai-sdk/react";
-import { use, useCallback, useEffect, useMemo, useRef } from "react";
+import { use, useCallback, useEffect, useMemo, useRef, useState } from "react";
 
 //#region src/ai-react.tsx
+/**
+* Extracts tool schemas from tools that have client-side execute functions.
+* These schemas are automatically sent to the server with each request.
+* @param tools - Record of tool name to tool definition
+* @returns Array of tool schemas to send to server, or undefined if none
+*/
+function extractClientToolSchemas(tools) {
+	if (!tools) return void 0;
+	const schemas = Object.entries(tools).filter(([_, tool$1]) => tool$1.execute).map(([name, tool$1]) => {
+		if (tool$1.inputSchema && !tool$1.parameters) console.warn(`[useAgentChat] Tool "${name}" uses deprecated 'inputSchema'. Please migrate to 'parameters'.`);
+		return {
+			name,
+			description: tool$1.description,
+			parameters: tool$1.parameters ?? tool$1.inputSchema
+		};
+	});
+	return schemas.length > 0 ? schemas : void 0;
+}
 const requestCache = /* @__PURE__ */ new Map();
 /**
 * React hook for building AI chat interfaces using an Agent
@@ -22,11 +40,12 @@ function detectToolsRequiringConfirmation(tools) {
 	return Object.entries(tools).filter(([_name, tool$1]) => !tool$1.execute).map(([name]) => name);
 }
 function useAgentChat(options) {
-	const { agent, getInitialMessages, messages: optionsInitialMessages, experimental_automaticToolResolution, tools, toolsRequiringConfirmation: manualToolsRequiringConfirmation, autoSendAfterAllConfirmationsResolved = true,...rest } = options;
+	const { agent, getInitialMessages, messages: optionsInitialMessages, experimental_automaticToolResolution, tools, toolsRequiringConfirmation: manualToolsRequiringConfirmation, autoContinueAfterToolResult = false, autoSendAfterAllConfirmationsResolved = true, resume = true, prepareSendMessagesRequest, ...rest } = options;
 	const toolsRequiringConfirmation = manualToolsRequiringConfirmation ?? detectToolsRequiringConfirmation(tools);
 	const agentUrl = new URL(`${(agent._url || agent._pkurl)?.replace("ws://", "http://").replace("wss://", "https://")}`);
 	agentUrl.searchParams.delete("_pk");
 	const agentUrlString = agentUrl.toString();
+	const initialMessagesCacheKey = `${agentUrlString}|${agent.agent ?? ""}|${agent.name ?? ""}`;
 	const agentRef = useRef(agent);
 	useEffect(() => {
 		agentRef.current = agent;
@@ -52,38 +71,42 @@ function useAgentChat(options) {
 		}
 	}
 	const getInitialMessagesFetch = getInitialMessages || defaultGetInitialMessagesFetch;
-	function doGetInitialMessages(getInitialMessagesOptions) {
-		if (requestCache.has(agentUrlString)) return requestCache.get(agentUrlString);
+	function doGetInitialMessages(getInitialMessagesOptions, cacheKey) {
+		if (requestCache.has(cacheKey)) return requestCache.get(cacheKey);
 		const promise = getInitialMessagesFetch(getInitialMessagesOptions);
-		requestCache.set(agentUrlString, promise);
+		requestCache.set(cacheKey, promise);
 		return promise;
 	}
 	const initialMessagesPromise = getInitialMessages === null ? null : doGetInitialMessages({
 		agent: agent.agent,
 		name: agent.name,
 		url: agentUrlString
-	});
+	}, initialMessagesCacheKey);
 	const initialMessages = initialMessagesPromise ? use(initialMessagesPromise) : optionsInitialMessages ?? [];
 	useEffect(() => {
 		if (!initialMessagesPromise) return;
-		requestCache.set(agentUrlString, initialMessagesPromise);
+		requestCache.set(initialMessagesCacheKey, initialMessagesPromise);
 		return () => {
-			if (requestCache.get(agentUrlString) === initialMessagesPromise) requestCache.delete(agentUrlString);
+			if (requestCache.get(initialMessagesCacheKey) === initialMessagesPromise) requestCache.delete(initialMessagesCacheKey);
 		};
-	}, [agentUrlString, initialMessagesPromise]);
+	}, [initialMessagesCacheKey, initialMessagesPromise]);
 	const aiFetch = useCallback(async (request, options$1 = {}) => {
 		const { method, keepalive, headers, body, redirect, integrity, signal, credentials, mode, referrer, referrerPolicy, window } = options$1;
 		const id = nanoid(8);
 		const abortController = new AbortController();
 		let controller;
 		const currentAgent = agentRef.current;
+		localRequestIdsRef.current.add(id);
 		signal?.addEventListener("abort", () => {
 			currentAgent.send(JSON.stringify({
 				id,
 				type: MessageType.CF_AGENT_CHAT_REQUEST_CANCEL
 			}));
 			abortController.abort();
-			controller.close();
+			try {
+				controller.close();
+			} catch {}
+			localRequestIdsRef.current.delete(id);
 		});
 		currentAgent.addEventListener("message", (event) => {
 			let data;
@@ -96,18 +119,27 @@ function useAgentChat(options) {
 				if (data.id === id) if (data.error) {
 					controller.error(new Error(data.body));
 					abortController.abort();
+					localRequestIdsRef.current.delete(id);
 				} else {
 					if (data.body?.trim()) controller.enqueue(new TextEncoder().encode(`data: ${data.body}\n\n`));
 					if (data.done) {
-						controller.close();
+						try {
+							controller.close();
+						} catch {}
 						abortController.abort();
+						localRequestIdsRef.current.delete(id);
 					}
 				}
 			}
 		}, { signal: abortController.signal });
-		const stream = new ReadableStream({ start(c) {
-			controller = c;
-		} });
+		const stream = new ReadableStream({
+			start(c) {
+				controller = c;
+			},
+			cancel(reason) {
+				console.warn("[agents/ai-react] cancelling stream", id, reason || "no reason");
+			}
+		});
 		currentAgent.send(JSON.stringify({
 			id,
 			init: {
@@ -128,19 +160,47 @@ function useAgentChat(options) {
 		}));
 		return new Response(stream);
 	}, []);
+	const toolsRef = useRef(tools);
+	toolsRef.current = tools;
+	const prepareSendMessagesRequestRef = useRef(prepareSendMessagesRequest);
+	prepareSendMessagesRequestRef.current = prepareSendMessagesRequest;
 	const customTransport = useMemo(() => ({
-		sendMessages: async (options$1) => {
+		sendMessages: async (sendMessageOptions) => {
+			const clientToolSchemas = extractClientToolSchemas(toolsRef.current);
 			return new DefaultChatTransport({
 				api: agentUrlString,
-				fetch: aiFetch
-			}).sendMessages(options$1);
+				fetch: aiFetch,
+				prepareSendMessagesRequest: clientToolSchemas || prepareSendMessagesRequestRef.current ? async (prepareOptions) => {
+					let body = {};
+					let headers;
+					let credentials;
+					let api;
+					if (clientToolSchemas) body = {
+						id: prepareOptions.id,
+						messages: prepareOptions.messages,
+						trigger: prepareOptions.trigger,
+						clientTools: clientToolSchemas
+					};
+					if (prepareSendMessagesRequestRef.current) {
+						const userResult = await prepareSendMessagesRequestRef.current(prepareOptions);
+						headers = userResult.headers;
+						credentials = userResult.credentials;
+						api = userResult.api;
+						body = {
+							...body,
+							...userResult.body ?? {}
+						};
+					}
+					return {
+						body,
+						headers,
+						credentials,
+						api
+					};
+				} : void 0
+			}).sendMessages(sendMessageOptions);
 		},
-		reconnectToStream: async (options$1) => {
-			return new DefaultChatTransport({
-				api: agentUrlString,
-				fetch: aiFetch
-			}).reconnectToStream(options$1);
-		}
+		reconnectToStream: async () => null
 	}), [agentUrlString, aiFetch]);
 	const useChatHelpers = useChat({
 		...rest,
@@ -149,6 +209,10 @@ function useAgentChat(options) {
 		id: agent._pk
 	});
 	const processedToolCalls = useRef(/* @__PURE__ */ new Set());
+	const isResolvingToolsRef = useRef(false);
+	const [clientToolResults, setClientToolResults] = useState(/* @__PURE__ */ new Map());
+	const messagesRef = useRef(useChatHelpers.messages);
+	messagesRef.current = useChatHelpers.messages;
 	const lastMessage = useChatHelpers.messages[useChatHelpers.messages.length - 1];
 	const pendingConfirmations = (() => {
 		if (!lastMessage || lastMessage.role !== "assistant") return {
@@ -166,40 +230,82 @@ function useAgentChat(options) {
 	pendingConfirmationsRef.current = pendingConfirmations;
 	useEffect(() => {
 		if (!experimental_automaticToolResolution) return;
+		if (isResolvingToolsRef.current) return;
 		const lastMessage$1 = useChatHelpers.messages[useChatHelpers.messages.length - 1];
 		if (!lastMessage$1 || lastMessage$1.role !== "assistant") return;
 		const toolCalls = lastMessage$1.parts.filter((part) => isToolUIPart(part) && part.state === "input-available" && !processedToolCalls.current.has(part.toolCallId));
-		if (toolCalls.length > 0) (async () => {
-			const toolCallsToResolve = toolCalls.filter((part) => isToolUIPart(part) && !toolsRequiringConfirmation.includes(getToolName(part)) && tools?.[getToolName(part)]?.execute);
+		if (toolCalls.length > 0) {
+			const currentTools = toolsRef.current;
+			const toolCallsToResolve = toolCalls.filter((part) => isToolUIPart(part) && !toolsRequiringConfirmation.includes(getToolName(part)) && currentTools?.[getToolName(part)]?.execute);
 			if (toolCallsToResolve.length > 0) {
-				for (const part of toolCallsToResolve) if (isToolUIPart(part)) {
-					processedToolCalls.current.add(part.toolCallId);
-					let toolOutput = null;
-					const toolName = getToolName(part);
-					const tool$1 = tools?.[toolName];
-					if (tool$1?.execute && part.input) try {
-						toolOutput = await tool$1.execute(part.input);
-					} catch (error) {
-						toolOutput = `Error executing tool: ${error instanceof Error ? error.message : String(error)}`;
+				isResolvingToolsRef.current = true;
+				(async () => {
+					try {
+						const toolResults = [];
+						for (const part of toolCallsToResolve) if (isToolUIPart(part)) {
+							let toolOutput = null;
+							const toolName = getToolName(part);
+							const tool$1 = currentTools?.[toolName];
+							if (tool$1?.execute && part.input !== void 0) try {
+								toolOutput = await tool$1.execute(part.input);
+							} catch (error) {
+								toolOutput = `Error executing tool: ${error instanceof Error ? error.message : String(error)}`;
+							}
+							processedToolCalls.current.add(part.toolCallId);
+							toolResults.push({
+								toolCallId: part.toolCallId,
+								toolName,
+								output: toolOutput
+							});
+						}
+						if (toolResults.length > 0) {
+							for (const result of toolResults) agentRef.current.send(JSON.stringify({
+								type: MessageType.CF_AGENT_TOOL_RESULT,
+								toolCallId: result.toolCallId,
+								toolName: result.toolName,
+								output: result.output,
+								autoContinue: autoContinueAfterToolResult
+							}));
+							await Promise.all(toolResults.map((result) => useChatHelpers.addToolResult({
+								tool: result.toolName,
+								toolCallId: result.toolCallId,
+								output: result.output
+							})));
+							setClientToolResults((prev) => {
+								const newMap = new Map(prev);
+								for (const result of toolResults) newMap.set(result.toolCallId, result.output);
+								return newMap;
+							});
+						}
+					} finally {
+						isResolvingToolsRef.current = false;
 					}
-					await useChatHelpers.addToolResult({
-						toolCallId: part.toolCallId,
-						tool: toolName,
-						output: toolOutput
-					});
-				}
-				if (pendingConfirmationsRef.current.toolCallIds.size === 0) useChatHelpers.sendMessage();
+				})();
 			}
-		})();
+		}
 	}, [
 		useChatHelpers.messages,
 		experimental_automaticToolResolution,
 		useChatHelpers.addToolResult,
-		useChatHelpers.sendMessage,
-		toolsRequiringConfirmation
+		toolsRequiringConfirmation,
+		autoContinueAfterToolResult
 	]);
+	/**
+	* Contains the request ID, accumulated message parts, and a unique message ID.
+	* Used for both resumed streams and real-time broadcasts from other tabs.
+	*/
+	const activeStreamRef = useRef(null);
+	/**
+	* Tracks request IDs initiated by this tab via aiFetch.
+	* Used to distinguish local requests from broadcasts.
+	*/
+	const localRequestIdsRef = useRef(/* @__PURE__ */ new Set());
 	useEffect(() => {
-		function onClearHistory(event) {
+		/**
+		* Unified message handler that parses JSON once and dispatches based on type.
+		* Avoids duplicate parsing overhead from separate listeners.
+		*/
+		function onAgentMessage(event) {
 			if (typeof event.data !== "string") return;
 			let data;
 			try {
@@ -207,46 +313,254 @@ function useAgentChat(options) {
 			} catch (_error) {
 				return;
 			}
-			if (data.type === MessageType.CF_AGENT_CHAT_CLEAR) useChatHelpers.setMessages([]);
-		}
-		function onMessages(event) {
-			if (typeof event.data !== "string") return;
-			let data;
-			try {
-				data = JSON.parse(event.data);
-			} catch (_error) {
-				return;
+			switch (data.type) {
+				case MessageType.CF_AGENT_CHAT_CLEAR:
+					useChatHelpers.setMessages([]);
+					break;
+				case MessageType.CF_AGENT_CHAT_MESSAGES:
+					useChatHelpers.setMessages(data.messages);
+					break;
+				case MessageType.CF_AGENT_MESSAGE_UPDATED:
+					useChatHelpers.setMessages((prevMessages) => {
+						const updatedMessage = data.message;
+						let idx = prevMessages.findIndex((m) => m.id === updatedMessage.id);
+						if (idx < 0) {
+							const updatedToolCallIds = new Set(updatedMessage.parts.filter((p) => "toolCallId" in p && p.toolCallId).map((p) => p.toolCallId));
+							if (updatedToolCallIds.size > 0) idx = prevMessages.findIndex((m) => m.parts.some((p) => "toolCallId" in p && updatedToolCallIds.has(p.toolCallId)));
+						}
+						if (idx >= 0) {
+							const updated = [...prevMessages];
+							updated[idx] = {
+								...updatedMessage,
+								id: prevMessages[idx].id
+							};
+							return updated;
+						}
+						return [...prevMessages, updatedMessage];
+					});
+					break;
+				case MessageType.CF_AGENT_STREAM_RESUMING:
+					if (!resume) return;
+					activeStreamRef.current = null;
+					activeStreamRef.current = {
+						id: data.id,
+						messageId: nanoid(),
+						parts: []
+					};
+					agentRef.current.send(JSON.stringify({
+						type: MessageType.CF_AGENT_STREAM_RESUME_ACK,
+						id: data.id
+					}));
+					break;
+				case MessageType.CF_AGENT_USE_CHAT_RESPONSE: {
+					if (localRequestIdsRef.current.has(data.id)) return;
+					const isContinuation = data.continuation === true;
+					if (!activeStreamRef.current || activeStreamRef.current.id !== data.id) {
+						let messageId = nanoid();
+						let existingParts = [];
+						if (isContinuation) {
+							const currentMessages = messagesRef.current;
+							for (let i = currentMessages.length - 1; i >= 0; i--) if (currentMessages[i].role === "assistant") {
+								messageId = currentMessages[i].id;
+								existingParts = [...currentMessages[i].parts];
+								break;
+							}
+						}
+						activeStreamRef.current = {
+							id: data.id,
+							messageId,
+							parts: existingParts
+						};
+					}
+					const activeMsg = activeStreamRef.current;
+					if (data.body?.trim()) try {
+						const chunkData = JSON.parse(data.body);
+						switch (chunkData.type) {
+							case "text-start":
+								activeMsg.parts.push({
+									type: "text",
+									text: "",
+									state: "streaming"
+								});
+								break;
+							case "text-delta": {
+								const lastTextPart = [...activeMsg.parts].reverse().find((p) => p.type === "text");
+								if (lastTextPart && lastTextPart.type === "text") lastTextPart.text += chunkData.delta;
+								else activeMsg.parts.push({
+									type: "text",
+									text: chunkData.delta
+								});
+								break;
+							}
+							case "text-end": {
+								const lastTextPart = [...activeMsg.parts].reverse().find((p) => p.type === "text");
+								if (lastTextPart && "state" in lastTextPart) lastTextPart.state = "done";
+								break;
+							}
+							case "reasoning-start":
+								activeMsg.parts.push({
+									type: "reasoning",
+									text: "",
+									state: "streaming"
+								});
+								break;
+							case "reasoning-delta": {
+								const lastReasoningPart = [...activeMsg.parts].reverse().find((p) => p.type === "reasoning");
+								if (lastReasoningPart && lastReasoningPart.type === "reasoning") lastReasoningPart.text += chunkData.delta;
+								break;
+							}
+							case "reasoning-end": {
+								const lastReasoningPart = [...activeMsg.parts].reverse().find((p) => p.type === "reasoning");
+								if (lastReasoningPart && "state" in lastReasoningPart) lastReasoningPart.state = "done";
+								break;
+							}
+							case "file":
+								activeMsg.parts.push({
+									type: "file",
+									mediaType: chunkData.mediaType,
+									url: chunkData.url
+								});
+								break;
+							case "source-url":
+								activeMsg.parts.push({
+									type: "source-url",
+									sourceId: chunkData.sourceId,
+									url: chunkData.url,
+									title: chunkData.title
+								});
+								break;
+							case "source-document":
+								activeMsg.parts.push({
+									type: "source-document",
+									sourceId: chunkData.sourceId,
+									mediaType: chunkData.mediaType,
+									title: chunkData.title,
+									filename: chunkData.filename
+								});
+								break;
+							case "tool-input-available":
+								activeMsg.parts.push({
+									type: `tool-${chunkData.toolName}`,
+									toolCallId: chunkData.toolCallId,
+									toolName: chunkData.toolName,
+									state: "input-available",
+									input: chunkData.input
+								});
+								break;
+							case "tool-output-available":
+								activeMsg.parts = activeMsg.parts.map((p) => {
+									if ("toolCallId" in p && p.toolCallId === chunkData.toolCallId && "state" in p) return {
+										...p,
+										state: "output-available",
+										output: chunkData.output
+									};
+									return p;
+								});
+								break;
+							case "step-start":
+								activeMsg.parts.push({ type: "step-start" });
+								break;
+						}
+						useChatHelpers.setMessages((prevMessages) => {
+							if (!activeMsg) return prevMessages;
+							const existingIdx = prevMessages.findIndex((m) => m.id === activeMsg.messageId);
+							const partialMessage = {
+								id: activeMsg.messageId,
+								role: "assistant",
+								parts: [...activeMsg.parts]
+							};
+							if (existingIdx >= 0) {
+								const updated = [...prevMessages];
+								updated[existingIdx] = partialMessage;
+								return updated;
+							}
+							return [...prevMessages, partialMessage];
+						});
+					} catch (parseError) {
+						console.warn("[useAgentChat] Failed to parse stream chunk:", parseError instanceof Error ? parseError.message : parseError, "body:", data.body?.slice(0, 100));
+					}
+					if (data.done || data.error) activeStreamRef.current = null;
+					break;
+				}
 			}
-			if (data.type === MessageType.CF_AGENT_CHAT_MESSAGES) useChatHelpers.setMessages(data.messages);
 		}
-		agent.addEventListener("message", onClearHistory);
-		agent.addEventListener("message", onMessages);
+		agent.addEventListener("message", onAgentMessage);
 		return () => {
-			agent.removeEventListener("message", onClearHistory);
-			agent.removeEventListener("message", onMessages);
+			agent.removeEventListener("message", onAgentMessage);
+			activeStreamRef.current = null;
 		};
-	}, [agent, useChatHelpers.setMessages]);
+	}, [
+		agent,
+		useChatHelpers.setMessages,
+		resume
+	]);
 	const addToolResultAndSendMessage = async (args) => {
 		const { toolCallId } = args;
-		await useChatHelpers.addToolResult(args);
-		if (!autoSendAfterAllConfirmationsResolved) {
-			useChatHelpers.sendMessage();
-			return;
-		}
-		const pending = pendingConfirmationsRef.current?.toolCallIds;
-		if (!pending) {
-			useChatHelpers.sendMessage();
-			return;
+		const toolName = "tool" in args ? args.tool : "";
+		const output = "output" in args ? args.output : void 0;
+		agentRef.current.send(JSON.stringify({
+			type: MessageType.CF_AGENT_TOOL_RESULT,
+			toolCallId,
+			toolName,
+			output,
+			autoContinue: autoContinueAfterToolResult
+		}));
+		setClientToolResults((prev) => new Map(prev).set(toolCallId, output));
+		useChatHelpers.addToolResult(args);
+		if (!autoContinueAfterToolResult) {
+			if (!autoSendAfterAllConfirmationsResolved) {
+				useChatHelpers.sendMessage();
+				return;
+			}
+			const pending = pendingConfirmationsRef.current?.toolCallIds;
+			if (!pending) {
+				useChatHelpers.sendMessage();
+				return;
+			}
+			const wasLast = pending.size === 1 && pending.has(toolCallId);
+			if (pending.has(toolCallId)) pending.delete(toolCallId);
+			if (wasLast || pending.size === 0) useChatHelpers.sendMessage();
 		}
-		const wasLast = pending.size === 1 && pending.has(toolCallId);
-		if (pending.has(toolCallId)) pending.delete(toolCallId);
-		if (wasLast || pending.size === 0) useChatHelpers.sendMessage();
 	};
+	const messagesWithToolResults = useMemo(() => {
+		if (clientToolResults.size === 0) return useChatHelpers.messages;
+		return useChatHelpers.messages.map((msg) => ({
+			...msg,
+			parts: msg.parts.map((p) => {
+				if (!("toolCallId" in p) || !("state" in p) || p.state !== "input-available" || !clientToolResults.has(p.toolCallId)) return p;
+				return {
+					...p,
+					state: "output-available",
+					output: clientToolResults.get(p.toolCallId)
+				};
+			})
+		}));
+	}, [useChatHelpers.messages, clientToolResults]);
+	useEffect(() => {
+		const currentToolCallIds = /* @__PURE__ */ new Set();
+		for (const msg of useChatHelpers.messages) for (const part of msg.parts) if ("toolCallId" in part && part.toolCallId) currentToolCallIds.add(part.toolCallId);
+		setClientToolResults((prev) => {
+			if (prev.size === 0) return prev;
+			let hasStaleEntries = false;
+			for (const toolCallId of prev.keys()) if (!currentToolCallIds.has(toolCallId)) {
+				hasStaleEntries = true;
+				break;
+			}
+			if (!hasStaleEntries) return prev;
+			const newMap = /* @__PURE__ */ new Map();
+			for (const [id, output] of prev) if (currentToolCallIds.has(id)) newMap.set(id, output);
+			return newMap;
+		});
+		for (const toolCallId of processedToolCalls.current) if (!currentToolCallIds.has(toolCallId)) processedToolCalls.current.delete(toolCallId);
+	}, [useChatHelpers.messages]);
 	return {
 		...useChatHelpers,
+		messages: messagesWithToolResults,
 		addToolResult: addToolResultAndSendMessage,
 		clearHistory: () => {
 			useChatHelpers.setMessages([]);
+			setClientToolResults(/* @__PURE__ */ new Map());
+			processedToolCalls.current.clear();
 			agent.send(JSON.stringify({ type: MessageType.CF_AGENT_CHAT_CLEAR }));
 		},
 		setMessages: (messages) => {
@@ -260,5 +574,5 @@ function useAgentChat(options) {
 }
 
 //#endregion
-export { detectToolsRequiringConfirmation, useAgentChat };
+export { detectToolsRequiringConfirmation, extractClientToolSchemas, useAgentChat };
 //# sourceMappingURL=ai-react.js.map