agents 0.0.0-295f4dd → 0.0.0-29938d4

package/dist/ai-react.d.ts

@@ -1,22 +1,64 @@
-import "./context-_sPQqJWv.js";
-import "./client-C_M5uPrn.js";
-import "./mcp-CzbSsLfc.js";
-import "./do-oauth-client-provider-B-ryFIPr.js";
-import "./index-CyDpAVHZ.js";
-import "./ai-types-D_hTbf25.js";
-import "./index-DUnsVDnf.js";
-import "./serializable-C4GLimgv.js";
-import "./client-ClORm6f0.js";
-import { r as useAgent } from "./react-DIGWa87z.js";
+import "./context-DcbQ8o7k.js";
+import "./client-DFotUKH_.js";
+import "./ai-types-0OnT3FHg.js";
+import "./index-CT2tCrLr.js";
+import "./client-CdM5I962.js";
+import { useAgent } from "./react.js";
+import { ChatInit, JSONSchema7, Tool, UIMessage } from "ai";
 import { UseChatOptions, useChat } from "@ai-sdk/react";
-import { ChatInit, UIMessage } from "ai";
 
 //#region src/ai-react.d.ts
+/**
+ * JSON Schema type for tool parameters.
+ * Re-exported from the AI SDK for convenience.
+ * @deprecated Import JSONSchema7 directly from "ai" instead.
+ */
+type JSONSchemaType = JSONSchema7;
+/**
+ * Definition for a tool that can be executed on the client.
+ * Tools with an `execute` function are automatically registered with the server.
+ *
+ * Note: Uses `parameters` (JSONSchema7) rather than AI SDK's `inputSchema` (FlexibleSchema)
+ * because client tools must be serializable for the wire format. Zod schemas cannot be
+ * serialized, so we require raw JSON Schema here.
+ */
 type AITool<Input = unknown, Output = unknown> = {
-  description?: string;
-  inputSchema?: unknown;
+  /** Human-readable description of what the tool does */
+  description?: Tool["description"];
+  /** JSON Schema defining the tool's input parameters */
+  parameters?: JSONSchema7;
+  /**
+   * @deprecated Use `parameters` instead. Will be removed in a future version.
+   */
+  inputSchema?: JSONSchema7;
+  /**
+   * Function to execute the tool on the client.
+   * If provided, the tool schema is automatically sent to the server.
+   */
   execute?: (input: Input) => Output | Promise<Output>;
 };
