agents 0.16.1 → 0.17.0

package/dist/chat/react.js

@@ -0,0 +1,1506 @@
+import { n as transition } from "../wire-types-nflOzNuU.js";
+import { getToolName, isToolUIPart } from "ai";
+import { nanoid } from "nanoid";
+import { use, useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { useChat } from "@ai-sdk/react";
+//#region src/chat/ws-chat-transport.ts
+/**
+* Short safety-net timeout for a resume probe when the server has said nothing.
+* Under normal operation the server answers a `STREAM_RESUME_REQUEST` with
+* `STREAM_RESUMING`, `STREAM_RESUME_NONE`, or `STREAM_PENDING` well before this.
+*/
+const RESUME_PROBE_TIMEOUT_MS = 5e3;
+/**
+* Extended backstop applied once the server says a turn is pending
+* (`STREAM_PENDING`, #1784). The pre-stream window (queueing, MCP setup,
+* debounce, model latency) can exceed the short probe timeout, and the server
+* guarantees a follow-up `STREAM_RESUMING` or `STREAM_RESUME_NONE` — so we wait
+* much longer (refreshed on every keep-waiting frame) but still cap it so a
+* dropped follow-up degrades to a null resolve instead of hanging forever.
+*/
+const RESUME_PENDING_TIMEOUT_MS = 6e4;
+/**
+* ChatTransport that sends messages over WebSocket and returns a
+* ReadableStream<UIMessageChunk> that the AI SDK's useChat consumes directly.
+* No fake fetch, no Response reconstruction, no double SSE parsing.
+*/
+var WebSocketChatTransport = class {
+	constructor(options) {
+		this._resumeResolver = null;
+		this._resumeNoneResolver = null;
+		this._onStreamPending = null;
+		this._expectToolContinuation = false;
+		this._abortToolContinuation = null;
+		this._activeServerTurnId = null;
+		this._cancelAttachedStream = null;
+		this.agent = options.agent;
+		this.prepareBody = options.prepareBody;
+		this.activeRequestIds = options.activeRequestIds;
+		this.cancelOnClientAbort = options.cancelOnClientAbort ?? false;
+	}
+	setCancelOnClientAbort(cancelOnClientAbort) {
+		this.cancelOnClientAbort = cancelOnClientAbort;
+	}
+	/**
+	* Explicitly cancel the active server turn, if any.
+	* This is separate from generic client-side abort/cancel lifecycle so
+	* clients can detach locally without stopping server work.
+	*/
+	cancelActiveServerTurn() {
+		const requestId = this._activeServerTurnId;
+		let cancelledRequest = false;
+		if (requestId) {
+			this.sendCancelFrame(requestId);
+			this._cancelAttachedStream?.();
+			this.clearActiveServerTurn(requestId);
+			cancelledRequest = true;
+		}
+		const cancelledToolContinuation = this.abortActiveToolContinuation();
+		return cancelledRequest || cancelledToolContinuation;
+	}
+	sendCancelFrame(requestId) {
+		try {
+			this.agent.send(JSON.stringify({
+				id: requestId,
+				type: "cf_agent_chat_request_cancel"
+			}));
+		} catch {}
+	}
+	setActiveServerTurn(requestId, cancelAttachedStream) {
+		this._activeServerTurnId = requestId;
+		this._cancelAttachedStream = cancelAttachedStream;
+	}
+	clearActiveServerTurn(requestId) {
+		if (this._activeServerTurnId === requestId) {
+			this._activeServerTurnId = null;
+			this._cancelAttachedStream = null;
+		}
+	}
+	/**
+	* Mark that the next reconnectToStream() call should attach to a
+	* server-initiated tool continuation rather than a page-load resume.
+	*/
+	expectToolContinuation() {
+		this._expectToolContinuation = true;
+	}
+	/**
+	* Abort the active client-side tool continuation stream, if one is attached
+	* to a server request id.
+	*/
+	abortActiveToolContinuation() {
+		return this._abortToolContinuation?.() ?? false;
+	}
+	/**
+	* True when the transport is waiting for a resume handshake.
+	*/
+	isAwaitingResume() {
+		return this._resumeResolver !== null || this._resumeNoneResolver !== null;
+	}
+	/**
+	* Called by onAgentMessage when it receives CF_AGENT_STREAM_RESUMING.
+	* If reconnectToStream is waiting, this handles the resume handshake
+	* (ACK + stream creation) and returns true. Otherwise returns false
+	* so the caller can use its own fallback path.
+	*/
+	handleStreamResuming(data) {
+		if (!this._resumeResolver) return false;
+		this._resumeResolver(data);
+		return true;
+	}
+	/**
+	* Called by onAgentMessage when it receives CF_AGENT_STREAM_RESUME_NONE.
+	* If reconnectToStream is waiting, resolves the promise with null
+	* immediately (no 5-second timeout). Returns true if handled.
+	*/
+	handleStreamResumeNone() {
+		if (!this._resumeNoneResolver) return false;
+		this._resumeNoneResolver();
+		return true;
+	}
+	/**
+	* Called by onAgentMessage when it receives CF_AGENT_STREAM_PENDING (#1784):
+	* the server accepted a turn but its stream has not started yet. If a resume
+	* path is awaiting, extend its probe timeout (so it keeps waiting for the
+	* eventual STREAM_RESUMING / STREAM_RESUME_NONE instead of resolving null
+	* after the short window). Returns true if a waiting path consumed it.
+	*/
+	handleStreamPending() {
+		if (!this._onStreamPending) return false;
+		this._onStreamPending();
+		return true;
+	}
+	/**
+	* Called by the hook's shared message handler when a server turn finishes
+	* outside the currently attached transport stream, such as after local-only
+	* client cleanup.
+	*/
+	handleServerTurnCompleted(requestId) {
+		this.clearActiveServerTurn(requestId);
+	}
+	/**
+	* Register a server turn that is being rendered outside a transport-owned
+	* stream, such as the hook's fallback cross-tab/resume observer path.
+	*/
+	observeServerTurn(requestId) {
+		this.setActiveServerTurn(requestId, null);
+	}
+	async sendMessages(options) {
+		const requestId = nanoid(8);
+		const abortController = new AbortController();
+		let completed = false;
+		let requestSent = false;
+		let extraBody = {};
+		if (this.prepareBody) extraBody = await this.prepareBody({
+			messages: options.messages,
+			trigger: options.trigger,
+			messageId: options.messageId
+		});
+		if (options.body) extraBody = {
+			...extraBody,
+			...options.body
+		};
+		const bodyPayload = JSON.stringify({
+			messages: options.messages,
+			trigger: options.trigger,
+			...extraBody
+		});
+		this.activeRequestIds?.add(requestId);
+		const agent = this.agent;
+		const activeIds = this.activeRequestIds;
+		const finish = (action, keepId = false, clearServerTurn = true) => {
+			if (completed) return;
+			completed = true;
+			if (clearServerTurn) this.clearActiveServerTurn(requestId);
+			try {
+				action();
+			} catch {}
+			if (!keepId) activeIds?.delete(requestId);
+			abortController.abort();
+		};
+		const abortError = /* @__PURE__ */ new Error("Aborted");
+		abortError.name = "AbortError";
+		const cancelActiveRequest = () => {
+			if (completed) return false;
+			finish(() => streamController.error(abortError), true);
+			return true;
+		};
+		this.setActiveServerTurn(requestId, cancelActiveRequest);
+		const onAbort = () => {
+			if (completed) return;
+			if (this.cancelOnClientAbort) {
+				if (requestSent) this.sendCancelFrame(requestId);
+				finish(() => streamController.error(abortError), requestSent);
+			} else finish(() => streamController.error(abortError), false, !requestSent);
+		};
+		let streamController;
+		const stream = new ReadableStream({
+			start(controller) {
+				streamController = controller;
+				const onMessage = (event) => {
+					try {
+						const data = JSON.parse(event.data);
+						if (data.type !== "cf_agent_use_chat_response") return;
+						if (data.id !== requestId) return;
+						if (data.error) {
+							finish(() => controller.error(new Error(data.body || "Stream error")));
+							return;
+						}
+						if (data.body?.trim()) try {
+							const chunk = JSON.parse(data.body);
+							controller.enqueue(chunk);
+						} catch {}
+						if (data.done) finish(() => controller.close());
+					} catch {}
+				};
+				const onClose = () => {
+					finish(() => controller.close(), false, false);
+				};
+				agent.addEventListener("message", onMessage, { signal: abortController.signal });
+				agent.addEventListener("close", onClose, { signal: abortController.signal });
+			},
+			cancel() {
+				onAbort();
+			}
+		});
+		if (options.abortSignal) {
+			options.abortSignal.addEventListener("abort", onAbort, { once: true });
+			if (options.abortSignal.aborted) onAbort();
+		}
+		if (completed) return stream;
+		requestSent = true;
+		agent.send(JSON.stringify({
+			id: requestId,
+			init: {
+				method: "POST",
+				body: bodyPayload
+			},
+			type: "cf_agent_use_chat_request"
+		}));
+		return stream;
+	}
+	async reconnectToStream(_options) {
+		if (this._expectToolContinuation) {
+			this._expectToolContinuation = false;
+			return this._createToolContinuationStream();
+		}
+		const activeIds = this.activeRequestIds;
+		return new Promise((resolve) => {
+			let resolved = false;
+			let timeout;
+			const done = (value) => {
+				if (resolved) return;
+				resolved = true;
+				this._resumeResolver = null;
+				this._resumeNoneResolver = null;
+				this._onStreamPending = null;
+				if (timeout) clearTimeout(timeout);
+				resolve(value);
+			};
+			this._onStreamPending = () => {
+				if (resolved) return;
+				if (timeout) clearTimeout(timeout);
+				timeout = setTimeout(() => done(null), RESUME_PENDING_TIMEOUT_MS);
+			};
+			this._resumeNoneResolver = () => done(null);
+			this._resumeResolver = (data) => {
+				const requestId = data.id;
+				activeIds?.add(requestId);
+				const stream = this._createResumeStream(requestId);
+				this.agent.send(JSON.stringify({
+					type: "cf_agent_stream_resume_ack",
+					id: requestId
+				}));
+				done(stream);
+			};
+			try {
+				this.agent.send(JSON.stringify({ type: "cf_agent_stream_resume_request" }));
+			} catch {}
+			timeout = setTimeout(() => done(null), RESUME_PROBE_TIMEOUT_MS);
+		});
+	}
+	/**
+	* Creates a deferred ReadableStream for client-side tool continuations.
+	* The stream is returned immediately so AI SDK status becomes "submitted"
+	* right after addToolOutput()/addToolApprovalResponse(), then it waits for
+	* the server to announce the continuation via STREAM_RESUMING.
+	*/
+	_createToolContinuationStream() {
+		const agent = this.agent;
+		const activeIds = this.activeRequestIds;
+		const streamController = new AbortController();
+		const abortError = /* @__PURE__ */ new Error("Aborted");
+		abortError.name = "AbortError";
+		let completed = false;
+		let requestId = null;
+		let readerController;
+		let onResumeRef = null;
+		let onResumeNoneRef = null;
+		const clearHandshakeResolvers = (resumeResolver, resumeNoneResolver) => {
+			if (resumeResolver === void 0 && resumeNoneResolver === void 0) {
+				this._resumeResolver = null;
+				this._resumeNoneResolver = null;
+				return;
+			}
+			if (resumeResolver && this._resumeResolver === resumeResolver) this._resumeResolver = null;
+			if (resumeNoneResolver && this._resumeNoneResolver === resumeNoneResolver) this._resumeNoneResolver = null;
+		};
+		const finish = (action, resumeResolver, resumeNoneResolver, keepRequestId = false) => {
+			if (completed) return;
+			completed = true;
+			this._abortToolContinuation = null;
+			this._onStreamPending = null;
+			clearHandshakeResolvers(resumeResolver, resumeNoneResolver);
+			try {
+				action();
+			} catch {}
+			if (requestId && !keepRequestId) activeIds?.delete(requestId);
+			streamController.abort();
+		};
+		const transport = this;
+		this._abortToolContinuation = () => {
+			if (completed) return false;
+			if (requestId === null) {
+				finish(() => readerController.error(abortError), onResumeRef, onResumeNoneRef);
+				return true;
+			}
+			try {
+				agent.send(JSON.stringify({
+					type: "cf_agent_chat_request_cancel",
+					id: requestId
+				}));
+			} catch {}
+			finish(() => readerController.error(abortError), onResumeRef, onResumeNoneRef, true);
+			return true;
+		};
+		return new ReadableStream({
+			start(controller) {
+				readerController = controller;
+				let timeout;
+				const onResumeNone = () => {
+					if (timeout) clearTimeout(timeout);
+					finish(() => controller.close(), onResume, onResumeNone);
+				};
+				const onResume = (data) => {
+					if (requestId) return;
+					requestId = data.id;
+					activeIds?.add(requestId);
+					clearHandshakeResolvers(onResume, onResumeNone);
+					transport._onStreamPending = null;
+					if (timeout) clearTimeout(timeout);
+					agent.send(JSON.stringify({
+						type: "cf_agent_stream_resume_ack",
+						id: requestId
+					}));
+				};
+				onResumeRef = onResume;
+				onResumeNoneRef = onResumeNone;
+				timeout = setTimeout(() => finish(() => controller.close(), onResume, onResumeNone), RESUME_PROBE_TIMEOUT_MS);
+				transport._onStreamPending = () => {
+					if (completed) return;
+					if (timeout) clearTimeout(timeout);
+					timeout = setTimeout(() => finish(() => controller.close(), onResume, onResumeNone), RESUME_PENDING_TIMEOUT_MS);
+				};
+				transport._resumeResolver = onResume;
+				transport._resumeNoneResolver = onResumeNone;
+				const onMessage = (event) => {
+					try {
+						const data = JSON.parse(event.data);
+						if (data.type !== "cf_agent_use_chat_response" || requestId == null || data.id !== requestId) return;
+						if (data.error) {
+							finish(() => controller.error(new Error(data.body || "Stream error")), onResume, onResumeNone);
+							return;
+						}
+						if (data.body?.trim()) try {
+							const chunk = JSON.parse(data.body);
+							controller.enqueue(chunk);
+						} catch {}
+						if (data.done) finish(() => controller.close(), onResume, onResumeNone);
+					} catch {}
+				};
+				const onClose = () => {
+					if (timeout) clearTimeout(timeout);
+					finish(() => controller.close(), onResume, onResumeNone);
+				};
+				agent.addEventListener("message", onMessage, { signal: streamController.signal });
+				agent.addEventListener("close", onClose, { signal: streamController.signal });
+				try {
+					agent.send(JSON.stringify({ type: "cf_agent_stream_resume_request" }));
+				} catch {
+					finish(() => controller.close());
+				}
+			},
+			cancel() {
+				if (requestId && transport.cancelOnClientAbort) {
+					transport.sendCancelFrame(requestId);
+					finish(() => {}, onResumeRef, onResumeNoneRef, true);
+				} else finish(() => {}, onResumeRef, onResumeNoneRef);
+			}
+		});
+	}
+	/**
+	* Creates a ReadableStream that receives resumed stream chunks
+	* and forwards them to useChat as UIMessageChunk objects.
+	*/
+	_createResumeStream(requestId) {
+		const agent = this.agent;
+		const activeIds = this.activeRequestIds;
+		const chunkController = new AbortController();
+		const abortError = /* @__PURE__ */ new Error("Aborted");
+		abortError.name = "AbortError";
+		let completed = false;
+		const finish = (action, keepId = false, clearServerTurn = true) => {
+			if (completed) return;
+			completed = true;
+			if (clearServerTurn) this.clearActiveServerTurn(requestId);
+			try {
+				action();
+			} catch {}
+			if (!keepId) activeIds?.delete(requestId);
+			chunkController.abort();
+		};
+		const cancelActiveRequest = () => {
+			if (completed) return false;
+			finish(() => streamController.error(abortError), true);
+			return true;
+		};
+		this.setActiveServerTurn(requestId, cancelActiveRequest);
+		let streamController;
+		const transport = this;
+		return new ReadableStream({
+			start(controller) {
+				streamController = controller;
+				const onMessage = (event) => {
+					try {
+						const data = JSON.parse(event.data);
+						if (data.type !== "cf_agent_use_chat_response") return;
+						if (data.id !== requestId) return;
+						if (data.error) {
+							finish(() => controller.error(new Error(data.body || "Stream error")));
+							return;
+						}
+						if (data.body?.trim()) try {
+							const chunk = JSON.parse(data.body);
+							controller.enqueue(chunk);
+						} catch {}
+						if (data.done) finish(() => controller.close());
+					} catch {}
+				};
+				const onClose = () => {
+					finish(() => controller.close(), false, false);
+				};
+				agent.addEventListener("message", onMessage, { signal: chunkController.signal });
+				agent.addEventListener("close", onClose, { signal: chunkController.signal });
+			},
+			cancel() {
+				if (transport.cancelOnClientAbort) {
+					transport.sendCancelFrame(requestId);
+					finish(() => {}, true);
+				} else finish(() => {}, false, false);
+			}
+		});
+	}
+};
+//#endregion
+//#region src/chat/react.tsx
+/**
+* One-shot deprecation warnings (warns once per key per session).
+*/
+const _deprecationWarnings = /* @__PURE__ */ new Set();
+function warnDeprecated(id, message) {
+	if (!_deprecationWarnings.has(id)) {
+		_deprecationWarnings.add(id);
+		console.warn(`[agents/chat] Deprecated: ${message}`);
+	}
+}
+/**
+* Extracts tool schemas from tools that have client-side execute functions.
+* These schemas are automatically sent to the server with each request.
+*
+* Called internally by `useAgentChat` when `tools` are provided.
+* Most apps do not need to call this directly.
+*
+* @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]) => tool.execute).map(([name, tool]) => {
+		if (tool.inputSchema && !tool.parameters) console.warn(`[useAgentChat] Tool "${name}" uses deprecated 'inputSchema'. Please migrate to 'parameters'.`);
+		return {
+			name,
+			description: tool.description,
+			parameters: tool.parameters ?? tool.inputSchema
+		};
+	});
+	return schemas.length > 0 ? schemas : void 0;
+}
+/**
+* Map internal tool part states to simplified UI-relevant states.
+*
+* @example
+* ```tsx
+* import { isToolUIPart } from "ai";
+* import { getToolPartState } from "@cloudflare/ai-chat/react";
+*
+* if (isToolUIPart(part)) {
+*   const state = getToolPartState(part);
+*   if (state === "complete") { ... }
+*   if (state === "waiting-approval") { ... }
+* }
+* ```
+*/
+function getToolPartState(part) {
+	switch (part.state) {
+		case "input-streaming": return "streaming";
+		case "approval-requested": return "waiting-approval";
+		case "approval-responded": return "approved";
+		case "output-available": return "complete";
+		case "output-error": return "error";
+		case "output-denied": return "denied";
+		default: return "loading";
+	}
+}
+/** Get the tool call ID from a tool UI part. */
+function getToolCallId(part) {
+	return part.toolCallId;
+}
+/** Get the tool input from a tool UI part (if available). */
+function getToolInput(part) {
+	return part.input;
+}
+/** Get the tool output from a tool UI part (if available). */
+function getToolOutput(part) {
+	return part.output;
+}
+/** Get the approval info from a tool UI part (if in approval state). */
+function getToolApproval(part) {
+	return part.approval;
+}
+function agentNameToKebab(name) {
+	if (name === name.toUpperCase() && name !== name.toLowerCase()) return name.toLowerCase().replace(/_/g, "-");
+	let result = name.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`);
+	result = result.startsWith("-") ? result.slice(1) : result;
+	return result.replace(/_/g, "-").replace(/-$/, "");
+}
+/**
+* Fetch messages from an agent's `/get-messages` HTTP endpoint.
+*
+* Use in framework route loaders to prefetch messages before the component
+* tree mounts, or anywhere you need messages outside a React hook.
+*
+* @example Standard routing
+* ```typescript
+* import { getAgentMessages } from "@cloudflare/ai-chat/react";
+*
+* const messages = await getAgentMessages({
+*   host: "https://my-app.workers.dev",
+*   agent: "ChatAgent",
+*   name: "session-123"
+* });
+* ```
+*
+* @example With basePath (custom URL)
+* ```typescript
+* const messages = await getAgentMessages({
+*   url: "https://my-app.workers.dev/custom/path/get-messages"
+* });
+* ```
+*/
+async function getAgentMessages(options) {
+	let messagesUrl;
+	if ("url" in options) messagesUrl = options.url;
+	else {
+		const agentSlug = agentNameToKebab(options.agent);
+		messagesUrl = `${options.host.endsWith("/") ? options.host.slice(0, -1) : options.host}/agents/${agentSlug}/${options.name}/get-messages`;
+	}
+	try {
+		const response = await fetch(messagesUrl, {
+			credentials: options.credentials,
+			headers: options.headers
+		});
+		if (!response.ok) {
+			console.warn(`[getAgentMessages] Failed to fetch: ${response.status} ${response.statusText}`);
+			return [];
+		}
+		const text = await response.text();
+		if (!text.trim()) return [];
+		return JSON.parse(text);
+	} catch (error) {
+		console.warn("[getAgentMessages] Fetch error:", error);
+		return [];
+	}
+}
+/**
+* Module-level cache for initial message fetches. Intentionally shared across
+* all useAgentChat instances to deduplicate requests during React Strict Mode
+* double-renders and re-renders. Cache keys include the agent URL, agent type,
+* and thread name to prevent cross-agent collisions.
+*/
+const requestCache = /* @__PURE__ */ new Map();
+function findLastAssistantMessage(messages) {
+	for (let index = messages.length - 1; index >= 0; index--) {
+		const message = messages[index];
+		if (message.role === "assistant") return {
+			index,
+			message
+		};
+	}
+	return null;
+}
+function moveMessageToEnd(messages, messageId) {
+	const idx = messages.findIndex((m) => m.id === messageId);
+	if (idx < 0 || idx === messages.length - 1) return messages;
+	const result = [...messages];
+	const [msg] = result.splice(idx, 1);
+	if (!msg) return messages;
+	result.push(msg);
+	return result;
+}
+function prependMissingHydratedMessages(hydratedMessages, currentMessages) {
+	if (currentMessages.length === 0) return hydratedMessages;
+	const currentMessageIds = new Set(currentMessages.map((message) => message.id));
+	const missingHydratedMessages = hydratedMessages.filter((message) => !currentMessageIds.has(message.id));
+	if (missingHydratedMessages.length === 0) return currentMessages;
+	return [...missingHydratedMessages, ...currentMessages];
+}
+/**
+* React hook for building AI chat interfaces using an Agent
+* @param options Chat options including the agent connection
+* @returns Chat interface controls and state with added clearHistory method
+*/
+/**
+* Automatically detects which tools require confirmation based on their configuration.
+* Tools require confirmation if they have no execute function AND are not server-executed.
+* @param tools - Record of tool name to tool definition
+* @returns Array of tool names that require confirmation
+*
+* @deprecated Use `needsApproval` on server-side tools instead.
+*/
+function detectToolsRequiringConfirmation(tools) {
+	warnDeprecated("detectToolsRequiringConfirmation", "detectToolsRequiringConfirmation() is deprecated. Use needsApproval on server-side tools instead. Will be removed in the next major version.");
+	if (!tools) return [];
+	return Object.entries(tools).filter(([_name, tool]) => !tool.execute).map(([name]) => name);
+}
+function useAgentChat(options) {
+	const { agent, getInitialMessages, messages: optionsInitialMessages, onToolCall, onData, experimental_automaticToolResolution, tools, toolsRequiringConfirmation: manualToolsRequiringConfirmation, autoContinueAfterToolResult = true, autoSendAfterAllConfirmationsResolved = true, resume = true, cancelOnClientAbort = false, syncMessagesToServer = true, body: bodyOption, prepareSendMessagesRequest, ...rest } = options;
+	if (manualToolsRequiringConfirmation) warnDeprecated("useAgentChat.toolsRequiringConfirmation", "The 'toolsRequiringConfirmation' option is deprecated. Use needsApproval on server-side tools instead. Will be removed in the next major version.");
+	if (experimental_automaticToolResolution) warnDeprecated("useAgentChat.experimental_automaticToolResolution", "The 'experimental_automaticToolResolution' option is deprecated. Use the onToolCall callback instead. Will be removed in the next major version.");
+	if (options.autoSendAfterAllConfirmationsResolved !== void 0) warnDeprecated("useAgentChat.autoSendAfterAllConfirmationsResolved", "The 'autoSendAfterAllConfirmationsResolved' option is deprecated. Use sendAutomaticallyWhen from AI SDK instead. Will be removed in the next major version.");
+	const toolsRequiringConfirmation = useMemo(() => {
+		if (manualToolsRequiringConfirmation) return manualToolsRequiringConfirmation;
+		if (!tools) return [];
+		return Object.entries(tools).filter(([_name, tool]) => !tool.execute).map(([name]) => name);
+	}, [manualToolsRequiringConfirmation, tools]);
+	const onToolCallRef = useRef(onToolCall);
+	onToolCallRef.current = onToolCall;
+	const onDataRef = useRef(onData);
+	onDataRef.current = onData;
+	const rawHttpUrl = agent.getHttpUrl();
+	const agentUrl = rawHttpUrl ? new URL(rawHttpUrl) : null;
+	if (agentUrl) agentUrl.searchParams.delete("_pk");
+	const agentUrlString = agentUrl?.toString() ?? null;
+	const agentAddressKey = Array.isArray(agent.path) ? JSON.stringify(agent.path.map((step) => [step.agent, step.name])) : JSON.stringify([[agent.agent ?? "", agent.name ?? ""]]);
+	const resolvedInitialMessagesCacheKey = agentUrl ? `${agentUrl.origin}${agentUrl.pathname}|${agentAddressKey}` : null;
+	const initialMessagesCacheKey = agentAddressKey;
+	const stableChatIdRef = useRef(null);
+	const previousAgentRef = useRef(null);
+	const previousAgentAddressKeyRef = useRef(null);
+	const fallbackChatId = agentAddressKey;
+	const agentPathChanged = Array.isArray(agent.path) && previousAgentAddressKeyRef.current !== null && previousAgentAddressKeyRef.current !== agentAddressKey;
+	if (stableChatIdRef.current === null) stableChatIdRef.current = resolvedInitialMessagesCacheKey ?? fallbackChatId;
+	else if (previousAgentRef.current !== agent || agentPathChanged) stableChatIdRef.current = resolvedInitialMessagesCacheKey ?? fallbackChatId;
+	previousAgentRef.current = agent;
+	previousAgentAddressKeyRef.current = agentAddressKey;
+	const agentRef = useRef(agent);
+	agentRef.current = agent;
+	async function defaultGetInitialMessagesFetch({ url }) {
+		if (!url) return [];
+		const getMessagesUrl = new URL(url);
+		getMessagesUrl.pathname += "/get-messages";
+		const response = await fetch(getMessagesUrl.toString(), {
+			credentials: options.credentials,
+			headers: options.headers
+		});
+		if (!response.ok) {
+			console.warn(`Failed to fetch initial messages: ${response.status} ${response.statusText}`);
+			return [];
+		}
+		const text = await response.text();
+		if (!text.trim()) return [];
+		try {
+			return JSON.parse(text);
+		} catch (error) {
+			console.warn("Failed to parse initial messages JSON:", error);
+			return [];
+		}
+	}
+	const getInitialMessagesFetch = getInitialMessages || defaultGetInitialMessagesFetch;
+	function doGetInitialMessages(getInitialMessagesOptions, cacheKey) {
+		if (requestCache.has(cacheKey)) return requestCache.get(cacheKey);
+		const promise = getInitialMessagesFetch(getInitialMessagesOptions);
+		requestCache.set(cacheKey, promise);
+		return promise;
+	}
+	const initialMessagesPromise = !(getInitialMessages === null ? false : getInitialMessages ? true : !!agentUrlString) ? null : doGetInitialMessages({
+		agent: agent.agent,
+		name: agent.name,
+		url: agentUrlString ?? void 0
+	}, initialMessagesCacheKey);
+	const initialMessages = initialMessagesPromise ? use(initialMessagesPromise) : optionsInitialMessages ?? [];
+	useEffect(() => {
+		if (!initialMessagesPromise) return;
+		requestCache.set(initialMessagesCacheKey, initialMessagesPromise);
+		return () => {
+			if (requestCache.get(initialMessagesCacheKey) === initialMessagesPromise) requestCache.delete(initialMessagesCacheKey);
+		};
+	}, [initialMessagesCacheKey, initialMessagesPromise]);
+	const toolsRef = useRef(tools);
+	toolsRef.current = tools;
+	const prepareSendMessagesRequestRef = useRef(prepareSendMessagesRequest);
+	prepareSendMessagesRequestRef.current = prepareSendMessagesRequest;
+	const bodyOptionRef = useRef(bodyOption);
+	bodyOptionRef.current = bodyOption;
+	/**
+	* Tracks request IDs initiated by this tab via the transport.
+	* Used by onAgentMessage to skip messages already handled by the transport.
+	*/
+	const localRequestIdsRef = useRef(/* @__PURE__ */ new Set());
+	const pendingReplayResumeRequestIdsRef = useRef(/* @__PURE__ */ new Set());
+	const replayHydratedAssistantMessageIdsRef = useRef(/* @__PURE__ */ new Set());
+	/**
+	* Request ids this socket already ACKed via the fallback resume path.
+	* The server sends CF_AGENT_STREAM_RESUMING for the same request from
+	* both onConnect and its CF_AGENT_STREAM_RESUME_REQUEST handler (#1733).
+	* The transport-handled path dedupes the second notify via
+	* localRequestIdsRef, but the fallback path used to ACK both — triggering
+	* a second full-buffer replay that duplicated streamed parts. Entries are
+	* dropped when the turn completes; the whole set resets when the socket
+	* closes, since a new connection legitimately needs a fresh ACK+replay.
+	*/
+	const fallbackAckedResumeRequestIdsRef = useRef(/* @__PURE__ */ new Set());
+	const customTransportRef = useRef(null);
+	if (customTransportRef.current === null) customTransportRef.current = new WebSocketChatTransport({
+		agent: agentRef.current,
+		activeRequestIds: localRequestIdsRef.current,
+		cancelOnClientAbort,
+		prepareBody: async ({ messages: msgs, trigger, messageId }) => {
+			let extraBody = {};
+			const currentBody = bodyOptionRef.current;
+			if (currentBody) extraBody = { ...typeof currentBody === "function" ? await currentBody() : currentBody };
+			if (toolsRef.current) {
+				const clientToolSchemas = extractClientToolSchemas(toolsRef.current);
+				if (clientToolSchemas) extraBody.clientTools = clientToolSchemas;
+			}
+			if (prepareSendMessagesRequestRef.current) {
+				const userResult = await prepareSendMessagesRequestRef.current({
+					id: agentRef.current._pk,
+					messages: msgs,
+					trigger,
+					messageId
+				});
+				if (userResult.body) Object.assign(extraBody, userResult.body);
+			}
+			return extraBody;
+		}
+	});
+	customTransportRef.current.agent = agentRef.current;
+	customTransportRef.current.setCancelOnClientAbort(cancelOnClientAbort);
+	const customTransport = customTransportRef.current;
+	const useChatHelpers = useChat({
+		...rest,
+		onData,
+		messages: initialMessages,
+		transport: customTransport,
+		id: stableChatIdRef.current,
+		resume
+	});
+	const { messages: chatMessages, setMessages, addToolResult, addToolApprovalResponse, sendMessage, resumeStream, status, stop } = useChatHelpers;
+	const statusRef = useRef(status);
+	statusRef.current = status;
+	const resumeStreamRef = useRef(resumeStream);
+	resumeStreamRef.current = resumeStream;
+	const hasConnectedOnceRef = useRef(false);
+	const resumingToolContinuationRef = useRef(false);
+	const pendingToolContinuationRef = useRef(false);
+	const observedToolContinuationRequestIdRef = useRef(null);
+	const continuationLaunchTimerRef = useRef(null);
+	const continuationGenerationRef = useRef(0);
+	const [isToolContinuation, setIsToolContinuation] = useState(false);
+	const resetToolContinuation = useCallback(() => {
+		continuationGenerationRef.current++;
+		pendingToolContinuationRef.current = false;
+		resumingToolContinuationRef.current = false;
+		observedToolContinuationRequestIdRef.current = null;
+		if (continuationLaunchTimerRef.current) {
+			clearTimeout(continuationLaunchTimerRef.current);
+			continuationLaunchTimerRef.current = null;
+		}
+		setIsToolContinuation(false);
+	}, []);
+	const scheduleToolContinuationLaunch = useCallback(() => {
+		if (!pendingToolContinuationRef.current || statusRef.current !== "ready" || continuationLaunchTimerRef.current) return;
+		continuationLaunchTimerRef.current = setTimeout(() => {
+			continuationLaunchTimerRef.current = null;
+			if (!pendingToolContinuationRef.current || statusRef.current !== "ready") return;
+			pendingToolContinuationRef.current = false;
+			const myGeneration = continuationGenerationRef.current;
+			customTransport.expectToolContinuation();
+			resumeStream().catch((error) => {
+				console.error("[useAgentChat] Tool continuation resume failed:", error);
+			}).finally(() => {
+				if (continuationGenerationRef.current !== myGeneration) return;
+				resumingToolContinuationRef.current = false;
+				setIsToolContinuation(false);
+			});
+		}, 0);
+	}, [customTransport, resumeStream]);
+	const startToolContinuation = useCallback(() => {
+		if (!autoContinueAfterToolResult || resumingToolContinuationRef.current) return;
+		++continuationGenerationRef.current;
+		resumingToolContinuationRef.current = true;
+		pendingToolContinuationRef.current = true;
+		setIsToolContinuation(true);
+		scheduleToolContinuationLaunch();
+	}, [autoContinueAfterToolResult, scheduleToolContinuationLaunch]);
+	useEffect(() => {
+		if (status === "error" && pendingToolContinuationRef.current) {
+			resetToolContinuation();
+			return;
+		}
+		scheduleToolContinuationLaunch();
+	}, [
+		resetToolContinuation,
+		scheduleToolContinuationLaunch,
+		status
+	]);
+	const stopWithToolContinuationAbort = useCallback(async () => {
+		try {
+			customTransport.cancelActiveServerTurn();
+			await stop();
+		} finally {
+			customTransport.abortActiveToolContinuation();
+		}
+	}, [stop, customTransport]);
+	const processedToolCalls = useRef(/* @__PURE__ */ new Set());
+	const isResolvingToolsRef = useRef(false);
+	const [toolResolutionTrigger, setToolResolutionTrigger] = useState(0);
+	const [clientToolResults, setClientToolResults] = useState(/* @__PURE__ */ new Map());
+	const messagesRef = useRef(chatMessages);
+	messagesRef.current = chatMessages;
+	const initialMessagesRef = useRef(initialMessages);
+	initialMessagesRef.current = initialMessages;
+	const seededInitialMessagesKeyRef = useRef(null);
+	const markInitialMessagesSeeded = useCallback(() => {
+		seededInitialMessagesKeyRef.current = initialMessagesCacheKey;
+	}, [initialMessagesCacheKey]);
+	useEffect(() => {
+		if (!initialMessagesPromise) return;
+		if (seededInitialMessagesKeyRef.current === initialMessagesCacheKey) return;
+		markInitialMessagesSeeded();
+		setMessages((prevMessages) => prependMissingHydratedMessages(initialMessagesRef.current, prevMessages));
+	}, [
+		initialMessagesCacheKey,
+		initialMessagesPromise,
+		markInitialMessagesSeeded,
+		setMessages
+	]);
+	const localResponseMessageIdsRef = useRef(/* @__PURE__ */ new Map());
+	const protectedStreamingAssistantRef = useRef(null);
+	const preserveProtectedStreamingAssistant = useCallback((messages) => {
+		const protection = protectedStreamingAssistantRef.current;
+		if (!protection) return [...messages];
+		const protectedIndex = messages.findIndex((message) => message.id === protection.assistantId);
+		if (protectedIndex >= 0 && messages.slice(protectedIndex + 1).some((message) => message.role === "assistant")) {
+			protectedStreamingAssistantRef.current = null;
+			return [...messages];
+		}
+		const protectedAssistant = messagesRef.current.find((message) => message.id === protection.assistantId) ?? messages.find((message) => message.id === protection.assistantId);
+		if (!protectedAssistant) return [...messages];
+		return [...messages.filter((message) => message.id !== protection.assistantId), protectedAssistant];
+	}, []);
+	const protectStreamingAssistantTail = useCallback(() => {
+		if (statusRef.current !== "streaming") return;
+		const assistantInfo = findLastAssistantMessage(messagesRef.current);
+		if (!assistantInfo) return;
+		if (protectedStreamingAssistantRef.current?.assistantId !== assistantInfo.message.id) protectedStreamingAssistantRef.current = {
+			assistantId: assistantInfo.message.id,
+			anchorMessageId: messagesRef.current[assistantInfo.index - 1]?.id ?? null
+		};
+		setMessages((prevMessages) => {
+			const protection = protectedStreamingAssistantRef.current;
+			if (!protection) return prevMessages;
+			return moveMessageToEnd(prevMessages, protection.assistantId);
+		});
+	}, [setMessages]);
+	const restoreProtectedStreamingAssistant = useCallback((assistantId) => {
+		const protection = protectedStreamingAssistantRef.current;
+		if (!protection || assistantId !== void 0 && protection.assistantId !== assistantId) return;
+		protectedStreamingAssistantRef.current = null;
+		setMessages((prevMessages) => {
+			const sourceIdx = prevMessages.findIndex((m) => m.id === protection.assistantId);
+			if (sourceIdx < 0) return prevMessages;
+			const result = [...prevMessages];
+			const [msg] = result.splice(sourceIdx, 1);
+			if (!msg) return prevMessages;
+			if (protection.anchorMessageId === null) result.unshift(msg);
+			else {
+				const anchorIdx = result.findIndex((m) => m.id === protection.anchorMessageId);
+				result.splice(anchorIdx >= 0 ? anchorIdx + 1 : sourceIdx, 0, msg);
+			}
+			return result;
+		});
+	}, [setMessages]);
+	const resetMatchingHydratedAssistantForReplay = useCallback((messageId) => {
+		setMessages((prevMessages) => {
+			const lastMessage = prevMessages[prevMessages.length - 1];
+			if (!lastMessage || lastMessage.role !== "assistant" || lastMessage.id !== messageId) return prevMessages;
+			replayHydratedAssistantMessageIdsRef.current.add(messageId);
+			const next = [...prevMessages];
+			next[next.length - 1] = {
+				...lastMessage,
+				parts: []
+			};
+			return next;
+		});
+	}, [setMessages]);
+	const collapseHydratedReplayTextParts = useCallback((message) => {
+		const parts = message.parts;
+		const nextParts = parts.filter((part, index) => {
+			if (part.type !== "text" || !("text" in part) || !part.text) return true;
+			return !parts.some((candidate, candidateIndex) => {
+				if (candidateIndex <= index) return false;
+				if (candidate.type !== "text" || !("text" in candidate) || !candidate.text) return false;
+				return candidate.text.startsWith(part.text);
+			});
+		});
+		return nextParts.length === parts.length ? message : {
+			...message,
+			parts: nextParts
+		};
+	}, []);
+	useEffect(() => {
+		if (replayHydratedAssistantMessageIdsRef.current.size === 0) return;
+		const idsToCollapse = new Set(chatMessages.filter((message) => replayHydratedAssistantMessageIdsRef.current.has(message.id) && message.role === "assistant" && collapseHydratedReplayTextParts(message) !== message).map((message) => message.id));
+		if (idsToCollapse.size === 0) return;
+		setMessages((prevMessages) => {
+			let changed = false;
+			const nextMessages = prevMessages.map((message) => {
+				if (!idsToCollapse.has(message.id)) return message;
+				const nextMessage = collapseHydratedReplayTextParts(message);
+				if (nextMessage !== message) changed = true;
+				return nextMessage;
+			});
+			return changed ? nextMessages : prevMessages;
+		});
+	}, [
+		chatMessages,
+		collapseHydratedReplayTextParts,
+		setMessages
+	]);
+	const resetLocalChatState = useCallback(() => {
+		markInitialMessagesSeeded();
+		setMessages([]);
+		setClientToolResults(/* @__PURE__ */ new Map());
+		setPendingOnToolCallIds(/* @__PURE__ */ new Set());
+		resetToolContinuation();
+		processedToolCalls.current.clear();
+		localResponseMessageIdsRef.current.clear();
+		pendingReplayResumeRequestIdsRef.current.clear();
+		fallbackAckedResumeRequestIdsRef.current.clear();
+		replayHydratedAssistantMessageIdsRef.current.clear();
+		protectedStreamingAssistantRef.current = null;
+	}, [
+		markInitialMessagesSeeded,
+		setMessages,
+		resetToolContinuation
+	]);
+	const sendMessageWithStreamingProtection = useCallback(async (message, options) => {
+		const request = sendMessage(message, options);
+		if (message !== void 0 && !(typeof message === "object" && message !== null && "messageId" in message && message.messageId != null)) protectStreamingAssistantTail();
+		return request;
+	}, [sendMessage, protectStreamingAssistantTail]);
+	const lastMessage = chatMessages[chatMessages.length - 1];
+	const pendingConfirmations = (() => {
+		if (!lastMessage || lastMessage.role !== "assistant") return {
+			messageId: void 0,
+			toolCallIds: /* @__PURE__ */ new Set()
+		};
+		const pendingIds = /* @__PURE__ */ new Set();
+		for (const part of lastMessage.parts ?? []) if (isToolUIPart(part) && part.state === "input-available" && toolsRequiringConfirmation.includes(getToolName(part))) pendingIds.add(part.toolCallId);
+		return {
+			messageId: lastMessage.id,
+			toolCallIds: pendingIds
+		};
+	})();
+	const pendingConfirmationsRef = useRef(pendingConfirmations);
+	pendingConfirmationsRef.current = pendingConfirmations;
+	const [pendingOnToolCallIds, setPendingOnToolCallIds] = useState(() => /* @__PURE__ */ new Set());
+	const finishOnToolCall = useCallback((toolCallId) => {
+		setPendingOnToolCallIds((prev) => {
+			if (!prev.has(toolCallId)) return prev;
+			const next = new Set(prev);
+			next.delete(toolCallId);
+			return next;
+		});
+	}, []);
+	useEffect(() => {
+		if (!experimental_automaticToolResolution) return;
+		if (isResolvingToolsRef.current) return;
+		const lastMsg = chatMessages[chatMessages.length - 1];
+		if (!lastMsg || lastMsg.role !== "assistant") return;
+		const toolCalls = lastMsg.parts.filter((part) => isToolUIPart(part) && part.state === "input-available" && !processedToolCalls.current.has(part.toolCallId));
+		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) {
+				isResolvingToolsRef.current = true;
+				(async () => {
+					try {
+						const toolResults = [];
+						for (const part of toolCallsToResolve) if (isToolUIPart(part)) {
+							let toolOutput = null;
+							const toolName = getToolName(part);
+							const tool = currentTools?.[toolName];
+							if (tool?.execute && part.input !== void 0) try {
+								toolOutput = await tool.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) {
+							const clientToolSchemas = extractClientToolSchemas(currentTools);
+							for (const result of toolResults) agentRef.current.send(JSON.stringify({
+								type: "cf_agent_tool_result",
+								toolCallId: result.toolCallId,
+								toolName: result.toolName,
+								output: result.output,
+								autoContinue: autoContinueAfterToolResult,
+								clientTools: clientToolSchemas
+							}));
+							await Promise.all(toolResults.map((result) => 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;
+							});
+							startToolContinuation();
+						}
+					} finally {
+						isResolvingToolsRef.current = false;
+						setToolResolutionTrigger((c) => c + 1);
+					}
+				})();
+			}
+		}
+	}, [
+		chatMessages,
+		experimental_automaticToolResolution,
+		addToolResult,
+		toolsRequiringConfirmation,
+		autoContinueAfterToolResult,
+		startToolContinuation,
+		toolResolutionTrigger
+	]);
+	const sendToolOutputToServer = useCallback((toolCallId, toolName, output, state, errorText) => {
+		const shouldAutoContinue = state === "output-error" ? false : autoContinueAfterToolResult;
+		agentRef.current.send(JSON.stringify({
+			type: "cf_agent_tool_result",
+			toolCallId,
+			toolName,
+			output,
+			...state ? { state } : {},
+			...errorText !== void 0 ? { errorText } : {},
+			autoContinue: shouldAutoContinue,
+			clientTools: toolsRef.current ? extractClientToolSchemas(toolsRef.current) : void 0
+		}));
+		if (state !== "output-error") setClientToolResults((prev) => new Map(prev).set(toolCallId, output));
+		if (shouldAutoContinue) startToolContinuation();
+	}, [autoContinueAfterToolResult, startToolContinuation]);
+	const sendToolApprovalToServer = useCallback((toolCallId, approved) => {
+		agentRef.current.send(JSON.stringify({
+			type: "cf_agent_tool_approval",
+			toolCallId,
+			approved,
+			autoContinue: autoContinueAfterToolResult
+		}));
+		if (autoContinueAfterToolResult) startToolContinuation();
+	}, [autoContinueAfterToolResult, startToolContinuation]);
+	useEffect(() => {
+		const currentOnToolCall = onToolCallRef.current;
+		if (!currentOnToolCall) return;
+		const lastMsg = chatMessages[chatMessages.length - 1];
+		if (!lastMsg || lastMsg.role !== "assistant") return;
+		const pendingToolCalls = lastMsg.parts.filter((part) => isToolUIPart(part) && part.state === "input-available" && !processedToolCalls.current.has(part.toolCallId));
+		for (const part of pendingToolCalls) if (isToolUIPart(part)) {
+			const toolCallId = part.toolCallId;
+			const toolName = getToolName(part);
+			processedToolCalls.current.add(toolCallId);
+			setPendingOnToolCallIds((prev) => {
+				if (prev.has(toolCallId)) return prev;
+				const next = new Set(prev);
+				next.add(toolCallId);
+				return next;
+			});
+			const addToolOutput = (opts) => {
+				sendToolOutputToServer(opts.toolCallId, toolName, opts.output, opts.state, opts.errorText);
+				addToolResult({
+					tool: toolName,
+					toolCallId: opts.toolCallId,
+					output: opts.state === "output-error" ? opts.errorText ?? "Tool execution denied by user" : opts.output
+				});
+			};
+			let result;
+			try {
+				result = currentOnToolCall({
+					toolCall: {
+						toolCallId,
+						toolName,
+						input: part.input
+					},
+					addToolOutput
+				});
+			} catch (error) {
+				finishOnToolCall(toolCallId);
+				throw error;
+			}
+			Promise.resolve(result).finally(() => {
+				finishOnToolCall(toolCallId);
+			});
+		}
+	}, [
+		chatMessages,
+		sendToolOutputToServer,
+		addToolResult,
+		finishOnToolCall
+	]);
+	const streamStateRef = useRef({ status: "idle" });
+	const [isServerStreaming, setIsServerStreaming] = useState(false);
+	const [isRecovering, setIsRecovering] = useState(false);
+	useEffect(() => {
+		const localResponseIds = localResponseMessageIdsRef.current;
+		/**
+		* 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 {
+				data = JSON.parse(event.data);
+			} catch (_error) {
+				return;
+			}
+			switch (data.type) {
+				case "cf_agent_chat_clear":
+					streamStateRef.current = transition(streamStateRef.current, { type: "clear" }).state;
+					setIsServerStreaming(false);
+					setIsRecovering(false);
+					resetLocalChatState();
+					break;
+				case "cf_agent_chat_recovering":
+					setIsRecovering(Boolean(data.recovering));
+					break;
+				case "cf_agent_chat_messages": {
+					let next = preserveProtectedStreamingAssistant(data.messages);
+					const observed = streamStateRef.current;
+					if (observed.status === "observing" && observed.accumulator.parts.length > 0) {
+						const snapshotIdx = next.findIndex((m) => m.id === observed.accumulator.messageId);
+						const snapshotParts = snapshotIdx >= 0 ? next[snapshotIdx].parts.length : 0;
+						if (observed.accumulator.parts.length >= snapshotParts) next = observed.accumulator.mergeInto(next);
+					}
+					setMessages(next);
+					break;
+				}
+				case "cf_agent_message_updated":
+					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;
+					});
+					break;
+				case "cf_agent_stream_resume_none":
+					customTransport.handleStreamResumeNone();
+					break;
+				case "cf_agent_stream_pending":
+					customTransport.handleStreamPending();
+					break;
+				case "cf_agent_stream_resuming": {
+					const isEarlyToolContinuation = resumingToolContinuationRef.current && !customTransport.isAwaitingResume();
+					if (!resume && !customTransport.isAwaitingResume()) {
+						if (!isEarlyToolContinuation) return;
+					}
+					if (!resumingToolContinuationRef.current) pendingReplayResumeRequestIdsRef.current.add(data.id);
+					if (customTransport.handleStreamResuming(data)) return;
+					if (localRequestIdsRef.current.has(data.id)) return;
+					if (fallbackAckedResumeRequestIdsRef.current.has(data.id)) return;
+					if (isEarlyToolContinuation) {
+						pendingToolContinuationRef.current = false;
+						observedToolContinuationRequestIdRef.current = data.id;
+						if (continuationLaunchTimerRef.current) {
+							clearTimeout(continuationLaunchTimerRef.current);
+							continuationLaunchTimerRef.current = null;
+						}
+					}
+					streamStateRef.current = transition(streamStateRef.current, {
+						type: "resume-fallback",
+						streamId: data.id,
+						messageId: nanoid()
+					}).state;
+					customTransport.observeServerTurn(data.id);
+					setIsServerStreaming(true);
+					setIsRecovering(false);
+					fallbackAckedResumeRequestIdsRef.current.add(data.id);
+					agentRef.current.send(JSON.stringify({
+						type: "cf_agent_stream_resume_ack",
+						id: data.id
+					}));
+					break;
+				}
+				case "cf_agent_use_chat_response": {
+					if (localRequestIdsRef.current.has(data.id)) {
+						if (data.body?.trim()) try {
+							const chunkData = JSON.parse(data.body);
+							if (chunkData.type === "start" && typeof chunkData.messageId === "string") {
+								localResponseIds.set(data.id, chunkData.messageId);
+								if (!data.continuation) {
+									if (protectedStreamingAssistantRef.current?.assistantId !== chunkData.messageId) {
+										const msgs = messagesRef.current;
+										const idx = msgs.findIndex((m) => m.id === chunkData.messageId);
+										const anchorMessageId = idx >= 0 ? msgs[idx - 1]?.id ?? null : msgs[msgs.length - 1]?.id ?? null;
+										protectedStreamingAssistantRef.current = {
+											assistantId: chunkData.messageId,
+											anchorMessageId
+										};
+									}
+								}
+								if (data.replay && !data.continuation && !resumingToolContinuationRef.current && observedToolContinuationRequestIdRef.current !== data.id) {
+									pendingReplayResumeRequestIdsRef.current.delete(data.id);
+									resetMatchingHydratedAssistantForReplay(chunkData.messageId);
+								}
+							}
+						} catch {}
+						if (data.done || data.replayComplete) pendingReplayResumeRequestIdsRef.current.delete(data.id);
+						if (data.done) {
+							if (streamStateRef.current.status === "observing" && streamStateRef.current.streamId === data.id) {
+								streamStateRef.current = { status: "idle" };
+								setIsServerStreaming(false);
+							}
+							customTransport.handleServerTurnCompleted(data.id);
+							restoreProtectedStreamingAssistant(localResponseIds.get(data.id));
+							localResponseIds.delete(data.id);
+							localRequestIdsRef.current.delete(data.id);
+							fallbackAckedResumeRequestIdsRef.current.delete(data.id);
+						}
+						return;
+					}
+					let chunkData;
+					if (data.replay && streamStateRef.current.status !== "observing" && !pendingReplayResumeRequestIdsRef.current.has(data.id)) return;
+					if (data.body?.trim()) try {
+						chunkData = JSON.parse(data.body);
+						if (data.replay && !data.continuation && !resumingToolContinuationRef.current && observedToolContinuationRequestIdRef.current !== data.id && typeof chunkData.messageId === "string" && chunkData.type === "start") {
+							pendingReplayResumeRequestIdsRef.current.delete(data.id);
+							resetMatchingHydratedAssistantForReplay(chunkData.messageId);
+						}
+						if (typeof chunkData.type === "string" && chunkData.type.startsWith("data-") && onDataRef.current) onDataRef.current(chunkData);
+					} 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.replayComplete) pendingReplayResumeRequestIdsRef.current.delete(data.id);
+					if (data.done) {
+						customTransport.handleServerTurnCompleted(data.id);
+						fallbackAckedResumeRequestIdsRef.current.delete(data.id);
+						setIsRecovering(false);
+					}
+					const completedObservedToolContinuation = data.done && observedToolContinuationRequestIdRef.current === data.id;
+					const result = transition(streamStateRef.current, {
+						type: "response",
+						streamId: data.id,
+						messageId: nanoid(),
+						chunkData,
+						done: data.done,
+						error: data.error,
+						replay: data.replay,
+						replayComplete: data.replayComplete,
+						continuation: data.continuation,
+						currentMessages: data.continuation ? messagesRef.current : void 0
+					});
+					streamStateRef.current = result.state;
+					if (result.messagesUpdate) setMessages(result.messagesUpdate);
+					setIsServerStreaming(result.isStreaming);
+					if (completedObservedToolContinuation) resetToolContinuation();
+					break;
+				}
+			}
+		}
+		const fallbackAckedResumeRequestIds = fallbackAckedResumeRequestIdsRef.current;
+		function onAgentClose() {
+			fallbackAckedResumeRequestIds.clear();
+		}
+		function onAgentOpen() {
+			if (!hasConnectedOnceRef.current) {
+				hasConnectedOnceRef.current = true;
+				return;
+			}
+			if (!resume || statusRef.current !== "ready" || resumingToolContinuationRef.current || customTransport.isAwaitingResume()) return;
+			Promise.resolve(resumeStreamRef.current?.()).catch(() => {});
+		}
+		agent.addEventListener("message", onAgentMessage);
+		agent.addEventListener("close", onAgentClose);
+		agent.addEventListener("open", onAgentOpen);
+		return () => {
+			agent.removeEventListener("message", onAgentMessage);
+			agent.removeEventListener("close", onAgentClose);
+			agent.removeEventListener("open", onAgentOpen);
+			fallbackAckedResumeRequestIds.clear();
+			streamStateRef.current = { status: "idle" };
+			setIsServerStreaming(false);
+			setIsRecovering(false);
+			protectedStreamingAssistantRef.current = null;
+			localResponseIds.clear();
+		};
+	}, [
+		agent,
+		setMessages,
+		resume,
+		customTransport,
+		preserveProtectedStreamingAssistant,
+		resetToolContinuation,
+		resetMatchingHydratedAssistantForReplay,
+		restoreProtectedStreamingAssistant,
+		resetLocalChatState
+	]);
+	const addToolResultAndSendMessage = async (args) => {
+		const { toolCallId } = args;
+		const toolName = "tool" in args ? args.tool : "";
+		const output = "output" in args ? args.output : void 0;
+		agentRef.current.send(JSON.stringify({
+			type: "cf_agent_tool_result",
+			toolCallId,
+			toolName,
+			output,
+			autoContinue: autoContinueAfterToolResult,
+			clientTools: toolsRef.current ? extractClientToolSchemas(toolsRef.current) : void 0
+		}));
+		setClientToolResults((prev) => new Map(prev).set(toolCallId, output));
+		addToolResult(args);
+		if (autoContinueAfterToolResult) startToolContinuation();
+		if (!autoContinueAfterToolResult) {
+			if (!autoSendAfterAllConfirmationsResolved) {
+				sendMessage();
+				return;
+			}
+			const pending = pendingConfirmationsRef.current?.toolCallIds;
+			if (!pending) {
+				sendMessage();
+				return;
+			}
+			const wasLast = pending.size === 1 && pending.has(toolCallId);
+			if (pending.has(toolCallId)) pending.delete(toolCallId);
+			if (wasLast || pending.size === 0) sendMessage();
+		}
+	};
+	const addToolApprovalResponseAndNotifyServer = (args) => {
+		const { id: approvalId, approved } = args;
+		let toolCallId;
+		for (const msg of messagesRef.current) {
+			for (const part of msg.parts) if ("toolCallId" in part && "approval" in part && part.approval?.id === approvalId) {
+				toolCallId = part.toolCallId;
+				break;
+			}
+			if (toolCallId) break;
+		}
+		if (toolCallId) sendToolApprovalToServer(toolCallId, approved);
+		else console.warn(`[useAgentChat] addToolApprovalResponse: Could not find toolCallId for approval ID "${approvalId}". Server will not be notified, which may cause duplicate messages.`);
+		addToolApprovalResponse(args);
+	};
+	const messagesWithToolResults = useMemo(() => {
+		if (clientToolResults.size === 0) return chatMessages;
+		return chatMessages.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)
+				};
+			})
+		}));
+	}, [chatMessages, clientToolResults]);
+	useEffect(() => {
+		const currentToolCallIds = /* @__PURE__ */ new Set();
+		for (const msg of chatMessages) 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);
+	}, [chatMessages]);
+	const addToolOutput = useCallback((opts) => {
+		const toolName = opts.toolName ?? "";
+		sendToolOutputToServer(opts.toolCallId, toolName, opts.output, opts.state, opts.errorText);
+		addToolResult({
+			tool: toolName,
+			toolCallId: opts.toolCallId,
+			output: opts.state === "output-error" ? opts.errorText ?? "Tool execution denied by user" : opts.output
+		});
+	}, [sendToolOutputToServer, addToolResult]);
+	const lastAssistantMessage = messagesWithToolResults[messagesWithToolResults.length - 1];
+	const hasPendingClientToolCalls = (() => {
+		if (pendingOnToolCallIds.size === 0 && !tools) return false;
+		if (!lastAssistantMessage || lastAssistantMessage.role !== "assistant") return false;
+		for (const part of lastAssistantMessage.parts) {
+			if (!isToolUIPart(part)) continue;
+			if (part.state !== "input-available") continue;
+			const toolName = getToolName(part);
+			if (toolsRequiringConfirmation.includes(toolName)) continue;
+			if (pendingOnToolCallIds.has(part.toolCallId)) return true;
+			if (tools?.[toolName]?.execute) return true;
+		}
+		return false;
+	})();
+	const effectiveIsServerStreaming = isServerStreaming || hasPendingClientToolCalls;
+	const isStreaming = status === "streaming" || effectiveIsServerStreaming;
+	return {
+		...useChatHelpers,
+		messages: messagesWithToolResults,
+		isServerStreaming: effectiveIsServerStreaming,
+		isStreaming,
+		/**
+		* True while a durable chat turn is being recovered (interrupted by a
+		* deploy/eviction or a stream-stall watchdog abort and now resuming, #1620).
+		* Distinct from `isStreaming` — a recovering turn isn't producing tokens
+		* yet. Render a "recovering…" hint; most UIs treat `isStreaming ||
+		* isRecovering` as "busy". Cleared automatically on the next stream/terminal.
+		*/
+		isRecovering,
+		isToolContinuation,
+		connectionError: agent.connectionError ?? null,
+		sendMessage: sendMessageWithStreamingProtection,
+		stop: stopWithToolContinuationAbort,
+		/**
+		* Provide output for a tool call. Use this for tools that require user interaction
+		* or client-side execution.
+		*/
+		addToolOutput,
+		/**
+		* @deprecated Use `addToolOutput` instead.
+		*/
+		addToolResult: addToolResultAndSendMessage,
+		/**
+		* Respond to a tool approval request. Use this for tools with `needsApproval`.
+		* This wrapper notifies the server before updating local state, preventing
+		* duplicate messages when sendMessage() is called afterward.
+		*/
+		addToolApprovalResponse: addToolApprovalResponseAndNotifyServer,
+		clearHistory: () => {
+			resetLocalChatState();
+			agent.send(JSON.stringify({ type: "cf_agent_chat_clear" }));
+		},
+		setMessages: (messagesOrUpdater) => {
+			let resolvedMessages;
+			if (typeof messagesOrUpdater === "function") resolvedMessages = messagesOrUpdater(messagesRef.current);
+			else resolvedMessages = messagesOrUpdater;
+			if (resolvedMessages.length === 0) markInitialMessagesSeeded();
+			setMessages(resolvedMessages);
+			if (syncMessagesToServer) agent.send(JSON.stringify({
+				messages: resolvedMessages,
+				type: "cf_agent_chat_messages"
+			}));
+		}
+	};
+}
+//#endregion
+export { WebSocketChatTransport, detectToolsRequiringConfirmation, extractClientToolSchemas, getAgentMessages, getToolApproval, getToolCallId, getToolInput, getToolOutput, getToolPartState, useAgentChat };
+
+//# sourceMappingURL=react.js.map