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

package/dist/index.mjs

@@ -1,1358 +1,588 @@
-import { $ as LATEST_PROTOCOL_VERSION, A as isTaskAugmentedRequestParams, B as LoggingLevelSchema, C as isInitializeRequest, D as isJSONRPCRequest, E as isJSONRPCNotification, F as CreateMessageResultWithToolsSchema, G as BAGGAGE_META_KEY, H as UnsupportedProtocolVersionError, I as ElicitResultSchema, J as DEFAULT_NEGOTIATED_PROTOCOL_VERSION, K as CLIENT_CAPABILITIES_META_KEY, L as EmptyResultSchema, M as CallToolRequestSchema, N as CallToolResultSchema, O as isJSONRPCResponse, P as CreateMessageResultSchema, Q as JSONRPC_VERSION, R as JSONRPCMessageSchema, S as isCallToolResult, T as isJSONRPCErrorResponse, U as UrlElicitationRequiredError, V as ProtocolError, W as ProtocolErrorCode, X as INVALID_PARAMS, Y as INTERNAL_ERROR, Z as INVALID_REQUEST, _ as validateStandardSchema, a as UriTemplate, at as SUPPORTED_PROTOCOL_VERSIONS, b as assertCompleteRequestPrompt, c as ReadBuffer, ct as getDisplayName, d as serializeMessage, dt as SdkError, et as LOG_LEVEL_META_KEY, f as DEFAULT_REQUEST_TIMEOUT_MSEC, ft as SdkErrorCode, g as standardSchemaToJsonSchema, h as promptArgumentsFromStandardSchema, ht as OAuthErrorCode, i as InMemoryTransport, it as RELATED_TASK_META_KEY, j as parseJSONRPCMessage, k as isJSONRPCResultResponse, l as STDIO_DEFAULT_MAX_BUFFER_SIZE, lt as checkResourceAllowed, m as mergeCapabilities, mt as OAuthError, n as normalizeRawShapeSchema, nt as PARSE_ERROR, o as createFetchWithInit, ot as TRACEPARENT_META_KEY, p as Protocol, pt as SdkHttpError, q as CLIENT_INFO_META_KEY, r as parseSchema, rt as PROTOCOL_VERSION_META_KEY, s as validateAndWarnToolName, st as TRACESTATE_META_KEY, t as fromJsonSchema$1, tt as METHOD_NOT_FOUND, u as deserializeMessage, ut as resourceUrlFromServerUrl, v as isSpecType, w as isInitializedNotification, x as assertCompleteRequestResourceTemplate, y as specTypeSchemas, z as ListRootsResultSchema } from "./src-Pa1iAvsj.mjs";
+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 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.
+* 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 Server = class extends Protocol {
-	_clientCapabilities;
-	_clientVersion;
-	_negotiatedProtocolVersion;
-	_capabilities;
-	_instructions;
-	_jsonSchemaValidator;
-	/**
-	* 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.
-	*/
-	constructor(_serverInfo, options) {
-		super(options);
-		this._serverInfo = _serverInfo;
-		this._capabilities = options?.capabilities ? { ...options.capabilities } : {};
-		this._instructions = options?.instructions;
-		this._jsonSchemaValidator = options?.jsonSchemaValidator ?? new DefaultJsonSchemaValidator();
-		this.setRequestHandler("initialize", (request) => this._oninitialize(request));
-		this.setNotificationHandler("notifications/initialized", () => this.oninitialized?.());
-		if (this._capabilities.logging) this._registerLoggingHandler();
-	}
+var PerRequestHTTPServerTransport = class {
+	onclose;
+	onerror;
+	onmessage;
+	_classification;
+	_responseMode;
+	_started = false;
+	_used = false;
+	_closed = false;
+	_terminalDelivered = false;
 	/**
-	* Registers the built-in `logging/setLevel` request handler.
-	*
-	* @deprecated Deprecated as of protocol version 2026-07-28 (SEP-2577).
-	* Remains functional during the deprecation window (at least twelve months).
-	* Migrate to stderr logging (STDIO servers) or OpenTelemetry.
+	* `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.
 	*/
-	_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 {};
-		});
+	_dispatchWindowOpen = false;
+	_requestId;
+	_deferredResponse;
+	_sse;
+	_abortCleanup;
+	constructor(options) {
+		this._classification = options.classification;
+		this._responseMode = options.responseMode ?? "auto";
 	}
