agents 0.24.0 → 0.26.0

package/dist/chat/react.d.ts

@@ -1,9 +1,12 @@
-import { n as ClientToolSchema } from "../client-tools-aIBO0Fk7.js";
+import {
+  l as ClientToolSchema,
+  t as ChatTurnOutcome
+} from "../wire-types-CrjKvDyi.js";
 import {
   n as WebSocketChatTransport,
   r as WebSocketChatTransportOptions,
   t as AgentConnection
-} from "../ws-chat-transport-UNRIS2xl.js";
+} from "../ws-chat-transport-BbT1A5Lc.js";
 import { ChatInit, JSONSchema7, Tool, UIMessage } from "ai";
 import { UseChatOptions, useChat } from "@ai-sdk/react";
 
@@ -190,6 +193,23 @@ type AddToolOutputOptions = {
     | "output-error" /** Error message when state is "output-error" */;
   errorText?: string;
 };
+/**
+ * A chat request that ended, passed to `onTurnEnd`.
+ */
+type ChatTurnEndEvent = {
+  /** The transport id of the request. */ requestId: string;
+  /**
+   * Ids of the user messages the request ended with. Absent when it did not
+   * end with a user message, or the server no longer has a record of it.
+   */
+  messageIds?: string[];
+  outcome: Exclude<
+    ChatTurnOutcome,
+    "recovering"
+  > /** The error message, when `outcome` is `"error"`. */;
+  error?: string /** Whether this outcome was replayed on reconnect rather than seen live. */;
+  replay: boolean;
+};
 /**
  * Callback for handling client-side tool execution.
  * Called when a tool without server-side execute is invoked.
@@ -243,6 +263,9 @@ type UseAgentChatOptions<
   /**
    * Callback for handling client-side tool execution.
    * Called when a tool without server-side `execute` is invoked by the LLM.
+   * It fires once the response stream ends, for each tool call still waiting
+   * for a result, so server tools that resolve in the same stream never
+   * reach it.
    *
    * Use this for:
    * - Tools that need browser APIs (geolocation, camera, etc.)
@@ -263,6 +286,21 @@ type UseAgentChatOptions<
    * ```
    */
   onToolCall?: OnToolCallCallback;
