agents 0.20.0 → 0.20.1

package/dist/mcp/client.d.ts

@@ -18,7 +18,7 @@ import {
   wt as MCPClientManagerOptions,
   xt as MCPClientElicitationHandler,
   yt as MCPAITool
-} from "../agent-tool-types-Btk9ETS-.js";
+} from "../agent-tool-types-BC-WFlsz.js";
 export {
   type ElicitRequest,
   type ElicitResult,

package/dist/mcp/index.d.ts

@@ -33,7 +33,7 @@ import {
   tn as MCPStorageApi,
   xt as MCPClientElicitationHandler,
   zt as RPCClientTransportOptions
-} from "../agent-tool-types-Btk9ETS-.js";
+} from "../agent-tool-types-BC-WFlsz.js";
 import {
   a as McpAuthContext,
   n as StatelessMcpHandler,

package/dist/mcp/index.js

@@ -1,13 +1,38 @@
 import "../types.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-zqKcsyFa.js";
 import { Agent, getAgentByName, getCurrentAgent } from "../index.js";
-import { a as KEEPALIVE_INTERVAL_MS, i as KEEPALIVE_FRAME, n as getMcpAuthContext, o as startKeepalive, r as runWithAuthContext, t as createStatelessMcpHandler } from "../handler-stateless-8hQN_kC3.js";
+import { n as getMcpAuthContext, r as runWithAuthContext, t as createStatelessMcpHandler } from "../handler-stateless-CIkKPETH.js";
 import { SSEClientTransport, StreamableHTTPClientTransport } from "@modelcontextprotocol/client";
 import { ElicitRequestSchema, InitializeRequestSchema, JSONRPCMessageSchema, SUPPORTED_PROTOCOL_VERSIONS, isInitializeRequest, isJSONRPCErrorResponse, isJSONRPCNotification, isJSONRPCRequest, isJSONRPCResultResponse } from "@modelcontextprotocol/sdk/types.js";
 import { McpServer, Server } from "@modelcontextprotocol/server";
 import { McpServer as McpServer$1 } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { Server as Server$1 } from "@modelcontextprotocol/sdk/server/index.js";
 import { WebStandardStreamableHTTPServerTransport as WebStandardStreamableHTTPServerTransport$1 } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
+//#region src/mcp/sse-keepalive.ts
+/**
+* SSE keepalive for the retained McpAgent WebSocket-to-SSE bridge.
+*
+* SDK-backed HTTP transports own their keepalive timers. This helper remains
+* only for the custom bridge, where long-running POST tool calls can otherwise
+* sit silent until Cloudflare's edge closes the idle stream.
+*
+* See cloudflare/agents#1583.
+*/
+/** Interval between bridge SSE keepalive comment frames, in ms. */
+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
@@ -1010,13 +1035,9 @@ var StreamableHTTPEdgeClientTransport = class extends StreamableHTTPClientTransp
 *     survive DO hibernation / eviction. On the first request after a cold
 *     start, the saved initialize params are replayed through the `Server`
 *     so client capabilities are re-established.
-*  3. **SSE keepalive** — SSE responses are wrapped in a TransformStream that
-*     injects a `: keepalive\n\n` comment frame every 25s so the Cloudflare
-*     edge ~5min idle-stream watchdog doesn't kill long-running tool calls.
-*     Disabled on the standalone GET stream when an `eventStore` is
-*     configured — clients recover idle drops via `Last-Event-ID` instead.
-*     POST response streams always keepalive (no resumption path during a
-*     mid-flight tool call). See cloudflare/agents#1583.
+*  3. **SSE keepalive** — delegated to the SDK transport, which writes SSE
+*     comment frames and owns timer cleanup. Configure the cadence with the
+*     inherited `keepAliveMs` option.
 *
 * Stateless handlers do not import this module. Everything else (session
 * validation, SSE streaming, protocol-version
@@ -1041,7 +1062,6 @@ var WorkerTransport = class extends WebStandardStreamableHTTPServerTransport$1 {
 		});
 		this._stateRestored = false;
 		this._bridgeInstalled = false;
-		this._keepaliveCleanups = /* @__PURE__ */ new Map();
 		this._closedRequestIds = /* @__PURE__ */ new Set();
 		this._corsOptions = corsOptions;
 		this._storage = storage;
@@ -1057,17 +1077,15 @@ var WorkerTransport = class extends WebStandardStreamableHTTPServerTransport$1 {
 	/**
 	* Top-level request entry point. Handles CORS preflight, restores any
 	* persisted state on first invocation, then delegates to the SDK transport
-	* and finally appends CORS headers + keepalive to whatever response comes
-	* back.
+	* and finally appends CORS headers to whatever response comes back.
 	*/
 	async handleRequest(request, options) {
 		if (request.method === "OPTIONS") return new Response(null, { headers: this.getCorsHeaders({ forPreflight: true }) });
 		await this.restoreState();
 		this.installOnSessionInitializedBridge();
 		await this.captureInitializeParams(request, options);
-		const requestIdForKeepalive = request.method === "GET" ? "_standalone" : this._pendingRequestId;
 		const response = await super.handleRequest(request, options);
-		return this.withCorsHeaders(this.withKeepalive(this.normalizeAllowHeader(response), requestIdForKeepalive));
+		return this.withCorsHeaders(this.normalizeAllowHeader(response));
 	}
 	/**
 	* The SDK's 405 responses advertise `Allow: GET, POST, DELETE` because
@@ -1087,19 +1105,10 @@ var WorkerTransport = class extends WebStandardStreamableHTTPServerTransport$1 {
 		});
 	}
 	closeSSEStream(requestId) {
-		this._keepaliveCleanups.get(requestId)?.();
-		this._keepaliveCleanups.delete(requestId);
 		this._closedRequestIds.add(requestId);
 		super.closeSSEStream(requestId);
 	}
-	closeStandaloneSSEStream() {
-		this._keepaliveCleanups.get("_standalone")?.();
-		this._keepaliveCleanups.delete("_standalone");
-		super.closeStandaloneSSEStream();
-	}
 	async close() {
-		for (const cleanup of Array.from(this._keepaliveCleanups.values())) cleanup();
-		this._keepaliveCleanups.clear();
 		this._closedRequestIds.clear();
 		await super.close();
 	}
@@ -1129,77 +1138,6 @@ var WorkerTransport = class extends WebStandardStreamableHTTPServerTransport$1 {
 		if (requestId !== void 0 && this._closedRequestIds.has(requestId)) return;
 		await super.send(message, options);
 	}
-	/**
-	* If the response is an SSE stream, tee the body through a TransformStream
-	* that injects a `: keepalive\n\n` comment frame every 25s. The interval
-	* is cleared when the wrapped stream closes — which happens both when the
-	* SDK ends the underlying stream naturally and when `closeSSEStream` is
-	* called.
-	*
-	* Keepalive policy:
-	*   - POST response streams (`key` is a request id): always keepalive.
-	*     In-progress tool calls have no recovery path — if the stream drops
-	*     mid-execution the result is lost — so we keep it under the
-	*     Cloudflare edge ~5min idle watchdog.
-	*   - Standalone GET stream (`key === "_standalone"`): keepalive only
-	*     when no `eventStore` is configured. When resumability is enabled,
-	*     clients reconnect with `Last-Event-ID` after an idle drop, so we
-	*     skip the keepalive and let the DO hibernate.
-	*
-	* Uses the shared `sse-keepalive` constants so both this wrapper and
-	* `McpAgent.serve()` write identical frames at the same cadence.
-	* See cloudflare/agents#1583.
-	*/
-	withKeepalive(response, key) {
-		if (!(response.headers.get("Content-Type") ?? "").includes("text/event-stream") || !response.body) return response;
-		if (key === "_standalone" && this.eventStoreConfigured()) return response;
-		const encoder = new TextEncoder();
-		let intervalId;
-		let controllerRef;
-		const clear = () => {
-			if (intervalId !== void 0) {
-				clearInterval(intervalId);
-				intervalId = void 0;
-			}
-			if (key !== void 0) this._keepaliveCleanups.delete(key);
-		};
-		const transform = new TransformStream({
-			start: (controller) => {
-				controllerRef = controller;
-				intervalId = setInterval(() => {
-					try {
-						controllerRef?.enqueue(encoder.encode(KEEPALIVE_FRAME));
-					} catch {
-						clear();
-					}
-				}, KEEPALIVE_INTERVAL_MS);
-				if (key !== void 0) this._keepaliveCleanups.set(key, clear);
-			},
-			transform(chunk, controller) {
-				controller.enqueue(chunk);
-			},
-			flush() {
-				clear();
-			},
-			cancel() {
-				clear();
-			}
-		});
-		const piped = response.body.pipeThrough(transform);
-		return new Response(piped, {
-			status: response.status,
-			statusText: response.statusText,
-			headers: response.headers
-		});
-	}
-	/**
-	* Does the SDK transport have an `eventStore`? Reaches into the SDK's
-	* private field because the option isn't surfaced on the public API —
-	* we only need a yes/no for keepalive policy.
-	*/
-	eventStoreConfigured() {
-		return this._eventStore !== void 0;
-	}
 	getCorsHeaders({ forPreflight } = {}) {
 		const merged = {
 			...DEFAULT_CORS_OPTIONS,
@@ -1235,19 +1173,15 @@ var WorkerTransport = class extends WebStandardStreamableHTTPServerTransport$1 {
 		this._bridgeInstalled = true;
 	}
 	async captureInitializeParams(request, handleOptions) {
-		this._pendingRequestId = void 0;
 		if (request.method !== "POST") return;
 		try {
 			const parsed = handleOptions?.parsedBody ?? await request.clone().json();
-			const messages = Array.isArray(parsed) ? parsed : [parsed];
-			const init = messages.find((m) => typeof m === "object" && m !== null && isInitializeRequest(m));
+			const init = (Array.isArray(parsed) ? parsed : [parsed]).find((m) => typeof m === "object" && m !== null && isInitializeRequest(m));
 			if (init && isInitializeRequest(init)) this._capturedInitializeParams = {
 				capabilities: init.params.capabilities,
 				clientInfo: init.params.clientInfo,
 				protocolVersion: init.params.protocolVersion
 			};
-			const firstRequest = messages.find((m) => typeof m === "object" && m !== null && "id" in m && "method" in m);
-			if (firstRequest) this._pendingRequestId = firstRequest.id;
 		} catch {}
 	}
 	async restoreState() {