-	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
-		};
+	async start() {
+		if (this._started) throw new Error("PerRequestHTTPServerTransport is already started");
+		this._started = true;
 	}
-	_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.
+	* Serves the single exchange: delivers the classified message to the
+	* connected server instance and resolves with the HTTP response.
 	*
-	* The new capabilities will be merged with any existing capabilities previously given (e.g., at initialization).
+	* 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).
 	*/
-	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();
-	}
-	/**
-	* Enforces server-side validation for `tools/call` results regardless of how the
-	* handler was registered.
-	*/
-	_wrapHandler(method, handler) {
-		if (method !== "tools/call") return handler;
-		return 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 validationResult = parseSchema(CallToolResultSchema, await handler(request, ctx));
-			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;
-		};
-	}
-	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;
-		}
-	}
-	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;
-		}
-	}
-	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;
+	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");
 		}
-	}
-	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._negotiatedProtocolVersion = protocolVersion;
-		this.transport?.setProtocolVersion?.(protocolVersion);
-		return {
-			protocolVersion,
-			capabilities: this.getCapabilities(),
-			serverInfo: this._serverInfo,
-			...this._instructions && { instructions: this._instructions }
+		const messageExtra = {
+			classification: this._classification,
+			...extra?.request !== void 0 && { request: extra.request },
+			...extra?.authInfo !== void 0 && { authInfo: extra.authInfo }
 		};
-	}
-	/**
-	* 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;
-	}
-	/**
-	* After initialization has completed, this will be populated with the protocol version negotiated
-	* with the client (the version the server responded with during the initialize handshake), or
-	* `undefined` before initialization.
-	*/
-	getNegotiatedProtocolVersion() {
-		return this._negotiatedProtocolVersion;
-	}
-	/**
-	* 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");
+		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);
 			}
-			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");
+			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;
 		}
-		if (params.tools) return this._requestWithSchema({
-			method: "sampling/createMessage",
-			params
-		}, CreateMessageResultWithToolsSchema, options);
-		return this._requestWithSchema({
-			method: "sampling/createMessage",
-			params
-		}, CreateMessageResultSchema, options);
+		this.onmessage(message, messageExtra);
+		return new Response(null, { status: 202 });
 	}
-	/**
-	* 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.
-	*/
-	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 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;
+		}
+		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;
 			}
-			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)}`);
-				}
-				return result;
+			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);
 	}
 	/**
-	* 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 SSE comment frame (a keep-alive heartbeat). Dropped when the
+	* exchange is not currently streaming.
 	*/
-	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);
+	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`);
 	}
-	/**
-	* Requests the list of roots from the client.
-	*
-	* @deprecated Deprecated as of protocol version 2026-07-28 (SEP-2577).
-	* Remains functional during the deprecation window (at least twelve months).
-	* Migrate to passing paths via tool parameters, resource URIs, or configuration.
-	*/
-	async listRoots(params, options) {
-		return this._requestWithSchema({
-			method: "roots/list",
-			params
-		}, ListRootsResultSchema, options);
+	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?.();
 	}
-	/**
-	* 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.
-	*
-	* @deprecated Deprecated as of protocol version 2026-07-28 (SEP-2577).
-	* Remains functional during the deprecation window (at least twelve months).
-	* Migrate to stderr logging (STDIO servers) or OpenTelemetry.
-	*/
-	async sendLoggingMessage(params, sessionId) {
-		if (this._capabilities.logging && !this.isMessageIgnored(params.level, sessionId)) return this.notification({
-			method: "notifications/message",
-			params
-		});
+	settleResponse(response) {
+		if (this._deferredResponse === void 0 || this._deferredResponse.settled) return;
+		this._deferredResponse.settled = true;
+		this._deferredResponse.resolve(response);
 	}
-	async sendResourceUpdated(params) {
-		return this.notification({
-			method: "notifications/resources/updated",
-			params
+	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"
+			}
+		}));
 	}