+  /**
+   * Called once for each chat request that ends, with the ids of the user
+   * messages it carried. Use it to settle optimistic sends by the ids the
+   * client minted. It fires for this tab's requests, for requests from other
+   * connections, and for outcomes replayed on reconnect. It does not fire for
+   * a request that recovery continues under a new request; that request
+   * reports the same `messageIds` when it ends.
+   *
+   * A message id can appear in more than one event, for example when a send
+   * is skipped and a later turn answers it. The last event for an id wins.
+   *
+   * For a request this tab is streaming, it fires once `status` has
+   * settled, so it can call `sendMessage`.
+   */
+  onTurnEnd?: (event: ChatTurnEndEvent) => void;
   /**
    * @deprecated Use `onToolCall` callback instead for automatic tool execution.
    * @description Whether to automatically resolve tool calls that do not require human interaction.
@@ -444,6 +482,8 @@ declare function useAgentChat<
 export {
   AITool,
   type AgentConnection,
+  ChatTurnEndEvent,
+  type ChatTurnOutcome,
   type ClientToolSchema,
   JSONSchemaType,
   OnToolCallCallback,

package/dist/chat/react.js

@@ -1,6 +1,7 @@
-import { n as STREAM_RESUME_NONE_REASONS, r as transition } from "../protocol-B0nh6KNf.js";
+import { isSocketAddressPending } from "../socket-address.js";
+import { i as transition, n as STREAM_RESUME_NONE_REASONS, r as observedDivergesFrom } from "../protocol-kHsr-f0X.js";
 import "../wire-types-CnMt6_HR.js";
-import { t as WebSocketChatTransport } from "../ws-chat-transport-rWwta645.js";
+import { t as WebSocketChatTransport } from "../ws-chat-transport-cqMKq3IY.js";
 import { getToolName, isToolUIPart } from "ai";
 import { nanoid } from "nanoid";
 import { use, useCallback, useEffect, useMemo, useRef, useState } from "react";
@@ -165,6 +166,11 @@ async function getAgentMessages(options) {
 	}
 }
 /**
+* Replays re-send only recent terminals, so duplicate suppression needs only
+* a recent window of ended request ids.
+*/
+const MAX_REMEMBERED_ENDED_TURNS = 500;
+/**
 * 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,
@@ -197,6 +203,12 @@ function prependMissingHydratedMessages(hydratedMessages, currentMessages) {
 	if (missingHydratedMessages.length === 0) return currentMessages;
 	return [...missingHydratedMessages, ...currentMessages];
 }
+function restoreBufferedSends(snapshot, local, bufferedIds) {
+	if (bufferedIds.size === 0) return snapshot;
+	const snapshotIds = new Set(snapshot.map((message) => message.id));
+	const restored = local.filter((message) => bufferedIds.has(message.id) && !snapshotIds.has(message.id));
+	return restored.length === 0 ? snapshot : [...snapshot, ...restored];
+}
 /**
 * React hook for building AI chat interfaces using an Agent
 * @param options Chat options including the agent connection
@@ -216,7 +228,7 @@ function detectToolsRequiringConfirmation(tools) {
 	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, throttle, experimental_throttle, ...rest } = options;
+	const { agent, getInitialMessages, messages: optionsInitialMessages, onToolCall, onTurnEnd, onData, experimental_automaticToolResolution, tools, toolsRequiringConfirmation: manualToolsRequiringConfirmation, autoContinueAfterToolResult = true, autoSendAfterAllConfirmationsResolved = true, resume = true, cancelOnClientAbort = false, syncMessagesToServer = true, body: bodyOption, prepareSendMessagesRequest, throttle, experimental_throttle, ...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.");
@@ -227,13 +239,38 @@ function useAgentChat(options) {
 	}, [manualToolsRequiringConfirmation, tools]);
 	const onToolCallRef = useRef(onToolCall);
 	onToolCallRef.current = onToolCall;
+	const onTurnEndRef = useRef(onTurnEnd);
+	onTurnEndRef.current = onTurnEnd;
+	const turnErrorsRef = useRef(/* @__PURE__ */ new Map());
+	const endedTurnIdsRef = useRef(/* @__PURE__ */ new Set());
+	const pendingTurnEndsRef = useRef([]);
 	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 socketAddressPending = isSocketAddressPending(agent);
+	const committedAddressRef = useRef(null);
+	let address = committedAddressRef.current;
+	if (!socketAddressPending || address === null) {
+		const rawHttpUrl = agent.getHttpUrl();
+		const url = rawHttpUrl ? new URL(rawHttpUrl) : null;
+		url?.searchParams.delete("_pk");
+		const route = agent.partySocketOptions;
+		address = {
+			urlString: url?.toString() ?? null,
+			addressKey: JSON.stringify([Array.isArray(agent.path) ? agent.path.map((step) => [step.agent, step.name]) : [[agent.agent ?? "", agent.name ?? ""]], route ? [
+				route.host ?? null,
+				route.basePath ?? null,
+				route.prefix ?? null,
+				route.party ?? null,
+				route.path ?? null
+			] : null]),
+			agent: agent.agent,
+			name: agent.name
+		};
+		if (!socketAddressPending) committedAddressRef.current = address;
+	}
+	const agentUrl = address.urlString ? new URL(address.urlString) : null;
+	const agentUrlString = address.urlString;
+	const agentAddressKey = address.addressKey;
 	const resolvedInitialMessagesCacheKey = agentUrl ? `${agentUrl.origin}${agentUrl.pathname}|${agentAddressKey}` : null;
 	const initialMessagesCacheKey = agentAddressKey;
 	const stableChatIdRef = useRef(null);
@@ -275,9 +312,9 @@ function useAgentChat(options) {
 		requestCache.set(cacheKey, promise);
 		return promise;
 	}
