agents 0.13.3 → 0.14.0

package/dist/mcp/index.js

@@ -1,11 +1,43 @@
 import "../types.js";
-import { a as RPCServerTransport, i as RPCClientTransport, o as RPC_DO_PREFIX } from "../client-D1kFXo80.js";
+import { c as RPC_DO_PREFIX, i as normalizeServerId, n as MCP_SERVER_ID_MAX_LENGTH, o as RPCClientTransport, s as RPCServerTransport } from "../client-NradHZZz.js";
 import { Agent, getAgentByName, getCurrentAgent } from "../index.js";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 import { ElicitRequestSchema, InitializeRequestSchema, JSONRPCMessageSchema, SUPPORTED_PROTOCOL_VERSIONS, isInitializeRequest, isJSONRPCErrorResponse, isJSONRPCNotification, isJSONRPCRequest, isJSONRPCResultResponse } from "@modelcontextprotocol/sdk/types.js";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+//#region src/mcp/sse-keepalive.ts
+/**
+* Shared SSE keepalive utility for MCP transports.
+*
+* Cloudflare's edge closes idle SSE responses after ~5 minutes. Writers
+* that may sit silent for that long (long-running tool calls, idle
+* standalone GET streams) arm a keepalive to keep the response under the
+* watchdog.
+*
+* See cloudflare/agents#1583.
+*/
+/** Interval between SSE keepalive comment frames, in ms.
+*
+* The WHATWG SSE spec recommends a comment line every "15 seconds or so"
+* (html.spec.whatwg.org §9.2.7). 25s gives comfortable headroom below
+* both the ~30s post-handler background-work cancellation window on
+* Workers and the ~5min Cloudflare edge idle-stream watchdog.
+*/
+const KEEPALIVE_INTERVAL_MS = 25e3;
+/** SSE comment frame the parser drops before any event dispatch. */
+const KEEPALIVE_FRAME = ": keepalive\n\n";
+/**
+* Start an SSE keepalive on `writer`. Returns a `clearInterval` handle
+* that the stream cleanup must invoke when the stream closes.
+*/
+function startKeepalive(writer, encoder) {
+	const handle = setInterval(() => {
+		writer.write(encoder.encode(KEEPALIVE_FRAME)).catch(() => clearInterval(handle));
+	}, KEEPALIVE_INTERVAL_MS);
+	return handle;
+}
+//#endregion
 //#region src/mcp/utils.ts
 /**
 * Since we use WebSockets to bridge the client to the
@@ -175,6 +207,14 @@ const createStreamingHttpHandler = (basePath, namespace, options = {}) => {
 					return new Response(body, { status: 500 });
 				}
 				ws.accept();
+				if (messages.every((msg) => isJSONRPCNotification(msg) || isJSONRPCResultResponse(msg))) {
+					ws.close();
+					return new Response(null, {
+						headers: corsHeaders(request, options.corsOptions),
+						status: 202
+					});
+				}
+				const keepAlive = startKeepalive(writer, encoder);
 				ws.addEventListener("message", (event) => {
 					async function onMessage(event) {
 						try {
@@ -183,6 +223,7 @@ const createStreamingHttpHandler = (basePath, namespace, options = {}) => {
 							if (message.type !== "cf_mcp_agent_event") return;
 							await writer.write(encoder.encode(message.event));
 							if (message.close) {
+								clearInterval(keepAlive);
 								ws?.close();
 								await writer.close().catch(() => {});
 							}
@@ -194,23 +235,18 @@ const createStreamingHttpHandler = (basePath, namespace, options = {}) => {
 				});
 				ws.addEventListener("error", (error) => {
 					async function onError(_error) {
+						clearInterval(keepAlive);
 						await writer.close().catch(() => {});
 					}
 					onError(error).catch(console.error);
 				});
 				ws.addEventListener("close", () => {
 					async function onClose() {
+						clearInterval(keepAlive);
 						await writer.close().catch(() => {});
 					}
 					onClose().catch(console.error);
 				});
-				if (messages.every((msg) => isJSONRPCNotification(msg) || isJSONRPCResultResponse(msg))) {
-					ws.close();
-					return new Response(null, {
-						headers: corsHeaders(request, options.corsOptions),
-						status: 202
-					});
-				}
 				return new Response(readable, {
 					headers: {
 						"Cache-Control": "no-cache",
@@ -531,6 +567,9 @@ var McpSSETransport = class {
 		this.onclose?.();
 	}
 };
+function isClearableEventStore(store) {
+	return typeof store.clearStream === "function";
+}
 /**
 * Adapted from: https://github.com/modelcontextprotocol/typescript-sdk/blob/main/src/client/streamableHttp.ts
 * - Validation and initialization are removed as they're handled in `McpAgent.serve()` handler.
@@ -540,10 +579,12 @@ var McpSSETransport = class {
 *
 * Besides these points, the implementation is the same and should be updated to match the original as new features are added.
 */
