agents 0.17.4 → 0.18.0

package/dist/chat/react.d.ts

@@ -69,11 +69,19 @@ declare class WebSocketChatTransport<
   private _resumeResolver;
   private _resumeNoneResolver;
   private _onStreamPending;
+  private _retryResumeProbe;
   private _expectToolContinuation;
   private _abortToolContinuation;
   private _activeServerTurnId;
   private _cancelAttachedStream;
+  private _detachResumeStream;
   constructor(options: WebSocketChatTransportOptions<ChatMessage>);
+  /**
+   * Point the singleton transport at a new Agent connection. A pending resolver
+   * belongs to the old Chat/socket generation and must settle before messages
+   * from the replacement connection can be consumed (#1914 review).
+   */
+  setAgent(agent: AgentConnection): void;
   setCancelOnClientAbort(cancelOnClientAbort: boolean): void;
   /**
    * Explicitly cancel the active server turn, if any.
@@ -98,6 +106,22 @@ declare class WebSocketChatTransport<
    * True when the transport is waiting for a resume handshake.
    */
   isAwaitingResume(): boolean;
+  /**
+   * Settle and detach the current handshake without interpreting it as a
+   * server-idle response. Used when the owning hook/agent generation changes.
+   */
+  cancelPendingResume(): boolean;
+  /**
+   * Invalidate all client-side resume state for an obsolete hook/agent
+   * generation without cancelling its durable server turn.
+   */
+  resetResumeState(): void;
+  /**
+   * Re-send the active handshake request on the latest socket generation. This
+   * preserves one AI SDK resume operation while recovering a request/reply lost
+   * with the previous WebSocket.
+   */
+  retryPendingResume(): boolean;
   /**
    * Called by onAgentMessage when it receives CF_AGENT_STREAM_RESUMING.
    * If reconnectToStream is waiting, this handles the resume handshake
@@ -110,7 +134,7 @@ declare class WebSocketChatTransport<
    * If reconnectToStream is waiting, resolves the promise with null
    * immediately (no 5-second timeout). Returns true if handled.
    */
-  handleStreamResumeNone(): boolean;
+  handleStreamResumeNone(data?: { probeId?: string }): boolean;
   /**
    * 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

package/dist/chat/react.js

@@ -1,4 +1,4 @@
-import { n as transition } from "../wire-types-nflOzNuU.js";
+import { i as transition, r as STREAM_RESUME_NONE_REASONS } from "../wire-types-CU9rLoeS.js";
 import { getToolName, isToolUIPart } from "ai";
 import { nanoid } from "nanoid";
 import { use, useCallback, useEffect, useMemo, useRef, useState } from "react";
@@ -29,15 +29,27 @@ var WebSocketChatTransport = class {
 		this._resumeResolver = null;
 		this._resumeNoneResolver = null;
 		this._onStreamPending = null;
+		this._retryResumeProbe = null;
 		this._expectToolContinuation = false;
 		this._abortToolContinuation = null;
 		this._activeServerTurnId = null;
 		this._cancelAttachedStream = null;
+		this._detachResumeStream = null;
 		this.agent = options.agent;
 		this.prepareBody = options.prepareBody;
 		this.activeRequestIds = options.activeRequestIds;
 		this.cancelOnClientAbort = options.cancelOnClientAbort ?? false;
 	}
+	/**
+	* Point the singleton transport at a new Agent connection. A pending resolver
+	* belongs to the old Chat/socket generation and must settle before messages
+	* from the replacement connection can be consumed (#1914 review).
+	*/
+	setAgent(agent) {
+		if (this.agent === agent) return;
+		this.resetResumeState();
+		this.agent = agent;
+	}
 	setCancelOnClientAbort(cancelOnClientAbort) {
 		this.cancelOnClientAbort = cancelOnClientAbort;
 	}
