@modelcontextprotocol/server 2.0.0-alpha.2 → 2.0.0-alpha.4

package/dist/index.mjs

@@ -1,1554 +1,1306 @@
-import { $ as PARSE_ERROR, A as parseJSONRPCMessage, B as ListRootsResultSchema, C as isInitializeRequest, D as isJSONRPCRequest, E as isJSONRPCNotification, F as CreateTaskResultSchema, G as ProtocolErrorCode, H as getResultSchema, I as ElicitResultSchema, J as INVALID_PARAMS, K as DEFAULT_NEGOTIATED_PROTOCOL_VERSION, L as EmptyResultSchema, M as CallToolResultSchema, N as CreateMessageResultSchema, O as isJSONRPCResultResponse, P as CreateMessageResultWithToolsSchema, Q as METHOD_NOT_FOUND, R as GetTaskPayloadResultSchema, S as assertCompleteRequestResourceTemplate, T as isJSONRPCErrorResponse, U as ProtocolError, V as LoggingLevelSchema, W as UrlElicitationRequiredError, X as JSONRPC_VERSION, Y as INVALID_REQUEST, Z as LATEST_PROTOCOL_VERSION, _ as mergeCapabilities, a as standardSchemaToJsonSchema, at as SdkError, b as parseSchema, c as createFetchWithInit, ct as OAuthErrorCode, d as deserializeMessage, et as RELATED_TASK_META_KEY, f as serializeMessage, g as Protocol, h as DEFAULT_REQUEST_TIMEOUT_MSEC, i as promptArgumentsFromStandardSchema, it as resourceUrlFromServerUrl, j as CallToolRequestSchema, k as isTaskAugmentedRequestParams, l as validateAndWarnToolName, m as toArrayAsync, n as CfWorkerJsonSchemaValidator, nt as getDisplayName, o as validateStandardSchema, ot as SdkErrorCode, p as takeResult, q as INTERNAL_ERROR, r as AjvJsonSchemaValidator, rt as checkResourceAllowed, s as UriTemplate, st as OAuthError, t as fromJsonSchema$1, tt as SUPPORTED_PROTOCOL_VERSIONS, u as ReadBuffer, v as extractTaskManagerOptions, w as isInitializedNotification, x as assertCompleteRequestPrompt, y as isTerminal, z as JSONRPCMessageSchema } from "./src-IKPjmxu7.mjs";
-import { DefaultJsonSchemaValidator, process } from "@modelcontextprotocol/server/_shims";
+import { A as classifyInboundRequest, At as SdkErrorCode, B as isInitializedNotification, C as isSpecType, Ct as TRACEPARENT_META_KEY, D as inputResponse, Dt as checkResourceAllowed, E as inputRequired, Et as requiredClientCapabilitiesForRequest, F as validateMcpParamHeaders, Ft as isCompletable, G as isJSONRPCResponse, H as isJSONRPCErrorResponse, I as assertCompleteRequestPrompt, J as parseJSONRPCMessage, K as isJSONRPCResultResponse, L as assertCompleteRequestResourceTemplate, M as modernOnlyStrictRejection, Mt as OAuthError, N as validateStandardRequestHeaders, Nt as OAuthErrorCode, O as LADDER_ERROR_HTTP_STATUS, Ot as resourceUrlFromServerUrl, P as scanXMcpHeaderDeclarations, Pt as completable, Q as requestMetaOf, R as isCallToolResult, S as setNegotiatedProtocolVersion, St as SUPPORTED_PROTOCOL_VERSIONS, T as acceptedContent, Tt as missingClientCapabilities, U as isJSONRPCNotification, V as isInputRequiredResult, W as isJSONRPCRequest, Y as JSONRPCMessageSchema, _ as STDIO_DEFAULT_MAX_BUFFER_SIZE, _t as METHOD_NOT_FOUND, a as seedClientIdentityFromEnvelope, at as ProtocolErrorCode, b as getDisplayName, bt as RELATED_TASK_META_KEY, ct as CLIENT_CAPABILITIES_META_KEY, d as createServerNotifier, dt as INTERNAL_ERROR, et as MissingRequiredClientCapabilityError, f as fromJsonSchema$1, ft as INVALID_PARAMS, g as ReadBuffer, gt as LOG_LEVEL_META_KEY, h as createFetchWithInit, ht as LATEST_PROTOCOL_VERSION, i as installModernOnlyHandlers, it as UrlElicitationRequiredError, j as httpStatusForErrorCode, jt as SdkHttpError, kt as SdkError, l as createListenRouter, lt as CLIENT_INFO_META_KEY, m as UriTemplate, mt as JSONRPC_VERSION, n as ResourceTemplate, nt as ResourceNotFoundError, o as DEFAULT_LISTEN_KEEPALIVE_MS, ot as SUPPORTED_MODERN_PROTOCOL_VERSIONS, p as InMemoryTransport, pt as INVALID_REQUEST, q as isTaskAugmentedRequestParams, r as Server, rt as UnsupportedProtocolVersionError, s as DEFAULT_MAX_SUBSCRIPTIONS, st as BAGGAGE_META_KEY, t as McpServer, tt as ProtocolError, u as InMemoryServerEventBus, ut as DEFAULT_NEGOTIATED_PROTOCOL_VERSION, v as deserializeMessage, vt as PARSE_ERROR, w as specTypeSchemas, wt as TRACESTATE_META_KEY, x as DEFAULT_REQUEST_TIMEOUT_MSEC, xt as SUBSCRIPTION_ID_META_KEY, y as serializeMessage, yt as PROTOCOL_VERSION_META_KEY, z as isInitializeRequest } from "./mcp-JttQJlI9.mjs";
+import { DefaultJsonSchemaValidator } from "@modelcontextprotocol/server/_shims";
 
-//#region src/server/completable.ts
-const COMPLETABLE_SYMBOL = Symbol.for("mcp.completable");
+//#region src/server/perRequestTransport.ts
 /**
-* Wraps a schema to provide autocompletion capabilities. Useful for, e.g., prompt arguments in MCP.
-*
-* @example
-* ```ts source="./completable.examples.ts#completable_basicUsage"
-* server.registerPrompt(
-*     'review-code',
-*     {
-*         title: 'Code Review',
-*         argsSchema: z.object({
-*             language: completable(z.string().describe('Programming language'), value =>
-*                 ['typescript', 'javascript', 'python', 'rust', 'go'].filter(lang => lang.startsWith(value))
-*             )
-*         })
-*     },
-*     ({ language }) => ({
-*         messages: [
-*             {
-*                 role: 'user' as const,
-*                 content: {
-*                     type: 'text' as const,
-*                     text: `Review this ${language} code.`
-*                 }
-*             }
-*         ]
-*     })
-* );
-* ```
-*
-* @see {@linkcode server/mcp.McpServer.registerPrompt | McpServer.registerPrompt} for using completable schemas in prompt argument definitions
-*/
-function completable(schema, complete) {
-	Object.defineProperty(schema, COMPLETABLE_SYMBOL, {
-		value: { complete },
-		enumerable: false,
-		writable: false,
-		configurable: false
-	});
-	return schema;
-}
-/**
-* Checks if a schema is completable (has completion metadata).
-*/
-function isCompletable(schema) {
-	return !!schema && typeof schema === "object" && COMPLETABLE_SYMBOL in schema;
-}
-/**
-* Gets the completer callback from a completable schema, if it exists.
-*/
-function getCompleter(schema) {
-	return schema[COMPLETABLE_SYMBOL]?.complete;
-}
-
-//#endregion
-//#region ../core/src/experimental/tasks/helpers.ts
-/**
-* Experimental task capability assertion helpers.
-* WARNING: These APIs are experimental and may change without notice.
-*
-* @experimental
-*/
-/**
-* Asserts that task creation is supported for `tools/call`.
-* Used to implement the `assertTaskCapability` or `assertTaskHandlerCapability` abstract methods on Protocol.
-*
-* @param requests - The task requests capability object
-* @param method - The method being checked
-* @param entityName - `'Server'` or `'Client'` for error messages
-* @throws {@linkcode SdkError} with {@linkcode SdkErrorCode.CapabilityNotSupported} if the capability is not supported
-*
-* @experimental
-*/
-function assertToolsCallTaskCapability(requests, method, entityName) {
-	if (!requests) throw new SdkError(SdkErrorCode.CapabilityNotSupported, `${entityName} does not support task creation (required for ${method})`);
-	switch (method) {
-		case "tools/call":
-			if (!requests.tools?.call) throw new SdkError(SdkErrorCode.CapabilityNotSupported, `${entityName} does not support task creation for tools/call (required for ${method})`);
-			break;
-		default: break;
-	}
-}
-/**
-* Asserts that task creation is supported for `sampling/createMessage` or `elicitation/create`.
-* Used to implement the `assertTaskCapability` or `assertTaskHandlerCapability` abstract methods on Protocol.
-*
-* @param requests - The task requests capability object
-* @param method - The method being checked
-* @param entityName - `'Server'` or `'Client'` for error messages
-* @throws {@linkcode SdkError} with {@linkcode SdkErrorCode.CapabilityNotSupported} if the capability is not supported
-*
-* @experimental
-*/
-function assertClientRequestTaskCapability(requests, method, entityName) {
-	if (!requests) throw new SdkError(SdkErrorCode.CapabilityNotSupported, `${entityName} does not support task creation (required for ${method})`);
-	switch (method) {
-		case "sampling/createMessage":
-			if (!requests.sampling?.createMessage) throw new SdkError(SdkErrorCode.CapabilityNotSupported, `${entityName} does not support task creation for sampling/createMessage (required for ${method})`);
-			break;
-		case "elicitation/create":
-			if (!requests.elicitation?.create) throw new SdkError(SdkErrorCode.CapabilityNotSupported, `${entityName} does not support task creation for elicitation/create (required for ${method})`);
-			break;
-		default: break;
-	}
-}
-
-//#endregion
-//#region ../core/src/experimental/tasks/stores/inMemory.ts
-/**
-* In-memory {@linkcode TaskStore} implementation for development and testing.
-* For production, use a database or distributed cache.
-* @experimental
+* The per-request micro-transport: a real, connected `Transport` whose whole
+* lifetime is one HTTP exchange. See the module documentation for the
+* response shapes it produces.
 */