+/**
+ * Schema for a client tool sent to the server.
+ * This is the wire format - what gets sent in the request body.
+ * Must match the server-side ClientToolSchema type in ai-chat-agent.ts.
+ */
+type ClientToolSchema = {
+  /** Unique name for the tool */
+  name: string;
+  /** Human-readable description of what the tool does */
+  description?: Tool["description"];
+  /** JSON Schema defining the tool's input parameters */
+  parameters?: JSONSchema7;
+};
+/**
+ * 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
+ */
+declare function extractClientToolSchemas(
+  tools?: Record<string, AITool<unknown, unknown>>
+): ClientToolSchema[] | undefined;
 type GetInitialMessagesOptions = {
   agent: string;
   name: string;
@@ -24,6 +66,47 @@ type GetInitialMessagesOptions = {
 };
 type UseChatParams<M extends UIMessage = UIMessage> = ChatInit<M> &
   UseChatOptions<M>;
+/**
+ * Options for preparing the send messages request.
+ * Used by prepareSendMessagesRequest callback.
+ */
+type PrepareSendMessagesRequestOptions<
+  ChatMessage extends UIMessage = UIMessage
+> = {
+  /** The chat ID */
+  id: string;
+  /** Messages to send */
+  messages: ChatMessage[];
+  /** What triggered this request */
+  trigger: "submit-message" | "regenerate-message";
+  /** ID of the message being sent (if applicable) */
+  messageId?: string;
+  /** Request metadata */
+  requestMetadata?: unknown;
+  /** Current body (if any) */
+  body?: Record<string, unknown>;
+  /** Current credentials (if any) */
+  credentials?: RequestCredentials;
+  /** Current headers (if any) */
+  headers?: HeadersInit;
+  /** API endpoint */
+  api?: string;
+};
+/**
+ * Return type for prepareSendMessagesRequest callback.
+ * Allows customizing headers, body, and credentials for each request.
+ * All fields are optional; only specify what you need to customize.
+ */
+type PrepareSendMessagesRequestResult = {
+  /** Custom headers to send with the request */
+  headers?: HeadersInit;
+  /** Custom body data to merge with the request */
+  body?: Record<string, unknown>;
+  /** Custom credentials option */
+  credentials?: RequestCredentials;
+  /** Custom API endpoint */
+  api?: string;
+};
 /**
  * Options for the useAgentChat hook
  */
@@ -47,18 +130,33 @@ type UseAgentChatOptions<
    */
   experimental_automaticToolResolution?: boolean;
   /**
-   * @description Tools object for automatic detection of confirmation requirements.
-   * Tools without execute function will require confirmation.
+   * Tools that can be executed on the client.
    */
   tools?: Record<string, AITool<unknown, unknown>>;
   /**
    * @description Manual override for tools requiring confirmation.
-   * If not provided, will auto-detect from tools object.
+   * If not provided, will auto-detect from tools object (tools without execute require confirmation).
    */
   toolsRequiringConfirmation?: string[];
+  /**
+   * When true, the server automatically continues the conversation after
+   * receiving client-side tool results, similar to how server-executed tools
+   * work with maxSteps in streamText. The continuation is merged into the
+   * same assistant message.
+   *
+   * When false (default), the client calls sendMessage() after tool results
+   * to continue the conversation, which creates a new assistant message.
+   *
+   * @default false
+   */
+  autoContinueAfterToolResult?: boolean;
   /**
    * When true (default), automatically sends the next message only after
    * all pending confirmation-required tool calls have been resolved.
+   * When false, sends immediately after each tool result.
+   *
+   * Only applies when `autoContinueAfterToolResult` is false.
+   *
    * @default true
    */
   autoSendAfterAllConfirmationsResolved?: boolean;
@@ -67,6 +165,18 @@ type UseAgentChatOptions<
    * @default true
    */
   resume?: boolean;
+  /**
+   * Callback to customize the request before sending messages.
+   * Use this for advanced scenarios like adding custom headers or dynamic context.
+   *
+   * Note: Client tool schemas are automatically sent when tools have `execute` functions.
+   * This callback can add additional data alongside the auto-extracted schemas.
+   */
+  prepareSendMessagesRequest?: (
+    options: PrepareSendMessagesRequestOptions<ChatMessage>
+  ) =>
+    | PrepareSendMessagesRequestResult
+    | Promise<PrepareSendMessagesRequestResult>;
 };
 /**
  * React hook for building AI chat interfaces using an Agent
@@ -91,5 +201,14 @@ declare function useAgentChat<
   clearHistory: () => void;
 };
 //#endregion
-export { AITool, detectToolsRequiringConfirmation, useAgentChat };
+export {
+  AITool,
+  ClientToolSchema,
+  JSONSchemaType,
+  PrepareSendMessagesRequestOptions,
+  PrepareSendMessagesRequestResult,
+  detectToolsRequiringConfirmation,
+  extractClientToolSchemas,
+  useAgentChat
+};
 //# sourceMappingURL=ai-react.d.ts.map

package/dist/ai-react.js

@@ -1,10 +1,28 @@
-import { t as MessageType } from "./ai-types-CwgHzwUb.js";
+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 { DefaultChatTransport, getToolName, isToolUIPart } from "ai";
-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,7 +40,7 @@ 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, resume = 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");
@@ -142,12 +160,45 @@ 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 () => null
 	}), [agentUrlString, aiFetch]);
@@ -158,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 {
@@ -175,37 +230,65 @@ 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.
@@ -237,6 +320,25 @@ function useAgentChat(options) {
 				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;
@@ -252,11 +354,24 @@ function useAgentChat(options) {
 					break;
 				case MessageType.CF_AGENT_USE_CHAT_RESPONSE: {
 					if (localRequestIdsRef.current.has(data.id)) return;
-					if (!activeStreamRef.current || activeStreamRef.current.id !== data.id) activeStreamRef.current = {
-						id: data.id,
-						messageId: nanoid(),
-						parts: []
-					};
+					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);
@@ -332,14 +447,16 @@ function useAgentChat(options) {
 									input: chunkData.input
 								});
 								break;
-							case "tool-output-available": {
-								const toolPart = activeMsg.parts.find((p) => "toolCallId" in p && p.toolCallId === chunkData.toolCallId);
-								if (toolPart && "state" in toolPart) {
-									toolPart.state = "output-available";
-									toolPart.output = chunkData.output;
-								}
+							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;
@@ -379,25 +496,71 @@ function useAgentChat(options) {
 	]);
 	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) => {
@@ -411,5 +574,5 @@ function useAgentChat(options) {
 }
 
 //#endregion
-export { detectToolsRequiringConfirmation, useAgentChat };
+export { detectToolsRequiringConfirmation, extractClientToolSchemas, useAgentChat };
 //# sourceMappingURL=ai-react.js.map