-	async sendResourceListChanged() {
-		return this.notification({ method: "notifications/resources/list_changed" });
+	finalizeStream() {
+		if (this._sse !== void 0 && !this._sse.closed) {
+			this._sse.closed = true;
+			try {
+				this._sse.controller.close();
+			} catch {}
+		}
+		queueMicrotask(() => void this.close());
 	}
-	async sendToolListChanged() {
-		return this.notification({ method: "notifications/tools/list_changed" });
+	writeMessageFrame(message) {
+		this.writeFrame(`event: message\ndata: ${JSON.stringify(message)}\n\n`);
 	}
-	async sendPromptListChanged() {
-		return this.notification({ method: "notifications/prompts/list_changed" });
+	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/server/mcp.ts
+//#region src/server/invoke.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.
+* Serves one classified inbound message on the given server instance and
+* returns the HTTP response for the exchange.
 *
-* @example
-* ```ts source="./mcp.examples.ts#McpServer_basicUsage"
-* const server = new McpServer({
-*     name: 'my-server',
-*     version: '1.0.0'
+* 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.
+*/
+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/server/streamableHttp.ts
+/**
+* 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
+*
+* @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
+* });
+* ```
+*
+* @example Hono.js
+* ```ts source="./streamableHttp.examples.ts#WebStandardStreamableHTTPServerTransport_hono"
+* app.all('/mcp', async c => {
+*     return transport.handleRequest(c.req.raw);
 * });
 * ```
+*
+* @example Cloudflare Workers
+* ```ts source="./streamableHttp.examples.ts#WebStandardStreamableHTTPServerTransport_workers"
+* const worker = {
+*     async fetch(request: Request): Promise<Response> {
+*         return transport.handleRequest(request);
+*     }
+* };
+* ```
 */
-var McpServer = class {
-	/**
-	* The underlying {@linkcode Server} instance, useful for advanced operations like sending notifications.
-	*/
-	server;
-	_registeredResources = {};
-	_registeredResourceTemplates = {};
-	_registeredTools = {};
-	_registeredPrompts = {};
-	constructor(serverInfo, options) {
-		this.server = new Server(serverInfo, options);
-		if (options?.capabilities?.tools) this.setToolRequestHandlers();
-		if (options?.capabilities?.resources) this.setResourceRequestHandlers();
-		if (options?.capabilities?.prompts) this.setPromptRequestHandlers();
+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;
 	}
 	/**
-	* 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);
-	* ```
+	* 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 connect(transport) {
-		return await this.server.connect(transport);
+	async start() {
+		if (this._started) throw new Error("Transport already started");
+		this._started = true;
 	}
 	/**
-	* Closes the connection.
+	* Sets the supported protocol versions for header validation.
+	* Called by the server during {@linkcode server/server.Server.connect | connect()} to pass its supported versions.
 	*/
-	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,
-				icons: tool.icons,
-				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 args = await this.validateToolInput(tool, request.params.arguments, request.params.name);
-				const result = await this.executeToolHandler(tool, args, ctx);
-				await this.validateToolOutput(tool, result, request.params.name);
-				return result;
-			} catch (error) {
-				if (error instanceof ProtocolError && error.code === ProtocolErrorCode.UrlElicitationRequired) throw error;
-				return this.createToolError(error instanceof Error ? error.message : String(error));
-			}
-		});
-		this._toolHandlersInitialized = true;
+	setSupportedProtocolVersions(versions) {
+		this._supportedProtocolVersions = versions;
 	}
 	/**
-	* Creates a tool error result.
-	*
-	* @param errorMessage - The error message.
-	* @returns The tool error result.
+	* Helper to create a JSON error response
 	*/
-	createToolError(errorMessage) {
-		return {
-			content: [{
-				type: "text",
-				text: errorMessage
-			}],
-			isError: true
+	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 tool input arguments against the tool's input schema.
+	* Validates request headers for DNS rebinding protection.
+	* @returns Error response if validation fails, `undefined` if validation passes.
 	*/
-	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;
+	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);
+			}
+		}
 	}
 	/**
-	* Validates tool output against the tool's output schema.
+	* Handles an incoming HTTP request, whether `GET`, `POST`, or `DELETE`
+	* Returns a `Response` object (Web Standard)
 	*/