+/** Fixed streamId for the standalone GET listen stream. */
+const STANDALONE_STREAM_ID = "_GET_stream";
 var StreamableHTTPServerTransport = class {
 	constructor(options) {
 		this._started = false;
-		this._requestResponseMap = /* @__PURE__ */ new Map();
+		this._streamResponseIds = /* @__PURE__ */ new Map();
 		const { agent } = getCurrentAgent();
 		if (!agent) throw new Error("McpAgent was not found in Transport constructor");
 		this.sessionId = agent.getSessionId();
@@ -558,19 +599,63 @@ var StreamableHTTPServerTransport = class {
 		this._started = true;
 	}
 	/**
-	* Handles GET requests for SSE stream
+	* Handles GET requests for SSE stream.
+	*
+	* Two roles a GET can play:
+	*   1. Fresh standalone listen stream — carries server-initiated
+	*      requests/notifications unrelated to any in-progress POST.
+	*   2. Resumption of a previously-disconnected stream via
+	*      `Last-Event-ID`. The disconnected stream may have been the
+	*      standalone stream OR a POST tool-call response stream; per the
+	*      MCP 2025-03-26 spec the server replays missed messages "on the
+	*      stream that was disconnected" and continues delivering
+	*      subsequent messages on that same stream.
+	*
+	* To resume a POST stream we recover the original streamId from the
+	* event-store and the original `requestIds` from durable storage,
+	* then write them onto the new WS connection so `send()` keeps
+	* routing in-flight tool responses to it.
 	*/
 	async handleGetRequest(req) {
-		const { connection } = getCurrentAgent();
+		const { connection, agent } = getCurrentAgent();
 		if (!connection) throw new Error("Connection was not found in handleGetRequest");
-		if (this._eventStore) {
-			const lastEventId = req.headers.get("last-event-id");
-			if (lastEventId) {
+		if (!agent) throw new Error("Agent was not found in handleGetRequest");
+		const lastEventId = req.headers.get("last-event-id");
+		if (this._eventStore && lastEventId) {
+			const resumedStreamId = await this._eventStore.getStreamIdForEventId?.(lastEventId);
+			if (resumedStreamId) {
+				const resumeState = { streamId: resumedStreamId };
+				if (resumedStreamId === STANDALONE_STREAM_ID) resumeState._standaloneSse = true;
+				else {
+					const persistedReqs = await agent.getStreamRequestIds(resumedStreamId);
+					if (persistedReqs && persistedReqs.length > 0) resumeState.requestIds = persistedReqs;
+				}
+				this.supersedePriorStreamConnections(agent, connection.id, resumedStreamId);
+				connection.setState(resumeState);
 				await this.replayEvents(lastEventId);
 				return;
 			}
 		}
-		connection.setState({ _standaloneSse: true });
+		this.supersedePriorStreamConnections(agent, connection.id, STANDALONE_STREAM_ID);
+		const standaloneState = {
+			streamId: STANDALONE_STREAM_ID,
+			_standaloneSse: true
+		};
+		connection.setState(standaloneState);
+	}
+	/**
+	* Close any connection (other than `selfId`) currently bound to
+	* `streamId`, so at most one live connection serves a given stream.
+	* Closing rather than mutating sibling state mirrors how the SDK's
+	* single `_streamMapping` entry gives last-writer-wins for free, and
+	* keeps `send()` from routing to a stale bridge.
+	*/
+	supersedePriorStreamConnections(agent, selfId, streamId) {
+		for (const other of agent.getConnections()) {
+			if (other.id === selfId) continue;
+			if (other.state?.streamId !== streamId) continue;
+			other.close(1e3, "Superseded by resumed stream");
+		}
 	}
 	/**
 	* Replays events that would have been sent after the specified event ID
@@ -635,10 +720,17 @@ var StreamableHTTPServerTransport = class {
 			});
 		}
 		else if (hasRequests) {
-			const { connection } = getCurrentAgent();
+			const { connection, agent } = getCurrentAgent();
 			if (!connection) throw new Error("Connection was not found in handlePostRequest");
+			if (!agent) throw new Error("Agent was not found in handlePostRequest");
 			const requestIds = messages.filter(isJSONRPCRequest).map((message) => message.id);
-			connection.setState({ requestIds });
+			const streamId = connection.id;
+			const postState = {
+				streamId,
+				requestIds
+			};
+			connection.setState(postState);
+			if (this._eventStore) await agent.setStreamRequestIds(streamId, requestIds);
 			for (const message of messages) {
 				if (this.messageInterceptor) {
 					if (await this.messageInterceptor(message, {
@@ -659,36 +751,228 @@ var StreamableHTTPServerTransport = class {
 		for (const conn of agent.getConnections()) conn.close(1e3, "Session closed");
 		this.onclose?.();
 	}
+	/**
+	* Store the event, decide whether this is the final response, write
+	* the SSE frame iff a live connection is attached, then run cleanup.
+	* Caller resolves `streamId` and `relatedIds` (from connection state
+	* or persisted reverse lookup) and passes `liveConnection` as null
+	* when the originating WS has dropped.
+	*/
+	async sendOnStream(agent, streamId, relatedIds, liveConnection, message, requestId) {
+		const eventId = await this._eventStore?.storeEvent(streamId, message);
+		let shouldClose = false;
+		if (isJSONRPCResultResponse(message) || isJSONRPCErrorResponse(message)) {
+			let responseIds = this._streamResponseIds.get(streamId);
+			if (!responseIds) {
+				responseIds = /* @__PURE__ */ new Set();
+				this._streamResponseIds.set(streamId, responseIds);
+			}
+			responseIds.add(requestId);
+			shouldClose = relatedIds.every((id) => responseIds.has(id));
+			if (shouldClose) this._streamResponseIds.delete(streamId);
+		}
+		if (liveConnection) try {
+			this.writeSSEEvent(liveConnection, message, eventId, shouldClose);
+		} catch (error) {
+			this.onerror?.(error);
+		}
+		if (shouldClose) {
+			await agent.deleteStreamRequestIds(streamId);
+			if (this._eventStore && isClearableEventStore(this._eventStore)) await this._eventStore.clearStream(streamId);
+		}
+	}
 	async send(message, options) {
+		const isResponse = isJSONRPCResultResponse(message) || isJSONRPCErrorResponse(message);
+		const requestId = isResponse ? message.id : options?.relatedRequestId;
+		if (requestId === void 0) {
+			if (isResponse) throw new Error("Cannot send a response on a standalone SSE stream unless resuming a previous client request");
+			return this.sendStandalone(message);
+		}
+		return this.sendForRequest(message, requestId);
+	}
+	/**
+	* Server-initiated message on the standalone GET stream. Stored under
+	* a fixed streamId so it's replayable even when no live connection is
+	* currently attached.
+	*
+	* Sent on exactly one stream, per MCP: "the server MUST send each of
+	* its JSON-RPC messages on only one of the connected streams; it MUST
+	* NOT broadcast the same message across multiple streams."
+	* `handleGetRequest` supersedes prior standalone connections, so
+	* there is at most one to send on.
+	*/
+	async sendStandalone(message) {
 		const { agent } = getCurrentAgent();
 		if (!agent) throw new Error("Agent was not found in send");
-		let requestId = options?.relatedRequestId;
-		if (isJSONRPCResultResponse(message) || isJSONRPCErrorResponse(message)) requestId = message.id;
-		if (requestId === void 0) {
-			if (isJSONRPCResultResponse(message) || isJSONRPCErrorResponse(message)) throw new Error("Cannot send a response on a standalone SSE stream unless resuming a previous client request");
-			let standaloneConnection;
-			for (const conn of agent.getConnections()) if (conn.state?._standaloneSse) standaloneConnection = conn;
-			if (standaloneConnection === void 0) return;
-			let eventId;
-			if (this._eventStore) eventId = await this._eventStore.storeEvent(standaloneConnection.id, message);
-			this.writeSSEEvent(standaloneConnection, message, eventId);
+		const eventId = await this._eventStore?.storeEvent(STANDALONE_STREAM_ID, message);
+		const standalone = Array.from(agent.getConnections()).find((conn) => conn.state?._standaloneSse);
+		if (standalone) this.writeSSEEvent(standalone, message, eventId);
+	}
+	/**
+	* Message scoped to a specific in-flight client request: a tool
+	* response, error, or progress notification. Resolves which stream
+	* owns the request id (live POST connection, resumed GET, or
+	* persisted reverse lookup for a dropped WS) and delegates to
+	* {@link sendOnStream} for the actual store / write / cleanup.
+	*/
+	async sendForRequest(message, requestId) {
+		const { agent, connection: originatingConnection } = getCurrentAgent();
+		if (!agent) throw new Error("Agent was not found in send");
+		const matchingConnections = Array.from(agent.getConnections()).filter((conn) => conn.state?.requestIds?.includes(requestId));
+		const liveConnection = matchingConnections.find((conn) => conn.id === originatingConnection?.id) ?? (matchingConnections.length === 1 ? matchingConnections[0] : null);
+		if (!liveConnection && matchingConnections.length > 1) {
+			const routingError = {
+				jsonrpc: "2.0",
+				id: requestId,
+				error: {
+					code: -32603,
+					message: "Internal error"
+				}
+			};
+			await Promise.all(matchingConnections.map((candidate) => this.sendOnStream(agent, candidate.state?.streamId ?? candidate.id, candidate.state?.requestIds ?? [], candidate, routingError, requestId)));
 			return;
 		}
-		const connection = Array.from(agent.getConnections()).find((conn) => conn.state?.requestIds?.includes(requestId));
-		if (!connection) throw new Error(`No connection established for request ID: ${String(requestId)}`);
-		let eventId;
-		if (this._eventStore) eventId = await this._eventStore.storeEvent(connection.id, message);
-		let shouldClose = false;
-		if (isJSONRPCResultResponse(message) || isJSONRPCErrorResponse(message)) {
-			this._requestResponseMap.set(requestId, message);
-			const relatedIds = connection.state?.requestIds ?? [];
-			shouldClose = relatedIds.every((id) => this._requestResponseMap.has(id));
-			if (shouldClose) for (const id of relatedIds) this._requestResponseMap.delete(id);
+		let streamId = liveConnection?.state?.streamId;
+		let relatedIds = liveConnection?.state?.requestIds;
+		if (!streamId) {
+			const stored = await agent.getStreamForRequestId(requestId);
+			if (!stored) throw new Error(`No active stream found for request ID: ${String(requestId)}`);
+			streamId = stored.streamId;
+			relatedIds = stored.requestIds;
 		}
-		this.writeSSEEvent(connection, message, eventId, shouldClose);
+		await this.sendOnStream(agent, streamId, relatedIds ?? [], liveConnection, message, requestId);
 	}
 };
 //#endregion
+//#region src/mcp/event-store.ts
+/**
+* Durable Object–backed {@link EventStore} for SSE resumability.
+*
+* Default for `McpAgent`. Override `McpAgent.getEventStore()` to swap
+* or disable.
+*
+* ## Storage layout
+*
+* Events are stored under `__mcp_event__:<streamId>:<seqHex>`, where
+* `<seqHex>` is a 16-char zero-padded counter so events in a stream
+* sort lexicographically and `getStreamIdForEventId` can recover the
+* stream from `eventId` without a storage hit.
+*
+* ## Lifecycle
+*
+* Each POST tool-call stream's events live only until the final
+* response is delivered. The transport calls {@link clearStream}
+* immediately after writing the close frame, so storage growth is
+* bounded by the in-flight POST streams plus the standalone GET
+* stream. There is no background sweep — quiescent agents do no work,
+* and the DO itself dies with the session.
+*
+* Standalone GET stream events (`_GET_stream`) are *not* cleared
+* automatically; they accumulate for the lifetime of the DO. Bounded
+* by session length in practice.
+*
+* Trade-off: if the client TCP connection dies *after* the close
+* frame has been enqueued on the WS but before the bytes reach the
+* client, the final message is unreplayable. Every earlier event in
+* the stream is still replayable while the in-flight stream is open.
+*
+* ## Stream id constraints
+*
+* `streamId` MUST NOT contain `:`. `storeEvent` asserts this so
+* embedders using custom stream ids fail loudly rather than risk
+* prefix-scan collisions (e.g. clearing `a` accidentally hitting
+* `a:b`). Default ids (`connection.id` UUIDs and the literal
+* `_GET_stream`) already satisfy this.
+*/
+var DurableObjectEventStore = class DurableObjectEventStore {
+	constructor(storage) {
+		this.seqByStream = /* @__PURE__ */ new Map();
+		this.seqInit = /* @__PURE__ */ new Map();
+		this.storage = storage;
+	}
+	async storeEvent(streamId, message) {
+		if (streamId.includes(":")) throw new Error(`DurableObjectEventStore: streamId must not contain ':' (got ${JSON.stringify(streamId)})`);
+		await this.ensureSeqLoaded(streamId);
+		const seq = (this.seqByStream.get(streamId) ?? 0) + 1;
+		this.seqByStream.set(streamId, seq);
+		const eventId = `${streamId}:${seq.toString(16).padStart(DurableObjectEventStore.SEQ_PAD, "0")}`;
+		const eventKey = `${DurableObjectEventStore.EVENT_KEY_PREFIX}${eventId}`;
+		await this.storage.put(eventKey, message);
+		return eventId;
+	}
+	async getStreamIdForEventId(eventId) {
+		const idx = eventId.lastIndexOf(":");
+		return idx > 0 ? eventId.slice(0, idx) : void 0;
+	}
+	async replayEventsAfter(lastEventId, { send }) {
+		const streamId = await this.getStreamIdForEventId(lastEventId);
+		if (!streamId) return "";
+		const prefix = `${DurableObjectEventStore.EVENT_KEY_PREFIX}${streamId}:`;
+		const startKey = `${DurableObjectEventStore.EVENT_KEY_PREFIX}${lastEventId}\x00`;
+		const rows = await this.storage.list({
+			prefix,
+			start: startKey,
+			limit: DurableObjectEventStore.REPLAY_LIMIT
+		});
+		for (const [key, message] of rows) await send(key.slice(DurableObjectEventStore.EVENT_KEY_PREFIX.length), message);
+		return streamId;
+	}
+	/**
+	* Drop the event log for a single stream. Called by the transport
+	* immediately after a POST's final response has been written to the
+	* wire — no future `Last-Event-ID` for this stream is expected to
+	* resolve.
+	*
+	* Lists and deletes in chunks of {@link DELETE_CHUNK} (128, the DO
+	* storage cap) so we never load the entire event log into memory.
+	* After deleting, the next `list` call won't see the deleted keys,
+	* so passing `start: <prefix>` again is enough — no cursor bookkeeping.
+	*/
+	async clearStream(streamId) {
+		const prefix = `${DurableObjectEventStore.EVENT_KEY_PREFIX}${streamId}:`;
+		for (;;) {
+			const rows = await this.storage.list({
+				prefix,
+				limit: DurableObjectEventStore.DELETE_CHUNK
+			});
+			if (rows.size === 0) break;
+			await this.storage.delete([...rows.keys()]);
+		}
+		this.seqByStream.delete(streamId);
+		this.seqInit.delete(streamId);
+	}
+	async ensureSeqLoaded(streamId) {
+		if (this.seqByStream.has(streamId)) return;
+		let pending = this.seqInit.get(streamId);
+		if (!pending) {
+			pending = (async () => {
+				const prefix = `${DurableObjectEventStore.EVENT_KEY_PREFIX}${streamId}:`;
+				const rows = await this.storage.list({
+					prefix,
+					reverse: true,
+					limit: 1
+				});
+				let seq = 0;
+				for (const key of rows.keys()) {
+					const parsed = Number.parseInt(key.slice(prefix.length), 16);
+					if (Number.isFinite(parsed)) seq = parsed;
+				}
+				if (!this.seqByStream.has(streamId)) this.seqByStream.set(streamId, seq);
+			})();
+			this.seqInit.set(streamId, pending);
+		}
+		try {
+			await pending;
+		} finally {
+			this.seqInit.delete(streamId);
+		}
+	}
+};
+DurableObjectEventStore.EVENT_KEY_PREFIX = "__mcp_event__:";
+DurableObjectEventStore.SEQ_PAD = 16;
+DurableObjectEventStore.DELETE_CHUNK = 128;
+DurableObjectEventStore.REPLAY_LIMIT = 1e3;
+//#endregion
 //#region src/mcp/client-transports.ts
 /**
 * Deprecated transport wrappers
@@ -886,21 +1170,16 @@ var WorkerTransport = class {
 			...this.getHeaders()
 		});
 		if (this.sessionId !== void 0) headers.set("mcp-session-id", this.sessionId);
-		const keepAlive = setInterval(() => {
-			try {
-				writer.write(encoder.encode("event: ping\ndata: \n\n"));
-			} catch {
-				clearInterval(keepAlive);
-			}
-		}, 3e4);
+		const keepAlive = this.eventStore ? void 0 : startKeepalive(writer, encoder);
+		const cleanup = () => {
+			if (keepAlive !== void 0) clearInterval(keepAlive);
+			this.streamMapping.delete(streamId);
+			writer.close().catch(() => {});
+		};
 		this.streamMapping.set(streamId, {
 			writer,
 			encoder,
-			cleanup: () => {
-				clearInterval(keepAlive);
-				this.streamMapping.delete(streamId);
-				writer.close().catch(() => {});
-			}
+			cleanup
 		});
 		if (this.retryInterval !== void 0) await writer.write(encoder.encode(`retry: ${this.retryInterval}\n\n`));
 		if (lastEventId && this.eventStore) {
@@ -914,11 +1193,7 @@ var WorkerTransport = class {
 				this.streamMapping.set(streamId, {
 					writer,
 					encoder,
-					cleanup: () => {
-						clearInterval(keepAlive);
-						this.streamMapping.delete(streamId);
-						writer.close().catch(() => {});
-					}
+					cleanup
 				});
 			}
 		}
@@ -1072,13 +1347,7 @@ var WorkerTransport = class {
 			...this.getHeaders()
 		});
 		if (this.sessionId !== void 0) headers.set("mcp-session-id", this.sessionId);
-		const keepAlive = setInterval(() => {
-			try {
-				writer.write(encoder.encode("event: ping\ndata: \n\n"));
-			} catch {
-				clearInterval(keepAlive);
-			}
-		}, 3e4);
+		const keepAlive = startKeepalive(writer, encoder);
 		this.streamMapping.set(streamId, {
 			writer,
 			encoder,
@@ -1325,6 +1594,49 @@ var McpAgent = class McpAgent extends Agent {
 	async getInitializeRequest() {
 		return this.ctx.storage.get("initializeRequest");
 	}
+	/** Persist the `requestIds` for a POST stream. @internal */
+	async setStreamRequestIds(streamId, requestIds) {
+		await this.ctx.storage.put(`${McpAgent.STREAM_REQS_KEY_PREFIX}${streamId}`, requestIds);
+	}
+	/** Read the persisted `requestIds` for a POST stream. @internal */
+	async getStreamRequestIds(streamId) {
+		return this.ctx.storage.get(`${McpAgent.STREAM_REQS_KEY_PREFIX}${streamId}`);
+	}
+	/** Drop the persisted `requestIds` for a POST stream. @internal */
+	async deleteStreamRequestIds(streamId) {
+		await this.ctx.storage.delete(`${McpAgent.STREAM_REQS_KEY_PREFIX}${streamId}`);
+	}
+	/**
+	* Reverse lookup: find which POST stream a given `requestId` belongs
+	* to, and return the stream's full `requestIds` list in the same
+	* pass. Used by the transport when the originating WS has dropped,
+	* so `send()` can still record events for replay and decide whether
+	* the stream is fully responded — mirrors the SDK's
+	* `_requestToStreamMapping` which outlives connection loss.
+	*
+	* Returning `requestIds` alongside `streamId` lets `send()` skip a
+	* second `getStreamRequestIds` read on the same key.
+	*
+	* O(n) in the number of in-flight POST streams — single-digit in
+	* practice since each stream is cleaned up on its final response.
+	* The `limit` is a defensive ceiling so an abandoned-POST leak can't
+	* unbounded-load this scan; if you hit it, something else has gone
+	* wrong and `send()` will throw `No active stream found`.
+	*
+	* @internal
+	*/
+	async getStreamForRequestId(requestId) {
+		const STREAM_REQS_SCAN_LIMIT = 1e3;
+		const rows = await this.ctx.storage.list({
+			prefix: McpAgent.STREAM_REQS_KEY_PREFIX,
+			limit: STREAM_REQS_SCAN_LIMIT
+		});
+		if (rows.size === STREAM_REQS_SCAN_LIMIT) console.warn(`McpAgent: getStreamForRequestId hit the ${STREAM_REQS_SCAN_LIMIT}-key scan cap; stale __mcp_stream_reqs__ entries may be accumulating from abandoned POSTs`);
+		for (const [key, requestIds] of rows) if (requestIds?.includes(requestId)) return {
+			streamId: key.slice(McpAgent.STREAM_REQS_KEY_PREFIX.length),
+			requestIds
+		};
+	}
 	/** Read the transport type for this agent.
 	* This relies on the naming scheme being `sse:${sessionId}`,
 	* `streamable-http:${sessionId}`, or `rpc:${sessionId}`.
@@ -1369,12 +1681,29 @@ var McpAgent = class McpAgent extends Agent {
 	getRpcTransportOptions() {
 		return {};
 	}
+	/**
+	* Returns the {@link EventStore} for SSE resumability. Defaults to a
+	* {@link DurableObjectEventStore} backed by this agent's storage,
+	* letting clients reconnect with `Last-Event-ID` after the Cloudflare
+	* edge closes an idle SSE stream (~5 minute watchdog) instead of
+	* relying on a server-side keepalive that would block hibernation.
+	*
+	* Per-stream events are cleared by the transport immediately after
+	* the final response is written to the wire, so there's no
+	* background cleanup — storage cost is bounded by the in-flight
+	* streams alone.
+	*
+	* Override to disable (`return undefined`) or swap implementations.
+	*/
+	getEventStore() {
+		return new DurableObjectEventStore(this.ctx.storage);
+	}
 	/** Returns a new transport matching the type of the Agent. */
 	initTransport() {
 		switch (this.getTransportType()) {
 			case "sse": return new McpSSETransport();
 			case "streamable-http": {
-				const transport = new StreamableHTTPServerTransport({});
+				const transport = new StreamableHTTPServerTransport({ eventStore: this.getEventStore() });
 				transport.messageInterceptor = (message) => {
 					return Promise.resolve(this._handleElicitationResponse(message));
 				};
@@ -1542,11 +1871,14 @@ var McpAgent = class McpAgent extends Agent {
 	async handleMcpMessage(message) {
 		await this.__unsafe_ensureInitialized();
 		if (!(this._transport instanceof RPCServerTransport)) throw new Error("Expected RPC transport");
-		if (!Array.isArray(message)) {
-			const parseResult = JSONRPCMessageSchema.safeParse(message);
-			if (parseResult.success && this._handleElicitationResponse(parseResult.data)) return await this._transport._awaitPendingResponse();
-		}
-		return await this._transport.handle(message);
+		const transport = this._transport;
+		return await this.keepAliveWhile(async () => {
+			if (!Array.isArray(message)) {
+				const parseResult = JSONRPCMessageSchema.safeParse(message);
+				if (parseResult.success && this._handleElicitationResponse(parseResult.data)) return await transport._awaitPendingResponse();
+			}
+			return await transport.handle(message);
+		});
 	}
 	/** Return a handler for the given path for this MCP.
 	* Defaults to Streamable HTTP transport.
@@ -1589,7 +1921,8 @@ var McpAgent = class McpAgent extends Agent {
 		});
 	}
 };
+McpAgent.STREAM_REQS_KEY_PREFIX = "__mcp_stream_reqs__:";
 //#endregion
-export { ElicitRequestSchema, McpAgent, RPCClientTransport, RPCServerTransport, RPC_DO_PREFIX, SSEEdgeClientTransport, StreamableHTTPEdgeClientTransport, WorkerTransport, createMcpHandler, experimental_createMcpHandler, getMcpAuthContext };
+export { DurableObjectEventStore, ElicitRequestSchema, MCP_SERVER_ID_MAX_LENGTH, McpAgent, RPCClientTransport, RPCServerTransport, RPC_DO_PREFIX, SSEEdgeClientTransport, StreamableHTTPEdgeClientTransport, WorkerTransport, createMcpHandler, experimental_createMcpHandler, getMcpAuthContext, normalizeServerId };
 
 //# sourceMappingURL=index.js.map