-var InMemoryTaskStore = class {
-	tasks = /* @__PURE__ */ new Map();
-	cleanupTimers = /* @__PURE__ */ new Map();
+var PerRequestHTTPServerTransport = class {
+	onclose;
+	onerror;
+	onmessage;
+	_classification;
+	_responseMode;
+	_started = false;
+	_used = false;
+	_closed = false;
+	_terminalDelivered = false;
 	/**
-	* Generates a unique task ID using Web Crypto API.
+	* `true` only while the inbound message is being delivered synchronously
+	* to the connected protocol layer. The pre-handler gates (the era
+	* registry gate, the edge→instance handoff check, the missing-handler
+	* rejection) answer inside this window; request handlers always run
+	* after it (the protocol layer defers them to a microtask). An error
+	* sent inside the window is therefore ladder-originated, and an error
+	* sent after it is handler-produced.
 	*/
-	generateTaskId() {
-		return crypto.randomUUID().replaceAll("-", "");
+	_dispatchWindowOpen = false;
+	_requestId;
+	_deferredResponse;
+	_sse;
+	_abortCleanup;
+	constructor(options) {
+		this._classification = options.classification;
+		this._responseMode = options.responseMode ?? "auto";
 	}
-	/** {@inheritDoc TaskStore.createTask} */
-	async createTask(taskParams, requestId, request, sessionId) {
-		const taskId = this.generateTaskId();
-		if (this.tasks.has(taskId)) throw new Error(`Task with ID ${taskId} already exists`);
-		const actualTtl = taskParams.ttl ?? null;
-		const createdAt = (/* @__PURE__ */ new Date()).toISOString();
-		const task = {
-			taskId,
-			status: "working",
-			ttl: actualTtl,
-			createdAt,
-			lastUpdatedAt: createdAt,
-			pollInterval: taskParams.pollInterval ?? 1e3
-		};
-		this.tasks.set(taskId, {
-			task,
-			request,
-			requestId,
-			sessionId
-		});
-		if (actualTtl) {
-			const timer = setTimeout(() => {
-				this.tasks.delete(taskId);
-				this.cleanupTimers.delete(taskId);
-			}, actualTtl);
-			this.cleanupTimers.set(taskId, timer);
-		}
-		return task;
+	async start() {
+		if (this._started) throw new Error("PerRequestHTTPServerTransport is already started");
+		this._started = true;
 	}
 	/**
-	* Retrieves a stored task, enforcing session ownership when a sessionId is provided.
-	* Returns undefined if the task does not exist or belongs to a different session.
+	* Serves the single exchange: delivers the classified message to the
+	* connected server instance and resolves with the HTTP response.
+	*
+	* Throws when called a second time (the transport is strictly
+	* single-use), or before a server has been connected to the transport.
+	* The returned promise rejects with a connection-closed error when the
+	* transport is closed before a response was produced (for example because
+	* the client disconnected).
 	*/
-	getStoredTask(taskId, sessionId) {
-		const stored = this.tasks.get(taskId);
-		if (!stored) return;
-		if (sessionId !== void 0 && stored.sessionId !== void 0 && stored.sessionId !== sessionId) return;
-		return stored;
-	}
-	async getTask(taskId, sessionId) {
-		const stored = this.getStoredTask(taskId, sessionId);
-		return stored ? { ...stored.task } : null;
-	}
-	/** {@inheritDoc TaskStore.storeTaskResult} */
-	async storeTaskResult(taskId, status, result, sessionId) {
-		const stored = this.getStoredTask(taskId, sessionId);
-		if (!stored) throw new Error(`Task with ID ${taskId} not found`);
-		if (isTerminal(stored.task.status)) throw new Error(`Cannot store result for task ${taskId} in terminal status '${stored.task.status}'. Task results can only be stored once.`);
-		stored.result = result;
-		stored.task.status = status;
-		stored.task.lastUpdatedAt = (/* @__PURE__ */ new Date()).toISOString();
-		if (stored.task.ttl) {
-			const existingTimer = this.cleanupTimers.get(taskId);
-			if (existingTimer) clearTimeout(existingTimer);
-			const timer = setTimeout(() => {
-				this.tasks.delete(taskId);
-				this.cleanupTimers.delete(taskId);
-			}, stored.task.ttl);
-			this.cleanupTimers.set(taskId, timer);
+	async handleMessage(message, extra) {
+		if (this._used) throw new Error("PerRequestHTTPServerTransport serves exactly one exchange; construct a new transport per request");
+		if (!this._started || this.onmessage === void 0) throw new Error("PerRequestHTTPServerTransport is not connected: connect a server to this transport before handling a message");
+		if (this._closed) throw new Error("PerRequestHTTPServerTransport is closed");
+		this._used = true;
+		const signal = extra?.request?.signal;
+		if (signal?.aborted) {
+			await this.close();
+			throw new SdkError(SdkErrorCode.ConnectionClosed, "The request was aborted before it could be handled");
 		}
-	}
-	/** {@inheritDoc TaskStore.getTaskResult} */
-	async getTaskResult(taskId, sessionId) {
-		const stored = this.getStoredTask(taskId, sessionId);
-		if (!stored) throw new Error(`Task with ID ${taskId} not found`);
-		if (!stored.result) throw new Error(`Task ${taskId} has no result stored`);
-		return stored.result;
-	}
-	/** {@inheritDoc TaskStore.updateTaskStatus} */
-	async updateTaskStatus(taskId, status, statusMessage, sessionId) {
-		const stored = this.getStoredTask(taskId, sessionId);
-		if (!stored) throw new Error(`Task with ID ${taskId} not found`);
-		if (isTerminal(stored.task.status)) throw new Error(`Cannot update task ${taskId} from terminal status '${stored.task.status}' to '${status}'. Terminal states (completed, failed, cancelled) cannot transition to other states.`);
-		stored.task.status = status;
-		if (statusMessage) stored.task.statusMessage = statusMessage;
-		stored.task.lastUpdatedAt = (/* @__PURE__ */ new Date()).toISOString();
-		if (isTerminal(status) && stored.task.ttl) {
-			const existingTimer = this.cleanupTimers.get(taskId);
-			if (existingTimer) clearTimeout(existingTimer);
-			const timer = setTimeout(() => {
-				this.tasks.delete(taskId);
-				this.cleanupTimers.delete(taskId);
-			}, stored.task.ttl);
-			this.cleanupTimers.set(taskId, timer);
+		const messageExtra = {
+			classification: this._classification,
+			...extra?.request !== void 0 && { request: extra.request },
+			...extra?.authInfo !== void 0 && { authInfo: extra.authInfo }
+		};
+		if (isJSONRPCRequest(message)) {
+			this._requestId = message.id;
+			let resolve;
+			let reject;
+			const promise = new Promise((promiseResolve, promiseReject) => {
+				resolve = promiseResolve;
+				reject = promiseReject;
+			});
+			this._deferredResponse = {
+				promise,
+				resolve,
+				reject,
+				settled: false
+			};
+			if (signal !== void 0) {
+				const onAbort = () => void this.close();
+				signal.addEventListener("abort", onAbort, { once: true });
+				this._abortCleanup = () => signal.removeEventListener("abort", onAbort);
+			}
+			this._dispatchWindowOpen = true;
+			try {
+				this.onmessage(message, messageExtra);
+			} finally {
+				this._dispatchWindowOpen = false;
+			}
+			if (this._responseMode === "sse" && !this._closed && !this._deferredResponse.settled) this.upgradeToSse();
+			return promise;
 		}
+		this.onmessage(message, messageExtra);
+		return new Response(null, { status: 202 });
 	}
-	/** {@inheritDoc TaskStore.listTasks} */
-	async listTasks(cursor, sessionId) {
-		const PAGE_SIZE = 10;
-		const filteredTaskIds = [...this.tasks.entries()].filter(([, stored]) => {
-			if (sessionId === void 0 || stored.sessionId === void 0) return true;
-			return stored.sessionId === sessionId;
-		}).map(([taskId]) => taskId);
-		let startIndex = 0;
-		if (cursor) {
-			const cursorIndex = filteredTaskIds.indexOf(cursor);
-			if (cursorIndex === -1) throw new Error(`Invalid cursor: ${cursor}`);
-			else startIndex = cursorIndex + 1;
+	async send(message, options) {
+		if (this._closed) return;
+		const isResponse = isJSONRPCResultResponse(message) || isJSONRPCErrorResponse(message);
+		const relatedId = isResponse ? message.id : options?.relatedRequestId;
+		if (this._requestId === void 0 || relatedId === void 0 || relatedId !== this._requestId) {
+			if (isResponse) this.onerror?.(/* @__PURE__ */ new Error(`Received a response for an unknown request id: ${String(message.id)}`));
+			return;
 		}
-		const pageTaskIds = filteredTaskIds.slice(startIndex, startIndex + PAGE_SIZE);
-		return {
-			tasks: pageTaskIds.map((taskId) => {
-				return { ...this.tasks.get(taskId).task };
-			}),
-			nextCursor: startIndex + PAGE_SIZE < filteredTaskIds.length ? pageTaskIds.at(-1) : void 0
-		};
+		if (isResponse) {
+			if (this._terminalDelivered) return;
+			this._terminalDelivered = true;
+			const ladderStatus = this._dispatchWindowOpen && isJSONRPCErrorResponse(message) ? LADDER_ERROR_HTTP_STATUS[message.error.code] : void 0;
+			if (ladderStatus !== void 0 && this._sse === void 0) {
+				this.settleResponse(Response.json(message, {
+					status: ladderStatus,
+					headers: { "Content-Type": "application/json" }
+				}));
+				queueMicrotask(() => void this.close());
+				return;
+			}
+			if (this._sse !== void 0 || this._responseMode === "sse") {
+				if (this._sse === void 0) this.upgradeToSse();
+				this.writeMessageFrame(message);
+				this.finalizeStream();
+				return;
+			}
+			this.settleResponse(Response.json(message, {
+				status: 200,
+				headers: { "Content-Type": "application/json" }
+			}));
+			queueMicrotask(() => void this.close());
+			return;
+		}
+		if (this._responseMode === "json") return;
+		if (this._sse === void 0) this.upgradeToSse();
+		this.writeMessageFrame(message);
 	}
 	/**
-	* Cleanup all timers (useful for testing or graceful shutdown)
+	* Writes an SSE comment frame (a keep-alive heartbeat). Dropped when the
+	* exchange is not currently streaming.
 	*/
-	cleanup() {
-		for (const timer of this.cleanupTimers.values()) clearTimeout(timer);
-		this.cleanupTimers.clear();
-		this.tasks.clear();
+	writeCommentFrame(comment) {
+		if (this._closed || this._sse === void 0 || this._sse.closed) return;
+		const frame = comment.split("\n").map((line) => `: ${line}`).join("\n");
+		this.writeFrame(`${frame}\n\n`);
 	}
-	/**
-	* Get all tasks (useful for debugging)
-	*/
-	getAllTasks() {
-		return [...this.tasks.values()].map((stored) => ({ ...stored.task }));
+	async close() {
+		if (this._closed) return;
+		this._closed = true;
+		this._abortCleanup?.();
+		this._abortCleanup = void 0;
+		if (this._sse !== void 0 && !this._sse.closed) {
+			this._sse.closed = true;
+			try {
+				this._sse.controller.close();
+			} catch {}
+		}
+		if (this._deferredResponse !== void 0 && !this._deferredResponse.settled) {
+			this._deferredResponse.settled = true;
+			this._deferredResponse.reject(new SdkError(SdkErrorCode.ConnectionClosed, "Connection closed before a response was produced"));
+		}
+		this.onclose?.();
 	}
-};
-/**
-* In-memory {@linkcode TaskMessageQueue} implementation for development and testing.
-* For production, use Redis or another distributed queue.
-* @experimental
-*/
-var InMemoryTaskMessageQueue = class {
-	queues = /* @__PURE__ */ new Map();
-	/**
-	* Generates a queue key from taskId.
-	* SessionId is intentionally ignored because taskIds are globally unique
-	* and tasks need to be accessible across HTTP requests/sessions.
-	*/
-	getQueueKey(taskId, _sessionId) {
-		return taskId;
+	settleResponse(response) {
+		if (this._deferredResponse === void 0 || this._deferredResponse.settled) return;
+		this._deferredResponse.settled = true;
+		this._deferredResponse.resolve(response);
 	}
-	/**
-	* Gets or creates a queue for the given task and session.
-	*/
-	getQueue(taskId, sessionId) {
-		const key = this.getQueueKey(taskId, sessionId);
-		let queue = this.queues.get(key);
-		if (!queue) {
-			queue = [];
-			this.queues.set(key, queue);
-		}
-		return queue;
+	upgradeToSse() {
+		let controller;
+		const readable = new ReadableStream({
+			start: (streamController) => {
+				controller = streamController;
+			},
+			cancel: () => {
+				this.close();
+			}
+		});
+		this._sse = {
+			controller,
+			encoder: new TextEncoder(),
+			closed: false
+		};
+		this.settleResponse(new Response(readable, {
+			status: 200,
+			headers: {
+				"Content-Type": "text/event-stream",
+				"Cache-Control": "no-cache",
+				Connection: "keep-alive",
+				"X-Accel-Buffering": "no"
+			}
+		}));
 	}
-	/**
-	* Adds a message to the end of the queue for a specific task.
-	* Atomically checks queue size and throws if maxSize would be exceeded.
-	* @param taskId The task identifier
-	* @param message The message to enqueue
-	* @param sessionId Optional session ID for binding the operation to a specific session
-	* @param maxSize Optional maximum queue size - if specified and queue is full, throws an error
-	* @throws Error if maxSize is specified and would be exceeded
-	*/
-	async enqueue(taskId, message, sessionId, maxSize) {
-		const queue = this.getQueue(taskId, sessionId);
-		if (maxSize !== void 0 && queue.length >= maxSize) throw new Error(`Task message queue overflow: queue size (${queue.length}) exceeds maximum (${maxSize})`);
-		queue.push(message);
+	finalizeStream() {
+		if (this._sse !== void 0 && !this._sse.closed) {
+			this._sse.closed = true;
+			try {
+				this._sse.controller.close();
+			} catch {}
+		}
+		queueMicrotask(() => void this.close());
 	}
-	/**
-	* Removes and returns the first message from the queue for a specific task.
-	* @param taskId The task identifier
-	* @param sessionId Optional session ID for binding the query to a specific session
-	* @returns The first message, or `undefined` if the queue is empty
-	*/
-	async dequeue(taskId, sessionId) {
-		return this.getQueue(taskId, sessionId).shift();
+	writeMessageFrame(message) {
+		this.writeFrame(`event: message\ndata: ${JSON.stringify(message)}\n\n`);
 	}
-	/**
-	* Removes and returns all messages from the queue for a specific task.
-	* @param taskId The task identifier
-	* @param sessionId Optional session ID for binding the query to a specific session
-	* @returns Array of all messages that were in the queue
-	*/
-	async dequeueAll(taskId, sessionId) {
-		const key = this.getQueueKey(taskId, sessionId);
-		const queue = this.queues.get(key) ?? [];
-		this.queues.delete(key);
-		return queue;
+	writeFrame(frame) {
+		if (this._sse === void 0 || this._sse.closed) return;
+		try {
+			this._sse.controller.enqueue(this._sse.encoder.encode(frame));
+		} catch (error) {
+			this.onerror?.(/* @__PURE__ */ new Error(`Failed to write to the response stream: ${error}`));
+		}
 	}
 };
 
 //#endregion
-//#region src/experimental/tasks/mcpServer.ts
+//#region src/server/invoke.ts
 /**
-* Experimental task features for {@linkcode McpServer}.
-*
-* Access via `server.experimental.tasks`:
-* ```typescript
-* server.experimental.tasks.registerToolTask('long-running', config, handler);
-* ```
+* Serves one classified inbound message on the given server instance and
+* returns the HTTP response for the exchange.
 *
-* @experimental
+* The instance is connected to a fresh single-exchange transport, the message
+* is injected through the normal transport message path, and whatever the
+* dispatch layer produces (the handler result, a protocol-level rejection, or
+* streamed related messages followed by the result) is captured as the
+* returned `Response`. For request exchanges, teardown rides the transport's
+* close chain once the terminal response has been delivered; notification
+* exchanges resolve with the 202 response immediately and do NOT run the
+* close chain — the transport stays connected until the caller closes it or
+* drops the per-request instance, which is the caller's choice either way.
 */
-var ExperimentalMcpServerTasks = class {
-	constructor(_mcpServer) {
-		this._mcpServer = _mcpServer;
-	}
-	registerToolTask(name, config, handler) {
-		const execution = {
-			taskSupport: "required",
-			...config.execution
-		};
-		if (execution.taskSupport === "forbidden") throw new Error(`Cannot register task-based tool '${name}' with taskSupport 'forbidden'. Use registerTool() instead.`);
-		return this._mcpServer._createRegisteredTool(name, config.title, config.description, config.inputSchema, config.outputSchema, config.annotations, execution, config._meta, handler);
-	}
-};
+async function invoke(server, message, ctx) {
+	const transport = new PerRequestHTTPServerTransport({
+		classification: ctx.classification,
+		...ctx.responseMode !== void 0 && { responseMode: ctx.responseMode }
+	});
+	await server.connect(transport);
+	return transport.handleMessage(message, {
+		...ctx.request !== void 0 && { request: ctx.request },
+		...ctx.authInfo !== void 0 && { authInfo: ctx.authInfo }
+	});
+}
 
 //#endregion
-//#region src/experimental/tasks/server.ts
+//#region src/server/streamableHttp.ts
 /**
-* Experimental task features for low-level MCP servers.
+* Server transport for Web Standards Streamable HTTP: this implements the MCP Streamable HTTP transport specification
+* using Web Standard APIs (`Request`, `Response`, `ReadableStream`).
+*
+* This transport works on any runtime that supports Web Standards: Node.js 18+, Cloudflare Workers, Deno, Bun, etc.
+*
+* In stateful mode:
+* - Session ID is generated and included in response headers
+* - Session ID is always included in initialization responses
+* - Requests with invalid session IDs are rejected with `404 Not Found`
+* - Non-initialization requests without a session ID are rejected with `400 Bad Request`
+* - State is maintained in-memory (connections, message history)
+*
+* In stateless mode:
+* - No Session ID is included in any responses
+* - No session validation is performed
 *
-* Access via `server.experimental.tasks`:
-* ```typescript
-* const stream = server.experimental.tasks.requestStream(request, options);
+* @example Stateful setup
+* ```ts source="./streamableHttp.examples.ts#WebStandardStreamableHTTPServerTransport_stateful"
+* const server = new McpServer({ name: 'my-server', version: '1.0.0' });
+*
+* const transport = new WebStandardStreamableHTTPServerTransport({
+*     sessionIdGenerator: () => crypto.randomUUID()
+* });
+*
+* await server.connect(transport);
+* ```
+*
+* @example Stateless setup
+* ```ts source="./streamableHttp.examples.ts#WebStandardStreamableHTTPServerTransport_stateless"
+* const transport = new WebStandardStreamableHTTPServerTransport({
+*     sessionIdGenerator: undefined
+* });
 * ```
 *
-* For high-level server usage with task-based tools, use {@linkcode index.McpServer | McpServer}.experimental.tasks instead.
+* @example Hono.js
+* ```ts source="./streamableHttp.examples.ts#WebStandardStreamableHTTPServerTransport_hono"
+* app.all('/mcp', async c => {
+*     return transport.handleRequest(c.req.raw);
+* });
+* ```
 *
-* @experimental
+* @example Cloudflare Workers
+* ```ts source="./streamableHttp.examples.ts#WebStandardStreamableHTTPServerTransport_workers"
+* const worker = {
+*     async fetch(request: Request): Promise<Response> {
+*         return transport.handleRequest(request);
+*     }
+* };
+* ```
 */
-var ExperimentalServerTasks = class {
-	constructor(_server) {
-		this._server = _server;
+var WebStandardStreamableHTTPServerTransport = class {
+	sessionIdGenerator;
+	_started = false;
+	_closed = false;
+	_streamMapping = /* @__PURE__ */ new Map();
+	_requestToStreamMapping = /* @__PURE__ */ new Map();
+	_requestResponseMap = /* @__PURE__ */ new Map();
+	_initialized = false;
+	_enableJsonResponse = false;
+	_standaloneSseStreamId = "_GET_stream";
+	_eventStore;
+	_onsessioninitialized;
+	_onsessionclosed;
+	_allowedHosts;
+	_allowedOrigins;
+	_enableDnsRebindingProtection;
+	_retryInterval;
+	_supportedProtocolVersions;
+	sessionId;
+	onclose;
+	onerror;
+	onmessage;
+	constructor(options = {}) {
+		this.sessionIdGenerator = options.sessionIdGenerator;
+		this._enableJsonResponse = options.enableJsonResponse ?? false;
+		this._eventStore = options.eventStore;
+		this._onsessioninitialized = options.onsessioninitialized;
+		this._onsessionclosed = options.onsessionclosed;
+		this._allowedHosts = options.allowedHosts;
+		this._allowedOrigins = options.allowedOrigins;
+		this._enableDnsRebindingProtection = options.enableDnsRebindingProtection ?? false;
+		this._retryInterval = options.retryInterval;
+		this._supportedProtocolVersions = options.supportedProtocolVersions ?? SUPPORTED_PROTOCOL_VERSIONS;
 	}
-	get _module() {
-		return this._server.taskManager;
+	/**
+	* Starts the transport. This is required by the {@linkcode Transport} interface but is a no-op
+	* for the Streamable HTTP transport as connections are managed per-request.
+	*/
+	async start() {
+		if (this._started) throw new Error("Transport already started");
+		this._started = true;
 	}
 	/**
-	* Sends a request and returns an AsyncGenerator that yields response messages.
-	* The generator is guaranteed to end with either a `'result'` or `'error'` message.
-	*
-	* This method provides streaming access to request processing, allowing you to
-	* observe intermediate task status updates for task-augmented requests.
-	*
-	* @param request - The request to send (method name determines the result schema)
-	* @param options - Optional request options (timeout, signal, task creation params, etc.)
-	* @returns AsyncGenerator that yields {@linkcode ResponseMessage} objects
-	*
-	* @experimental
+	* Sets the supported protocol versions for header validation.
+	* Called by the server during {@linkcode server/server.Server.connect | connect()} to pass its supported versions.
 	*/
-	requestStream(request, options) {
-		const resultSchema = getResultSchema(request.method);
-		return this._module.requestStream(request, resultSchema, options);
+	setSupportedProtocolVersions(versions) {
+		this._supportedProtocolVersions = versions;
 	}
 	/**
-	* Sends a sampling request and returns an AsyncGenerator that yields response messages.
-	* The generator is guaranteed to end with either a 'result' or 'error' message.
-	*
-	* For task-augmented requests, yields 'taskCreated' and 'taskStatus' messages
-	* before the final result.
-	*
-	* @example
-	* ```typescript
-	* const stream = server.experimental.tasks.createMessageStream({
-	*     messages: [{ role: 'user', content: { type: 'text', text: 'Hello' } }],
-	*     maxTokens: 100
-	* }, {
-	*     onprogress: (progress) => {
-	*         // Handle streaming tokens via progress notifications
-	*         console.log('Progress:', progress.message);
-	*     }
-	* });
-	*
-	* for await (const message of stream) {
-	*     switch (message.type) {
-	*         case 'taskCreated':
-	*             console.log('Task created:', message.task.taskId);
-	*             break;
-	*         case 'taskStatus':
-	*             console.log('Task status:', message.task.status);
-	*             break;
-	*         case 'result':
-	*             console.log('Final result:', message.result);
-	*             break;
-	*         case 'error':
-	*             console.error('Error:', message.error);
-	*             break;
-	*     }
-	* }
-	* ```
-	*
-	* @param params - The sampling request parameters
-	* @param options - Optional request options (timeout, signal, task creation params, onprogress, etc.)
-	* @returns AsyncGenerator that yields ResponseMessage objects
-	*
-	* @experimental
+	* Helper to create a JSON error response
 	*/
-	createMessageStream(params, options) {
-		const clientCapabilities = this._server.getClientCapabilities();
-		if ((params.tools || params.toolChoice) && !clientCapabilities?.sampling?.tools) throw new SdkError(SdkErrorCode.CapabilityNotSupported, "Client does not support sampling tools capability.");
-		if (params.messages.length > 0) {
-			const lastMessage = params.messages.at(-1);
-			const lastContent = Array.isArray(lastMessage.content) ? lastMessage.content : [lastMessage.content];
-			const hasToolResults = lastContent.some((c) => c.type === "tool_result");
-			const previousMessage = params.messages.length > 1 ? params.messages.at(-2) : void 0;
-			const previousContent = previousMessage ? Array.isArray(previousMessage.content) ? previousMessage.content : [previousMessage.content] : [];
-			const hasPreviousToolUse = previousContent.some((c) => c.type === "tool_use");
-			if (hasToolResults) {
-				if (lastContent.some((c) => c.type !== "tool_result")) throw new Error("The last message must contain only tool_result content if any is present");
-				if (!hasPreviousToolUse) throw new Error("tool_result blocks are not matching any tool_use from the previous message");
-			}
-			if (hasPreviousToolUse) {
-				const toolUseIds = new Set(previousContent.filter((c) => c.type === "tool_use").map((c) => c.id));
-				const toolResultIds = new Set(lastContent.filter((c) => c.type === "tool_result").map((c) => c.toolUseId));
-				if (toolUseIds.size !== toolResultIds.size || ![...toolUseIds].every((id) => toolResultIds.has(id))) throw new Error("ids of tool_result blocks and tool_use blocks from previous message do not match");
+	createJsonErrorResponse(status, code, message, options) {
+		const error = {
+			code,
+			message
+		};
+		if (options?.data !== void 0) error.data = options.data;
+		return Response.json({
+			jsonrpc: "2.0",
+			error,
+			id: null
+		}, {
+			status,
+			headers: {
+				"Content-Type": "application/json",
+				...options?.headers
 			}
-		}
-		return this.requestStream({
-			method: "sampling/createMessage",
-			params
-		}, options);
+		});
 	}
 	/**
-	* Sends an elicitation request and returns an AsyncGenerator that yields response messages.
-	* The generator is guaranteed to end with either a 'result' or 'error' message.
-	*
-	* For task-augmented requests (especially URL-based elicitation), yields 'taskCreated'
-	* and 'taskStatus' messages before the final result.
-	*
-	* @example
-	* ```typescript
-	* const stream = server.experimental.tasks.elicitInputStream({
-	*     mode: 'url',
-	*     message: 'Please authenticate',
-	*     elicitationId: 'auth-123',
-	*     url: 'https://example.com/auth'
-	* }, {
-	*     task: { ttl: 300000 } // Task-augmented for long-running auth flow
-	* });
-	*
-	* for await (const message of stream) {
-	*     switch (message.type) {
-	*         case 'taskCreated':
-	*             console.log('Task created:', message.task.taskId);
-	*             break;
-	*         case 'taskStatus':
-	*             console.log('Task status:', message.task.status);
-	*             break;
-	*         case 'result':
-	*             console.log('User action:', message.result.action);
-	*             break;
-	*         case 'error':
-	*             console.error('Error:', message.error);
-	*             break;
-	*     }
-	* }
-	* ```
-	*
-	* @param params - The elicitation request parameters
-	* @param options - Optional request options (timeout, signal, task creation params, etc.)
-	* @returns AsyncGenerator that yields ResponseMessage objects
-	*
-	* @experimental
+	* Validates request headers for DNS rebinding protection.
+	* @returns Error response if validation fails, `undefined` if validation passes.
 	*/
-	elicitInputStream(params, options) {
-		const clientCapabilities = this._server.getClientCapabilities();
-		const mode = params.mode ?? "form";
-		switch (mode) {
-			case "url":
-				if (!clientCapabilities?.elicitation?.url) throw new SdkError(SdkErrorCode.CapabilityNotSupported, "Client does not support url elicitation.");
-				break;
-			case "form":
-				if (!clientCapabilities?.elicitation?.form) throw new SdkError(SdkErrorCode.CapabilityNotSupported, "Client does not support form elicitation.");
-				break;
+	validateRequestHeaders(req) {
+		if (!this._enableDnsRebindingProtection) return;
+		if (this._allowedHosts && this._allowedHosts.length > 0) {
+			const hostHeader = req.headers.get("host");
+			if (!hostHeader || !this._allowedHosts.includes(hostHeader)) {
+				const error = `Invalid Host header: ${hostHeader}`;
+				this.onerror?.(new Error(error));
+				return this.createJsonErrorResponse(403, -32e3, error);
+			}
+		}
+		if (this._allowedOrigins && this._allowedOrigins.length > 0) {
+			const originHeader = req.headers.get("origin");
+			if (originHeader && !this._allowedOrigins.includes(originHeader)) {
+				const error = `Invalid Origin header: ${originHeader}`;
+				this.onerror?.(new Error(error));
+				return this.createJsonErrorResponse(403, -32e3, error);
+			}
 		}
-		const normalizedParams = mode === "form" && params.mode !== "form" ? {
-			...params,
-			mode: "form"
-		} : params;
-		return this.requestStream({
-			method: "elicitation/create",
-			params: normalizedParams
-		}, options);
 	}
 	/**
-	* Gets the current status of a task.
-	*
-	* @param taskId - The task identifier
-	* @param options - Optional request options
-	* @returns The task status
-	*
-	* @experimental
-	*/
-	async getTask(taskId, options) {
-		return this._module.getTask({ taskId }, options);
-	}
-	/**
-	* Retrieves the result of a completed task.
-	*
-	* @param taskId - The task identifier
-	* @param options - Optional request options
-	* @returns The task result. The payload structure matches the result type of the
-	*   original request (e.g., a `tools/call` task returns a `CallToolResult`).
-	*
-	* @experimental
-	*/
-	async getTaskResult(taskId, options) {
-		return this._module.getTaskResult({ taskId }, GetTaskPayloadResultSchema, options);
-	}
-	/**
-	* Lists tasks with optional pagination.
-	*
-	* @param cursor - Optional pagination cursor
-	* @param options - Optional request options
-	* @returns List of tasks with optional next cursor
-	*
-	* @experimental
-	*/
-	async listTasks(cursor, options) {
-		return this._module.listTasks(cursor ? { cursor } : void 0, options);
-	}
-	/**
-	* Cancels a running task.
-	*
-	* @param taskId - The task identifier
-	* @param options - Optional request options
-	*
-	* @experimental
-	*/
-	async cancelTask(taskId, options) {
-		return this._module.cancelTask({ taskId }, options);
-	}
-};
-
-//#endregion
-//#region src/server/server.ts
-/**
-* An MCP server on top of a pluggable transport.
-*
-* This server will automatically respond to the initialization flow as initiated from the client.
-*
-* @deprecated Use {@linkcode server/mcp.McpServer | McpServer} instead for the high-level API. Only use `Server` for advanced use cases.
-*/
-var Server = class extends Protocol {
-	_clientCapabilities;
-	_clientVersion;
-	_capabilities;
-	_instructions;
-	_jsonSchemaValidator;
-	_experimental;
-	/**
-	* Callback for when initialization has fully completed (i.e., the client has sent an `notifications/initialized` notification).
-	*/
-	oninitialized;
-	/**
-	* Initializes this server with the given name and version information.
+	* Handles an incoming HTTP request, whether `GET`, `POST`, or `DELETE`
+	* Returns a `Response` object (Web Standard)
 	*/
-	constructor(_serverInfo, options) {
-		super({
-			...options,
-			tasks: extractTaskManagerOptions(options?.capabilities?.tasks)
-		});
-		this._serverInfo = _serverInfo;
-		this._capabilities = options?.capabilities ? { ...options.capabilities } : {};
-		this._instructions = options?.instructions;
-		this._jsonSchemaValidator = options?.jsonSchemaValidator ?? new DefaultJsonSchemaValidator();
-		if (options?.capabilities?.tasks) {
-			const { taskStore, taskMessageQueue, defaultTaskPollInterval, maxTaskQueueSize, ...wireCapabilities } = options.capabilities.tasks;
-			this._capabilities.tasks = wireCapabilities;
+	async handleRequest(req, options) {
+		const validationError = this.validateRequestHeaders(req);
+		if (validationError) return validationError;
+		switch (req.method) {
+			case "POST": return this.handlePostRequest(req, options);
+			case "GET": return this.handleGetRequest(req);
+			case "DELETE": return this.handleDeleteRequest(req);
+			default: return this.handleUnsupportedRequest();
 		}
-		this.setRequestHandler("initialize", (request) => this._oninitialize(request));
-		this.setNotificationHandler("notifications/initialized", () => this.oninitialized?.());
-		if (this._capabilities.logging) this._registerLoggingHandler();
-	}
-	_registerLoggingHandler() {
-		this.setRequestHandler("logging/setLevel", async (request, ctx) => {
-			const transportSessionId = ctx.sessionId || ctx.http?.req?.headers.get("mcp-session-id") || void 0;
-			const { level } = request.params;
-			const parseResult = parseSchema(LoggingLevelSchema, level);
-			if (parseResult.success) this._loggingLevels.set(transportSessionId, parseResult.data);
-			return {};
-		});
-	}
-	buildContext(ctx, transportInfo) {
-		const hasHttpInfo = ctx.http || transportInfo?.request || transportInfo?.closeSSEStream || transportInfo?.closeStandaloneSSEStream;
-		return {
-			...ctx,
-			mcpReq: {
-				...ctx.mcpReq,
-				log: (level, data, logger) => this.sendLoggingMessage({
-					level,
-					data,
-					logger
-				}),
-				elicitInput: (params, options) => this.elicitInput(params, options),
-				requestSampling: (params, options) => this.createMessage(params, options)
-			},
-			http: hasHttpInfo ? {
-				...ctx.http,
-				req: transportInfo?.request,
-				closeSSE: transportInfo?.closeSSEStream,
-				closeStandaloneSSE: transportInfo?.closeStandaloneSSEStream
-			} : void 0
-		};
 	}
 	/**
-	* Access experimental features.
-	*
-	* WARNING: These APIs are experimental and may change without notice.
+	* Returns true if the client's protocol version supports empty SSE data in
+	* priming events (the fix shipped with protocol version `2025-11-25`).
 	*
-	* @experimental
+	* The version is checked for membership in this transport instance's
+	* supported protocol versions rather than with an open-ended
+	* `>= '2025-11-25'` comparison: the value may come from an `initialize`
+	* request body, which (unlike the `MCP-Protocol-Version` header) is not
+	* validated against `supportedProtocolVersions` before reaching this
+	* check. An unknown future version string must not silently enable
+	* behavior reserved for versions this transport actually supports.
 	*/
-	get experimental() {
-		if (!this._experimental) this._experimental = { tasks: new ExperimentalServerTasks(this) };
-		return this._experimental;
+	supportsEmptySSEData(protocolVersion) {
+		return this._supportedProtocolVersions.includes(protocolVersion) && protocolVersion >= "2025-11-25";
 	}
-	_loggingLevels = /* @__PURE__ */ new Map();
-	LOG_LEVEL_SEVERITY = new Map(LoggingLevelSchema.options.map((level, index) => [level, index]));
-	isMessageIgnored = (level, sessionId) => {
-		const currentLevel = this._loggingLevels.get(sessionId);
-		return currentLevel ? this.LOG_LEVEL_SEVERITY.get(level) < this.LOG_LEVEL_SEVERITY.get(currentLevel) : false;
-	};
 	/**
-	* Registers new capabilities. This can only be called before connecting to a transport.
-	*
-	* The new capabilities will be merged with any existing capabilities previously given (e.g., at initialization).
+	* Writes a priming event to establish resumption capability.
+	* Only sends if `eventStore` is configured (opt-in for resumability) and
+	* the client's protocol version supports empty SSE data (a supported
+	* version that is >= `2025-11-25`).
 	*/
-	registerCapabilities(capabilities) {
-		if (this.transport) throw new SdkError(SdkErrorCode.AlreadyConnected, "Cannot register capabilities after connecting to transport");
-		const hadLogging = !!this._capabilities.logging;
-		this._capabilities = mergeCapabilities(this._capabilities, capabilities);
-		if (!hadLogging && this._capabilities.logging) this._registerLoggingHandler();
+	async writePrimingEvent(controller, encoder, streamId, protocolVersion) {
+		if (!this._eventStore) return;
+		if (!this.supportsEmptySSEData(protocolVersion)) return;
+		const primingEventId = await this._eventStore.storeEvent(streamId, {});
+		let primingEvent = `id: ${primingEventId}\ndata: \n\n`;
+		if (this._retryInterval !== void 0) primingEvent = `id: ${primingEventId}\nretry: ${this._retryInterval}\ndata: \n\n`;
+		controller.enqueue(encoder.encode(primingEvent));
 	}
 	/**
-	* Override request handler registration to enforce server-side validation for `tools/call`.
+	* Handles `GET` requests for SSE stream
 	*/
-	setRequestHandler(method, handler) {
-		if (method === "tools/call") {
-			const wrappedHandler = async (request, ctx) => {
-				const validatedRequest = parseSchema(CallToolRequestSchema, request);
-				if (!validatedRequest.success) {
-					const errorMessage = validatedRequest.error instanceof Error ? validatedRequest.error.message : String(validatedRequest.error);
-					throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Invalid tools/call request: ${errorMessage}`);
-				}
-				const { params } = validatedRequest.data;
-				const result = await Promise.resolve(handler(request, ctx));
-				if (params.task) {
-					const taskValidationResult = parseSchema(CreateTaskResultSchema, result);
-					if (!taskValidationResult.success) {
-						const errorMessage = taskValidationResult.error instanceof Error ? taskValidationResult.error.message : String(taskValidationResult.error);
-						throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Invalid task creation result: ${errorMessage}`);
-					}
-					return taskValidationResult.data;
-				}
-				const validationResult = parseSchema(CallToolResultSchema, result);
-				if (!validationResult.success) {
-					const errorMessage = validationResult.error instanceof Error ? validationResult.error.message : String(validationResult.error);
-					throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Invalid tools/call result: ${errorMessage}`);
-				}
-				return validationResult.data;
-			};
-			return super.setRequestHandler(method, wrappedHandler);
-		}
-		return super.setRequestHandler(method, handler);
-	}
-	assertCapabilityForMethod(method) {
-		switch (method) {
-			case "sampling/createMessage":
-				if (!this._clientCapabilities?.sampling) throw new SdkError(SdkErrorCode.CapabilityNotSupported, `Client does not support sampling (required for ${method})`);
-				break;
-			case "elicitation/create":
-				if (!this._clientCapabilities?.elicitation) throw new SdkError(SdkErrorCode.CapabilityNotSupported, `Client does not support elicitation (required for ${method})`);
-				break;
-			case "roots/list":
-				if (!this._clientCapabilities?.roots) throw new SdkError(SdkErrorCode.CapabilityNotSupported, `Client does not support listing roots (required for ${method})`);
-				break;
-			case "ping": break;
+	async handleGetRequest(req) {
+		if (!req.headers.get("accept")?.includes("text/event-stream")) {
+			this.onerror?.(/* @__PURE__ */ new Error("Not Acceptable: Client must accept text/event-stream"));
+			return this.createJsonErrorResponse(406, -32e3, "Not Acceptable: Client must accept text/event-stream");
 		}
-	}
-	assertNotificationCapability(method) {
-		switch (method) {
-			case "notifications/message":
-				if (!this._capabilities.logging) throw new SdkError(SdkErrorCode.CapabilityNotSupported, `Server does not support logging (required for ${method})`);
-				break;
-			case "notifications/resources/updated":
-			case "notifications/resources/list_changed":
-				if (!this._capabilities.resources) throw new SdkError(SdkErrorCode.CapabilityNotSupported, `Server does not support notifying about resources (required for ${method})`);
-				break;
-			case "notifications/tools/list_changed":
-				if (!this._capabilities.tools) throw new SdkError(SdkErrorCode.CapabilityNotSupported, `Server does not support notifying of tool list changes (required for ${method})`);
-				break;
-			case "notifications/prompts/list_changed":
-				if (!this._capabilities.prompts) throw new SdkError(SdkErrorCode.CapabilityNotSupported, `Server does not support notifying of prompt list changes (required for ${method})`);
-				break;
-			case "notifications/elicitation/complete":
-				if (!this._clientCapabilities?.elicitation?.url) throw new SdkError(SdkErrorCode.CapabilityNotSupported, `Client does not support URL elicitation (required for ${method})`);
-				break;
-			case "notifications/cancelled": break;
-			case "notifications/progress": break;
+		const sessionError = this.validateSession(req);
+		if (sessionError) return sessionError;
+		const protocolError = this.validateProtocolVersion(req);
+		if (protocolError) return protocolError;
+		if (this._eventStore) {
+			const lastEventId = req.headers.get("last-event-id");
+			if (lastEventId) return this.replayEvents(lastEventId);
 		}
-	}
-	assertRequestHandlerCapability(method) {
-		switch (method) {
-			case "completion/complete":
-				if (!this._capabilities.completions) throw new SdkError(SdkErrorCode.CapabilityNotSupported, `Server does not support completions (required for ${method})`);
-				break;
-			case "logging/setLevel":
-				if (!this._capabilities.logging) throw new SdkError(SdkErrorCode.CapabilityNotSupported, `Server does not support logging (required for ${method})`);
-				break;
-			case "prompts/get":
-			case "prompts/list":
-				if (!this._capabilities.prompts) throw new SdkError(SdkErrorCode.CapabilityNotSupported, `Server does not support prompts (required for ${method})`);
-				break;
-			case "resources/list":
-			case "resources/templates/list":
-			case "resources/read":
-				if (!this._capabilities.resources) throw new SdkError(SdkErrorCode.CapabilityNotSupported, `Server does not support resources (required for ${method})`);
-				break;
-			case "tools/call":
-			case "tools/list":
-				if (!this._capabilities.tools) throw new SdkError(SdkErrorCode.CapabilityNotSupported, `Server does not support tools (required for ${method})`);
-				break;
-			case "ping":
-			case "initialize": break;
+		if (this._streamMapping.get(this._standaloneSseStreamId) !== void 0) {
+			this.onerror?.(/* @__PURE__ */ new Error("Conflict: Only one SSE stream is allowed per session"));
+			return this.createJsonErrorResponse(409, -32e3, "Conflict: Only one SSE stream is allowed per session");
 		}
-	}
-	assertTaskCapability(method) {
-		assertClientRequestTaskCapability(this._clientCapabilities?.tasks?.requests, method, "Client");
-	}
-	assertTaskHandlerCapability(method) {
-		assertToolsCallTaskCapability(this._capabilities?.tasks?.requests, method, "Server");
-	}
-	async _oninitialize(request) {
-		const requestedVersion = request.params.protocolVersion;
-		this._clientCapabilities = request.params.capabilities;
-		this._clientVersion = request.params.clientInfo;
-		const protocolVersion = this._supportedProtocolVersions.includes(requestedVersion) ? requestedVersion : this._supportedProtocolVersions[0] ?? LATEST_PROTOCOL_VERSION;
-		this.transport?.setProtocolVersion?.(protocolVersion);
-		return {
-			protocolVersion,
-			capabilities: this.getCapabilities(),
-			serverInfo: this._serverInfo,
-			...this._instructions && { instructions: this._instructions }
-		};
-	}
-	/**
-	* After initialization has completed, this will be populated with the client's reported capabilities.
-	*/
-	getClientCapabilities() {
-		return this._clientCapabilities;
-	}
-	/**
-	* After initialization has completed, this will be populated with information about the client's name and version.
-	*/
-	getClientVersion() {
-		return this._clientVersion;
-	}
-	/**
-	* Returns the current server capabilities.
-	*/
-	getCapabilities() {
-		return this._capabilities;
-	}
-	async ping() {
-		return this._requestWithSchema({ method: "ping" }, EmptyResultSchema);
-	}
-	async createMessage(params, options) {
-		if ((params.tools || params.toolChoice) && !this._clientCapabilities?.sampling?.tools) throw new SdkError(SdkErrorCode.CapabilityNotSupported, "Client does not support sampling tools capability.");
-		if (params.messages.length > 0) {
-			const lastMessage = params.messages.at(-1);
-			const lastContent = Array.isArray(lastMessage.content) ? lastMessage.content : [lastMessage.content];
-			const hasToolResults = lastContent.some((c) => c.type === "tool_result");
-			const previousMessage = params.messages.length > 1 ? params.messages.at(-2) : void 0;
-			const previousContent = previousMessage ? Array.isArray(previousMessage.content) ? previousMessage.content : [previousMessage.content] : [];
-			const hasPreviousToolUse = previousContent.some((c) => c.type === "tool_use");
-			if (hasToolResults) {
-				if (lastContent.some((c) => c.type !== "tool_result")) throw new ProtocolError(ProtocolErrorCode.InvalidParams, "The last message must contain only tool_result content if any is present");
-				if (!hasPreviousToolUse) throw new ProtocolError(ProtocolErrorCode.InvalidParams, "tool_result blocks are not matching any tool_use from the previous message");
+		const encoder = new TextEncoder();
+		let streamController;
+		const readable = new ReadableStream({
+			start: (controller) => {
+				streamController = controller;
+			},
+			cancel: () => {
+				if (this._streamMapping.get(this._standaloneSseStreamId)?.controller === streamController) this._streamMapping.delete(this._standaloneSseStreamId);
 			}
-			if (hasPreviousToolUse) {
-				const toolUseIds = new Set(previousContent.filter((c) => c.type === "tool_use").map((c) => c.id));
-				const toolResultIds = new Set(lastContent.filter((c) => c.type === "tool_result").map((c) => c.toolUseId));
-				if (toolUseIds.size !== toolResultIds.size || ![...toolUseIds].every((id) => toolResultIds.has(id))) throw new ProtocolError(ProtocolErrorCode.InvalidParams, "ids of tool_result blocks and tool_use blocks from previous message do not match");
+		});
+		const headers = {
+			"Content-Type": "text/event-stream",
+			"Cache-Control": "no-cache, no-transform",
+			Connection: "keep-alive"
+		};
+		if (this.sessionId !== void 0) headers["mcp-session-id"] = this.sessionId;
+		this._streamMapping.set(this._standaloneSseStreamId, {
+			controller: streamController,
+			encoder,
+			cleanup: () => {
+				this._streamMapping.delete(this._standaloneSseStreamId);
+				try {
+					streamController.close();
+				} catch {}
 			}
-		}
-		if (params.tools) return this._requestWithSchema({
-			method: "sampling/createMessage",
-			params
-		}, CreateMessageResultWithToolsSchema, options);
-		return this._requestWithSchema({
-			method: "sampling/createMessage",
-			params
-		}, CreateMessageResultSchema, options);
+		});
+		return new Response(readable, { headers });
 	}
 	/**
-	* Creates an elicitation request for the given parameters.
-	* For backwards compatibility, `mode` may be omitted for form requests and will default to `"form"`.
-	* @param params The parameters for the elicitation request.
-	* @param options Optional request options.
-	* @returns The result of the elicitation request.
+	* Replays events that would have been sent after the specified event ID
+	* Only used when resumability is enabled
 	*/
-	async elicitInput(params, options) {
-		switch (params.mode ?? "form") {
-			case "url": {
-				if (!this._clientCapabilities?.elicitation?.url) throw new SdkError(SdkErrorCode.CapabilityNotSupported, "Client does not support url elicitation.");
-				const urlParams = params;
-				return this._requestWithSchema({
-					method: "elicitation/create",
-					params: urlParams
-				}, ElicitResultSchema, options);
+	async replayEvents(lastEventId) {
+		if (!this._eventStore) {
+			this.onerror?.(/* @__PURE__ */ new Error("Event store not configured"));
+			return this.createJsonErrorResponse(400, -32e3, "Event store not configured");
+		}
+		try {
+			let streamId;
+			if (this._eventStore.getStreamIdForEventId) {
+				streamId = await this._eventStore.getStreamIdForEventId(lastEventId);
+				if (!streamId) {
+					this.onerror?.(/* @__PURE__ */ new Error("Invalid event ID format"));
+					return this.createJsonErrorResponse(400, -32e3, "Invalid event ID format");
+				}
+				if (this._streamMapping.get(streamId) !== void 0) {
+					this.onerror?.(/* @__PURE__ */ new Error("Conflict: Stream already has an active connection"));
+					return this.createJsonErrorResponse(409, -32e3, "Conflict: Stream already has an active connection");
+				}
 			}
-			case "form": {
-				if (!this._clientCapabilities?.elicitation?.form) throw new SdkError(SdkErrorCode.CapabilityNotSupported, "Client does not support form elicitation.");
-				const formParams = params.mode === "form" ? params : {
-					...params,
-					mode: "form"
-				};
-				const result = await this._requestWithSchema({
-					method: "elicitation/create",
-					params: formParams
-				}, ElicitResultSchema, options);
-				if (result.action === "accept" && result.content && formParams.requestedSchema) try {
-					const validationResult = this._jsonSchemaValidator.getValidator(formParams.requestedSchema)(result.content);
-					if (!validationResult.valid) throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Elicitation response content does not match requested schema: ${validationResult.errorMessage}`);
-				} catch (error) {
-					if (error instanceof ProtocolError) throw error;
-					throw new ProtocolError(ProtocolErrorCode.InternalError, `Error validating elicitation response: ${error instanceof Error ? error.message : String(error)}`);
+			const headers = {
+				"Content-Type": "text/event-stream",
+				"Cache-Control": "no-cache, no-transform",
+				Connection: "keep-alive"
+			};
+			if (this.sessionId !== void 0) headers["mcp-session-id"] = this.sessionId;
+			const encoder = new TextEncoder();
+			let streamController;
+			let replayedStreamId;
+			const readable = new ReadableStream({
+				start: (controller) => {
+					streamController = controller;
+				},
+				cancel: () => {
+					if (replayedStreamId !== void 0 && this._streamMapping.get(replayedStreamId)?.controller === streamController) this._streamMapping.delete(replayedStreamId);
+				}
+			});
+			const replayedEventIds = /* @__PURE__ */ new Set();
+			replayedStreamId = await this._eventStore.replayEventsAfter(lastEventId, { send: async (eventId, message) => {
+				replayedEventIds.add(eventId);
+				if (!this.writeSSEEvent(streamController, encoder, message, eventId)) try {
+					streamController.close();
+				} catch {}
+			} });
+			this._streamMapping.set(replayedStreamId, {
+				controller: streamController,
+				encoder,
+				replayedEventIds,
+				cleanup: () => {
+					this._streamMapping.delete(replayedStreamId);
+					try {
+						streamController.close();
+					} catch {}
+				}
+			});
+			if (replayedStreamId !== this._standaloneSseStreamId) {
+				if (![...this._requestToStreamMapping.values()].includes(replayedStreamId)) {
+					this._streamMapping.delete(replayedStreamId);
+					try {
+						streamController.close();
+					} catch {}
 				}
-				return result;
 			}
+			return new Response(readable, { headers });
+		} catch (error) {
+			this.onerror?.(error);
+			return this.createJsonErrorResponse(500, -32e3, "Error replaying events");
 		}
 	}
 	/**
-	* Creates a reusable callback that, when invoked, will send a `notifications/elicitation/complete`
-	* notification for the specified elicitation ID.
-	*
-	* @param elicitationId The ID of the elicitation to mark as complete.
-	* @param options Optional notification options. Useful when the completion notification should be related to a prior request.
-	* @returns A function that emits the completion notification when awaited.
+	* Writes an event to an SSE stream via controller with proper formatting
 	*/
-	createElicitationCompletionNotifier(elicitationId, options) {
-		if (!this._clientCapabilities?.elicitation?.url) throw new SdkError(SdkErrorCode.CapabilityNotSupported, "Client does not support URL elicitation (required for notifications/elicitation/complete)");
-		return () => this.notification({
-			method: "notifications/elicitation/complete",
-			params: { elicitationId }
-		}, options);
-	}
-	async listRoots(params, options) {
-		return this._requestWithSchema({
-			method: "roots/list",
-			params
-		}, ListRootsResultSchema, options);
+	writeSSEEvent(controller, encoder, message, eventId) {
+		try {
+			let eventData = `event: message\n`;
+			if (eventId) eventData += `id: ${eventId}\n`;
+			eventData += `data: ${JSON.stringify(message)}\n\n`;
+			controller.enqueue(encoder.encode(eventData));
+			return true;
+		} catch (error) {
+			this.onerror?.(error);
+			return false;
+		}
 	}
 	/**
-	* Sends a logging message to the client, if connected.
-	* Note: You only need to send the parameters object, not the entire JSON-RPC message.
-	* @see {@linkcode LoggingMessageNotification}
-	* @param params
-	* @param sessionId Optional for stateless transports and backward compatibility.
+	* Handles unsupported requests (`PUT`, `PATCH`, etc.)
 	*/
-	async sendLoggingMessage(params, sessionId) {
-		if (this._capabilities.logging && !this.isMessageIgnored(params.level, sessionId)) return this.notification({
-			method: "notifications/message",
-			params
-		});
-	}
-	async sendResourceUpdated(params) {
-		return this.notification({
-			method: "notifications/resources/updated",
-			params
+	handleUnsupportedRequest() {
+		this.onerror?.(/* @__PURE__ */ new Error("Method not allowed."));
+		return Response.json({
+			jsonrpc: "2.0",
+			error: {
+				code: -32e3,
+				message: "Method not allowed."
+			},
+			id: null
+		}, {
+			status: 405,
+			headers: {
+				Allow: "GET, POST, DELETE",
+				"Content-Type": "application/json"
+			}
 		});
 	}
-	async sendResourceListChanged() {
-		return this.notification({ method: "notifications/resources/list_changed" });
-	}
-	async sendToolListChanged() {
-		return this.notification({ method: "notifications/tools/list_changed" });
-	}
-	async sendPromptListChanged() {
-		return this.notification({ method: "notifications/prompts/list_changed" });
-	}
-};
-
-//#endregion
-//#region src/server/mcp.ts
-/**
-* High-level MCP server that provides a simpler API for working with resources, tools, and prompts.
-* For advanced usage (like sending notifications or setting custom request handlers), use the underlying
-* {@linkcode Server} instance available via the {@linkcode McpServer.server | server} property.
-*
-* @example
-* ```ts source="./mcp.examples.ts#McpServer_basicUsage"
-* const server = new McpServer({
-*     name: 'my-server',
-*     version: '1.0.0'
-* });
-* ```
-*/
-var McpServer = class {
-	/**
-	* The underlying {@linkcode Server} instance, useful for advanced operations like sending notifications.
-	*/
-	server;
-	_registeredResources = {};
-	_registeredResourceTemplates = {};
-	_registeredTools = {};
-	_registeredPrompts = {};
-	_experimental;
-	constructor(serverInfo, options) {
-		this.server = new Server(serverInfo, options);
-	}
-	/**
-	* Access experimental features.
-	*
-	* WARNING: These APIs are experimental and may change without notice.
-	*
-	* @experimental
-	*/
-	get experimental() {
-		if (!this._experimental) this._experimental = { tasks: new ExperimentalMcpServerTasks(this) };
-		return this._experimental;
-	}
-	/**
-	* Attaches to the given transport, starts it, and starts listening for messages.
-	*
-	* The `server` object assumes ownership of the {@linkcode Transport}, replacing any callbacks that have already been set, and expects that it is the only user of the {@linkcode Transport} instance going forward.
-	*
-	* @example
-	* ```ts source="./mcp.examples.ts#McpServer_connect_stdio"
-	* const server = new McpServer({ name: 'my-server', version: '1.0.0' });
-	* const transport = new StdioServerTransport();
-	* await server.connect(transport);
-	* ```
-	*/
-	async connect(transport) {
-		return await this.server.connect(transport);
-	}
 	/**
-	* Closes the connection.
+	* Handles `POST` requests containing JSON-RPC messages
 	*/
-	async close() {
-		await this.server.close();
-	}
-	_toolHandlersInitialized = false;
-	setToolRequestHandlers() {
-		if (this._toolHandlersInitialized) return;
-		this.server.assertCanSetRequestHandler("tools/list");
-		this.server.assertCanSetRequestHandler("tools/call");
-		this.server.registerCapabilities({ tools: { listChanged: this.server.getCapabilities().tools?.listChanged ?? true } });
-		this.server.setRequestHandler("tools/list", () => ({ tools: Object.entries(this._registeredTools).filter(([, tool]) => tool.enabled).map(([name, tool]) => {
-			const toolDefinition = {
-				name,
-				title: tool.title,
-				description: tool.description,
-				inputSchema: tool.inputSchema ? standardSchemaToJsonSchema(tool.inputSchema, "input") : EMPTY_OBJECT_JSON_SCHEMA,
-				annotations: tool.annotations,
-				execution: tool.execution,
-				_meta: tool._meta
-			};
-			if (tool.outputSchema) toolDefinition.outputSchema = standardSchemaToJsonSchema(tool.outputSchema, "output");
-			return toolDefinition;
-		}) }));
-		this.server.setRequestHandler("tools/call", async (request, ctx) => {
-			const tool = this._registeredTools[request.params.name];
-			if (!tool) throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Tool ${request.params.name} not found`);
-			if (!tool.enabled) throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Tool ${request.params.name} disabled`);
-			try {
-				const isTaskRequest = !!request.params.task;
-				const taskSupport = tool.execution?.taskSupport;
-				const isTaskHandler = "createTask" in tool.handler;
-				if ((taskSupport === "required" || taskSupport === "optional") && !isTaskHandler) throw new ProtocolError(ProtocolErrorCode.InternalError, `Tool ${request.params.name} has taskSupport '${taskSupport}' but was not registered with registerToolTask`);
-				if (taskSupport === "required" && !isTaskRequest) throw new ProtocolError(ProtocolErrorCode.MethodNotFound, `Tool ${request.params.name} requires task augmentation (taskSupport: 'required')`);
-				if (taskSupport === "optional" && !isTaskRequest && isTaskHandler) return await this.handleAutomaticTaskPolling(tool, request, ctx);
-				const args = await this.validateToolInput(tool, request.params.arguments, request.params.name);
-				const result = await this.executeToolHandler(tool, args, ctx);
-				if (isTaskRequest) return result;
-				await this.validateToolOutput(tool, result, request.params.name);
-				return result;
+	async handlePostRequest(req, options) {
+		try {
+			const acceptHeader = req.headers.get("accept");
+			if (!acceptHeader?.includes("application/json") || !acceptHeader.includes("text/event-stream")) {
+				this.onerror?.(/* @__PURE__ */ new Error("Not Acceptable: Client must accept both application/json and text/event-stream"));
+				return this.createJsonErrorResponse(406, -32e3, "Not Acceptable: Client must accept both application/json and text/event-stream");
+			}
+			const ct = req.headers.get("content-type");
+			if (!ct || !ct.includes("application/json")) {
+				this.onerror?.(/* @__PURE__ */ new Error("Unsupported Media Type: Content-Type must be application/json"));
+				return this.createJsonErrorResponse(415, -32e3, "Unsupported Media Type: Content-Type must be application/json");
+			}
+			const request = req;
+			let rawMessage;
+			if (options?.parsedBody === void 0) try {
+				rawMessage = await req.json();
 			} catch (error) {
-				if (error instanceof ProtocolError && error.code === ProtocolErrorCode.UrlElicitationRequired) throw error;
-				return this.createToolError(error instanceof Error ? error.message : String(error));
+				this.onerror?.(error);
+				return this.createJsonErrorResponse(400, -32700, "Parse error: Invalid JSON");
 			}
-		});
-		this._toolHandlersInitialized = true;
-	}
-	/**
-	* Creates a tool error result.
-	*
-	* @param errorMessage - The error message.
-	* @returns The tool error result.
-	*/
-	createToolError(errorMessage) {
-		return {
-			content: [{
-				type: "text",
-				text: errorMessage
-			}],
-			isError: true
-		};
-	}
-	/**
-	* Validates tool input arguments against the tool's input schema.
-	*/
-	async validateToolInput(tool, args, toolName) {
-		if (!tool.inputSchema) return;
-		const parseResult = await validateStandardSchema(tool.inputSchema, args ?? {});
-		if (!parseResult.success) throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Input validation error: Invalid arguments for tool ${toolName}: ${parseResult.error}`);
-		return parseResult.data;
-	}
-	/**
-	* Validates tool output against the tool's output schema.
-	*/
-	async validateToolOutput(tool, result, toolName) {
-		if (!tool.outputSchema) return;
-		if (!("content" in result)) return;
-		if (result.isError) return;
-		if (!result.structuredContent) throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Output validation error: Tool ${toolName} has an output schema but no structured content was provided`);
-		const parseResult = await validateStandardSchema(tool.outputSchema, result.structuredContent);
-		if (!parseResult.success) throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Output validation error: Invalid structured content for tool ${toolName}: ${parseResult.error}`);
-	}
-	/**
-	* Executes a tool handler (either regular or task-based).
-	*/
-	async executeToolHandler(tool, args, ctx) {
-		return tool.executor(args, ctx);
-	}
-	/**
-	* Handles automatic task polling for tools with `taskSupport` `'optional'`.
-	*/
-	async handleAutomaticTaskPolling(tool, request, ctx) {
-		if (!ctx.task?.store) throw new Error("No task store provided for task-capable tool.");
-		const args = await this.validateToolInput(tool, request.params.arguments, request.params.name);
-		const createTaskResult = await tool.executor(args, ctx);
-		const taskId = createTaskResult.task.taskId;
-		let task = createTaskResult.task;
-		const pollInterval = task.pollInterval ?? 5e3;
-		while (task.status !== "completed" && task.status !== "failed" && task.status !== "cancelled") {
-			await new Promise((resolve) => setTimeout(resolve, pollInterval));
-			const updatedTask = await ctx.task.store.getTask(taskId);
-			if (!updatedTask) throw new ProtocolError(ProtocolErrorCode.InternalError, `Task ${taskId} not found during polling`);
-			task = updatedTask;
-		}
-		return await ctx.task.store.getTaskResult(taskId);
-	}
-	_completionHandlerInitialized = false;
-	setCompletionRequestHandler() {
-		if (this._completionHandlerInitialized) return;
-		this.server.assertCanSetRequestHandler("completion/complete");
-		this.server.registerCapabilities({ completions: {} });
-		this.server.setRequestHandler("completion/complete", async (request) => {
-			switch (request.params.ref.type) {
-				case "ref/prompt":
-					assertCompleteRequestPrompt(request);
-					return this.handlePromptCompletion(request, request.params.ref);
-				case "ref/resource":
-					assertCompleteRequestResourceTemplate(request);
-					return this.handleResourceCompletion(request, request.params.ref);
-				default: throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Invalid completion reference: ${request.params.ref}`);
-			}
-		});
-		this._completionHandlerInitialized = true;
-	}
-	async handlePromptCompletion(request, ref) {
-		const prompt = this._registeredPrompts[ref.name];
-		if (!prompt) throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Prompt ${ref.name} not found`);
-		if (!prompt.enabled) throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Prompt ${ref.name} disabled`);
-		if (!prompt.argsSchema) return EMPTY_COMPLETION_RESULT;
-		const field = unwrapOptionalSchema(getSchemaShape(prompt.argsSchema)?.[request.params.argument.name]);
-		if (!isCompletable(field)) return EMPTY_COMPLETION_RESULT;
-		const completer = getCompleter(field);
-		if (!completer) return EMPTY_COMPLETION_RESULT;
-		return createCompletionResult(await completer(request.params.argument.value, request.params.context));
-	}
-	async handleResourceCompletion(request, ref) {
-		const template = Object.values(this._registeredResourceTemplates).find((t) => t.resourceTemplate.uriTemplate.toString() === ref.uri);
-		if (!template) {
-			if (this._registeredResources[ref.uri]) return EMPTY_COMPLETION_RESULT;
-			throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Resource template ${request.params.ref.uri} not found`);
-		}
-		const completer = template.resourceTemplate.completeCallback(request.params.argument.name);
-		if (!completer) return EMPTY_COMPLETION_RESULT;
-		return createCompletionResult(await completer(request.params.argument.value, request.params.context));
-	}
-	_resourceHandlersInitialized = false;
-	setResourceRequestHandlers() {
-		if (this._resourceHandlersInitialized) return;
-		this.server.assertCanSetRequestHandler("resources/list");
-		this.server.assertCanSetRequestHandler("resources/templates/list");
-		this.server.assertCanSetRequestHandler("resources/read");
-		this.server.registerCapabilities({ resources: { listChanged: this.server.getCapabilities().resources?.listChanged ?? true } });
-		this.server.setRequestHandler("resources/list", async (_request, ctx) => {
-			const resources = Object.entries(this._registeredResources).filter(([_, resource]) => resource.enabled).map(([uri, resource]) => ({
-				uri,
-				name: resource.name,
-				...resource.metadata
-			}));
-			const templateResources = [];
-			for (const template of Object.values(this._registeredResourceTemplates)) {
-				if (!template.resourceTemplate.listCallback) continue;
-				const result = await template.resourceTemplate.listCallback(ctx);
-				for (const resource of result.resources) templateResources.push({
-					...template.metadata,
-					...resource
-				});
-			}
-			return { resources: [...resources, ...templateResources] };
-		});
-		this.server.setRequestHandler("resources/templates/list", async () => {
-			return { resourceTemplates: Object.entries(this._registeredResourceTemplates).map(([name, template]) => ({
-				name,
-				uriTemplate: template.resourceTemplate.uriTemplate.toString(),
-				...template.metadata
-			})) };
-		});
-		this.server.setRequestHandler("resources/read", async (request, ctx) => {
-			const uri = new URL(request.params.uri);
-			const resource = this._registeredResources[uri.toString()];
-			if (resource) {
-				if (!resource.enabled) throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Resource ${uri} disabled`);
-				return resource.readCallback(uri, ctx);
-			}
-			for (const template of Object.values(this._registeredResourceTemplates)) {
-				const variables = template.resourceTemplate.uriTemplate.match(uri.toString());
-				if (variables) return template.readCallback(uri, variables, ctx);
+			else rawMessage = options.parsedBody;
+			let messages;
+			try {
+				messages = Array.isArray(rawMessage) ? rawMessage.map((msg) => JSONRPCMessageSchema.parse(msg)) : [JSONRPCMessageSchema.parse(rawMessage)];
+			} catch (error) {
+				this.onerror?.(error);
+				return this.createJsonErrorResponse(400, -32700, "Parse error: Invalid JSON-RPC message");
 			}
-			throw new ProtocolError(ProtocolErrorCode.ResourceNotFound, `Resource ${uri} not found`);
-		});
-		this._resourceHandlersInitialized = true;
-	}
-	_promptHandlersInitialized = false;
-	setPromptRequestHandlers() {
-		if (this._promptHandlersInitialized) return;
-		this.server.assertCanSetRequestHandler("prompts/list");
-		this.server.assertCanSetRequestHandler("prompts/get");
-		this.server.registerCapabilities({ prompts: { listChanged: this.server.getCapabilities().prompts?.listChanged ?? true } });
-		this.server.setRequestHandler("prompts/list", () => ({ prompts: Object.entries(this._registeredPrompts).filter(([, prompt]) => prompt.enabled).map(([name, prompt]) => {
-			return {
-				name,
-				title: prompt.title,
-				description: prompt.description,
-				arguments: prompt.argsSchema ? promptArgumentsFromStandardSchema(prompt.argsSchema) : void 0,
-				_meta: prompt._meta
-			};
-		}) }));
-		this.server.setRequestHandler("prompts/get", async (request, ctx) => {
-			const prompt = this._registeredPrompts[request.params.name];
-			if (!prompt) throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Prompt ${request.params.name} not found`);
-			if (!prompt.enabled) throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Prompt ${request.params.name} disabled`);
-			return prompt.handler(request.params.arguments, ctx);
-		});
-		this._promptHandlersInitialized = true;
-	}
-	registerResource(name, uriOrTemplate, config, readCallback) {
-		if (typeof uriOrTemplate === "string") {
-			if (this._registeredResources[uriOrTemplate]) throw new Error(`Resource ${uriOrTemplate} is already registered`);
-			const registeredResource = this._createRegisteredResource(name, config.title, uriOrTemplate, config, readCallback);
-			this.setResourceRequestHandlers();
-			this.sendResourceListChanged();
-			return registeredResource;
-		} else {
-			if (this._registeredResourceTemplates[name]) throw new Error(`Resource template ${name} is already registered`);
-			const registeredResourceTemplate = this._createRegisteredResourceTemplate(name, config.title, uriOrTemplate, config, readCallback);
-			this.setResourceRequestHandlers();
-			this.sendResourceListChanged();
-			return registeredResourceTemplate;
-		}
-	}
-	_createRegisteredResource(name, title, uri, metadata, readCallback) {
-		const registeredResource = {
-			name,
-			title,
-			metadata,
-			readCallback,
-			enabled: true,
-			disable: () => registeredResource.update({ enabled: false }),
-			enable: () => registeredResource.update({ enabled: true }),
-			remove: () => registeredResource.update({ uri: null }),
-			update: (updates) => {
-				if (updates.uri !== void 0 && updates.uri !== uri) {
-					delete this._registeredResources[uri];
-					if (updates.uri) this._registeredResources[updates.uri] = registeredResource;
+			const isInitializationRequest = messages.some((element) => isInitializeRequest(element));
+			if (isInitializationRequest) {
+				if (this._initialized && this.sessionId !== void 0) {
+					this.onerror?.(/* @__PURE__ */ new Error("Invalid Request: Server already initialized"));
+					return this.createJsonErrorResponse(400, -32600, "Invalid Request: Server already initialized");
 				}
-				if (updates.name !== void 0) registeredResource.name = updates.name;
-				if (updates.title !== void 0) registeredResource.title = updates.title;
-				if (updates.metadata !== void 0) registeredResource.metadata = updates.metadata;
-				if (updates.callback !== void 0) registeredResource.readCallback = updates.callback;
-				if (updates.enabled !== void 0) registeredResource.enabled = updates.enabled;
-				this.sendResourceListChanged();
-			}
-		};
-		this._registeredResources[uri] = registeredResource;
-		return registeredResource;
-	}
-	_createRegisteredResourceTemplate(name, title, template, metadata, readCallback) {
-		const registeredResourceTemplate = {
-			resourceTemplate: template,
-			title,
-			metadata,
-			readCallback,
-			enabled: true,
-			disable: () => registeredResourceTemplate.update({ enabled: false }),
-			enable: () => registeredResourceTemplate.update({ enabled: true }),
-			remove: () => registeredResourceTemplate.update({ name: null }),
-			update: (updates) => {
-				if (updates.name !== void 0 && updates.name !== name) {
-					delete this._registeredResourceTemplates[name];
-					if (updates.name) this._registeredResourceTemplates[updates.name] = registeredResourceTemplate;
+				if (messages.length > 1) {
+					this.onerror?.(/* @__PURE__ */ new Error("Invalid Request: Only one initialization request is allowed"));
+					return this.createJsonErrorResponse(400, -32600, "Invalid Request: Only one initialization request is allowed");
 				}
-				if (updates.title !== void 0) registeredResourceTemplate.title = updates.title;
-				if (updates.template !== void 0) registeredResourceTemplate.resourceTemplate = updates.template;
-				if (updates.metadata !== void 0) registeredResourceTemplate.metadata = updates.metadata;
-				if (updates.callback !== void 0) registeredResourceTemplate.readCallback = updates.callback;
-				if (updates.enabled !== void 0) registeredResourceTemplate.enabled = updates.enabled;
-				this.sendResourceListChanged();
+				this.sessionId = this.sessionIdGenerator?.();
+				this._initialized = true;
+				if (this.sessionId && this._onsessioninitialized) await Promise.resolve(this._onsessioninitialized(this.sessionId));
 			}
-		};
-		this._registeredResourceTemplates[name] = registeredResourceTemplate;
-		const variableNames = template.uriTemplate.variableNames;
-		if (Array.isArray(variableNames) && variableNames.some((v) => !!template.completeCallback(v))) this.setCompletionRequestHandler();
-		return registeredResourceTemplate;
-	}
-	_createRegisteredPrompt(name, title, description, argsSchema, callback, _meta) {
-		let currentArgsSchema = argsSchema;
-		let currentCallback = callback;
-		const registeredPrompt = {
-			title,
-			description,
-			argsSchema,
-			_meta,
-			handler: createPromptHandler(name, argsSchema, callback),
-			enabled: true,
-			disable: () => registeredPrompt.update({ enabled: false }),
-			enable: () => registeredPrompt.update({ enabled: true }),
-			remove: () => registeredPrompt.update({ name: null }),
-			update: (updates) => {
-				if (updates.name !== void 0 && updates.name !== name) {
-					delete this._registeredPrompts[name];
-					if (updates.name) this._registeredPrompts[updates.name] = registeredPrompt;
-				}
-				if (updates.title !== void 0) registeredPrompt.title = updates.title;
-				if (updates.description !== void 0) registeredPrompt.description = updates.description;
-				if (updates._meta !== void 0) registeredPrompt._meta = updates._meta;
-				let needsHandlerRegen = false;
-				if (updates.argsSchema !== void 0) {
-					registeredPrompt.argsSchema = updates.argsSchema;
-					currentArgsSchema = updates.argsSchema;
-					needsHandlerRegen = true;
-				}
-				if (updates.callback !== void 0) {
-					currentCallback = updates.callback;
-					needsHandlerRegen = true;
-				}
-				if (needsHandlerRegen) registeredPrompt.handler = createPromptHandler(name, currentArgsSchema, currentCallback);
-				if (updates.enabled !== void 0) registeredPrompt.enabled = updates.enabled;
-				this.sendPromptListChanged();
+			if (!isInitializationRequest) {
+				const sessionError = this.validateSession(req);
+				if (sessionError) return sessionError;
+				const protocolError = this.validateProtocolVersion(req);
+				if (protocolError) return protocolError;
 			}
-		};
-		this._registeredPrompts[name] = registeredPrompt;
-		if (argsSchema) {
-			const shape = getSchemaShape(argsSchema);
-			if (shape) {
-				if (Object.values(shape).some((field) => {
-					return isCompletable(unwrapOptionalSchema(field));
-				})) this.setCompletionRequestHandler();
+			if (!messages.some((element) => isJSONRPCRequest(element))) {
+				for (const message of messages) this.onmessage?.(message, {
+					authInfo: options?.authInfo,
+					request
+				});
+				return new Response(null, { status: 202 });
 			}
-		}
-		return registeredPrompt;
-	}
-	_createRegisteredTool(name, title, description, inputSchema, outputSchema, annotations, execution, _meta, handler) {
-		validateAndWarnToolName(name);
-		let currentHandler = handler;
-		const registeredTool = {
-			title,
-			description,
-			inputSchema,
-			outputSchema,
-			annotations,
-			execution,
-			_meta,
-			handler,
-			executor: createToolExecutor(inputSchema, handler),
-			enabled: true,
-			disable: () => registeredTool.update({ enabled: false }),
-			enable: () => registeredTool.update({ enabled: true }),
-			remove: () => registeredTool.update({ name: null }),
-			update: (updates) => {
-				if (updates.name !== void 0 && updates.name !== name) {
-					if (typeof updates.name === "string") validateAndWarnToolName(updates.name);
-					delete this._registeredTools[name];
-					if (updates.name) this._registeredTools[updates.name] = registeredTool;
-				}
-				if (updates.title !== void 0) registeredTool.title = updates.title;
-				if (updates.description !== void 0) registeredTool.description = updates.description;
-				let needsExecutorRegen = false;
-				if (updates.paramsSchema !== void 0) {
-					registeredTool.inputSchema = updates.paramsSchema;
-					needsExecutorRegen = true;
+			const streamId = crypto.randomUUID();
+			const initRequest = messages.find((m) => isInitializeRequest(m));
+			const clientProtocolVersion = initRequest ? initRequest.params.protocolVersion : req.headers.get("mcp-protocol-version") ?? DEFAULT_NEGOTIATED_PROTOCOL_VERSION;
+			if (this._enableJsonResponse) return new Promise((resolve) => {
+				this._streamMapping.set(streamId, {
+					resolveJson: resolve,
+					cleanup: () => {
+						this._streamMapping.delete(streamId);
+					}
+				});
+				for (const message of messages) if (isJSONRPCRequest(message)) this._requestToStreamMapping.set(message.id, streamId);
+				for (const message of messages) this.onmessage?.(message, {
+					authInfo: options?.authInfo,
+					request
+				});
+			});
+			const encoder = new TextEncoder();
+			let streamController;
+			const readable = new ReadableStream({
+				start: (controller) => {
+					streamController = controller;
+				},
+				cancel: () => {
+					if (this._streamMapping.get(streamId)?.controller === streamController) this._streamMapping.delete(streamId);
 				}
-				if (updates.callback !== void 0) {
-					registeredTool.handler = updates.callback;
-					currentHandler = updates.callback;
-					needsExecutorRegen = true;
+			});
+			const headers = {
+				"Content-Type": "text/event-stream",
+				"Cache-Control": "no-cache",
+				Connection: "keep-alive"
+			};
+			if (this.sessionId !== void 0) headers["mcp-session-id"] = this.sessionId;
+			for (const message of messages) if (isJSONRPCRequest(message)) {
+				this._streamMapping.set(streamId, {
+					controller: streamController,
+					encoder,
+					cleanup: () => {
+						this._streamMapping.delete(streamId);
+						try {
+							streamController.close();
+						} catch {}
+					}
+				});
+				this._requestToStreamMapping.set(message.id, streamId);
+			}
+			await this.writePrimingEvent(streamController, encoder, streamId, clientProtocolVersion);
+			for (const message of messages) {
+				let closeSSEStream;
+				let closeStandaloneSSEStream;
+				if (isJSONRPCRequest(message) && this._eventStore && this.supportsEmptySSEData(clientProtocolVersion)) {
+					closeSSEStream = () => {
+						this.closeSSEStream(message.id);
+					};
+					closeStandaloneSSEStream = () => {
+						this.closeStandaloneSSEStream();
+					};
 				}
-				if (needsExecutorRegen) registeredTool.executor = createToolExecutor(registeredTool.inputSchema, currentHandler);
-				if (updates.outputSchema !== void 0) registeredTool.outputSchema = updates.outputSchema;
-				if (updates.annotations !== void 0) registeredTool.annotations = updates.annotations;
-				if (updates._meta !== void 0) registeredTool._meta = updates._meta;
-				if (updates.enabled !== void 0) registeredTool.enabled = updates.enabled;
-				this.sendToolListChanged();
+				this.onmessage?.(message, {
+					authInfo: options?.authInfo,
+					request,
+					closeSSEStream,
+					closeStandaloneSSEStream
+				});
 			}
-		};
-		this._registeredTools[name] = registeredTool;
-		this.setToolRequestHandlers();
-		this.sendToolListChanged();
-		return registeredTool;
-	}
-	/**
-	* Registers a tool with a config object and callback.
-	*
-	* @example
-	* ```ts source="./mcp.examples.ts#McpServer_registerTool_basic"
-	* server.registerTool(
-	*     'calculate-bmi',
-	*     {
-	*         title: 'BMI Calculator',
-	*         description: 'Calculate Body Mass Index',
-	*         inputSchema: z.object({
-	*             weightKg: z.number(),
-	*             heightM: z.number()
-	*         }),
-	*         outputSchema: z.object({ bmi: z.number() })
-	*     },
-	*     async ({ weightKg, heightM }) => {
-	*         const output = { bmi: weightKg / (heightM * heightM) };
-	*         return {
-	*             content: [{ type: 'text', text: JSON.stringify(output) }],
-	*             structuredContent: output
-	*         };
-	*     }
-	* );
-	* ```
-	*/
-	registerTool(name, config, cb) {
-		if (this._registeredTools[name]) throw new Error(`Tool ${name} is already registered`);
-		const { title, description, inputSchema, outputSchema, annotations, _meta } = config;
-		return this._createRegisteredTool(name, title, description, inputSchema, outputSchema, annotations, { taskSupport: "forbidden" }, _meta, cb);
+			return new Response(readable, {
+				status: 200,
+				headers
+			});
+		} catch (error) {
+			this.onerror?.(error);
+			return this.createJsonErrorResponse(400, -32700, "Parse error", { data: String(error) });
+		}
 	}
 	/**
-	* Registers a prompt with a config object and callback.
-	*
-	* @example
-	* ```ts source="./mcp.examples.ts#McpServer_registerPrompt_basic"
-	* server.registerPrompt(
-	*     'review-code',
-	*     {
-	*         title: 'Code Review',
-	*         description: 'Review code for best practices',
-	*         argsSchema: z.object({ code: z.string() })
-	*     },
-	*     ({ code }) => ({
-	*         messages: [
-	*             {
-	*                 role: 'user' as const,
-	*                 content: {
-	*                     type: 'text' as const,
-	*                     text: `Please review this code:\n\n${code}`
-	*                 }
-	*             }
-	*         ]
-	*     })
-	* );
-	* ```
+	* Handles `DELETE` requests to terminate sessions
 	*/
-	registerPrompt(name, config, cb) {
-		if (this._registeredPrompts[name]) throw new Error(`Prompt ${name} is already registered`);
-		const { title, description, argsSchema, _meta } = config;
-		const registeredPrompt = this._createRegisteredPrompt(name, title, description, argsSchema, cb, _meta);
-		this.setPromptRequestHandlers();
-		this.sendPromptListChanged();
-		return registeredPrompt;
+	async handleDeleteRequest(req) {
+		const sessionError = this.validateSession(req);
+		if (sessionError) return sessionError;
+		const protocolError = this.validateProtocolVersion(req);
+		if (protocolError) return protocolError;
+		await Promise.resolve(this._onsessionclosed?.(this.sessionId));
+		await this.close();
+		return new Response(null, { status: 200 });
 	}
 	/**
-	* Checks if the server is connected to a transport.
-	* @returns `true` if the server is connected
+	* Validates session ID for non-initialization requests.
+	* Returns `Response` error if invalid, `undefined` otherwise
 	*/
-	isConnected() {
-		return this.server.transport !== void 0;
+	validateSession(req) {
+		if (this.sessionIdGenerator === void 0) return;
+		if (!this._initialized) {
+			this.onerror?.(/* @__PURE__ */ new Error("Bad Request: Server not initialized"));
+			return this.createJsonErrorResponse(400, -32e3, "Bad Request: Server not initialized");
+		}
+		const sessionId = req.headers.get("mcp-session-id");
+		if (!sessionId) {
+			this.onerror?.(/* @__PURE__ */ new Error("Bad Request: Mcp-Session-Id header is required"));
+			return this.createJsonErrorResponse(400, -32e3, "Bad Request: Mcp-Session-Id header is required");
+		}
+		if (sessionId !== this.sessionId) {
+			this.onerror?.(/* @__PURE__ */ new Error("Session not found"));
+			return this.createJsonErrorResponse(404, -32001, "Session not found");
+		}
 	}
 	/**
-	* Sends a logging message to the client, if connected.
-	* Note: You only need to send the parameters object, not the entire JSON-RPC message.
-	* @see {@linkcode LoggingMessageNotification}
-	* @param params
-	* @param sessionId Optional for stateless transports and backward compatibility.
+	* Validates the `MCP-Protocol-Version` header on incoming requests.
 	*
-	* @example
-	* ```ts source="./mcp.examples.ts#McpServer_sendLoggingMessage_basic"
-	* await server.sendLoggingMessage({
-	*     level: 'info',
-	*     data: 'Processing complete'
-	* });
-	* ```
-	*/
-	async sendLoggingMessage(params, sessionId) {
-		return this.server.sendLoggingMessage(params, sessionId);
-	}
-	/**
-	* Sends a resource list changed event to the client, if connected.
-	*/
-	sendResourceListChanged() {
-		if (this.isConnected()) this.server.sendResourceListChanged();
-	}
-	/**
-	* Sends a tool list changed event to the client, if connected.
-	*/
-	sendToolListChanged() {
-		if (this.isConnected()) this.server.sendToolListChanged();
-	}
-	/**
-	* Sends a prompt list changed event to the client, if connected.
+	* For initialization: Version negotiation handles unknown versions gracefully
+	* (server responds with its supported version).
+	*
+	* For subsequent requests with `MCP-Protocol-Version` header:
+	* - Accept if in supported list
+	* - 400 if unsupported
+	*
+	* For HTTP requests without the `MCP-Protocol-Version` header:
+	* - Accept and default to the version negotiated at initialization
 	*/
-	sendPromptListChanged() {
-		if (this.isConnected()) this.server.sendPromptListChanged();
-	}
-};
-/**
-* A resource template combines a URI pattern with optional functionality to enumerate
-* all resources matching that pattern.
-*/
-var ResourceTemplate = class {
-	_uriTemplate;
-	constructor(uriTemplate, _callbacks) {
-		this._callbacks = _callbacks;
-		this._uriTemplate = typeof uriTemplate === "string" ? new UriTemplate(uriTemplate) : uriTemplate;
+	validateProtocolVersion(req) {
+		const protocolVersion = req.headers.get("mcp-protocol-version");
+		if (protocolVersion !== null && !this._supportedProtocolVersions.includes(protocolVersion)) {
+			const error = `Bad Request: Unsupported protocol version: ${protocolVersion} (supported versions: ${this._supportedProtocolVersions.join(", ")})`;
+			this.onerror?.(new Error(error));
+			return this.createJsonErrorResponse(400, -32e3, error);
+		}
 	}
-	/**
-	* Gets the URI template pattern.
-	*/
-	get uriTemplate() {
-		return this._uriTemplate;
+	async close() {
+		if (this._closed) return;
+		this._closed = true;
+		for (const { cleanup } of this._streamMapping.values()) cleanup();
+		this._streamMapping.clear();
+		this._requestResponseMap.clear();
+		this.onclose?.();
 	}
 	/**
-	* Gets the list callback, if one was provided.
+	* Close an SSE stream for a specific request, triggering client reconnection.
+	* Use this to implement polling behavior during long-running operations -
+	* client will reconnect after the retry interval specified in the priming event.
 	*/
-	get listCallback() {
-		return this._callbacks.list;
+	closeSSEStream(requestId) {
+		const streamId = this._requestToStreamMapping.get(requestId);
+		if (!streamId) return;
+		const stream = this._streamMapping.get(streamId);
+		if (stream) stream.cleanup();
 	}
 	/**
-	* Gets the callback for completing a specific URI template variable, if one was provided.
+	* Close the standalone `GET` SSE stream, triggering client reconnection.
+	* Use this to implement polling behavior for server-initiated notifications.
 	*/
-	completeCallback(variable) {
-		return this._callbacks.complete?.[variable];
+	closeStandaloneSSEStream() {
+		const stream = this._streamMapping.get(this._standaloneSseStreamId);
+		if (stream) stream.cleanup();
 	}
-};
-/**
-* Creates an executor that invokes the handler with the appropriate arguments.
-* When `inputSchema` is defined, the handler is called with `(args, ctx)`.
-* When `inputSchema` is undefined, the handler is called with just `(ctx)`.
-*/
-function createToolExecutor(inputSchema, handler) {
-	if ("createTask" in handler) {
-		const taskHandler = handler;
-		return async (args, ctx) => {
-			if (!ctx.task?.store) throw new Error("No task store provided.");
-			const taskCtx = {
-				...ctx,
-				task: {
-					store: ctx.task.store,
-					requestedTtl: ctx.task?.requestedTtl
+	async send(message, options) {
+		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 eventId;
+			if (this._eventStore) eventId = await this._eventStore.storeEvent(this._standaloneSseStreamId, message);
+			const standaloneSse = this._streamMapping.get(this._standaloneSseStreamId);
+			if (standaloneSse === void 0) return;
+			if (standaloneSse.controller && standaloneSse.encoder && (eventId === void 0 || !standaloneSse.replayedEventIds?.has(eventId))) this.writeSSEEvent(standaloneSse.controller, standaloneSse.encoder, message, eventId);
+			return;
+		}
+		const streamId = this._requestToStreamMapping.get(requestId);
+		if (!streamId) throw new Error(`No connection established for request ID: ${String(requestId)}`);
+		let stream = this._streamMapping.get(streamId);
+		if (!this._enableJsonResponse) {
+			let eventId;
+			if (this._eventStore) {
+				eventId = await this._eventStore.storeEvent(streamId, message);
+				stream = this._streamMapping.get(streamId);
+			}
+			if (stream?.controller && stream?.encoder && (eventId === void 0 || !stream.replayedEventIds?.has(eventId))) this.writeSSEEvent(stream.controller, stream.encoder, message, eventId);
+		}
+		if (isJSONRPCResultResponse(message) || isJSONRPCErrorResponse(message)) {
+			this._requestResponseMap.set(requestId, message);
+			const relatedIds = [...this._requestToStreamMapping.entries()].filter(([_, sid]) => sid === streamId).map(([id]) => id);
+			if (relatedIds.every((id) => this._requestResponseMap.has(id))) {
+				if (!stream) {
+					if (this._enableJsonResponse) throw new Error(`No connection established for request ID: ${String(requestId)}`);
+					if (!this._eventStore) {
+						this.onerror?.(/* @__PURE__ */ new Error(`Response for request ID ${String(requestId)} is undeliverable: per-request stream is disconnected and no eventStore is configured`));
+						for (const id of relatedIds) {
+							this._requestResponseMap.delete(id);
+							this._requestToStreamMapping.delete(id);
+						}
+						return;
+					}
+					for (const id of relatedIds) {
+						this._requestResponseMap.delete(id);
+						this._requestToStreamMapping.delete(id);
+					}
+					return;
 				}
-			};
-			if (inputSchema) return taskHandler.createTask(args, taskCtx);
-			return taskHandler.createTask(taskCtx);
-		};
-	}
-	if (inputSchema) {
-		const callback$1 = handler;
-		return async (args, ctx) => callback$1(args, ctx);
+				if (this._enableJsonResponse && stream.resolveJson) {
+					const headers = { "Content-Type": "application/json" };
+					if (this.sessionId !== void 0) headers["mcp-session-id"] = this.sessionId;
+					const responses = relatedIds.map((id) => this._requestResponseMap.get(id));
+					if (responses.length === 1) stream.resolveJson(Response.json(responses[0], {
+						status: 200,
+						headers
+					}));
+					else stream.resolveJson(Response.json(responses, {
+						status: 200,
+						headers
+					}));
+					stream.cleanup();
+				} else stream.cleanup();
+				for (const id of relatedIds) {
+					this._requestResponseMap.delete(id);
+					this._requestToStreamMapping.delete(id);
+				}
+			}
+		}
 	}
-	const callback = handler;
-	return async (_args, ctx) => callback(ctx);
-}
-const EMPTY_OBJECT_JSON_SCHEMA = {
-	type: "object",
-	properties: {}
 };
+
+//#endregion
+//#region src/server/createMcpHandler.ts
 /**
-* Creates a type-safe prompt handler that captures the schema and callback in a closure.
-* This eliminates the need for type assertions at the call site.
+* The JSON-RPC id to echo on an entry-built error response: the body's `id`
+* when the body is a single JSON-RPC request whose id is a string or number,
+* `null` otherwise. Error responses must carry the id of the request they
+* correspond to whenever it could be read; `null` is reserved for the cases
+* where no single request id is determinable — unparseable bodies, body-less
+* methods, notifications, posted responses and batch arrays.
 */
-function createPromptHandler(name, argsSchema, callback) {
-	if (argsSchema) {
-		const typedCallback = callback;
-		return async (args, ctx) => {
-			const parseResult = await validateStandardSchema(argsSchema, args);
-			if (!parseResult.success) throw new ProtocolError(ProtocolErrorCode.InvalidParams, `Invalid arguments for prompt ${name}: ${parseResult.error}`);
-			return typedCallback(parseResult.data, ctx);
-		};
-	} else {
-		const typedCallback = callback;
-		return async (_args, ctx) => {
-			return typedCallback(ctx);
-		};
-	}
+function echoableRequestId(body) {
+	if (body === null || typeof body !== "object" || Array.isArray(body)) return null;
+	const { method, id } = body;
+	if (typeof method !== "string") return null;
+	return typeof id === "string" || typeof id === "number" ? id : null;
+}
+function jsonRpcErrorResponse(httpStatus, code, message, data, id = null) {
+	return Response.json({
+		jsonrpc: "2.0",
+		error: {
+			code,
+			message,
+			...data !== void 0 && { data }
+		},
+		id
+	}, { status: httpStatus });
+}
+function rejectionResponse(rejection, id = null) {
+	return jsonRpcErrorResponse(rejection.httpStatus, rejection.code, rejection.message, rejection.data, id);
+}
+function toError(value) {
+	return value instanceof Error ? value : new Error(String(value));
 }
-function createCompletionResult(suggestions) {
-	return { completion: {
-		values: suggestions.map(String).slice(0, 100),
-		total: suggestions.length,
-		hasMore: suggestions.length > 100
-	} };
+function internalServerErrorResponse(id = null) {
+	return jsonRpcErrorResponse(500, -32603, "Internal server error", void 0, id);
+}
+/**
+* The entry's default legacy serving (`legacy: 'stateless'`): per-request
+* stateless serving of 2025-era traffic using the same factory as the modern
+* path. Exported as a standalone building block for hand-wired compositions
+* (for example mounting legacy stateless serving on its own route next to a
+* strict modern endpoint).
+*
+* Each POST is served by a fresh instance from the factory connected to a
+* fresh streamable HTTP transport constructed with only
+* `sessionIdGenerator: undefined` — the established stateless idiom, unchanged.
+* Because serving is per-request and stateless, GET and DELETE (2025 session
+* operations) are answered with `405` / `Method not allowed.`, exactly like the
+* canonical stateless example.
+*
+* The optional `onerror` callback receives factory and serving failures on
+* this leg (reporting only — the response stays the 500 internal-error body).
+* The entry passes its own `onerror` here when expanding the default, so
+* legacy-leg failures are never silently swallowed.
+*/
+function legacyStatelessFallback(factory, onerror) {
+	return async (request, options) => {
+		if (request.method.toUpperCase() !== "POST") return jsonRpcErrorResponse(405, -32e3, "Method not allowed.");
+		try {
+			const product = await factory({
+				era: "legacy",
+				...options?.authInfo !== void 0 && { authInfo: options.authInfo },
+				requestInfo: request
+			});
+			const transport = new WebStandardStreamableHTTPServerTransport({ sessionIdGenerator: void 0 });
+			await product.connect(transport);
+			const teardown = () => {
+				transport.close().catch(() => {});
+				product.close().catch(() => {});
+			};
+			request.signal?.addEventListener("abort", teardown, { once: true });
+			const response = await transport.handleRequest(request, {
+				...options?.authInfo !== void 0 && { authInfo: options.authInfo },
+				...options?.parsedBody !== void 0 && { parsedBody: options.parsedBody }
+			});
+			if (response.body === null || !(response.headers.get("content-type") ?? "").includes("text/event-stream")) {
+				teardown();
+				return response;
+			}
+			const reader = response.body.getReader();
+			let toreDown = false;
+			const completeExchange = () => {
+				if (!toreDown) {
+					toreDown = true;
+					teardown();
+				}
+			};
+			const monitoredBody = new ReadableStream({
+				pull: async (controller) => {
+					try {
+						const { done, value } = await reader.read();
+						if (done) {
+							completeExchange();
+							controller.close();
+							return;
+						}
+						if (value !== void 0) controller.enqueue(value);
+					} catch (error) {
+						completeExchange();
+						controller.error(error);
+					}
+				},
+				cancel: (reason) => {
+					completeExchange();
+					return reader.cancel(reason).catch(() => {});
+				}
+			});
+			return new Response(monitoredBody, {
+				status: response.status,
+				statusText: response.statusText,
+				headers: response.headers
+			});
+		} catch (error) {
+			try {
+				onerror?.(toError(error));
+			} catch {}
+			return internalServerErrorResponse(echoableRequestId(options?.parsedBody));
+		}
+	};
 }
-const EMPTY_COMPLETION_RESULT = { completion: {
-	values: [],
-	hasMore: false
-} };
-/** @internal Gets the shape of a Zod object schema */
-function getSchemaShape(schema) {
-	const candidate = schema;
-	if (candidate.shape && typeof candidate.shape === "object") return candidate.shape;
+/**
+* The entry's classification step: read the request body exactly once (unless
+* a pre-parsed body is supplied) and classify the request with
+* {@linkcode classifyInboundRequest}. This is the single code path behind both
+* {@linkcode createMcpHandler}'s routing and the exported
+* {@linkcode isLegacyRequest} predicate, so the two can never disagree.
+*
+* Pass `needsForward: false` when the caller never reads `forwardRequest` —
+* the body-preserving clone is then skipped and `forwardRequest` is the
+* (consumed) input request.
+*/
+async function classifyEntryRequest(request, providedParsedBody, needsForward = true) {
+	const httpMethod = request.method.toUpperCase();
+	let body;
+	let parsedBody = providedParsedBody;
+	let forwardRequest = request;
+	let unparseable = false;
+	if (httpMethod === "POST") {
+		if (parsedBody === void 0) {
+			if (needsForward) forwardRequest = request.clone();
+			let bodyText;
+			try {
+				bodyText = await request.text();
+			} catch {
+				return { step: "unreadable-body" };
+			}
+			try {
+				body = bodyText.length === 0 ? void 0 : JSON.parse(bodyText);
+			} catch {
+				unparseable = true;
+			}
+			if (!unparseable && body !== void 0) parsedBody = body;
+		} else body = parsedBody;
+		if (unparseable || body === void 0) return {
+			step: "no-json-body",
+			forwardRequest
+		};
+	}
+	return {
+		step: "classified",
+		outcome: classifyInboundRequest({
+			httpMethod,
+			protocolVersionHeader: request.headers.get("mcp-protocol-version") ?? void 0,
+			mcpMethodHeader: request.headers.get("mcp-method") ?? void 0,
+			mcpNameHeader: request.headers.get("mcp-name") ?? void 0,
+			...body !== void 0 && { body }
+		}),
+		body,
+		parsedBody,
+		forwardRequest
+	};
 }
-/** @internal Checks if a Zod schema is optional */
-function isOptionalSchema(schema) {
-	return schema?.type === "optional";
+/**
+* Whether {@linkcode createMcpHandler} would route this request to its legacy
+* (2025-era) serving rather than the modern (2026-07-28) path.
+*
+* Call it with just the request: `await isLegacyRequest(request)`. For a
+* `POST` the body is read from an internal clone, so the request you pass
+* stays fully readable for whichever handler you route it to — no second
+* argument is needed. (In a Node `(req, res)` handler, build that `Request`
+* with `toWebRequest(req)` from `@modelcontextprotocol/node`; behind a body
+* parser, which has already drained the Node stream, build it as
+* `toWebRequest(req, req.body)` so the bytes come from the parsed body —
+* either way the predicate still takes just the request.) The optional
+* `parsedBody` is a perf escape hatch for a body you already hold parsed:
+* pass it and the predicate classifies from the value directly, reading and
+* cloning nothing. It is needed, not just faster, when the request's own
+* body was already read — the internal clone is then impossible (cloning a
+* used body throws a `TypeError`), so such a single-argument call rejects
+* instead of guessing.
+*
+* This is the entry's own classification step exported as a predicate — it
+* runs exactly the code `createMcpHandler` runs to make the routing decision,
+* not a re-implementation — so a hand-wired composition that branches on it
+* can never disagree with the entry. Use it to keep an existing legacy
+* deployment (for example a sessionful streamable HTTP wiring) serving 2025
+* traffic next to a strict modern endpoint, now that the entry has no
+* handler-valued `legacy` option:
+*
+* ```ts
+* import { createMcpHandler, isLegacyRequest } from '@modelcontextprotocol/server';
+*
+* const modern = createMcpHandler(factory, { legacy: 'reject' });
+*
+* export default {
+*     async fetch(request: Request): Promise<Response> {
+*         if (await isLegacyRequest(request)) {
+*             // e.g. an existing sessionful WebStandardStreamableHTTPServerTransport wiring
+*             return myExistingLegacyHandler(request);
+*         }
+*         return modern.fetch(request);
+*     }
+* };
+* ```
+*
+* Semantics (identical to the entry's routing):
+*
+* - Returns `true` only for requests with no per-request `_meta` envelope
+*   claim: claim-less POSTs (including the `initialize` handshake and 2025-era
+*   notification POSTs without a modern protocol-version header), body-less
+*   GET/DELETE session operations, all-legacy JSON-RPC batch arrays, posted
+*   JSON-RPC responses, and POSTs whose body is empty or not valid JSON.
+* - Returns `false` for everything the modern path answers, including its
+*   validation-ladder rejections: a request carrying the envelope claim (even
+*   one naming a revision the endpoint does not serve — the modern path
+*   answers it with the unsupported-protocol-version error), a malformed
+*   envelope behind a present claim (answered `-32602`), a request whose
+*   `MCP-Protocol-Version` header names a modern revision but that lacks the
+*   envelope (`-32602`), and header/body mismatches (`-32020`). Consumers
+*   routing on the predicate must send `false` traffic to the modern handler,
+*   never to a legacy handler — the modern path owns those error answers.
+* - `server/discover` probes sent by negotiating clients always carry the
+*   envelope claim, so they are never legacy; a hand-built claim-less POST to
+*   a method named `server/discover` has no claim and classifies legacy,
+*   exactly as the entry itself routes it.
+*/
+async function isLegacyRequest(request, parsedBody) {
+	const classified = await classifyEntryRequest(parsedBody === void 0 && request.method.toUpperCase() === "POST" ? request.clone() : request, parsedBody, false);
+	return classified.step === "no-json-body" || classified.step === "classified" && classified.outcome.kind === "legacy";
 }
-/** @internal Unwraps an optional Zod schema */
-function unwrapOptionalSchema(schema) {
-	if (!isOptionalSchema(schema)) return schema;
-	return schema.def?.innerType ?? schema;
+/**
+* Creates an HTTP handler that serves the 2026-07-28 protocol revision from a
+* per-request server factory and, by default, falls back to old-school
+* stateless serving for 2025-era traffic. Pass `legacy: 'reject'` for a
+* modern-only strict endpoint.
+*
+* Mounting: `handler.fetch` is the web-standard face (Cloudflare Workers,
+* Deno, Bun, Hono's `c.req.raw`); for Express/Fastify/plain `node:http`, wrap
+* the handler once with `toNodeHandler(handler)` from
+* `@modelcontextprotocol/node`. When mounting bare on a fetch-native runtime,
+* put Origin/Host validation in front of the handler — the entry itself is
+* deliberately validation-free:
+*
+* ```ts
+* import { hostHeaderValidationResponse, originValidationResponse, localhostAllowedHostnames, localhostAllowedOrigins } from '@modelcontextprotocol/server';
+*
+* export default {
+*     async fetch(request: Request): Promise<Response> {
+*         const rejected =
+*             hostHeaderValidationResponse(request, localhostAllowedHostnames()) ??
+*             originValidationResponse(request, localhostAllowedOrigins());
+*         return rejected ?? handler.fetch(request);
+*     }
+* };
+* ```
+*
+* Use ONE factory for both legs: the same tools/resources/prompts definition
+* backs the modern path and the stateless legacy fallback, so the two eras can
+* never drift apart. To keep an existing legacy deployment (for example a
+* sessionful streamable HTTP wiring) serving 2025 traffic instead of the
+* stateless fallback, route in user land with {@linkcode isLegacyRequest} in
+* front of a strict handler — see that predicate's documentation for the
+* pattern. Power users composing transport-neutral routing can also use the
+* exported building blocks directly: {@linkcode classifyInboundRequest} for
+* the era decision and `PerRequestHTTPServerTransport` for single-exchange
+* serving.
+*
+* The entry performs no token verification: `authInfo` given to `fetch` is
+* passed through to handlers and the factory as-is and is never derived from
+* request headers.
+*/
+function createMcpHandler(factory, options = {}) {
+	const { legacy, onerror, responseMode } = options;
+	if (typeof legacy === "function") throw new TypeError("The 'legacy' option only accepts 'stateless' or 'reject', not a handler function. To serve 2025-era traffic with your own handler, route in user land with the exported isLegacyRequest(request) predicate in front of a strict (legacy: 'reject') handler.");
+	/** Modern per-request instances with an exchange still in flight (close() tears these down). */
+	const inflight = /* @__PURE__ */ new Set();
+	let closed = false;
+	const reportError = (error) => {
+		try {
+			onerror?.(error);
+		} catch {}
+	};
+	const bus = options.bus ?? new InMemoryServerEventBus(reportError);
+	const notify = createServerNotifier(bus);
+	const listenRouter = createListenRouter({
+		bus,
+		maxSubscriptions: options.maxSubscriptions ?? DEFAULT_MAX_SUBSCRIPTIONS,
+		keepAliveMs: options.keepAliveMs ?? DEFAULT_LISTEN_KEEPALIVE_MS,
+		onerror: reportError
+	});
+	if (responseMode === "json") console.warn("responseMode: 'json' drops mid-call notifications. subscriptions/listen streams are always served over SSE regardless; other notifications emitted before a result are dropped.");
+	const legacyHandler = legacy === "reject" ? void 0 : legacyStatelessFallback(factory, reportError);
+	async function serveModern(route, request, authInfo) {
+		const claimedRevision = route.classification.revision;
+		if (claimedRevision === void 0 || !SUPPORTED_MODERN_PROTOCOL_VERSIONS.includes(claimedRevision)) {
+			const error = new UnsupportedProtocolVersionError({
+				supported: [...SUPPORTED_MODERN_PROTOCOL_VERSIONS],
+				requested: claimedRevision ?? "unknown"
+			});
+			reportError(error);
+			return jsonRpcErrorResponse(400, error.code, error.message, error.data, echoableRequestId(route.message));
+		}
+		const stdHeaderRejection = validateStandardRequestHeaders({
+			httpMethod: request.method,
+			mcpMethodHeader: request.headers.get("mcp-method") ?? void 0,
+			mcpNameHeader: request.headers.get("mcp-name") ?? void 0
+		}, route);
+		if (stdHeaderRejection !== void 0) {
+			reportError(/* @__PURE__ */ new Error(`Rejected inbound request (${stdHeaderRejection.cell}): ${stdHeaderRejection.message}`));
+			return rejectionResponse(stdHeaderRejection, echoableRequestId(route.message));
+		}
+		const meta = route.messageKind === "request" ? requestMetaOf(route.message.params) : void 0;
+		const declaredClientCapabilities = meta?.[CLIENT_CAPABILITIES_META_KEY];
+		if (route.messageKind === "request") {
+			const required = requiredClientCapabilitiesForRequest(route.message.method);
+			if (required !== void 0) {
+				const missing = missingClientCapabilities(required, declaredClientCapabilities);
+				if (missing !== void 0) {
+					const error = new MissingRequiredClientCapabilityError({ requiredCapabilities: missing });
+					reportError(error);
+					return jsonRpcErrorResponse(httpStatusForErrorCode(error.code, "ladder"), error.code, error.message, error.data, route.message.id);
+				}
+			}
+		}
+		const product = await factory({
+			era: "modern",
+			...authInfo !== void 0 && { authInfo },
+			requestInfo: request
+		});
+		const server = product instanceof McpServer ? product.server : product;
+		if (route.messageKind === "request" && route.message.method === "subscriptions/listen") {
+			const capabilities = server.getCapabilities();
+			product.close().catch(reportError);
+			return listenRouter.serve(route.message, request.signal, capabilities);
+		}
+		if (route.messageKind === "request" && route.message.method === "tools/call" && product instanceof McpServer) {
+			const callParams = route.message.params;
+			const toolName = typeof callParams?.name === "string" ? callParams.name : void 0;
+			const inputSchema = toolName === void 0 ? void 0 : product.toolInputSchemaJson(toolName);
+			if (inputSchema !== void 0) {
+				const scan = scanXMcpHeaderDeclarations(inputSchema);
+				if (scan.valid && scan.declarations.length > 0) {
+					const rejection = validateMcpParamHeaders(scan.declarations, callParams?.arguments, request.headers);
+					if (rejection !== void 0) {
+						product.close().catch(reportError);
+						reportError(/* @__PURE__ */ new Error(`Rejected inbound request (${rejection.cell}): ${rejection.message}`));
+						return rejectionResponse(rejection, route.message.id);
+					}
+				}
+			}
+		}
+		setNegotiatedProtocolVersion(server, claimedRevision);
+		installModernOnlyHandlers(server, SUPPORTED_MODERN_PROTOCOL_VERSIONS);
+		if (meta !== void 0) seedClientIdentityFromEnvelope(server, {
+			clientInfo: meta[CLIENT_INFO_META_KEY],
+			clientCapabilities: declaredClientCapabilities
+		});
+		const previousOnClose = server.onclose;
+		inflight.add(server);
+		server.onclose = () => {
+			inflight.delete(server);
+			previousOnClose?.();
+		};
+		try {
+			const response = await invoke(product, route.message, {
+				classification: route.classification,
+				request,
+				...authInfo !== void 0 && { authInfo },
+				...responseMode !== void 0 && { responseMode }
+			});
+			if (route.messageKind === "notification") queueMicrotask(() => void server.close().catch(() => {}));
+			return response;
+		} catch (error) {
+			if (error instanceof SdkError && error.code === SdkErrorCode.ConnectionClosed) return new Response(null, { status: 499 });
+			await server.close().catch(() => {});
+			inflight.delete(server);
+			reportError(toError(error));
+			return internalServerErrorResponse(echoableRequestId(route.message));
+		}
+	}
+	async function serveLegacyRoute(route, forwardRequest, authInfo, parsedBody) {
+		if (legacyHandler !== void 0) return legacyHandler(forwardRequest, {
+			...authInfo !== void 0 && { authInfo },
+			...parsedBody !== void 0 && { parsedBody }
+		});
+		const strict = modernOnlyStrictRejection(route, SUPPORTED_MODERN_PROTOCOL_VERSIONS);
+		if (strict === void 0) return new Response(null, { status: 202 });
+		reportError(/* @__PURE__ */ new Error(`Rejected 2025-era request on a modern-only endpoint (${strict.cell}): ${strict.message}`));
+		return rejectionResponse(strict, echoableRequestId(parsedBody));
+	}
+	async function handle(request, requestOptions) {
+		const authInfo = requestOptions?.authInfo;
+		const classified = await classifyEntryRequest(request, requestOptions?.parsedBody);
+		if (classified.step === "unreadable-body") return jsonRpcErrorResponse(400, -32700, "Parse error: the request body could not be read");
+		if (classified.step === "no-json-body") {
+			if (legacyHandler !== void 0) return legacyHandler(classified.forwardRequest, { ...authInfo !== void 0 && { authInfo } });
+			return jsonRpcErrorResponse(400, -32700, "Parse error: the request body is not valid JSON");
+		}
+		const { outcome, body, parsedBody, forwardRequest } = classified;
+		try {
+			switch (outcome.kind) {
+				case "reject":
+					reportError(/* @__PURE__ */ new Error(`Rejected inbound request (${outcome.cell}): ${outcome.message}`));
+					return rejectionResponse(outcome, echoableRequestId(body));
+				case "modern": return await serveModern(outcome, request, authInfo);
+				case "legacy": return await serveLegacyRoute(outcome, forwardRequest, authInfo, parsedBody);
+			}
+		} catch (error) {
+			reportError(toError(error));
+			return internalServerErrorResponse(echoableRequestId(body));
+		}
+	}
+	const fetchFace = async (request, requestOptions) => {
+		if (closed) throw new Error("This MCP handler has been closed");
+		try {
+			return await handle(request, requestOptions);
+		} catch (error) {
+			reportError(toError(error));
+			return internalServerErrorResponse(echoableRequestId(requestOptions?.parsedBody));
+		}
+	};
+	return {
+		fetch: fetchFace,
+		notify,
+		bus,
+		close: async () => {
+			closed = true;
+			listenRouter.closeAll();
+			const closing = [...inflight].map((server) => server.close().catch(() => {}));
+			inflight.clear();
+			await Promise.all(closing);
+		}
+	};
 }
 
 //#endregion
@@ -1622,667 +1374,197 @@ function hostHeaderValidationResponse(req, allowedHostnames) {
 }
 
 //#endregion
-//#region src/server/stdio.ts
+//#region src/server/middleware/originValidation.ts
 /**
-* Server transport for stdio: this communicates with an MCP client by reading from the current process' `stdin` and writing to `stdout`.
-*
-* This transport is only available in Node.js environments.
+* Validate an `Origin` header against an allowlist of hostnames (port-agnostic).
 *
-* @example
-* ```ts source="./stdio.examples.ts#StdioServerTransport_basicUsage"
-* const server = new McpServer({ name: 'my-server', version: '1.0.0' });
-* const transport = new StdioServerTransport();
-* await server.connect(transport);
-* ```
+* - A missing/empty `Origin` header passes: non-browser clients do not send one,
+*   and only browser-originated requests carry the header this check defends against.
+* - Allowlist items are hostnames only (no scheme, no port), the same convention as
+*   `validateHostHeader`. For IPv6, include brackets (e.g. `[::1]`).
+* - Any present value that cannot be parsed as an origin URL — including the literal
+*   `null` origin browsers send for opaque contexts — is rejected (deny on failure).
 */
-var StdioServerTransport = class {
-	_readBuffer = new ReadBuffer();
-	_started = false;
-	_closed = false;
-	constructor(_stdin = process.stdin, _stdout = process.stdout) {
-		this._stdin = _stdin;
-		this._stdout = _stdout;
+function validateOriginHeader(originHeader, allowedOriginHostnames) {
+	if (originHeader === null || originHeader === void 0 || originHeader === "") return { ok: true };
+	let hostname;
+	try {
+		hostname = new URL(originHeader).hostname;
+	} catch {
+		return {
+			ok: false,
+			errorCode: "invalid_origin_header",
+			message: `Invalid Origin header: ${originHeader}`,
+			originHeader
+		};
 	}
-	onclose;
-	onerror;
-	onmessage;
-	_ondata = (chunk) => {
-		this._readBuffer.append(chunk);
-		this.processReadBuffer();
+	if (hostname === "") return {
+		ok: false,
+		errorCode: "invalid_origin_header",
+		message: `Invalid Origin header: ${originHeader}`,
+		originHeader
 	};
-	_onerror = (error) => {
-		this.onerror?.(error);
+	if (!allowedOriginHostnames.includes(hostname)) return {
+		ok: false,
+		errorCode: "invalid_origin",
+		message: `Invalid Origin: ${hostname}`,
+		originHeader,
+		hostname
 	};
-	_onstdouterror = (error) => {
-		this.onerror?.(error);
-		this.close().catch(() => {});
+	return {
+		ok: true,
+		origin: originHeader,
+		hostname
 	};
-	/**
-	* Starts listening for messages on `stdin`.
-	*/
-	async start() {
-		if (this._started) throw new Error("StdioServerTransport already started! If using Server class, note that connect() calls start() automatically.");
-		this._started = true;
-		this._stdin.on("data", this._ondata);
-		this._stdin.on("error", this._onerror);
-		this._stdout.on("error", this._onstdouterror);
-	}
-	processReadBuffer() {
-		while (true) try {
-			const message = this._readBuffer.readMessage();
-			if (message === null) break;
-			this.onmessage?.(message);
-		} catch (error) {
-			this.onerror?.(error);
-		}
-	}
-	async close() {
-		if (this._closed) return;
-		this._closed = true;
-		this._stdin.off("data", this._ondata);
-		this._stdin.off("error", this._onerror);
-		this._stdout.off("error", this._onstdouterror);
-		if (this._stdin.listenerCount("data") === 0) this._stdin.pause();
-		this._readBuffer.clear();
-		this.onclose?.();
-	}
-	send(message) {
-		if (this._closed) return Promise.reject(/* @__PURE__ */ new Error("StdioServerTransport is closed"));
-		return new Promise((resolve, reject) => {
-			const json = serializeMessage(message);
-			let settled = false;
-			const onError = (error) => {
-				if (settled) return;
-				settled = true;
-				this._stdout.off("error", onError);
-				this._stdout.off("drain", onDrain);
-				reject(error);
-			};
-			const onDrain = () => {
-				if (settled) return;
-				settled = true;
-				this._stdout.off("error", onError);
-				this._stdout.off("drain", onDrain);
-				resolve();
-			};
-			this._stdout.once("error", onError);
-			if (this._stdout.write(json)) {
-				if (settled) return;
-				settled = true;
-				this._stdout.off("error", onError);
-				resolve();
-			} else if (!settled) this._stdout.once("drain", onDrain);
-		});
-	}
-};
+}
+/**
+* Convenience allowlist of localhost-class origin hostnames, mirroring
+* `localhostAllowedHostnames`.
+*/
+function localhostAllowedOrigins() {
+	return [
+		"localhost",
+		"127.0.0.1",
+		"[::1]"
+	];
+}
+/**
+* Web-standard `Request` helper for Origin validation: returns a `403` JSON-RPC
+* error response when the request's `Origin` header is not allowed, and
+* `undefined` when the request may proceed.
+*
+* ```ts
+* const rejected = originValidationResponse(request, localhostAllowedOrigins());
+* if (rejected) return rejected;
+* ```
+*/
+function originValidationResponse(req, allowedOriginHostnames) {
+	const result = validateOriginHeader(req.headers.get("origin"), allowedOriginHostnames);
+	if (result.ok) return void 0;
+	return Response.json({
+		jsonrpc: "2.0",
+		error: {
+			code: -32e3,
+			message: result.message
+		},
+		id: null
+	}, {
+		status: 403,
+		headers: { "Content-Type": "application/json" }
+	});
+}
 
 //#endregion
-//#region src/server/streamableHttp.ts
+//#region src/server/requestStateCodec.ts
+const PREFIX = "v1.";
+function bytesToBase64Url(bytes) {
+	let bin = "";
+	for (const b of bytes) bin += String.fromCodePoint(b);
+	return btoa(bin).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/, "");
+}
+function constantTimeTagEqual(a, b) {
+	if (a.length !== b.length) return false;
+	let r = 0;
+	for (let i = 0; i < a.length; i++) r |= a.codePointAt(i) ^ b.codePointAt(i);
+	return r === 0;
+}
+function base64UrlToBytes(s) {
+	const b64 = s.replaceAll("-", "+").replaceAll("_", "/");
+	const bin = atob(b64);
+	const bytes = new Uint8Array(bin.length);
+	for (let i = 0; i < bin.length; i++) bytes[i] = bin.codePointAt(i);
+	return bytes;
+}
 /**
-* Server transport for Web Standards Streamable HTTP: this implements the MCP Streamable HTTP transport specification
-* using Web Standard APIs (`Request`, `Response`, `ReadableStream`).
-*
-* This transport works on any runtime that supports Web Standards: Node.js 18+, Cloudflare Workers, Deno, Bun, etc.
-*
-* In stateful mode:
-* - Session ID is generated and included in response headers
-* - Session ID is always included in initialization responses
-* - Requests with invalid session IDs are rejected with `404 Not Found`
-* - Non-initialization requests without a session ID are rejected with `400 Bad Request`
-* - State is maintained in-memory (connections, message history)
-*
-* In stateless mode:
-* - No Session ID is included in any responses
-* - No session validation is performed
+* Create an opt-in HMAC-SHA256 codec for the multi-round-trip `requestState`
+* (protocol revision 2026-07-28).
 *
-* @example Stateful setup
-* ```ts source="./streamableHttp.examples.ts#WebStandardStreamableHTTPServerTransport_stateful"
-* const server = new McpServer({ name: 'my-server', version: '1.0.0' });
+* `requestState` round-trips through the client and is attacker-controlled
+* input on re-entry. The SDK applies no protection of its own; this helper is
+* the convenience implementation of the spec's integrity MUST so authors don't
+* hand-roll HMAC. Wire shape:
 *
-* const transport = new WebStandardStreamableHTTPServerTransport({
-*     sessionIdGenerator: () => crypto.randomUUID()
-* });
+*     "v1." b64url({"p":<payload>,"exp":<unixSeconds>,"b":<bindTag>?}) "." b64url(mac)
 *
-* await server.connect(transport);
-* ```
+* where `bindTag` is `b64url(HMAC(key, "mcp.requestState.bind:" + bind(ctx))[:16])`
+* — the binding value is never embedded raw.
 *
-* @example Stateless setup
-* ```ts source="./streamableHttp.examples.ts#WebStandardStreamableHTTPServerTransport_stateless"
-* const transport = new WebStandardStreamableHTTPServerTransport({
-*     sessionIdGenerator: undefined
-* });
-* ```
+* The codec is **signed, not encrypted**: the body is integrity-protected but
+* the client can base64url-decode it and read the payload (`p`) in clear. Do
+* not put secrets in the payload; use an AEAD construction if confidentiality
+* is required. The handler reads its payload back via the typed
+* `ctx.mcpReq.requestState<T>()` accessor — the seam has already run `verify`
+* (integrity proven, payload decoded) by the time the handler is entered.
 *
-* @example Hono.js
-* ```ts source="./streamableHttp.examples.ts#WebStandardStreamableHTTPServerTransport_hono"
-* app.all('/mcp', async c => {
-*     return transport.handleRequest(c.req.raw);
-* });
-* ```
+* Verification is fail-closed and constant-time (WebCrypto `subtle.verify` for
+* the body MAC; a fixed-length XOR-accumulator compare for the bind tag).
+* See `examples/mrtr/server.ts` for a worked end-to-end example.
 *
-* @example Cloudflare Workers
-* ```ts source="./streamableHttp.examples.ts#WebStandardStreamableHTTPServerTransport_workers"
-* const worker = {
-*     async fetch(request: Request): Promise<Response> {
-*         return transport.handleRequest(request);
-*     }
-* };
-* ```
+* Design comparison (mcp.d `secureRequestState`, the peer SDK's reference
+* implementation): mcp.d additionally offers an AES-256-GCM encrypted mode and
+* derives independent cipher / bind-HMAC sub-keys from the operator secret via
+* HKDF-SHA256, with an auto-generated per-process ephemeral key when none is
+* supplied. This codec deliberately ships only the signed mode and a single
+* keyed HMAC (domain-separated by input prefix) — HKDF sub-key derivation and
+* an encrypted mode are intentionally out of scope for the initial release.
 */
-var WebStandardStreamableHTTPServerTransport = class {
-	sessionIdGenerator;
-	_started = false;
-	_streamMapping = /* @__PURE__ */ new Map();
-	_requestToStreamMapping = /* @__PURE__ */ new Map();
-	_requestResponseMap = /* @__PURE__ */ new Map();
-	_initialized = false;
-	_enableJsonResponse = false;
-	_standaloneSseStreamId = "_GET_stream";
-	_eventStore;
-	_onsessioninitialized;
-	_onsessionclosed;
-	_allowedHosts;
-	_allowedOrigins;
-	_enableDnsRebindingProtection;
-	_retryInterval;
-	_supportedProtocolVersions;
-	sessionId;
-	onclose;
-	onerror;
-	onmessage;
-	constructor(options = {}) {
-		this.sessionIdGenerator = options.sessionIdGenerator;
-		this._enableJsonResponse = options.enableJsonResponse ?? false;
-		this._eventStore = options.eventStore;
-		this._onsessioninitialized = options.onsessioninitialized;
-		this._onsessionclosed = options.onsessionclosed;
-		this._allowedHosts = options.allowedHosts;
-		this._allowedOrigins = options.allowedOrigins;
-		this._enableDnsRebindingProtection = options.enableDnsRebindingProtection ?? false;
-		this._retryInterval = options.retryInterval;
-		this._supportedProtocolVersions = options.supportedProtocolVersions ?? SUPPORTED_PROTOCOL_VERSIONS;
-	}
-	/**
-	* Starts the transport. This is required by the {@linkcode Transport} interface but is a no-op
-	* for the Streamable HTTP transport as connections are managed per-request.
-	*/
-	async start() {
-		if (this._started) throw new Error("Transport already started");
-		this._started = true;
-	}
-	/**
-	* Sets the supported protocol versions for header validation.
-	* Called by the server during {@linkcode server/server.Server.connect | connect()} to pass its supported versions.
-	*/
-	setSupportedProtocolVersions(versions) {
-		this._supportedProtocolVersions = versions;
-	}
-	/**
-	* Helper to create a JSON error response
-	*/
-	createJsonErrorResponse(status, code, message, options) {
-		const error = {
-			code,
-			message
-		};
-		if (options?.data !== void 0) error.data = options.data;
-		return Response.json({
-			jsonrpc: "2.0",
-			error,
-			id: null
-		}, {
-			status,
-			headers: {
-				"Content-Type": "application/json",
-				...options?.headers
-			}
-		});
-	}
-	/**
-	* Validates request headers for DNS rebinding protection.
-	* @returns Error response if validation fails, `undefined` if validation passes.
-	*/
-	validateRequestHeaders(req) {
-		if (!this._enableDnsRebindingProtection) return;
-		if (this._allowedHosts && this._allowedHosts.length > 0) {
-			const hostHeader = req.headers.get("host");
-			if (!hostHeader || !this._allowedHosts.includes(hostHeader)) {
-				const error = `Invalid Host header: ${hostHeader}`;
-				this.onerror?.(new Error(error));
-				return this.createJsonErrorResponse(403, -32e3, error);
-			}
-		}
-		if (this._allowedOrigins && this._allowedOrigins.length > 0) {
-			const originHeader = req.headers.get("origin");
-			if (originHeader && !this._allowedOrigins.includes(originHeader)) {
-				const error = `Invalid Origin header: ${originHeader}`;
-				this.onerror?.(new Error(error));
-				return this.createJsonErrorResponse(403, -32e3, error);
-			}
-		}
-	}
-	/**
-	* Handles an incoming HTTP request, whether `GET`, `POST`, or `DELETE`
-	* Returns a `Response` object (Web Standard)
-	*/
-	async handleRequest(req, options) {
-		const validationError = this.validateRequestHeaders(req);
-		if (validationError) return validationError;
-		switch (req.method) {
-			case "POST": return this.handlePostRequest(req, options);
-			case "GET": return this.handleGetRequest(req);
-			case "DELETE": return this.handleDeleteRequest(req);
-			default: return this.handleUnsupportedRequest();
-		}
-	}
-	/**
-	* Writes a priming event to establish resumption capability.
-	* Only sends if `eventStore` is configured (opt-in for resumability) and
-	* the client's protocol version supports empty SSE data (>= `2025-11-25`).
-	*/
-	async writePrimingEvent(controller, encoder, streamId, protocolVersion) {
-		if (!this._eventStore) return;
-		if (protocolVersion < "2025-11-25") return;
-		const primingEventId = await this._eventStore.storeEvent(streamId, {});
-		let primingEvent = `id: ${primingEventId}\ndata: \n\n`;
-		if (this._retryInterval !== void 0) primingEvent = `id: ${primingEventId}\nretry: ${this._retryInterval}\ndata: \n\n`;
-		controller.enqueue(encoder.encode(primingEvent));
-	}
-	/**
-	* Handles `GET` requests for SSE stream
-	*/
-	async handleGetRequest(req) {
-		if (!req.headers.get("accept")?.includes("text/event-stream")) {
-			this.onerror?.(/* @__PURE__ */ new Error("Not Acceptable: Client must accept text/event-stream"));
-			return this.createJsonErrorResponse(406, -32e3, "Not Acceptable: Client must accept text/event-stream");
-		}
-		const sessionError = this.validateSession(req);
-		if (sessionError) return sessionError;
-		const protocolError = this.validateProtocolVersion(req);
-		if (protocolError) return protocolError;
-		if (this._eventStore) {
-			const lastEventId = req.headers.get("last-event-id");
-			if (lastEventId) return this.replayEvents(lastEventId);
-		}
-		if (this._streamMapping.get(this._standaloneSseStreamId) !== void 0) {
-			this.onerror?.(/* @__PURE__ */ new Error("Conflict: Only one SSE stream is allowed per session"));
-			return this.createJsonErrorResponse(409, -32e3, "Conflict: Only one SSE stream is allowed per session");
-		}
-		const encoder = new TextEncoder();
-		let streamController;
-		const readable = new ReadableStream({
-			start: (controller) => {
-				streamController = controller;
-			},
-			cancel: () => {
-				this._streamMapping.delete(this._standaloneSseStreamId);
-			}
-		});
-		const headers = {
-			"Content-Type": "text/event-stream",
-			"Cache-Control": "no-cache, no-transform",
-			Connection: "keep-alive"
-		};
-		if (this.sessionId !== void 0) headers["mcp-session-id"] = this.sessionId;
-		this._streamMapping.set(this._standaloneSseStreamId, {
-			controller: streamController,
-			encoder,
-			cleanup: () => {
-				this._streamMapping.delete(this._standaloneSseStreamId);
-				try {
-					streamController.close();
-				} catch {}
-			}
-		});
-		return new Response(readable, { headers });
-	}
-	/**
-	* Replays events that would have been sent after the specified event ID
-	* Only used when resumability is enabled
-	*/
-	async replayEvents(lastEventId) {
-		if (!this._eventStore) {
-			this.onerror?.(/* @__PURE__ */ new Error("Event store not configured"));
-			return this.createJsonErrorResponse(400, -32e3, "Event store not configured");
-		}
-		try {
-			let streamId;
-			if (this._eventStore.getStreamIdForEventId) {
-				streamId = await this._eventStore.getStreamIdForEventId(lastEventId);
-				if (!streamId) {
-					this.onerror?.(/* @__PURE__ */ new Error("Invalid event ID format"));
-					return this.createJsonErrorResponse(400, -32e3, "Invalid event ID format");
-				}
-				if (this._streamMapping.get(streamId) !== void 0) {
-					this.onerror?.(/* @__PURE__ */ new Error("Conflict: Stream already has an active connection"));
-					return this.createJsonErrorResponse(409, -32e3, "Conflict: Stream already has an active connection");
-				}
-			}
-			const headers = {
-				"Content-Type": "text/event-stream",
-				"Cache-Control": "no-cache, no-transform",
-				Connection: "keep-alive"
+function createRequestStateCodec(options) {
+	const subtle = globalThis.crypto?.subtle;
+	if (subtle === void 0) throw new TypeError("createRequestStateCodec requires the Web Crypto API (globalThis.crypto.subtle); see https://ts.sdk.modelcontextprotocol.io/v2/troubleshooting for the Node.js polyfill instructions");
+	const keyBytes = typeof options.key === "string" ? new TextEncoder().encode(options.key) : Uint8Array.from(options.key);
+	if (keyBytes.byteLength < 32) throw new RangeError(`createRequestStateCodec: key must be at least 32 bytes (got ${keyBytes.byteLength})`);
+	const ttlSeconds = options.ttlSeconds ?? 600;
+	if (!Number.isFinite(ttlSeconds)) throw new RangeError("createRequestStateCodec: ttlSeconds must be a finite number");
+	const bind = options.bind;
+	let cryptoKey;
+	const importedKey = () => cryptoKey ??= subtle.importKey("raw", keyBytes, {
+		name: "HMAC",
+		hash: "SHA-256"
+	}, false, ["sign", "verify"]);
+	const utf8 = new TextEncoder();
+	const BIND_LABEL = "mcp.requestState.bind:";
+	const bindTag = async (value) => {
+		return bytesToBase64Url(new Uint8Array(await subtle.sign("HMAC", await importedKey(), utf8.encode(BIND_LABEL + value))).slice(0, 16));
+	};
+	return {
+		async mint(payload, ctx) {
+			const envelope = {
+				p: payload,
+				exp: Math.floor(Date.now() / 1e3) + ttlSeconds
 			};
-			if (this.sessionId !== void 0) headers["mcp-session-id"] = this.sessionId;
-			const encoder = new TextEncoder();
-			let streamController;
-			const readable = new ReadableStream({
-				start: (controller) => {
-					streamController = controller;
-				},
-				cancel: () => {}
-			});
-			const replayedStreamId = await this._eventStore.replayEventsAfter(lastEventId, { send: async (eventId, message) => {
-				if (!this.writeSSEEvent(streamController, encoder, message, eventId)) try {
-					streamController.close();
-				} catch {}
-			} });
-			this._streamMapping.set(replayedStreamId, {
-				controller: streamController,
-				encoder,
-				cleanup: () => {
-					this._streamMapping.delete(replayedStreamId);
-					try {
-						streamController.close();
-					} catch {}
-				}
-			});
-			return new Response(readable, { headers });
-		} catch (error) {
-			this.onerror?.(error);
-			return this.createJsonErrorResponse(500, -32e3, "Error replaying events");
-		}
-	}
-	/**
-	* Writes an event to an SSE stream via controller with proper formatting
-	*/
-	writeSSEEvent(controller, encoder, message, eventId) {
-		try {
-			let eventData = `event: message\n`;
-			if (eventId) eventData += `id: ${eventId}\n`;
-			eventData += `data: ${JSON.stringify(message)}\n\n`;
-			controller.enqueue(encoder.encode(eventData));
-			return true;
-		} catch (error) {
-			this.onerror?.(error);
-			return false;
-		}
-	}
-	/**
-	* Handles unsupported requests (`PUT`, `PATCH`, etc.)
-	*/
-	handleUnsupportedRequest() {
-		this.onerror?.(/* @__PURE__ */ new Error("Method not allowed."));
-		return Response.json({
-			jsonrpc: "2.0",
-			error: {
-				code: -32e3,
-				message: "Method not allowed."
-			},
-			id: null
-		}, {
-			status: 405,
-			headers: {
-				Allow: "GET, POST, DELETE",
-				"Content-Type": "application/json"
-			}
-		});
-	}
-	/**
-	* Handles `POST` requests containing JSON-RPC messages
-	*/
-	async handlePostRequest(req, options) {
-		try {
-			const acceptHeader = req.headers.get("accept");
-			if (!acceptHeader?.includes("application/json") || !acceptHeader.includes("text/event-stream")) {
-				this.onerror?.(/* @__PURE__ */ new Error("Not Acceptable: Client must accept both application/json and text/event-stream"));
-				return this.createJsonErrorResponse(406, -32e3, "Not Acceptable: Client must accept both application/json and text/event-stream");
-			}
-			const ct = req.headers.get("content-type");
-			if (!ct || !ct.includes("application/json")) {
-				this.onerror?.(/* @__PURE__ */ new Error("Unsupported Media Type: Content-Type must be application/json"));
-				return this.createJsonErrorResponse(415, -32e3, "Unsupported Media Type: Content-Type must be application/json");
+			if (bind !== void 0) {
+				if (ctx === void 0) throw new TypeError("createRequestStateCodec: mint() requires ctx when a bind callback is configured");
+				envelope.b = await bindTag(bind(ctx));
 			}
-			const request = req;
-			let rawMessage;
-			if (options?.parsedBody === void 0) try {
-				rawMessage = await req.json();
-			} catch (error) {
-				this.onerror?.(error);
-				return this.createJsonErrorResponse(400, -32700, "Parse error: Invalid JSON");
-			}
-			else rawMessage = options.parsedBody;
-			let messages;
+			const body = bytesToBase64Url(utf8.encode(JSON.stringify(envelope)));
+			return `${PREFIX}${body}.${bytesToBase64Url(new Uint8Array(await subtle.sign("HMAC", await importedKey(), utf8.encode(PREFIX + body))))}`;
+		},
+		async verify(state, ctx) {
+			const dot = state.lastIndexOf(".");
+			if (!state.startsWith(PREFIX) || dot <= 3) throw new Error("malformed");
+			const body = state.slice(3, dot);
+			let macBytes;
 			try {
-				messages = Array.isArray(rawMessage) ? rawMessage.map((msg) => JSONRPCMessageSchema.parse(msg)) : [JSONRPCMessageSchema.parse(rawMessage)];
-			} catch (error) {
-				this.onerror?.(error);
-				return this.createJsonErrorResponse(400, -32700, "Parse error: Invalid JSON-RPC message");
-			}
-			const isInitializationRequest = messages.some((element) => isInitializeRequest(element));
-			if (isInitializationRequest) {
-				if (this._initialized && this.sessionId !== void 0) {
-					this.onerror?.(/* @__PURE__ */ new Error("Invalid Request: Server already initialized"));
-					return this.createJsonErrorResponse(400, -32600, "Invalid Request: Server already initialized");
-				}
-				if (messages.length > 1) {
-					this.onerror?.(/* @__PURE__ */ new Error("Invalid Request: Only one initialization request is allowed"));
-					return this.createJsonErrorResponse(400, -32600, "Invalid Request: Only one initialization request is allowed");
-				}
-				this.sessionId = this.sessionIdGenerator?.();
-				this._initialized = true;
-				if (this.sessionId && this._onsessioninitialized) await Promise.resolve(this._onsessioninitialized(this.sessionId));
-			}
-			if (!isInitializationRequest) {
-				const sessionError = this.validateSession(req);
-				if (sessionError) return sessionError;
-				const protocolError = this.validateProtocolVersion(req);
-				if (protocolError) return protocolError;
+				macBytes = base64UrlToBytes(state.slice(dot + 1));
+			} catch {
+				throw new Error("malformed");
 			}
-			if (!messages.some((element) => isJSONRPCRequest(element))) {
-				for (const message of messages) this.onmessage?.(message, {
-					authInfo: options?.authInfo,
-					request
-				});
-				return new Response(null, { status: 202 });
-			}
-			const streamId = crypto.randomUUID();
-			const initRequest = messages.find((m) => isInitializeRequest(m));
-			const clientProtocolVersion = initRequest ? initRequest.params.protocolVersion : req.headers.get("mcp-protocol-version") ?? DEFAULT_NEGOTIATED_PROTOCOL_VERSION;
-			if (this._enableJsonResponse) return new Promise((resolve) => {
-				this._streamMapping.set(streamId, {
-					resolveJson: resolve,
-					cleanup: () => {
-						this._streamMapping.delete(streamId);
-					}
-				});
-				for (const message of messages) if (isJSONRPCRequest(message)) this._requestToStreamMapping.set(message.id, streamId);
-				for (const message of messages) this.onmessage?.(message, {
-					authInfo: options?.authInfo,
-					request
-				});
-			});
-			const encoder = new TextEncoder();
-			let streamController;
-			const readable = new ReadableStream({
-				start: (controller) => {
-					streamController = controller;
-				},
-				cancel: () => {
-					this._streamMapping.delete(streamId);
-				}
-			});
-			const headers = {
-				"Content-Type": "text/event-stream",
-				"Cache-Control": "no-cache",
-				Connection: "keep-alive"
-			};
-			if (this.sessionId !== void 0) headers["mcp-session-id"] = this.sessionId;
-			for (const message of messages) if (isJSONRPCRequest(message)) {
-				this._streamMapping.set(streamId, {
-					controller: streamController,
-					encoder,
-					cleanup: () => {
-						this._streamMapping.delete(streamId);
-						try {
-							streamController.close();
-						} catch {}
-					}
-				});
-				this._requestToStreamMapping.set(message.id, streamId);
-			}
-			await this.writePrimingEvent(streamController, encoder, streamId, clientProtocolVersion);
-			for (const message of messages) {
-				let closeSSEStream;
-				let closeStandaloneSSEStream;
-				if (isJSONRPCRequest(message) && this._eventStore && clientProtocolVersion >= "2025-11-25") {
-					closeSSEStream = () => {
-						this.closeSSEStream(message.id);
-					};
-					closeStandaloneSSEStream = () => {
-						this.closeStandaloneSSEStream();
-					};
-				}
-				this.onmessage?.(message, {
-					authInfo: options?.authInfo,
-					request,
-					closeSSEStream,
-					closeStandaloneSSEStream
-				});
-			}
-			return new Response(readable, {
-				status: 200,
-				headers
-			});
-		} catch (error) {
-			this.onerror?.(error);
-			return this.createJsonErrorResponse(400, -32700, "Parse error", { data: String(error) });
-		}
-	}
-	/**
-	* Handles `DELETE` requests to terminate sessions
-	*/
-	async handleDeleteRequest(req) {
-		const sessionError = this.validateSession(req);
-		if (sessionError) return sessionError;
-		const protocolError = this.validateProtocolVersion(req);
-		if (protocolError) return protocolError;
-		await Promise.resolve(this._onsessionclosed?.(this.sessionId));
-		await this.close();
-		return new Response(null, { status: 200 });
-	}
-	/**
-	* Validates session ID for non-initialization requests.
-	* Returns `Response` error if invalid, `undefined` otherwise
-	*/
-	validateSession(req) {
-		if (this.sessionIdGenerator === void 0) return;
-		if (!this._initialized) {
-			this.onerror?.(/* @__PURE__ */ new Error("Bad Request: Server not initialized"));
-			return this.createJsonErrorResponse(400, -32e3, "Bad Request: Server not initialized");
-		}
-		const sessionId = req.headers.get("mcp-session-id");
-		if (!sessionId) {
-			this.onerror?.(/* @__PURE__ */ new Error("Bad Request: Mcp-Session-Id header is required"));
-			return this.createJsonErrorResponse(400, -32e3, "Bad Request: Mcp-Session-Id header is required");
-		}
-		if (sessionId !== this.sessionId) {
-			this.onerror?.(/* @__PURE__ */ new Error("Session not found"));
-			return this.createJsonErrorResponse(404, -32001, "Session not found");
-		}
-	}
-	/**
-	* Validates the `MCP-Protocol-Version` header on incoming requests.
-	*
-	* For initialization: Version negotiation handles unknown versions gracefully
-	* (server responds with its supported version).
-	*
-	* For subsequent requests with `MCP-Protocol-Version` header:
-	* - Accept if in supported list
-	* - 400 if unsupported
-	*
-	* For HTTP requests without the `MCP-Protocol-Version` header:
-	* - Accept and default to the version negotiated at initialization
-	*/
-	validateProtocolVersion(req) {
-		const protocolVersion = req.headers.get("mcp-protocol-version");
-		if (protocolVersion !== null && !this._supportedProtocolVersions.includes(protocolVersion)) {
-			const error = `Bad Request: Unsupported protocol version: ${protocolVersion} (supported versions: ${this._supportedProtocolVersions.join(", ")})`;
-			this.onerror?.(new Error(error));
-			return this.createJsonErrorResponse(400, -32e3, error);
-		}
-	}
-	async close() {
-		for (const { cleanup } of this._streamMapping.values()) cleanup();
-		this._streamMapping.clear();
-		this._requestResponseMap.clear();
-		this.onclose?.();
-	}
-	/**
-	* Close an SSE stream for a specific request, triggering client reconnection.
-	* Use this to implement polling behavior during long-running operations -
-	* client will reconnect after the retry interval specified in the priming event.
-	*/
-	closeSSEStream(requestId) {
-		const streamId = this._requestToStreamMapping.get(requestId);
-		if (!streamId) return;
-		const stream = this._streamMapping.get(streamId);
-		if (stream) stream.cleanup();
-	}
-	/**
-	* Close the standalone `GET` SSE stream, triggering client reconnection.
-	* Use this to implement polling behavior for server-initiated notifications.
-	*/
-	closeStandaloneSSEStream() {
-		const stream = this._streamMapping.get(this._standaloneSseStreamId);
-		if (stream) stream.cleanup();
-	}
-	async send(message, options) {
-		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 eventId;
-			if (this._eventStore) eventId = await this._eventStore.storeEvent(this._standaloneSseStreamId, message);
-			const standaloneSse = this._streamMapping.get(this._standaloneSseStreamId);
-			if (standaloneSse === void 0) return;
-			if (standaloneSse.controller && standaloneSse.encoder) this.writeSSEEvent(standaloneSse.controller, standaloneSse.encoder, message, eventId);
-			return;
-		}
-		const streamId = this._requestToStreamMapping.get(requestId);
-		if (!streamId) throw new Error(`No connection established for request ID: ${String(requestId)}`);
-		const stream = this._streamMapping.get(streamId);
-		if (!this._enableJsonResponse && stream?.controller && stream?.encoder) {
-			let eventId;
-			if (this._eventStore) eventId = await this._eventStore.storeEvent(streamId, message);
-			this.writeSSEEvent(stream.controller, stream.encoder, message, eventId);
-		}
-		if (isJSONRPCResultResponse(message) || isJSONRPCErrorResponse(message)) {
-			this._requestResponseMap.set(requestId, message);
-			const relatedIds = [...this._requestToStreamMapping.entries()].filter(([_, sid]) => sid === streamId).map(([id]) => id);
-			if (relatedIds.every((id) => this._requestResponseMap.has(id))) {
-				if (!stream) throw new Error(`No connection established for request ID: ${String(requestId)}`);
-				if (this._enableJsonResponse && stream.resolveJson) {
-					const headers = { "Content-Type": "application/json" };
-					if (this.sessionId !== void 0) headers["mcp-session-id"] = this.sessionId;
-					const responses = relatedIds.map((id) => this._requestResponseMap.get(id));
-					if (responses.length === 1) stream.resolveJson(Response.json(responses[0], {
-						status: 200,
-						headers
-					}));
-					else stream.resolveJson(Response.json(responses, {
-						status: 200,
-						headers
-					}));
-				} else stream.cleanup();
-				for (const id of relatedIds) {
-					this._requestResponseMap.delete(id);
-					this._requestToStreamMapping.delete(id);
-				}
+			if (!await subtle.verify("HMAC", await importedKey(), macBytes, utf8.encode(PREFIX + body))) throw new Error("mac");
+			let envelope;
+			try {
+				envelope = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(base64UrlToBytes(body)));
+			} catch {
+				throw new Error("malformed");
 			}
+			if (typeof envelope.exp !== "number" || envelope.exp < Math.floor(Date.now() / 1e3)) throw new Error("expired");
+			if (bind !== void 0) {
+				const expected = await bindTag(bind(ctx));
+				if (envelope.b === void 0 || !constantTimeTagEqual(envelope.b, expected)) throw new Error("bind");
+			} else if (envelope.b !== void 0) throw new Error("bind");
+			return envelope.p;
 		}
-	}
-};
+	};
+}
 
 //#endregion
 //#region src/fromJsonSchema.ts
@@ -2292,5 +1574,5 @@ function fromJsonSchema(schema, validator) {
 }
 
 //#endregion
-export { AjvJsonSchemaValidator, CfWorkerJsonSchemaValidator, DEFAULT_NEGOTIATED_PROTOCOL_VERSION, DEFAULT_REQUEST_TIMEOUT_MSEC, ExperimentalMcpServerTasks, ExperimentalServerTasks, INTERNAL_ERROR, INVALID_PARAMS, INVALID_REQUEST, InMemoryTaskMessageQueue, InMemoryTaskStore, JSONRPC_VERSION, LATEST_PROTOCOL_VERSION, METHOD_NOT_FOUND, McpServer, OAuthError, OAuthErrorCode, PARSE_ERROR, ProtocolError, ProtocolErrorCode, RELATED_TASK_META_KEY, ReadBuffer, ResourceTemplate, SUPPORTED_PROTOCOL_VERSIONS, SdkError, SdkErrorCode, Server, StdioServerTransport, UriTemplate, UrlElicitationRequiredError, WebStandardStreamableHTTPServerTransport, assertClientRequestTaskCapability, assertCompleteRequestPrompt, assertCompleteRequestResourceTemplate, assertToolsCallTaskCapability, checkResourceAllowed, completable, createFetchWithInit, deserializeMessage, fromJsonSchema, getDisplayName, hostHeaderValidationResponse, isCompletable, isInitializeRequest, isInitializedNotification, isJSONRPCErrorResponse, isJSONRPCNotification, isJSONRPCRequest, isJSONRPCResultResponse, isTaskAugmentedRequestParams, isTerminal, localhostAllowedHostnames, parseJSONRPCMessage, resourceUrlFromServerUrl, serializeMessage, takeResult, toArrayAsync, validateHostHeader };
+export { BAGGAGE_META_KEY, CLIENT_CAPABILITIES_META_KEY, CLIENT_INFO_META_KEY, DEFAULT_NEGOTIATED_PROTOCOL_VERSION, DEFAULT_REQUEST_TIMEOUT_MSEC, INTERNAL_ERROR, INVALID_PARAMS, INVALID_REQUEST, InMemoryServerEventBus, InMemoryTransport, JSONRPC_VERSION, LATEST_PROTOCOL_VERSION, LOG_LEVEL_META_KEY, METHOD_NOT_FOUND, McpServer, MissingRequiredClientCapabilityError, OAuthError, OAuthErrorCode, PARSE_ERROR, PROTOCOL_VERSION_META_KEY, PerRequestHTTPServerTransport, ProtocolError, ProtocolErrorCode, RELATED_TASK_META_KEY, ReadBuffer, ResourceNotFoundError, ResourceTemplate, STDIO_DEFAULT_MAX_BUFFER_SIZE, SUBSCRIPTION_ID_META_KEY, SUPPORTED_PROTOCOL_VERSIONS, SdkError, SdkErrorCode, SdkHttpError, Server, TRACEPARENT_META_KEY, TRACESTATE_META_KEY, UnsupportedProtocolVersionError, UriTemplate, UrlElicitationRequiredError, WebStandardStreamableHTTPServerTransport, acceptedContent, assertCompleteRequestPrompt, assertCompleteRequestResourceTemplate, checkResourceAllowed, classifyInboundRequest, completable, createFetchWithInit, createMcpHandler, createRequestStateCodec, deserializeMessage, fromJsonSchema, getDisplayName, hostHeaderValidationResponse, inputRequired, inputResponse, isCallToolResult, isCompletable, isInitializeRequest, isInitializedNotification, isInputRequiredResult, isJSONRPCErrorResponse, isJSONRPCNotification, isJSONRPCRequest, isJSONRPCResponse, isJSONRPCResultResponse, isLegacyRequest, isSpecType, isTaskAugmentedRequestParams, legacyStatelessFallback, localhostAllowedHostnames, localhostAllowedOrigins, originValidationResponse, parseJSONRPCMessage, resourceUrlFromServerUrl, serializeMessage, specTypeSchemas, validateHostHeader, validateOriginHeader };
 //# sourceMappingURL=index.mjs.map