-	const initialMessagesPromise = !(getInitialMessages === null ? false : getInitialMessages ? true : !!agentUrlString) ? null : doGetInitialMessages({
-		agent: agent.agent,
-		name: agent.name,
+	const initialMessagesPromise = !(getInitialMessages === null || committedAddressRef.current === null ? false : getInitialMessages ? true : !!agentUrlString) ? null : doGetInitialMessages({
+		agent: address.agent,
+		name: address.name,
 		url: agentUrlString ?? void 0
 	}, initialMessagesCacheKey);
 	const initialMessages = initialMessagesPromise ? use(initialMessagesPromise) : optionsInitialMessages ?? [];
@@ -299,6 +336,7 @@ function useAgentChat(options) {
 	* Used by onAgentMessage to skip messages already handled by the transport.
 	*/
 	const localRequestIdsRef = useRef(/* @__PURE__ */ new Set());
+	const pendingBufferedSendIdsRef = useRef(/* @__PURE__ */ new Set());
 	const pendingReplayResumeRequestIdsRef = useRef(/* @__PURE__ */ new Set());
 	const replayHydratedAssistantMessageIdsRef = useRef(/* @__PURE__ */ new Set());
 	/**
@@ -317,6 +355,9 @@ function useAgentChat(options) {
 		agent: agentRef.current,
 		activeRequestIds: localRequestIdsRef.current,
 		cancelOnClientAbort,
+		onRequestBuffered: (messageId) => {
+			if (messageId) pendingBufferedSendIdsRef.current.add(messageId);
+		},
 		prepareBody: async ({ messages: msgs, trigger, messageId }) => {
 			let extraBody = {};
 			const currentBody = bodyOptionRef.current;
@@ -449,6 +490,8 @@ function useAgentChat(options) {
 	const isResolvingToolsRef = useRef(false);
 	const [toolResolutionTrigger, setToolResolutionTrigger] = useState(0);
 	const [clientToolResults, setClientToolResults] = useState(/* @__PURE__ */ new Map());
+	const clientToolResultsRef = useRef(clientToolResults);
+	clientToolResultsRef.current = clientToolResults;
 	const initialMessagesRef = useRef(initialMessages);
 	initialMessagesRef.current = initialMessages;
 	const seededInitialMessagesKeyRef = useRef(null);
@@ -569,10 +612,15 @@ function useAgentChat(options) {
 		fallbackAckedResumeRequestIdsRef.current.clear();
 		replayHydratedAssistantMessageIdsRef.current.clear();
 		protectedStreamingAssistantRef.current = null;
+		pendingBufferedSendIdsRef.current.clear();
+		customTransport.appliedChunks.clear();
+		turnErrorsRef.current.clear();
+		pendingTurnEndsRef.current = [];
 	}, [
 		markInitialMessagesSeeded,
 		setMessages,
-		resetToolContinuation
+		resetToolContinuation,
+		customTransport
 	]);
 	const sendMessageWithStreamingProtection = useCallback(async (message, options) => {
 		const request = sendMessage(message, options);
@@ -695,9 +743,33 @@ function useAgentChat(options) {
 		}));
 		if (autoContinueAfterToolResult) startToolContinuation();
 	}, [autoContinueAfterToolResult, startToolContinuation]);
+	const [isServerStreaming, setIsServerStreaming] = useState(false);
+	const [unresolvedObservedRequestId, setUnresolvedObservedRequestId] = useState(null);
+	const unresolvedObservedRequestIdRef = useRef(unresolvedObservedRequestId);
+	unresolvedObservedRequestIdRef.current = unresolvedObservedRequestId;
+	const [recoveringRequestId, setRecoveringRequestIdState] = useState(null);
+	const recoveringRequestIdRef = useRef(null);
+	const setRecoveringRequestId = useCallback((requestId) => {
+		recoveringRequestIdRef.current = requestId;
+		setRecoveringRequestIdState(requestId);
+	}, []);
+	useEffect(() => {
+		if (status === "submitted") {
+			setUnresolvedObservedRequestId(null);
+			setRecoveringRequestId(null);
+		}
+	}, [status, setRecoveringRequestId]);
+	useEffect(() => {
+		if (status === "submitted" || status === "streaming") return;
+		const events = pendingTurnEndsRef.current;
+		if (events.length === 0) return;
+		pendingTurnEndsRef.current = [];
+		for (const event of events) onTurnEndRef.current?.(event);
+	}, [status]);
 	useEffect(() => {
 		const currentOnToolCall = onToolCallRef.current;
 		if (!currentOnToolCall) return;
+		if (status === "streaming" || status === "submitted" || isServerStreaming || unresolvedObservedRequestId !== null || recoveringRequestId !== null) 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));
@@ -739,15 +811,53 @@ function useAgentChat(options) {
 		}
 	}, [
 		chatMessages,
+		status,
+		isServerStreaming,
+		unresolvedObservedRequestId,
+		recoveringRequestId,
 		sendToolOutputToServer,
 		addToolResult,
 		finishOnToolCall
 	]);
 	const streamStateRef = useRef({ status: "idle" });