@@ -97,6 +109,35 @@ var WebSocketChatTransport = class {
 		return this._resumeResolver !== null || this._resumeNoneResolver !== null;
 	}
 	/**
+	* Settle and detach the current handshake without interpreting it as a
+	* server-idle response. Used when the owning hook/agent generation changes.
+	*/
+	cancelPendingResume() {
+		const resolveNone = this._resumeNoneResolver;
+		if (!resolveNone) return false;
+		return resolveNone({});
+	}
+	/**
+	* Invalidate all client-side resume state for an obsolete hook/agent
+	* generation without cancelling its durable server turn.
+	*/
+	resetResumeState() {
+		this._expectToolContinuation = false;
+		this.cancelPendingResume();
+		this._detachResumeStream?.();
+	}
+	/**
+	* Re-send the active handshake request on the latest socket generation. This
+	* preserves one AI SDK resume operation while recovering a request/reply lost
+	* with the previous WebSocket.
+	*/
+	retryPendingResume() {
+		const retry = this._retryResumeProbe;
+		if (!retry) return false;
+		retry();
+		return true;
+	}
+	/**
 	* 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
@@ -112,10 +153,9 @@ var WebSocketChatTransport = class {
 	* If reconnectToStream is waiting, resolves the promise with null
 	* immediately (no 5-second timeout). Returns true if handled.
 	*/
