agents 0.0.0-295f4dd → 0.0.0-29938d4

package/dist/ai-chat-agent.js

@@ -1,13 +1,35 @@
 import { t as agentContext } from "./context-BkKbAa1R.js";
-import { t as MessageType } from "./ai-types-CwgHzwUb.js";
-import "./client-CcyhkGfN.js";
+import { t as MessageType } from "./ai-types-DEtF_8Km.js";
+import "./client-DjTPRM8-.js";
 import "./client-QZa2Rq0l.js";
 import "./do-oauth-client-provider-B1fVIshX.js";
-import { t as Agent } from "./src-BmbDclOA.js";
-import { r as autoTransformMessages } from "./ai-chat-v5-migration-DguhuLKF.js";
+import { t as Agent } from "./src-BZDh910Z.js";
+import { autoTransformMessages } from "./ai-chat-v5-migration.js";
+import { jsonSchema, tool } from "ai";
 import { nanoid } from "nanoid";
 
 //#region src/ai-chat-agent.ts
+/**
+* Converts client tool schemas to AI SDK tool format.
+*
+* These tools have no `execute` function - when the AI model calls them,
+* the tool call is sent back to the client for execution.
+*
+* @param clientTools - Array of tool schemas from the client
+* @returns Record of AI SDK tools that can be spread into your tools object
+*/
+function createToolsFromClientSchemas(clientTools) {
+	if (!clientTools || clientTools.length === 0) return {};
+	const seenNames = /* @__PURE__ */ new Set();
+	for (const t of clientTools) {
+		if (seenNames.has(t.name)) console.warn(`[createToolsFromClientSchemas] Duplicate tool name "${t.name}" found. Later definitions will override earlier ones.`);
+		seenNames.add(t.name);
+	}
+	return Object.fromEntries(clientTools.map((t) => [t.name, tool({
+		description: t.description ?? "",
+		inputSchema: jsonSchema(t.parameters ?? { type: "object" })
+	})]));
+}
 /** Number of chunks to buffer before flushing to SQLite */
 const CHUNK_BUFFER_SIZE = 10;
 /** Maximum buffer size to prevent memory issues on rapid reconnections */