-	const [isServerStreaming, setIsServerStreaming] = useState(false);
 	const [isRecovering, setIsRecovering] = useState(false);
 	useEffect(() => {
 		const localResponseIds = localResponseMessageIdsRef.current;
+		const turnErrors = turnErrorsRef.current;
+		const endedTurnIds = endedTurnIdsRef.current;
+		let idleProbeNeeded = false;
+		let idleProbeId = null;
+		let serverReportsRecovery = false;
+		function reportTurnEnd(frame) {
+			if (frame.error && !frame.done) {
+				turnErrors.set(frame.id, frame.body);
+				if (turnErrors.size > MAX_REMEMBERED_ENDED_TURNS) {
+					const oldest = turnErrors.keys().next().value;
+					if (oldest !== void 0) turnErrors.delete(oldest);
+				}
+				return;
+			}
+			if (!frame.done) return;
+			const earlierError = turnErrors.get(frame.id);
+			turnErrors.delete(frame.id);
+			const outcome = frame.error ? "error" : frame.outcome ?? (earlierError !== void 0 ? "error" : "completed");
+			if (outcome === "recovering" || endedTurnIds.has(frame.id)) return;
+			endedTurnIds.add(frame.id);
+			if (endedTurnIds.size > MAX_REMEMBERED_ENDED_TURNS) {
+				const oldest = endedTurnIds.values().next().value;
+				if (oldest !== void 0) endedTurnIds.delete(oldest);
+			}
+			const error = frame.error ? frame.body : earlierError;
+			const event = {
+				requestId: frame.id,
+				...frame.messageIds ? { messageIds: frame.messageIds } : {},
+				outcome,
+				...outcome === "error" && error ? { error } : {},
+				replay: frame.replay === true
+			};
+			if (localRequestIdsRef.current.has(frame.id) && (statusRef.current === "submitted" || statusRef.current === "streaming")) pendingTurnEndsRef.current.push(event);
+			else onTurnEndRef.current?.(event);
+		}
 		/**
 		* Unified message handler that parses JSON once and dispatches based on type.
 		* Avoids duplicate parsing overhead from separate listeners.
@@ -764,24 +874,31 @@ function useAgentChat(options) {
 				case "cf_agent_chat_clear":
 					streamStateRef.current = transition(streamStateRef.current, { type: "clear" }).state;
 					setIsServerStreaming(false);
+					setUnresolvedObservedRequestId(null);
+					setRecoveringRequestId(null);
 					setIsRecovering(false);
 					resetLocalChatState();
 					break;
 				case "cf_agent_chat_recovering":
 					setIsRecovering(Boolean(data.recovering));
+					serverReportsRecovery = Boolean(data.recovering);
+					if (!data.recovering) setRecoveringRequestId(null);
 					break;
-				case "cf_agent_chat_messages":
+				case "cf_agent_chat_messages": {
+					const bufferedSendIds = data.connect ? new Set(pendingBufferedSendIdsRef.current) : /* @__PURE__ */ new Set();
+					pendingBufferedSendIdsRef.current.clear();
 					setMessages((currentMessages) => {
 						let next = preserveProtectedStreamingAssistant(data.messages, currentMessages);
 						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);
+							if (observed.accumulator.parts.length >= snapshotParts && !observedDivergesFrom(observed.accumulator, next)) next = observed.accumulator.mergeInto(next);
 						}
-						return next;
+						return restoreBufferedSends(next, currentMessages, bufferedSendIds);
 					});
 					break;