-	handleStreamResumeNone() {
+	handleStreamResumeNone(data = {}) {
 		if (!this._resumeNoneResolver) return false;
-		this._resumeNoneResolver();
-		return true;
+		return this._resumeNoneResolver(data);
 	}
 	/**
 	* Called by onAgentMessage when it receives CF_AGENT_STREAM_PENDING (#1784):
@@ -239,30 +279,47 @@ var WebSocketChatTransport = class {
 		return stream;
 	}
 	async reconnectToStream(_options) {
+		if (this.isAwaitingResume()) return null;
 		if (this._expectToolContinuation) {
 			this._expectToolContinuation = false;
 			return this._createToolContinuationStream();
 		}
 		const activeIds = this.activeRequestIds;
+		const probeId = nanoid(8);
 		return new Promise((resolve) => {
 			let resolved = false;
 			let timeout;
+			let resumeResolver = null;
+			let resumeNoneResolver = null;
+			let onStreamPending = null;
+			let retryResumeProbe = null;
+			const clearOwnedCallbacks = () => {
+				if (resumeResolver && this._resumeResolver === resumeResolver) this._resumeResolver = null;
+				if (resumeNoneResolver && this._resumeNoneResolver === resumeNoneResolver) this._resumeNoneResolver = null;
+				if (onStreamPending && this._onStreamPending === onStreamPending) this._onStreamPending = null;
+				if (retryResumeProbe && this._retryResumeProbe === retryResumeProbe) this._retryResumeProbe = null;
+			};
 			const done = (value) => {
 				if (resolved) return;
 				resolved = true;
-				this._resumeResolver = null;
-				this._resumeNoneResolver = null;
-				this._onStreamPending = null;
+				clearOwnedCallbacks();
 				if (timeout) clearTimeout(timeout);
 				resolve(value);
 			};
-			this._onStreamPending = () => {
-				if (resolved) return;
+			const armTimeout = (delay) => {
 				if (timeout) clearTimeout(timeout);
-				timeout = setTimeout(() => done(null), RESUME_PENDING_TIMEOUT_MS);
+				timeout = setTimeout(() => done(null), delay);
+			};
+			onStreamPending = () => {
+				if (resolved) return;
+				armTimeout(RESUME_PENDING_TIMEOUT_MS);
 			};
-			this._resumeNoneResolver = () => done(null);
-			this._resumeResolver = (data) => {
+			resumeNoneResolver = (data) => {
+				if (data.probeId && data.probeId !== probeId) return false;
+				done(null);
+				return true;
+			};
+			resumeResolver = (data) => {
 				const requestId = data.id;
 				activeIds?.add(requestId);
 				const stream = this._createResumeStream(requestId);
@@ -272,10 +329,21 @@ var WebSocketChatTransport = class {
 				}));
 				done(stream);
 			};
-			try {
-				this.agent.send(JSON.stringify({ type: "cf_agent_stream_resume_request" }));
-			} catch {}
-			timeout = setTimeout(() => done(null), RESUME_PROBE_TIMEOUT_MS);
+			retryResumeProbe = () => {
+				if (resolved) return;
+				armTimeout(RESUME_PROBE_TIMEOUT_MS);
+				try {
+					this.agent.send(JSON.stringify({
+						type: "cf_agent_stream_resume_request",
+						probeId
+					}));
+				} catch {}
+			};
+			this._onStreamPending = onStreamPending;
+			this._resumeNoneResolver = resumeNoneResolver;
+			this._resumeResolver = resumeResolver;
+			this._retryResumeProbe = retryResumeProbe;
+			retryResumeProbe();
 		});
 	}
 	/**
@@ -292,24 +360,26 @@ var WebSocketChatTransport = class {
 		abortError.name = "AbortError";
 		let completed = false;
 		let requestId = null;
-		let readerController;
+		let readerController = null;
+		const probeId = nanoid(8);
 		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;
+		let onStreamPendingRef = null;
+		let retryResumeProbeRef = null;
+		let abortToolContinuationRef = null;
+		let detachResumeStreamRef = null;
+		const clearOwnedHandshake = () => {
+			if (onResumeRef && this._resumeResolver === onResumeRef) this._resumeResolver = null;
+			if (onResumeNoneRef && this._resumeNoneResolver === onResumeNoneRef) this._resumeNoneResolver = null;
+			if (onStreamPendingRef && this._onStreamPending === onStreamPendingRef) this._onStreamPending = null;
+			if (retryResumeProbeRef && this._retryResumeProbe === retryResumeProbeRef) this._retryResumeProbe = null;
 		};
-		const finish = (action, resumeResolver, resumeNoneResolver, keepRequestId = false) => {
+		const finish = (action, keepRequestId = false) => {
 			if (completed) return;
 			completed = true;
-			this._abortToolContinuation = null;
-			this._onStreamPending = null;
-			clearHandshakeResolvers(resumeResolver, resumeNoneResolver);
+			if (this._abortToolContinuation === abortToolContinuationRef) this._abortToolContinuation = null;
+			if (this._detachResumeStream === detachResumeStreamRef) this._detachResumeStream = null;
+			clearOwnedHandshake();
 			try {
 				action();
 			} catch {}
@@ -317,10 +387,10 @@ var WebSocketChatTransport = class {
 			streamController.abort();
 		};
 		const transport = this;
-		this._abortToolContinuation = () => {
+		abortToolContinuationRef = () => {
 			if (completed) return false;
 			if (requestId === null) {
-				finish(() => readerController.error(abortError), onResumeRef, onResumeNoneRef);
+				finish(() => readerController?.error(abortError));
 				return true;
 			}
 			try {
@@ -329,71 +399,87 @@ var WebSocketChatTransport = class {
 					id: requestId
 				}));
 			} catch {}
-			finish(() => readerController.error(abortError), onResumeRef, onResumeNoneRef, true);
+			finish(() => readerController?.error(abortError), true);
 			return true;
 		};
+		this._abortToolContinuation = abortToolContinuationRef;
+		detachResumeStreamRef = () => {
+			if (completed) return false;
+			finish(() => readerController?.close());
+			return true;
+		};
+		this._detachResumeStream = detachResumeStreamRef;
 		return new ReadableStream({
 			start(controller) {
 				readerController = controller;
 				let timeout;
-				const onResumeNone = () => {
+				const armTimeout = (delay) => {
 					if (timeout) clearTimeout(timeout);
-					finish(() => controller.close(), onResume, onResumeNone);
+					timeout = setTimeout(() => finish(() => controller.close()), delay);
+				};
+				const onResumeNone = (data) => {
+					if (data.probeId && data.probeId !== probeId) return false;
+					finish(() => controller.close());
+					return true;
 				};
 				const onResume = (data) => {
 					if (requestId) return;
 					requestId = data.id;
 					activeIds?.add(requestId);
-					clearHandshakeResolvers(onResume, onResumeNone);
-					transport._onStreamPending = null;
+					clearOwnedHandshake();
 					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 = () => {
+				const onStreamPending = () => {
 					if (completed) return;
-					if (timeout) clearTimeout(timeout);
-					timeout = setTimeout(() => finish(() => controller.close(), onResume, onResumeNone), RESUME_PENDING_TIMEOUT_MS);
+					armTimeout(RESUME_PENDING_TIMEOUT_MS);
+				};
+				const retryResumeProbe = () => {
+					if (completed || requestId !== null) return;
+					armTimeout(RESUME_PROBE_TIMEOUT_MS);
+					try {
+						transport.agent.send(JSON.stringify({
+							type: "cf_agent_stream_resume_request",
+							probeId
+						}));
+					} catch {}
 				};
+				onResumeRef = onResume;
+				onResumeNoneRef = onResumeNone;
+				onStreamPendingRef = onStreamPending;
+				retryResumeProbeRef = retryResumeProbe;
 				transport._resumeResolver = onResume;
 				transport._resumeNoneResolver = onResumeNone;
+				transport._onStreamPending = onStreamPending;
+				transport._retryResumeProbe = retryResumeProbe;
 				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);
+							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(), onResume, onResumeNone);
+						if (data.done) finish(() => controller.close());
 					} catch {}
 				};
-				const onClose = () => {
-					if (timeout) clearTimeout(timeout);
-					finish(() => controller.close(), onResume, onResumeNone);
-				};
+				const onClose = () => finish(() => controller.close());
 				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());
-				}
+				retryResumeProbe();
 			},
 			cancel() {
 				if (requestId && transport.cancelOnClientAbort) {
 					transport.sendCancelFrame(requestId);
-					finish(() => {}, onResumeRef, onResumeNoneRef, true);
-				} else finish(() => {}, onResumeRef, onResumeNoneRef);
+					finish(() => {}, true);
+				} else finish(() => {});
 			}
 		});
 	}
@@ -408,24 +494,32 @@ var WebSocketChatTransport = class {
 		const abortError = /* @__PURE__ */ new Error("Aborted");
 		abortError.name = "AbortError";
 		let completed = false;
+		let detachResumeStream = null;
 		const finish = (action, keepId = false, clearServerTurn = true) => {
 			if (completed) return;
 			completed = true;
 			if (clearServerTurn) this.clearActiveServerTurn(requestId);
+			if (this._detachResumeStream === detachResumeStream) this._detachResumeStream = null;
 			try {
 				action();
 			} catch {}
 			if (!keepId) activeIds?.delete(requestId);
 			chunkController.abort();
 		};
+		let streamController = null;
 		const cancelActiveRequest = () => {
 			if (completed) return false;
-			finish(() => streamController.error(abortError), true);
+			finish(() => streamController?.error(abortError), true);
 			return true;
 		};
 		this.setActiveServerTurn(requestId, cancelActiveRequest);
-		let streamController;
 		const transport = this;
+		detachResumeStream = () => {
+			if (completed) return false;
+			finish(() => streamController?.close());
+			return true;
+		};
+		this._detachResumeStream = detachResumeStream;
 		return new ReadableStream({
 			start(controller) {
 				streamController = controller;
@@ -763,7 +857,7 @@ function useAgentChat(options) {
 			return extraBody;
 		}
 	});
-	customTransportRef.current.agent = agentRef.current;
+	customTransportRef.current.setAgent(agentRef.current);
 	customTransportRef.current.setCancelOnClientAbort(cancelOnClientAbort);
 	const customTransport = customTransportRef.current;
 	const useChatHelpers = useChat({
@@ -772,16 +866,36 @@ function useAgentChat(options) {
 		messages: initialMessages,
 		transport: customTransport,
 		id: stableChatIdRef.current,
-		resume
+		resume: false
 	});
-	const { messages: chatMessages, setMessages, addToolResult, addToolApprovalResponse, sendMessage, resumeStream, status, stop } = useChatHelpers;
+	const { messages: chatMessages, setMessages, addToolResult, addToolApprovalResponse, sendMessage, resumeStream: rawResumeStream, status, stop } = useChatHelpers;
 	const statusRef = useRef(status);
 	statusRef.current = status;
+	const resumeGenerationRef = useRef(0);
+	const resumeOperationRef = useRef(null);
+	const reconnectProbePendingRef = useRef(false);
+	const reconnectProbeRunnerRef = useRef(null);
+	const invalidateResumeGeneration = useCallback(() => {
+		resumeGenerationRef.current++;
+		resumeOperationRef.current = null;
+	}, []);
+	const resumeStream = useCallback((...args) => {
+		const active = resumeOperationRef.current;
+		if (active) return active.promise;
+		const operation = {
+			generation: resumeGenerationRef.current,
+			promise: Promise.resolve()
+		};
+		resumeOperationRef.current = operation;
+		operation.promise = rawResumeStream(...args).finally(() => {
+			if (resumeOperationRef.current !== operation || resumeGenerationRef.current !== operation.generation) return;
+			resumeOperationRef.current = null;
+			reconnectProbeRunnerRef.current?.();
+		});
+		return operation.promise;
+	}, [rawResumeStream]);
 	const resumeStreamRef = useRef(resumeStream);
 	resumeStreamRef.current = resumeStream;
-	const hasConnectedOnceRef = useRef(false);
-	const resumeInFlightRef = useRef(false);
-	const resumeGenerationRef = useRef(0);
 	const resumingToolContinuationRef = useRef(false);
 	const pendingToolContinuationRef = useRef(false);
 	const observedToolContinuationRequestIdRef = useRef(null);
@@ -801,20 +915,24 @@ function useAgentChat(options) {
 	}, []);
 	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);
-			});
+		const timer = setTimeout(() => {
+			(async () => {
+				while (resumeOperationRef.current) await resumeOperationRef.current.promise.catch(() => {});
+				if (continuationLaunchTimerRef.current === timer) continuationLaunchTimerRef.current = null;
+				if (!pendingToolContinuationRef.current || statusRef.current !== "ready") return;
+				pendingToolContinuationRef.current = false;
+				const myGeneration = continuationGenerationRef.current;
+				customTransport.expectToolContinuation();
+				await resumeStream().catch((error) => {
+					console.error("[useAgentChat] Tool continuation resume failed:", error);
+				}).finally(() => {
+					if (continuationGenerationRef.current !== myGeneration) return;
+					resumingToolContinuationRef.current = false;
+					setIsToolContinuation(false);
+				});
+			})();
 		}, 0);