-	async validateToolOutput(tool, result, toolName) {
-		if (!tool.outputSchema) 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}`);
-	}
+	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();
+		}
+	}
 	/**
-	* Executes a tool handler.
+	* Returns true if the client's protocol version supports empty SSE data in
+	* priming events (the fix shipped with protocol version `2025-11-25`).
+	*
+	* 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.
 	*/
-	async executeToolHandler(tool, args, ctx) {
-		return tool.executor(args, ctx);
-	}
-	_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;
+	supportsEmptySSEData(protocolVersion) {
+		return this._supportedProtocolVersions.includes(protocolVersion) && protocolVersion >= "2025-11-25";
 	}
-	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));
+	/**
+	* 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`).
+	*/
+	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));
 	}
-	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`);
+	/**
+	* 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 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
-				});
+		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: () => {
+				if (this._streamMapping.get(this._standaloneSseStreamId)?.controller === streamController) this._streamMapping.delete(this._standaloneSseStreamId);
 			}
-			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);
+		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 {}
 			}
-			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,
-				icons: prompt.icons,
-				_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;
+		return new Response(readable, { headers });
 	}
-	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;
+	/**
+	* 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");
 		}
-	}
-	_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;
+		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 (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 (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");
 				}
-				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._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, icons, _meta) {
-		let currentArgsSchema = argsSchema;
-		let currentCallback = callback;
-		const registeredPrompt = {
-			title,
-			description,
-			argsSchema,
-			icons,
-			_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;
+			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);
 				}
-				if (updates.title !== void 0) registeredPrompt.title = updates.title;
-				if (updates.description !== void 0) registeredPrompt.description = updates.description;
-				if (updates.icons !== void 0) registeredPrompt.icons = updates.icons;
-				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;
+			});
+			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 (updates.callback !== void 0) {
-					currentCallback = updates.callback;
-					needsHandlerRegen = true;
+			});
+			if (replayedStreamId !== this._standaloneSseStreamId) {
+				if (![...this._requestToStreamMapping.values()].includes(replayedStreamId)) {
+					this._streamMapping.delete(replayedStreamId);
+					try {
+						streamController.close();
+					} catch {}
 				}
-				if (needsHandlerRegen) registeredPrompt.handler = createPromptHandler(name, currentArgsSchema, currentCallback);
-				if (updates.enabled !== void 0) registeredPrompt.enabled = updates.enabled;
-				this.sendPromptListChanged();
-			}
-		};
-		this._registeredPrompts[name] = registeredPrompt;
-		if (argsSchema) {
-			const shape = getSchemaShape(argsSchema);
-			if (shape) {
-				if (Object.values(shape).some((field) => {
-					return isCompletable(unwrapOptionalSchema(field));
-				})) this.setCompletionRequestHandler();
 			}
+			return new Response(readable, { headers });
+		} catch (error) {
+			this.onerror?.(error);
+			return this.createJsonErrorResponse(500, -32e3, "Error replaying events");
 		}
-		return registeredPrompt;
-	}
-	_createRegisteredTool(name, title, description, inputSchema, outputSchema, annotations, icons, execution, _meta, handler) {
-		validateAndWarnToolName(name);
-		let currentHandler = handler;
-		const registeredTool = {
-			title,
-			description,
-			inputSchema,
-			outputSchema,
-			annotations,
-			icons,
-			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;
-				}
-				if (updates.callback !== void 0) {
-					registeredTool.handler = updates.callback;
-					currentHandler = updates.callback;
-					needsExecutorRegen = true;
-				}
-				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.icons !== void 0) registeredTool.icons = updates.icons;
-				if (updates._meta !== void 0) registeredTool._meta = updates._meta;
-				if (updates.enabled !== void 0) registeredTool.enabled = updates.enabled;
-				this.sendToolListChanged();
-			}
-		};
-		this._registeredTools[name] = registeredTool;
-		this.setToolRequestHandlers();
-		this.sendToolListChanged();
-		return registeredTool;
-	}
-	registerTool(name, config, cb) {
-		if (this._registeredTools[name]) throw new Error(`Tool ${name} is already registered`);
-		const { title, description, inputSchema, outputSchema, annotations, icons, _meta } = config;
-		return this._createRegisteredTool(name, title, description, normalizeRawShapeSchema(inputSchema), normalizeRawShapeSchema(outputSchema), annotations, icons, void 0, _meta, cb);
-	}
-	registerPrompt(name, config, cb) {
-		if (this._registeredPrompts[name]) throw new Error(`Prompt ${name} is already registered`);
-		const { title, description, argsSchema, icons, _meta } = config;
-		const registeredPrompt = this._createRegisteredPrompt(name, title, description, normalizeRawShapeSchema(argsSchema), cb, icons, _meta);
-		this.setPromptRequestHandlers();
-		this.sendPromptListChanged();
-		return registeredPrompt;
-	}
-	/**
-	* Checks if the server is connected to a transport.
-	* @returns `true` if the server is connected
-	*/
-	isConnected() {
-		return this.server.transport !== void 0;
-	}
-	/**
-	* 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.
-	*
-	* @example
-	* ```ts source="./mcp.examples.ts#McpServer_sendLoggingMessage_basic"
-	* await server.sendLoggingMessage({
-	*     level: 'info',
-	*     data: 'Processing complete'
-	* });
-	* ```
-	*
-	* @deprecated Deprecated as of protocol version 2026-07-28 (SEP-2577).
-	* Remains functional during the deprecation window (at least twelve months).
-	* Migrate to stderr logging (STDIO servers) or OpenTelemetry.
-	*/
-	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.
-	*/
-	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;
 	}
 	/**
-	* Gets the URI template pattern.
+	* Writes an event to an SSE stream via controller with proper formatting
 	*/
-	get uriTemplate() {
-		return this._uriTemplate;
+	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;
+		}
 	}
 	/**
-	* Gets the list callback, if one was provided.
+	* Handles unsupported requests (`PUT`, `PATCH`, etc.)
 	*/
-	get listCallback() {
-		return this._callbacks.list;
+	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"
+			}
+		});
 	}
 	/**
-	* Gets the callback for completing a specific URI template variable, if one was provided.
-	*/
-	completeCallback(variable) {
-		return this._callbacks.complete?.[variable];
-	}
-};
-/**
-* 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 (inputSchema) {
-		const callback$1 = handler;
-		return async (args, ctx) => callback$1(args, ctx);
-	}
-	const callback = handler;
-	return async (_args, ctx) => callback(ctx);
-}
-const EMPTY_OBJECT_JSON_SCHEMA = {
-	type: "object",
-	properties: {}
-};
-/**
-* 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.
-*/
-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 createCompletionResult(suggestions) {
-	return { completion: {
-		values: suggestions.map(String).slice(0, 100),
-		total: suggestions.length,
-		hasMore: suggestions.length > 100
-	} };
-}
-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;
-}
-/** @internal Checks if a Zod schema is optional */
-function isOptionalSchema(schema) {
-	return schema?.type === "optional";
-}
-/** @internal Unwraps an optional Zod schema */
-function unwrapOptionalSchema(schema) {
-	if (!isOptionalSchema(schema)) return schema;
-	return schema.def?.innerType ?? schema;
-}
-
-//#endregion
-//#region src/server/middleware/hostHeaderValidation.ts
-/**
-* Parse and validate a `Host` header against an allowlist of hostnames (port-agnostic).
-*
-* - Input host header may include a port (e.g. `localhost:3000`) or IPv6 brackets (e.g. `[::1]:3000`).
-* - Allowlist items should be hostnames only (no ports). For IPv6, include brackets (e.g. `[::1]`).
-*/
-function validateHostHeader(hostHeader, allowedHostnames) {
-	if (!hostHeader) return {
-		ok: false,
-		errorCode: "missing_host",
-		message: "Missing Host header"
-	};
-	let hostname;
-	try {
-		hostname = new URL(`http://${hostHeader}`).hostname;
-	} catch {
-		return {
-			ok: false,
-			errorCode: "invalid_host_header",
-			message: `Invalid Host header: ${hostHeader}`,
-			hostHeader
-		};
-	}
-	if (!allowedHostnames.includes(hostname)) return {
-		ok: false,
-		errorCode: "invalid_host",
-		message: `Invalid Host: ${hostname}`,
-		hostHeader,
-		hostname
-	};
-	return {
-		ok: true,
-		hostname
-	};
-}
-/**
-* Convenience allowlist for `localhost` DNS rebinding protection.
-*/
-function localhostAllowedHostnames() {
-	return [
-		"localhost",
-		"127.0.0.1",
-		"[::1]"
-	];
-}
-/**
-* Web-standard `Request` helper for DNS rebinding protection.
-* @example
-* ```ts source="./hostHeaderValidation.examples.ts#hostHeaderValidationResponse_basicUsage"
-* const result = validateHostHeader(req.headers.get('host'), ['localhost']);
-* ```
-*/
-function hostHeaderValidationResponse(req, allowedHostnames) {
-	const result = validateHostHeader(req.headers.get("host"), allowedHostnames);
-	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
-/**
-* 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
-*
-* @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
-* });
-* ```
-*
-* @example Hono.js
-* ```ts source="./streamableHttp.examples.ts#WebStandardStreamableHTTPServerTransport_hono"
-* app.all('/mcp', async c => {
-*     return transport.handleRequest(c.req.raw);
-* });
-* ```
-*
-* @example Cloudflare Workers
-* ```ts source="./streamableHttp.examples.ts#WebStandardStreamableHTTPServerTransport_workers"
-* const worker = {
-*     async fetch(request: Request): Promise<Response> {
-*         return transport.handleRequest(request);
-*     }
-* };
-* ```
-*/
-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;
-	}
-	/**
-	* 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();
-		}
-	}
-	/**
-	* Returns true if the client's protocol version supports empty SSE data in
-	* priming events (the fix shipped with protocol version `2025-11-25`).
-	*
-	* 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.
-	*/
-	supportsEmptySSEData(protocolVersion) {
-		return this._supportedProtocolVersions.includes(protocolVersion) && protocolVersion >= "2025-11-25";
-	}
-	/**
-	* 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`).
-	*/
-	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));
-	}
-	/**
-	* 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"
-			};
-			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
+	* Handles `POST` requests containing JSON-RPC messages
 	*/
 	async handlePostRequest(req, options) {
 		try {
@@ -1432,7 +662,7 @@ var WebStandardStreamableHTTPServerTransport = class {
 					streamController = controller;
 				},
 				cancel: () => {
-					this._streamMapping.delete(streamId);
+					if (this._streamMapping.get(streamId)?.controller === streamController) this._streamMapping.delete(streamId);
 				}
 			});
 			const headers = {
@@ -1571,22 +801,40 @@ var WebStandardStreamableHTTPServerTransport = class {
 			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);
+			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)}`);
-		const stream = this._streamMapping.get(streamId);
-		if (!this._enableJsonResponse && stream?.controller && stream?.encoder) {
+		let stream = this._streamMapping.get(streamId);
+		if (!this._enableJsonResponse) {
 			let eventId;
-			if (this._eventStore) eventId = await this._eventStore.storeEvent(streamId, message);
-			this.writeSSEEvent(stream.controller, stream.encoder, message, 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) throw new Error(`No connection established for request ID: ${String(requestId)}`);
+				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 (this._enableJsonResponse && stream.resolveJson) {
 					const headers = { "Content-Type": "application/json" };
 					if (this.sessionId !== void 0) headers["mcp-session-id"] = this.sessionId;
@@ -1599,6 +847,7 @@ var WebStandardStreamableHTTPServerTransport = class {
 						status: 200,
 						headers
 					}));
+					stream.cleanup();
 				} else stream.cleanup();
 				for (const id of relatedIds) {
 					this._requestResponseMap.delete(id);
@@ -1609,6 +858,714 @@ var WebStandardStreamableHTTPServerTransport = class {
 	}
 };
 
+//#endregion
+//#region src/server/createMcpHandler.ts
+/**
+* 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 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 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));
+		}
+	};
+}
+/**
+* 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
+	};
+}
+/**
+* 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";
+}
+/**
+* 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
+//#region src/server/middleware/hostHeaderValidation.ts
+/**
+* Parse and validate a `Host` header against an allowlist of hostnames (port-agnostic).
+*
+* - Input host header may include a port (e.g. `localhost:3000`) or IPv6 brackets (e.g. `[::1]:3000`).
+* - Allowlist items should be hostnames only (no ports). For IPv6, include brackets (e.g. `[::1]`).
+*/
+function validateHostHeader(hostHeader, allowedHostnames) {
+	if (!hostHeader) return {
+		ok: false,
+		errorCode: "missing_host",
+		message: "Missing Host header"
+	};
+	let hostname;
+	try {
+		hostname = new URL(`http://${hostHeader}`).hostname;
+	} catch {
+		return {
+			ok: false,
+			errorCode: "invalid_host_header",
+			message: `Invalid Host header: ${hostHeader}`,
+			hostHeader
+		};
+	}
+	if (!allowedHostnames.includes(hostname)) return {
+		ok: false,
+		errorCode: "invalid_host",
+		message: `Invalid Host: ${hostname}`,
+		hostHeader,
+		hostname
+	};
+	return {
+		ok: true,
+		hostname
+	};
+}
+/**
+* Convenience allowlist for `localhost` DNS rebinding protection.
+*/
+function localhostAllowedHostnames() {
+	return [
+		"localhost",
+		"127.0.0.1",
+		"[::1]"
+	];
+}
+/**
+* Web-standard `Request` helper for DNS rebinding protection.
+* @example
+* ```ts source="./hostHeaderValidation.examples.ts#hostHeaderValidationResponse_basicUsage"
+* const result = validateHostHeader(req.headers.get('host'), ['localhost']);
+* ```
+*/
+function hostHeaderValidationResponse(req, allowedHostnames) {
+	const result = validateHostHeader(req.headers.get("host"), allowedHostnames);
+	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/middleware/originValidation.ts
+/**
+* Validate an `Origin` header against an allowlist of hostnames (port-agnostic).
+*
+* - 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).
+*/
+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
+		};
+	}
+	if (hostname === "") return {
+		ok: false,
+		errorCode: "invalid_origin_header",
+		message: `Invalid Origin header: ${originHeader}`,
+		originHeader
+	};
+	if (!allowedOriginHostnames.includes(hostname)) return {
+		ok: false,
+		errorCode: "invalid_origin",
+		message: `Invalid Origin: ${hostname}`,
+		originHeader,
+		hostname
+	};
+	return {
+		ok: true,
+		origin: originHeader,
+		hostname
+	};
+}
+/**
+* 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/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;
+}
+/**
+* Create an opt-in HMAC-SHA256 codec for the multi-round-trip `requestState`
+* (protocol revision 2026-07-28).
+*
+* `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:
+*
+*     "v1." b64url({"p":<payload>,"exp":<unixSeconds>,"b":<bindTag>?}) "." b64url(mac)
+*
+* where `bindTag` is `b64url(HMAC(key, "mcp.requestState.bind:" + bind(ctx))[:16])`
+* — the binding value is never embedded raw.
+*
+* 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.
+*
+* 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.
+*
+* 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.
+*/
+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 (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 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 {
+				macBytes = base64UrlToBytes(state.slice(dot + 1));
+			} catch {
+				throw new Error("malformed");
+			}
+			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
 let _defaultValidator;
@@ -1617,5 +1574,5 @@ function fromJsonSchema(schema, validator) {
 }
 
 //#endregion
-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, InMemoryTransport, JSONRPC_VERSION, LATEST_PROTOCOL_VERSION, LOG_LEVEL_META_KEY, METHOD_NOT_FOUND, McpServer, OAuthError, OAuthErrorCode, PARSE_ERROR, PROTOCOL_VERSION_META_KEY, ProtocolError, ProtocolErrorCode, RELATED_TASK_META_KEY, ReadBuffer, ResourceTemplate, STDIO_DEFAULT_MAX_BUFFER_SIZE, SUPPORTED_PROTOCOL_VERSIONS, SdkError, SdkErrorCode, SdkHttpError, Server, TRACEPARENT_META_KEY, TRACESTATE_META_KEY, UnsupportedProtocolVersionError, UriTemplate, UrlElicitationRequiredError, WebStandardStreamableHTTPServerTransport, assertCompleteRequestPrompt, assertCompleteRequestResourceTemplate, checkResourceAllowed, completable, createFetchWithInit, deserializeMessage, fromJsonSchema, getDisplayName, hostHeaderValidationResponse, isCallToolResult, isCompletable, isInitializeRequest, isInitializedNotification, isJSONRPCErrorResponse, isJSONRPCNotification, isJSONRPCRequest, isJSONRPCResponse, isJSONRPCResultResponse, isSpecType, isTaskAugmentedRequestParams, localhostAllowedHostnames, parseJSONRPCMessage, resourceUrlFromServerUrl, serializeMessage, specTypeSchemas, 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