agents 0.20.0 → 0.21.0

package/dist/chat/react.js

@@ -1,560 +1,10 @@
-import { i as transition, r as STREAM_RESUME_NONE_REASONS } from "../wire-types-CU9rLoeS.js";
+import { n as STREAM_RESUME_NONE_REASONS, r as transition } from "../protocol-Dqc2MQxo.js";
+import "../wire-types-CnMt6_HR.js";
+import { t as WebSocketChatTransport } from "../ws-chat-transport-CIoOBbO7.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._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;
-	}
-	/**
-	* 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;
-	}
-	/**
-	* 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
-	* 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(data = {}) {
-		if (!this._resumeNoneResolver) return false;
-		return this._resumeNoneResolver(data);
-	}
-	/**
-	* 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.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;
-				clearOwnedCallbacks();
-				if (timeout) clearTimeout(timeout);
-				resolve(value);
-			};
-			const armTimeout = (delay) => {
-				if (timeout) clearTimeout(timeout);
-				timeout = setTimeout(() => done(null), delay);
-			};
-			onStreamPending = () => {
-				if (resolved) return;
-				armTimeout(RESUME_PENDING_TIMEOUT_MS);
-			};
-			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);
-				this.agent.send(JSON.stringify({
-					type: "cf_agent_stream_resume_ack",
-					id: requestId
-				}));
-				done(stream);
-			};
-			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();
-		});
-	}
-	/**
-	* 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 = null;
-		const probeId = nanoid(8);
-		let onResumeRef = null;
-		let onResumeNoneRef = 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, keepRequestId = false) => {
-			if (completed) return;
-			completed = true;
-			if (this._abortToolContinuation === abortToolContinuationRef) this._abortToolContinuation = null;
-			if (this._detachResumeStream === detachResumeStreamRef) this._detachResumeStream = null;
-			clearOwnedHandshake();
-			try {
-				action();
-			} catch {}
-			if (requestId && !keepRequestId) activeIds?.delete(requestId);
-			streamController.abort();
-		};
-		const transport = this;
-		abortToolContinuationRef = () => {
-			if (completed) return false;
-			if (requestId === null) {
-				finish(() => readerController?.error(abortError));
-				return true;
-			}
-			try {
-				agent.send(JSON.stringify({
-					type: "cf_agent_chat_request_cancel",
-					id: requestId
-				}));
-			} catch {}
-			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 armTimeout = (delay) => {
-					if (timeout) clearTimeout(timeout);
-					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);
-					clearOwnedHandshake();
-					if (timeout) clearTimeout(timeout);
-					agent.send(JSON.stringify({
-						type: "cf_agent_stream_resume_ack",
-						id: requestId
-					}));
-				};
-				const onStreamPending = () => {
-					if (completed) return;
-					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")));
-							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());
-				agent.addEventListener("message", onMessage, { signal: streamController.signal });
-				agent.addEventListener("close", onClose, { signal: streamController.signal });
-				retryResumeProbe();
-			},
-			cancel() {
-				if (requestId && transport.cancelOnClientAbort) {
-					transport.sendCancelFrame(requestId);
-					finish(() => {}, true);
-				} else finish(() => {});
-			}
-		});
-	}
-	/**
-	* 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;
-		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);
-			return true;
-		};
-		this.setActiveServerTurn(requestId, cancelActiveRequest);
-		const transport = this;
-		detachResumeStream = () => {
-			if (completed) return false;
-			finish(() => streamController?.close());
-			return true;
-		};
-		this._detachResumeStream = detachResumeStream;
-		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).
@@ -1386,8 +836,8 @@ function useAgentChat(options) {
 								}
 							}
 						} catch {}
-						if (data.done || data.replayComplete) pendingReplayResumeRequestIdsRef.current.delete(data.id);
-						if (data.done) {
+						if (data.done || data.error || data.replayComplete) pendingReplayResumeRequestIdsRef.current.delete(data.id);
+						if (data.done || data.error) {
 							if (streamStateRef.current.status === "observing" && streamStateRef.current.streamId === data.id) {
 								streamStateRef.current = { status: "idle" };
 								setIsServerStreaming(false);
@@ -1403,6 +853,19 @@ function useAgentChat(options) {
 					}
 					let chunkData;
 					if (data.replay && streamStateRef.current.status !== "observing" && !pendingReplayResumeRequestIdsRef.current.has(data.id)) return;
+					if (data.error) {
+						pendingReplayResumeRequestIdsRef.current.delete(data.id);
+						customTransport.handleServerTurnCompleted(data.id);
+						fallbackAckedResumeRequestIdsRef.current.delete(data.id);
+						setIsRecovering(false);
+						if (streamStateRef.current.status === "idle" || streamStateRef.current.streamId === data.id) {
+							const result = transition(streamStateRef.current, { type: "clear" });
+							streamStateRef.current = result.state;
+							setIsServerStreaming(result.isStreaming);
+						}
+						if (observedToolContinuationRequestIdRef.current === data.id) resetToolContinuation();
+						break;
+					}
 					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") {