+		continuationLaunchTimerRef.current = timer;
 	}, [customTransport, resumeStream]);
 	const startToolContinuation = useCallback(() => {
 		if (!autoContinueAfterToolResult || resumingToolContinuationRef.current) return;
@@ -1203,7 +1321,12 @@ function useAgentChat(options) {
 					});
 					break;
 				case "cf_agent_stream_resume_none":
-					customTransport.handleStreamResumeNone();
+					if (customTransport.handleStreamResumeNone(data) && 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);
+						if (observedToolContinuationRequestIdRef.current !== null) resetToolContinuation();
+					}
 					break;
 				case "cf_agent_stream_pending":
 					customTransport.handleStreamPending();
@@ -1274,6 +1397,7 @@ function useAgentChat(options) {
 							localResponseIds.delete(data.id);
 							localRequestIdsRef.current.delete(data.id);
 							fallbackAckedResumeRequestIdsRef.current.delete(data.id);
+							if (observedToolContinuationRequestIdRef.current === data.id) resetToolContinuation();
 						}
 						return;
 					}
@@ -1317,28 +1441,51 @@ function useAgentChat(options) {
 			}
 		}
 		const fallbackAckedResumeRequestIds = fallbackAckedResumeRequestIdsRef.current;
+		let socketIsOpen = false;
+		let sawClose = false;
+		let disposed = false;
+		const clearFallbackObserver = () => {
+			const result = transition(streamStateRef.current, { type: "clear" });
+			streamStateRef.current = result.state;
+			setIsServerStreaming(result.isStreaming);
+			if (observedToolContinuationRequestIdRef.current !== null) resetToolContinuation();
+		};
+		const tryPendingReconnectProbe = () => {
+			if (disposed || !socketIsOpen || !reconnectProbePendingRef.current) return;
+			if (!resume) {
+				reconnectProbePendingRef.current = false;
+				return;
+			}
+			if (customTransport.retryPendingResume()) {
+				reconnectProbePendingRef.current = false;
+				return;
+			}
+			const canReconcileObservedContinuation = observedToolContinuationRequestIdRef.current !== null;
+			if (statusRef.current !== "ready" && statusRef.current !== "error" || resumingToolContinuationRef.current && !canReconcileObservedContinuation || resumeOperationRef.current !== null) return;
+			reconnectProbePendingRef.current = false;
+			resumeStreamRef.current().catch(() => {});
+		};
+		reconnectProbeRunnerRef.current = tryPendingReconnectProbe;
 		function onAgentClose() {
+			socketIsOpen = false;
+			sawClose = true;
 			fallbackAckedResumeRequestIds.clear();
+			if (!resume) clearFallbackObserver();
 		}
 		function onAgentOpen() {
-			if (!hasConnectedOnceRef.current) {
-				hasConnectedOnceRef.current = true;
-				return;
-			}
-			if (!resume || statusRef.current !== "ready" || resumingToolContinuationRef.current || resumeInFlightRef.current || customTransport.isAwaitingResume()) return;
-			const resumeStreamFn = resumeStreamRef.current;
-			if (!resumeStreamFn) return;
-			resumeInFlightRef.current = true;
-			const myGeneration = resumeGenerationRef.current;
-			Promise.resolve(resumeStreamFn()).catch(() => {}).finally(() => {
-				if (resumeGenerationRef.current !== myGeneration) return;
-				resumeInFlightRef.current = false;
-			});
+			socketIsOpen = true;
+			if (!sawClose) return;
+			sawClose = false;
+			reconnectProbePendingRef.current = true;
+			tryPendingReconnectProbe();
 		}
 		agent.addEventListener("message", onAgentMessage);
 		agent.addEventListener("close", onAgentClose);
 		agent.addEventListener("open", onAgentOpen);
 		return () => {
+			disposed = true;
+			if (reconnectProbeRunnerRef.current === tryPendingReconnectProbe) reconnectProbeRunnerRef.current = null;
+			reconnectProbePendingRef.current = false;
 			agent.removeEventListener("message", onAgentMessage);
 			agent.removeEventListener("close", onAgentClose);
 			agent.removeEventListener("open", onAgentOpen);
@@ -1348,8 +1495,8 @@ function useAgentChat(options) {
 			setIsRecovering(false);
 			protectedStreamingAssistantRef.current = null;
 			localResponseIds.clear();
-			resumeGenerationRef.current++;
-			resumeInFlightRef.current = false;
+			customTransport.resetResumeState();
+			invalidateResumeGeneration();
 		};
 	}, [
 		agent,
@@ -1360,8 +1507,16 @@ function useAgentChat(options) {
 		resetToolContinuation,
 		resetMatchingHydratedAssistantForReplay,
 		restoreProtectedStreamingAssistant,
-		resetLocalChatState
+		resetLocalChatState,
+		invalidateResumeGeneration
 	]);
+	useEffect(() => {
+		if (!resume) return;
+		resumeStream().catch(() => {});
+	}, [resume, resumeStream]);
+	useEffect(() => {
+		reconnectProbeRunnerRef.current?.();
+	}, [isToolContinuation, status]);
 	const addToolResultAndSendMessage = async (args) => {
 		const { toolCallId } = args;
 		const toolName = "tool" in args ? args.tool : "";
@@ -1464,6 +1619,7 @@ function useAgentChat(options) {
 	const isStreaming = status === "streaming" || effectiveIsServerStreaming;
 	return {
 		...useChatHelpers,
+		resumeStream,
 		messages: messagesWithToolResults,
 		isServerStreaming: effectiveIsServerStreaming,
 		isStreaming,