@@ -28,6 +50,9 @@ var AIChatAgent = class extends Agent {
 		super(ctx, env);
 		this._activeStreamId = null;
 		this._activeRequestId = null;
+		this._streamingMessage = null;
+		this._streamCompletionPromise = null;
+		this._streamCompletionResolve = null;
 		this._streamChunkIndex = 0;
 		this._chunkBuffer = [];
 		this._isFlushingChunks = false;
@@ -72,7 +97,7 @@ var AIChatAgent = class extends Agent {
 				}
 				if (data.type === MessageType.CF_AGENT_USE_CHAT_REQUEST && data.init.method === "POST") {
 					const { body } = data.init;
-					const { messages } = JSON.parse(body);
+					const { messages, clientTools } = JSON.parse(body);
 					const transformedMessages = autoTransformMessages(messages);
 					this._broadcastChatMessage({
 						messages: transformedMessages,
@@ -104,8 +129,11 @@ var AIChatAgent = class extends Agent {
 									timestamp: Date.now(),
 									type: "message:response"
 								}, this.ctx);
-							}, abortSignal ? { abortSignal } : void 0);
-							if (response) await this._reply(data.id, response);
+							}, {
+								abortSignal,
+								clientTools
+							});
+							if (response) await this._reply(data.id, response, [connection.id]);
 							else {
 								console.warn(`[AIChatAgent] onChatMessage returned no response for chatMessageId: ${chatMessageId}`);
 								this._broadcastChatMessage({
@@ -143,6 +171,42 @@ var AIChatAgent = class extends Agent {
 					if (this._activeStreamId && this._activeRequestId && this._activeRequestId === data.id) this._sendStreamChunks(connection, this._activeStreamId, this._activeRequestId);
 					return;
 				}
+				if (data.type === MessageType.CF_AGENT_TOOL_RESULT) {
+					const { toolCallId, toolName, output, autoContinue } = data;
+					this._applyToolResult(toolCallId, toolName, output).then((applied) => {
+						if (applied && autoContinue) {
+							const waitForStream = async () => {
+								if (this._streamCompletionPromise) await this._streamCompletionPromise;
+								else await new Promise((resolve) => setTimeout(resolve, 500));
+							};
+							waitForStream().then(() => {
+								const continuationId = nanoid();
+								const abortSignal = this._getAbortSignal(continuationId);
+								this._tryCatchChat(async () => {
+									return agentContext.run({
+										agent: this,
+										connection,
+										request: void 0,
+										email: void 0
+									}, async () => {
+										const response = await this.onChatMessage(async (_finishResult) => {
+											this._removeAbortController(continuationId);
+											this.observability?.emit({
+												displayMessage: "Chat message response (tool continuation)",
+												id: continuationId,
+												payload: {},
+												timestamp: Date.now(),
+												type: "message:response"
+											}, this.ctx);
+										}, { abortSignal });
+										if (response) await this._reply(continuationId, response, [], { continuation: true });
+									});
+								});
+							});
+						}
+					});
+					return;
+				}
 			}
 			return _onMessage(connection, message);
 		};
@@ -344,7 +408,7 @@ var AIChatAgent = class extends Agent {
 	/**
 	* Handle incoming chat messages and generate a response
 	* @param onFinish Callback to be called when the response is finished
-	* @param options.signal A signal to pass to any child requests which can be used to cancel them
+	* @param options Options including abort signal and client-defined tools
 	* @returns Response to send to the client or undefined
 	*/
 	async onChatMessage(onFinish, options) {
@@ -362,46 +426,262 @@ var AIChatAgent = class extends Agent {
 		});
 	}
 	async persistMessages(messages, excludeBroadcastIds = []) {
-		for (const message of messages) this.sql`
+		const mergedMessages = this._mergeIncomingWithServerState(messages);
+		for (const message of mergedMessages) {
+			const sanitizedMessage = this._sanitizeMessageForPersistence(message);
+			const messageToSave = this._resolveMessageForToolMerge(sanitizedMessage);
+			this.sql`
         insert into cf_ai_chat_agent_messages (id, message)
-        values (${message.id}, ${JSON.stringify(message)})
+        values (${messageToSave.id}, ${JSON.stringify(messageToSave)})
         on conflict(id) do update set message = excluded.message
       `;
+		}
 		this.messages = autoTransformMessages(this._loadMessagesFromDb());
 		this._broadcastChatMessage({
-			messages,
+			messages: mergedMessages,
 			type: MessageType.CF_AGENT_CHAT_MESSAGES
 		}, excludeBroadcastIds);
 	}
-	async _reply(id, response) {
+	/**
+	* Merges incoming messages with existing server state.
+	* This preserves tool outputs that the server has (via _applyToolResult)
+	* but the client doesn't have yet.
+	*
+	* @param incomingMessages - Messages from the client
+	* @returns Messages with server's tool outputs preserved
+	*/
+	_mergeIncomingWithServerState(incomingMessages) {
+		const serverToolOutputs = /* @__PURE__ */ new Map();
+		for (const msg of this.messages) {
+			if (msg.role !== "assistant") continue;
+			for (const part of msg.parts) if ("toolCallId" in part && "state" in part && part.state === "output-available" && "output" in part) serverToolOutputs.set(part.toolCallId, part.output);
+		}
+		if (serverToolOutputs.size === 0) return incomingMessages;
+		return incomingMessages.map((msg) => {
+			if (msg.role !== "assistant") return msg;
+			let hasChanges = false;
+			const updatedParts = msg.parts.map((part) => {
+				if ("toolCallId" in part && "state" in part && part.state === "input-available" && serverToolOutputs.has(part.toolCallId)) {
+					hasChanges = true;
+					return {
+						...part,
+						state: "output-available",
+						output: serverToolOutputs.get(part.toolCallId)
+					};
+				}
+				return part;
+			});
+			return hasChanges ? {
+				...msg,
+				parts: updatedParts
+			} : msg;
+		});
+	}
+	/**
+	* Resolves a message for persistence, handling tool result merging.
+	* If the message contains tool parts with output-available state, checks if there's
+	* an existing message with the same toolCallId that should be updated instead of
+	* creating a duplicate. This prevents the "Duplicate item found" error from OpenAI
+	* when client-side tool results arrive in a new request.
+	*
+	* @param message - The message to potentially merge
+	* @returns The message with the correct ID (either original or merged)
+	*/
+	_resolveMessageForToolMerge(message) {
+		if (message.role !== "assistant") return message;
+		for (const part of message.parts) if ("toolCallId" in part && "state" in part && part.state === "output-available") {
+			const toolCallId = part.toolCallId;
+			const existingMessage = this._findMessageByToolCallId(toolCallId);
+			if (existingMessage && existingMessage.id !== message.id) return {
+				...message,
+				id: existingMessage.id
+			};
+		}
+		return message;
+	}
+	/**
+	* Finds an existing assistant message that contains a tool part with the given toolCallId.
+	* Used to detect when a tool result should update an existing message rather than
+	* creating a new one.
+	*
+	* @param toolCallId - The tool call ID to search for
+	* @returns The existing message if found, undefined otherwise
+	*/
+	_findMessageByToolCallId(toolCallId) {
+		for (const msg of this.messages) {
+			if (msg.role !== "assistant") continue;
+			for (const part of msg.parts) if ("toolCallId" in part && part.toolCallId === toolCallId) return msg;
+		}
+	}
+	/**
+	* Sanitizes a message for persistence by removing ephemeral provider-specific
+	* data that should not be stored or sent back in subsequent requests.
+	*
+	* This handles two issues with the OpenAI Responses API:
+	*
+	* 1. **Duplicate item IDs**: The AI SDK's @ai-sdk/openai provider (v2.0.x+)
+	*    defaults to using OpenAI's Responses API which assigns unique itemIds
+	*    to each message part. When these IDs are persisted and sent back,
+	*    OpenAI rejects them as duplicates.
+	*
+	* 2. **Empty reasoning parts**: OpenAI may return reasoning parts with empty
+	*    text and encrypted content. These cause "Non-OpenAI reasoning parts are
+	*    not supported" warnings when sent back via convertToModelMessages().
+	*
+	* @param message - The message to sanitize
+	* @returns A new message with ephemeral provider data removed
+	*/
+	_sanitizeMessageForPersistence(message) {
+		const sanitizedParts = message.parts.filter((part) => {
+			if (part.type === "reasoning") {
+				const reasoningPart = part;
+				if (!reasoningPart.text || reasoningPart.text.trim() === "") return false;
+			}
+			return true;
+		}).map((part) => {
+			let sanitizedPart = part;
+			if ("providerMetadata" in sanitizedPart && sanitizedPart.providerMetadata && typeof sanitizedPart.providerMetadata === "object" && "openai" in sanitizedPart.providerMetadata) sanitizedPart = this._stripOpenAIMetadata(sanitizedPart, "providerMetadata");
+			if ("callProviderMetadata" in sanitizedPart && sanitizedPart.callProviderMetadata && typeof sanitizedPart.callProviderMetadata === "object" && "openai" in sanitizedPart.callProviderMetadata) sanitizedPart = this._stripOpenAIMetadata(sanitizedPart, "callProviderMetadata");
+			return sanitizedPart;
+		});
+		return {
+			...message,
+			parts: sanitizedParts
+		};
+	}
+	/**
+	* Helper to strip OpenAI-specific ephemeral fields from a metadata object.
+	* Removes itemId and reasoningEncryptedContent while preserving other fields.
+	*/
+	_stripOpenAIMetadata(part, metadataKey) {
+		const metadata = part[metadataKey];
+		if (!metadata?.openai) return part;
+		const { itemId: _itemId, reasoningEncryptedContent: _rec, ...restOpenai } = metadata.openai;
+		const hasOtherOpenaiFields = Object.keys(restOpenai).length > 0;
+		const { openai: _openai, ...restMetadata } = metadata;
+		let newMetadata;
+		if (hasOtherOpenaiFields) newMetadata = {
+			...restMetadata,
+			openai: restOpenai
+		};
+		else if (Object.keys(restMetadata).length > 0) newMetadata = restMetadata;
+		const { [metadataKey]: _oldMeta, ...restPart } = part;
+		if (newMetadata) return {
+			...restPart,
+			[metadataKey]: newMetadata
+		};
+		return restPart;
+	}
+	/**
+	* Applies a tool result to an existing assistant message.
+	* This is used when the client sends CF_AGENT_TOOL_RESULT for client-side tools.
+	* The server is the source of truth, so we update the message here and broadcast
+	* the update to all clients.
+	*
+	* @param toolCallId - The tool call ID this result is for
+	* @param toolName - The name of the tool
+	* @param output - The output from the tool execution
+	* @returns true if the result was applied, false if the message was not found
+	*/
+	async _applyToolResult(toolCallId, _toolName, output) {
+		let message;
+		if (this._streamingMessage) {
+			for (const part of this._streamingMessage.parts) if ("toolCallId" in part && part.toolCallId === toolCallId) {
+				message = this._streamingMessage;
+				break;
+			}
+		}
+		if (!message) for (let attempt = 0; attempt < 10; attempt++) {
+			message = this._findMessageByToolCallId(toolCallId);
+			if (message) break;
+			await new Promise((resolve) => setTimeout(resolve, 100));
+		}
+		if (!message) {
+			console.warn(`[AIChatAgent] _applyToolResult: Could not find message with toolCallId ${toolCallId} after retries`);
+			return false;
+		}
+		const isStreamingMessage = message === this._streamingMessage;
+		let updated = false;
+		if (isStreamingMessage) {
+			for (const part of message.parts) if ("toolCallId" in part && part.toolCallId === toolCallId && "state" in part && part.state === "input-available") {
+				part.state = "output-available";
+				part.output = output;
+				updated = true;
+				break;
+			}
+		} else {
+			const updatedParts = message.parts.map((part) => {
+				if ("toolCallId" in part && part.toolCallId === toolCallId && "state" in part && part.state === "input-available") {
+					updated = true;
+					return {
+						...part,
+						state: "output-available",
+						output
+					};
+				}
+				return part;
+			});
+			if (updated) {
+				const updatedMessage = this._sanitizeMessageForPersistence({
+					...message,
+					parts: updatedParts
+				});
+				this.sql`
+          update cf_ai_chat_agent_messages 
+          set message = ${JSON.stringify(updatedMessage)}
+          where id = ${message.id}
+        `;
+				this.messages = autoTransformMessages(this._loadMessagesFromDb());
+			}
+		}
+		if (!updated) {
+			console.warn(`[AIChatAgent] _applyToolResult: Tool part with toolCallId ${toolCallId} not in input-available state`);
+			return false;
+		}
+		if (!isStreamingMessage) {
+			const broadcastMessage = this._findMessageByToolCallId(toolCallId);
+			if (broadcastMessage) this._broadcastChatMessage({
+				type: MessageType.CF_AGENT_MESSAGE_UPDATED,
+				message: broadcastMessage
+			});
+		}
+		return true;
+	}
+	async _reply(id, response, excludeBroadcastIds = [], options = {}) {
+		const { continuation = false } = options;
 		return this._tryCatchChat(async () => {
 			if (!response.body) {
 				this._broadcastChatMessage({
 					body: "",
 					done: true,
 					id,
-					type: MessageType.CF_AGENT_USE_CHAT_RESPONSE
+					type: MessageType.CF_AGENT_USE_CHAT_RESPONSE,
+					...continuation && { continuation: true }
 				});
 				return;
 			}
 			const streamId = this._startStream(id);
-			const { getToolName, isToolUIPart, parsePartialJson } = await import("ai");
+			const { getToolName: getToolName$1, isToolUIPart: isToolUIPart$1, parsePartialJson } = await import("ai");
 			const reader = response.body.getReader();
 			const message = {
 				id: `assistant_${Date.now()}_${Math.random().toString(36).slice(2, 11)}`,
 				role: "assistant",
 				parts: []
 			};
+			this._streamingMessage = message;
+			this._streamCompletionPromise = new Promise((resolve) => {
+				this._streamCompletionResolve = resolve;
+			});
 			let activeTextParts = {};
 			let activeReasoningParts = {};
 			const partialToolCalls = {};
-			function updateDynamicToolPart(options) {
-				const part = message.parts.find((part$1) => part$1.type === "dynamic-tool" && part$1.toolCallId === options.toolCallId);
-				const anyOptions = options;
+			function updateDynamicToolPart(options$1) {
+				const part = message.parts.find((part$1) => part$1.type === "dynamic-tool" && part$1.toolCallId === options$1.toolCallId);
+				const anyOptions = options$1;
 				const anyPart = part;
 				if (part != null) {
-					part.state = options.state;
-					anyPart.toolName = options.toolName;
+					part.state = options$1.state;
+					anyPart.toolName = options$1.toolName;
 					anyPart.input = anyOptions.input;
 					anyPart.output = anyOptions.output;
 					anyPart.errorText = anyOptions.errorText;
@@ -410,9 +690,9 @@ var AIChatAgent = class extends Agent {
 					if (anyOptions.providerMetadata != null && part.state === "input-available") part.callProviderMetadata = anyOptions.providerMetadata;
 				} else message.parts.push({
 					type: "dynamic-tool",
-					toolName: options.toolName,
-					toolCallId: options.toolCallId,
-					state: options.state,
+					toolName: options$1.toolName,
+					toolCallId: options$1.toolCallId,
+					state: options$1.state,
 					input: anyOptions.input,
 					output: anyOptions.output,
 					errorText: anyOptions.errorText,
@@ -420,12 +700,12 @@ var AIChatAgent = class extends Agent {
 					...anyOptions.providerMetadata != null ? { callProviderMetadata: anyOptions.providerMetadata } : {}
 				});
 			}
-			function updateToolPart(options) {
-				const part = message.parts.find((part$1) => isToolUIPart(part$1) && part$1.toolCallId === options.toolCallId);
-				const anyOptions = options;
+			function updateToolPart(options$1) {
+				const part = message.parts.find((part$1) => isToolUIPart$1(part$1) && part$1.toolCallId === options$1.toolCallId);
+				const anyOptions = options$1;
 				const anyPart = part;
 				if (part != null) {
-					part.state = options.state;
+					part.state = options$1.state;
 					anyPart.input = anyOptions.input;
 					anyPart.output = anyOptions.output;
 					anyPart.errorText = anyOptions.errorText;
@@ -434,9 +714,9 @@ var AIChatAgent = class extends Agent {
 					anyPart.providerExecuted = anyOptions.providerExecuted ?? part.providerExecuted;
 					if (anyOptions.providerMetadata != null && part.state === "input-available") part.callProviderMetadata = anyOptions.providerMetadata;
 				} else message.parts.push({
-					type: `tool-${options.toolName}`,
-					toolCallId: options.toolCallId,
-					state: options.state,
+					type: `tool-${options$1.toolName}`,
+					toolCallId: options$1.toolCallId,
+					state: options$1.state,
 					input: anyOptions.input,
 					output: anyOptions.output,
 					rawInput: anyOptions.rawInput,
@@ -463,7 +743,8 @@ var AIChatAgent = class extends Agent {
 							body: "",
 							done: true,
 							id,
-							type: MessageType.CF_AGENT_USE_CHAT_RESPONSE
+							type: MessageType.CF_AGENT_USE_CHAT_RESPONSE,
+							...continuation && { continuation: true }
 						});
 						break;
 					}
@@ -548,7 +829,7 @@ var AIChatAgent = class extends Agent {
 									});
 									break;
 								case "tool-input-start": {
-									const toolInvocations = message.parts.filter(isToolUIPart);
+									const toolInvocations = message.parts.filter(isToolUIPart$1);
 									partialToolCalls[data.toolCallId] = {
 										text: "",
 										toolName: data.toolName,
@@ -637,11 +918,11 @@ var AIChatAgent = class extends Agent {
 											preliminary: data.preliminary
 										});
 									} else {
-										const toolInvocation = message.parts.filter(isToolUIPart).find((invocation) => invocation.toolCallId === data.toolCallId);
+										const toolInvocation = message.parts.filter(isToolUIPart$1).find((invocation) => invocation.toolCallId === data.toolCallId);
 										if (!toolInvocation) throw new Error("Tool invocation not found");
 										updateToolPart({
 											toolCallId: data.toolCallId,
-											toolName: getToolName(toolInvocation),
+											toolName: getToolName$1(toolInvocation),
 											state: "output-available",
 											input: toolInvocation.input,
 											output: data.output,
@@ -662,11 +943,11 @@ var AIChatAgent = class extends Agent {
 											errorText: data.errorText
 										});
 									} else {
-										const toolInvocation = message.parts.filter(isToolUIPart).find((invocation) => invocation.toolCallId === data.toolCallId);
+										const toolInvocation = message.parts.filter(isToolUIPart$1).find((invocation) => invocation.toolCallId === data.toolCallId);
 										if (!toolInvocation) throw new Error("Tool invocation not found");
 										updateToolPart({
 											toolCallId: data.toolCallId,
-											toolName: getToolName(toolInvocation),
+											toolName: getToolName$1(toolInvocation),
 											state: "output-error",
 											input: toolInvocation.input,
 											rawInput: "rawInput" in toolInvocation ? toolInvocation.rawInput : void 0,
@@ -716,7 +997,8 @@ var AIChatAgent = class extends Agent {
 								body: chunkBody,
 								done: false,
 								id,
-								type: MessageType.CF_AGENT_USE_CHAT_RESPONSE
+								type: MessageType.CF_AGENT_USE_CHAT_RESPONSE,
+								...continuation && { continuation: true }
 							});
 						} catch (_error) {}
 					} else if (chunk.length > 0) {
@@ -733,7 +1015,8 @@ var AIChatAgent = class extends Agent {
 							body: chunkBody,
 							done: false,
 							id,
-							type: MessageType.CF_AGENT_USE_CHAT_RESPONSE
+							type: MessageType.CF_AGENT_USE_CHAT_RESPONSE,
+							...continuation && { continuation: true }
 						});
 					}
 				}
@@ -745,14 +1028,37 @@ var AIChatAgent = class extends Agent {
 						done: true,
 						error: true,
 						id,
-						type: MessageType.CF_AGENT_USE_CHAT_RESPONSE
+						type: MessageType.CF_AGENT_USE_CHAT_RESPONSE,
+						...continuation && { continuation: true }
 					});
 				}
 				throw error;
 			} finally {
 				reader.releaseLock();
 			}
-			if (message.parts.length > 0) await this.persistMessages([...this.messages, message]);
+			if (message.parts.length > 0) if (continuation) {
+				let lastAssistantIdx = -1;
+				for (let i = this.messages.length - 1; i >= 0; i--) if (this.messages[i].role === "assistant") {
+					lastAssistantIdx = i;
+					break;
+				}
+				if (lastAssistantIdx >= 0) {
+					const lastAssistant = this.messages[lastAssistantIdx];
+					const mergedMessage = {
+						...lastAssistant,
+						parts: [...lastAssistant.parts, ...message.parts]
+					};
+					const updatedMessages = [...this.messages];
+					updatedMessages[lastAssistantIdx] = mergedMessage;
+					await this.persistMessages(updatedMessages, excludeBroadcastIds);
+				} else await this.persistMessages([...this.messages, message], excludeBroadcastIds);
+			} else await this.persistMessages([...this.messages, message], excludeBroadcastIds);
+			this._streamingMessage = null;
+			if (this._streamCompletionResolve) {
+				this._streamCompletionResolve();
+				this._streamCompletionResolve = null;
+				this._streamCompletionPromise = null;
+			}
 		});
 	}
 	/**
@@ -816,5 +1122,5 @@ var AIChatAgent = class extends Agent {
 };
 
 //#endregion
-export { AIChatAgent };
+export { AIChatAgent, createToolsFromClientSchemas };
 //# sourceMappingURL=ai-chat-agent.js.map