+				}
 				case "cf_agent_message_updated":
 					setMessages((prevMessages) => {
 						const updatedMessage = data.message;
@@ -801,21 +918,33 @@ function useAgentChat(options) {
 						return prevMessages;
 					});
 					break;
-				case "cf_agent_stream_resume_none":
-					if (customTransport.handleStreamResumeNone(data) && data.reason === STREAM_RESUME_NONE_REASONS.IDLE && typeof data.probeId === "string") {
+				case "cf_agent_stream_resume_none": {
+					const handled = customTransport.handleStreamResumeNone(data);
+					const answersIdleProbe = idleProbeId !== null && data.probeId === idleProbeId;
+					if (answersIdleProbe) idleProbeId = null;
+					if ((handled || answersIdleProbe) && data.reason === STREAM_RESUME_NONE_REASONS.IDLE && typeof data.probeId === "string") {
 						const result = transition(streamStateRef.current, { type: "clear" });
 						streamStateRef.current = result.state;
 						setIsServerStreaming(result.isStreaming);
+						setUnresolvedObservedRequestId(null);
+						if (!serverReportsRecovery) setRecoveringRequestId(null);
 						if (observedToolContinuationRequestIdRef.current !== null) resetToolContinuation();
 					}
 					break;
+				}
 				case "cf_agent_stream_pending":
 					customTransport.handleStreamPending();
 					break;
 				case "cf_agent_stream_resuming": {
+					setUnresolvedObservedRequestId((current) => current === data.id ? current : null);
+					if (data.probeId !== void 0 && data.probeId === idleProbeId) idleProbeId = null;
 					const isEarlyToolContinuation = resumingToolContinuationRef.current && !customTransport.isAwaitingResume();
 					if (!resume && !customTransport.isAwaitingResume()) {
-						if (!isEarlyToolContinuation) return;
+						if (!isEarlyToolContinuation) {
+							if (data.probeId === void 0) setUnresolvedObservedRequestId(data.id);
+							if (recoveringRequestIdRef.current !== null && recoveringRequestIdRef.current !== data.id) setRecoveringRequestId(null);
+							return;
+						}
 					}
 					if (!resumingToolContinuationRef.current) pendingReplayResumeRequestIdsRef.current.add(data.id);
 					if (customTransport.handleStreamResuming(data)) return;
@@ -836,6 +965,7 @@ function useAgentChat(options) {
 					}).state;
 					customTransport.observeServerTurn(data.id);
 					setIsServerStreaming(true);
+					if (recoveringRequestIdRef.current !== null && recoveringRequestIdRef.current !== data.id) setRecoveringRequestId(null);
 					setIsRecovering(false);
 					fallbackAckedResumeRequestIdsRef.current.add(data.id);
 					agentRef.current.send(JSON.stringify({
@@ -845,6 +975,10 @@ function useAgentChat(options) {
 					break;
 				}
 				case "cf_agent_use_chat_response": {
+					if (data.done || data.error) setUnresolvedObservedRequestId((current) => current === data.id ? null : current);
+					if (data.done && data.outcome === "recovering") setRecoveringRequestId(data.id);
+					else if (recoveringRequestIdRef.current !== null && recoveringRequestIdRef.current !== data.id && !data.replay && data.outcome !== "skipped") setRecoveringRequestId(null);
+					reportTurnEnd(data);
 					if (localRequestIdsRef.current.has(data.id)) {
 						if (data.body?.trim()) try {
 							const chunkData = JSON.parse(data.body);
@@ -884,8 +1018,15 @@ function useAgentChat(options) {
 					}
 					let chunkData;
 					if (data.replay && streamStateRef.current.status !== "observing" && !pendingReplayResumeRequestIdsRef.current.has(data.id)) return;
+					if (data.done && !data.error && !(streamStateRef.current.status === "observing" && streamStateRef.current.streamId === data.id) && !pendingReplayResumeRequestIdsRef.current.has(data.id) && observedToolContinuationRequestIdRef.current !== data.id) {
+						customTransport.appliedChunks.forget(data.id);
+						customTransport.handleServerTurnCompleted(data.id);
+						fallbackAckedResumeRequestIdsRef.current.delete(data.id);
+						break;
+					}
 					if (data.error) {
 						pendingReplayResumeRequestIdsRef.current.delete(data.id);
+						customTransport.appliedChunks.forget(data.id);
 						customTransport.handleServerTurnCompleted(data.id);
 						fallbackAckedResumeRequestIdsRef.current.delete(data.id);
 						setIsRecovering(false);
@@ -897,13 +1038,14 @@ function useAgentChat(options) {
 						if (observedToolContinuationRequestIdRef.current === data.id) resetToolContinuation();
 						break;
 					}
+					const appliedReplay = customTransport.appliedChunks.isAppliedReplay(data.id, data);
 					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);
+						if (typeof chunkData.type === "string" && chunkData.type.startsWith("data-") && !appliedReplay && 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));
 					}
@@ -911,14 +1053,17 @@ function useAgentChat(options) {
 					if (data.done) {
 						customTransport.handleServerTurnCompleted(data.id);
 						fallbackAckedResumeRequestIdsRef.current.delete(data.id);
-						setIsRecovering(false);
+						if (data.outcome !== "recovering") setIsRecovering(false);
 					}
 					const completedObservedToolContinuation = data.done && observedToolContinuationRequestIdRef.current === data.id;
+					const alreadyApplied = appliedReplay && chunkData?.type !== "start";
+					if (data.done) customTransport.appliedChunks.forget(data.id);
+					else if (!alreadyApplied) customTransport.appliedChunks.record(data.id, data.seq);
 					const result = transition(streamStateRef.current, {
 						type: "response",
 						streamId: data.id,
 						messageId: nanoid(),
-						chunkData,
+						chunkData: alreadyApplied ? void 0 : chunkData,
 						done: data.done,
 						error: data.error,
 						replay: data.replay,
@@ -938,6 +1083,7 @@ function useAgentChat(options) {
 		let sawClose = false;
 		let disposed = false;
 		const clearFallbackObserver = () => {
+			if (streamStateRef.current.status === "observing") setUnresolvedObservedRequestId(streamStateRef.current.streamId);
 			const result = transition(streamStateRef.current, { type: "clear" });
 			streamStateRef.current = result.state;
 			setIsServerStreaming(result.isStreaming);
@@ -947,6 +1093,14 @@ function useAgentChat(options) {
 			if (disposed || !socketIsOpen || !reconnectProbePendingRef.current) return;
 			if (!resume) {
 				reconnectProbePendingRef.current = false;
+				if (idleProbeNeeded) {
+					idleProbeNeeded = false;
+					idleProbeId = nanoid();
+					agentRef.current.send(JSON.stringify({
+						type: "cf_agent_stream_resume_request",
+						probeId: idleProbeId
+					}));
+				}
 				return;
 			}
 			if (customTransport.retryPendingResume()) {
@@ -962,8 +1116,14 @@ function useAgentChat(options) {
 		function onAgentClose() {
 			socketIsOpen = false;
 			sawClose = true;
+			serverReportsRecovery = false;
 			fallbackAckedResumeRequestIds.clear();
-			if (!resume) clearFallbackObserver();
+			const unfinishedTurnId = customTransport.activeServerTurnId;
+			if (unfinishedTurnId !== null) setUnresolvedObservedRequestId(unfinishedTurnId);
+			if (!resume) {
+				idleProbeNeeded ||= unfinishedTurnId !== null || streamStateRef.current.status === "observing" || unresolvedObservedRequestIdRef.current !== null || recoveringRequestIdRef.current !== null;
+				clearFallbackObserver();
+			}
 		}
 		function onAgentOpen() {
 			socketIsOpen = true;
@@ -985,6 +1145,7 @@ function useAgentChat(options) {
 			fallbackAckedResumeRequestIds.clear();
 			streamStateRef.current = { status: "idle" };
 			setIsServerStreaming(false);
+			setUnresolvedObservedRequestId(null);
 			setIsRecovering(false);
 			protectedStreamingAssistantRef.current = null;
 			localResponseIds.clear();
@@ -1001,7 +1162,8 @@ function useAgentChat(options) {
 		resetMatchingHydratedAssistantForReplay,
 		restoreProtectedStreamingAssistant,
 		resetLocalChatState,
-		invalidateResumeGeneration
+		invalidateResumeGeneration,
+		setRecoveringRequestId
 	]);
 	useEffect(() => {
 		if (!resume) return;
@@ -1071,17 +1233,11 @@ function useAgentChat(options) {
 	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;
+		const isStale = (id) => !currentToolCallIds.has(id);
+		if ([...clientToolResultsRef.current.keys()].some(isStale)) setClientToolResults((prev) => {
+			const next = /* @__PURE__ */ new Map();
+			for (const [id, output] of prev) if (!isStale(id)) next.set(id, output);
+			return next.size === prev.size ? prev : next;
 		});
 		for (const toolCallId of processedToolCalls.current) if (!currentToolCallIds.has(toolCallId)) processedToolCalls.current.delete(toolCallId);
 	}, [chatMessages]);