@tmcp/transport-http 0.8.6 → 0.9.0

package/src/index.js

@@ -1,7 +1,7 @@
 /**
  * @import { AuthInfo, McpServer } from "tmcp";
  * @import { OAuth  } from "@tmcp/auth";
- * @import { StreamSessionManager, InfoSessionManager } from "@tmcp/session-manager";
+ * @import { StreamSessionManager, InfoSessionManager, SubscriptionManager } from "@tmcp/session-manager";
  * @import { OptionalizeSessionManager } from "./type-utils.js"
  */
 
@@ -22,17 +22,42 @@
  * 	path?: string | null
  * 	oauth?: OAuth<"built">
  * 	cors?: CorsConfig | boolean,
+ * 	allowedOrigins?: string | string[] | true
  * 	sessionManager?: { streams?: StreamSessionManager, info?: OptionalizeSessionManager<InfoSessionManager> }
+ * 	subscriptionManager?: SubscriptionManager
  * 	disableSse?: boolean
  * }} HttpTransportOptions
  */
 
+/**
+ * @typedef {{ promise: Promise<boolean>, resolve: (registered: boolean) => void }} SubscriptionRegistration
+ * @typedef {{ controller?: ReadableStreamDefaultController, state: 'open' | 'cancelled' | 'disconnected', signal?: AbortSignal, subscription?: { id: string | number, registration: SubscriptionRegistration } }} SubscriptionSink
+ */
+
 import { AsyncLocalStorage } from 'node:async_hooks';
 import {
 	InMemoryStreamSessionManager,
 	InMemoryInfoSessionManager,
+	InMemorySubscriptionManager,
 } from '@tmcp/session-manager';
 import { DEV } from 'esm-env';
+import {
+	getPerRequestProtocolVersions,
+	McpError,
+	UNSUPPORTED_PROTOCOL_VERSION,
+} from 'tmcp';
+import { isPerRequestMethodAllowed } from 'tmcp/method-policy';
+import {
+	validate_request_headers,
+	validate_tool_parameter_headers,
+} from './request-headers.js';
+
+const PER_REQUEST_METADATA_KEYS = [
+	'io.modelcontextprotocol/protocolVersion',
+	'io.modelcontextprotocol/clientCapabilities',
+	'io.modelcontextprotocol/clientInfo',
+	'io.modelcontextprotocol/logLevel',
+];
 
 /**
  * @template {Record<string, unknown> | undefined} [TCustom=undefined]
@@ -48,7 +73,7 @@ export class HttpTransport {
 	#server;
 
 	/**
-	 * @type {Required<Omit<HttpTransportOptions, 'oauth' | 'cors' | 'sessionManager' | 'disableSse'>> & { cors?: CorsConfig | boolean, sessionManager: SessionManager, disableSse?: boolean }}
+	 * @type {Required<Omit<HttpTransportOptions, 'oauth' | 'cors' | 'allowedOrigins' | 'sessionManager' | 'subscriptionManager' | 'disableSse'>> & { cors?: CorsConfig | boolean, allowedOrigins?: string | string[] | true, sessionManager: SessionManager, disableSse?: boolean }}
 	 */
 	#options;
 
@@ -58,7 +83,7 @@ export class HttpTransport {
 	#path;
 
 	/**
-	 * @type {AsyncLocalStorage<ReadableStreamDefaultController | undefined>}
+	 * @type {AsyncLocalStorage<SubscriptionSink | undefined>}
 	 */
 	#controller_storage = new AsyncLocalStorage();
 
@@ -74,6 +99,15 @@ export class HttpTransport {
 
 	#text_encoder = new TextEncoder();
 
+	/** @type {SubscriptionManager} */
+	#subscription_manager;
+
+	/** @type {Map<string, Map<string | number, SubscriptionSink>>} */
+	#subscription_sinks = new Map();
+	/** @type {WeakMap<Response, { id: string | number, origin: string }>} */
+	#subscription_responses = new WeakMap();
+	#warned_implicit_origin = false;
+
 	/**
 	 *
 	 * @param {McpServer<any, TCustom>} server
@@ -86,7 +120,9 @@ export class HttpTransport {
 			path = '/mcp',
 			oauth,
 			cors,
+			allowedOrigins,
 			disableSse,
+			subscriptionManager: _subscriptionManager,
 			sessionManager: _sessionManager = {
 				streams: new InMemoryStreamSessionManager(),
 				info: new InMemoryInfoSessionManager(),
@@ -103,6 +139,9 @@ export class HttpTransport {
 				_sessionManager.streams ?? new InMemoryStreamSessionManager(),
 			info: _sessionManager.info ?? new InMemoryInfoSessionManager(),
 		};
+		const subscriptionManager = /** @type {SubscriptionManager} */ (
+			_subscriptionManager ?? new InMemorySubscriptionManager()
+		);
 
 		if (options?.path === undefined && DEV) {
 			// TODO: remove on 1.0.0 release
@@ -119,10 +158,12 @@ export class HttpTransport {
 			getSessionId,
 			path,
 			cors,
+			allowedOrigins,
 			sessionManager,
 			disableSse,
 		};
 		this.#path = path;
+		this.#subscription_manager = subscriptionManager;
 
 		this.#server.on('initialize', ({ capabilities, clientInfo }) => {
 			const sessionId = this.#session_id_storage.getStore();
@@ -159,33 +200,186 @@ export class HttpTransport {
 			this.#options.sessionManager.info.setLogLevel(sessionId, level);
 		});
 
-		this.#server.on('broadcast', async ({ request }) => {
-			let sessions = undefined;
-			if (request.method === 'notifications/resources/updated') {
-				sessions =
-					await this.#options.sessionManager.info.getSubscriptions(
-						request.params.uri,
+		this.#server.on(
+			'broadcast',
+			async ({ request, subscriptionOnly: subscription_only }) => {
+				void Promise.resolve(
+					this.#subscription_manager.send(request),
+				).catch(() => {});
+				if (subscription_only) return;
+				let sessions = undefined;
+				if (request.method === 'notifications/resources/updated') {
+					sessions =
+						await this.#options.sessionManager.info.getSubscriptions(
+							request.params.uri,
+						);
+				}
+				await this.#options.sessionManager.streams.send(
+					sessions,
+					'event: message\ndata: ' + JSON.stringify(request) + '\n\n',
+				);
+			},
+		);
+
+		this.#server.on(
+			'send',
+			({ request, subscriptionId, subscriptionOrigin }) => {
+				if (
+					subscriptionId !== undefined &&
+					subscriptionOrigin !== undefined
+				) {
+					const sink = this.#subscription_sinks
+						.get(subscriptionOrigin)
+						?.get(subscriptionId);
+					if (!sink) return;
+					if (
+						request.method ===
+						'notifications/subscriptions/acknowledged'
+					) {
+						sink.subscription?.registration.resolve(true);
+					}
+					if (sink.state !== 'open' || !sink.controller) return;
+					try {
+						sink.controller.enqueue(
+							this.#text_encoder.encode(
+								'event: message\ndata: ' +
+									JSON.stringify(request) +
+									'\n\n',
+							),
+						);
+					} catch {
+						sink.state = 'disconnected';
+						void this.#subscription_manager.close(
+							subscriptionId,
+							subscriptionOrigin,
+							'cancelled',
+						);
+					}
+					return;
+				}
+				// use the current controller if the request has an id (it means it's a request and not a notification)
+				const sink = this.#controller_storage.getStore();
+				if (
+					!sink?.controller ||
+					sink.state !== 'open' ||
+					sink.signal?.aborted
+				)
+					return;
+
+				try {
+					sink.controller.enqueue(
+						this.#text_encoder.encode(
+							'event: message\ndata: ' +
+								JSON.stringify(request) +
+								'\n\n',
+						),
 					);
-			}
-			await this.#options.sessionManager.streams.send(
-				sessions,
-				'event: message\ndata: ' + JSON.stringify(request) + '\n\n',
-			);
-		});
+				} catch {
+					// The response stream may have closed before background work sent.
+				}
+			},
+		);
+	}
 
-		this.#server.on('send', async ({ request }) => {
-			// use the current controller if the request has an id (it means it's a request and not a notification)
-			const controller = this.#controller_storage.getStore();
-			if (!controller) return;
+	/**
+	 * @param {string} origin
+	 * @param {string | number} id
+	 * @param {SubscriptionSink} sink
+	 * @returns {boolean}
+	 */
+	#register_subscription_sink(origin, id, sink) {
+		let sinks = this.#subscription_sinks.get(origin);
+		if (!sinks) {
+			sinks = new Map();
+			this.#subscription_sinks.set(origin, sinks);
+		}
+		if (sinks.has(id)) return false;
+		sinks.set(id, sink);
+		return true;
+	}
 
-			controller.enqueue(
-				this.#text_encoder.encode(
-					'event: message\ndata: ' + JSON.stringify(request) + '\n\n',
-				),
-			);
+	/**
+	 * @param {string} origin
+	 * @param {string | number} id
+	 * @param {SubscriptionSink} sink
+	 */
+	#delete_subscription_sink(origin, id, sink) {
+		const sinks = this.#subscription_sinks.get(origin);
+		if (sinks?.get(id) !== sink) return;
+		sinks.delete(id);
+		if (sinks.size === 0) this.#subscription_sinks.delete(origin);
+	}
+
+	/**
+	 * Cancel a routed subscription after its manager registration attempt has
+	 * completed. This closes a listen that races cancellation without allowing
+	 * a duplicate POST to affect the original sink.
+	 * @param {string | number} id
+	 * @param {string} origin
+	 */
+	async #cancel_subscription(id, origin) {
+		const sink = this.#subscription_sinks.get(origin)?.get(id);
+		if (!sink) return false;
+		sink.state = 'cancelled';
+		const registered = await sink.subscription?.registration.promise;
+		if (!registered) return false;
+		this.#delete_subscription_sink(origin, id, sink);
+		return this.#subscription_manager.close(id, origin, 'cancelled');
+	}
+
+	/** @param {SubscriptionSink} sink */
+	#manager_for_sink(sink) {
+		return /** @type {SubscriptionManager} */ ({
+			create: (subscription, callbacks) => {
+				if (
+					this.#subscription_sinks
+						.get(subscription.origin)
+						?.get(subscription.id) !== sink
+				) {
+					return false;
+				}
+				return this.#subscription_manager.create(subscription, {
+					...callbacks,
+					close: (reason) => {
+						if (
+							reason === 'cancelled' &&
+							sink.state !== 'disconnected'
+						) {
+							sink.state = 'cancelled';
+						}
+						return callbacks.close(reason);
+					},
+				});
+			},
+			send: (notification) =>
+				this.#subscription_manager.send(notification),
+			close: (id, origin, reason) =>
+				this.#subscription_manager.close(id, origin, reason),
+			closeAll: (origin, reason) =>
+				this.#subscription_manager.closeAll(origin, reason),
 		});
 	}
 
+	/** @param {Request} request */
+	#allows_origin(request) {
+		const origin = request.headers.get('origin');
+		if (!origin) return true;
+		if (origin === new URL(request.url).origin) return true;
+		const allowed = this.#options.allowedOrigins;
+		if (allowed === undefined) {
+			if (!this.#warned_implicit_origin) {
+				console.warn(
+					'[tmcp][transport-http] Cross-origin requests are allowed because `allowedOrigins` is not configured. Set it to an explicit origin list, `[]` to reject all cross-origin requests, or `true` to explicitly allow every origin.',
+				);
+				this.#warned_implicit_origin = true;
+			}
+			return true;
+		}
+		if (allowed === true) return true;
+		if (typeof allowed === 'string') return allowed === origin;
+		return Array.isArray(allowed) && allowed.includes(origin);
+	}
+
 	/**
 	 * Applies CORS headers to a response based on the configuration
 	 * @param {Response} response - The response to modify
@@ -273,6 +467,7 @@ export class HttpTransport {
 	 * @param {string} session_id
 	 */
 	async #handle_delete(session_id) {
+		await this.#subscription_manager.closeAll(session_id, 'cancelled');
 		await this.#options.sessionManager.streams.delete(session_id);
 		await this.#options.sessionManager.info.delete(session_id);
 		return new Response(null, {
@@ -283,6 +478,51 @@ export class HttpTransport {
 		});
 	}
 
+	/**
+	 * @param {number} status
+	 * @param {string | number | null} id
+	 * @param {number} code
+	 * @param {string} message
+	 * @param {unknown} [data]
+	 * @param {string} [session_id]
+	 */
+	#json_rpc_error(status, id, code, message, data, session_id) {
+		return new Response(
+			JSON.stringify({
+				jsonrpc: '2.0',
+				id,
+				error: {
+					code,
+					message,
+					...(data === undefined ? {} : { data }),
+				},
+			}),
+			{
+				status,
+				headers: {
+					'Content-Type': 'application/json',
+					...(session_id ? { 'mcp-session-id': session_id } : {}),
+				},
+			},
+		);
+	}
+
+	/**
+	 * @param {string | undefined} session_id
+	 * @param {string} data
+	 * @param {string | number | null} [id]
+	 */
+	#invalid_request(session_id, data, id = null) {
+		return this.#json_rpc_error(
+			400,
+			id,
+			-32600,
+			'Invalid Request',
+			data,
+			session_id,
+		);
+	}
+
 	/**
 	 *
 	 * @param {string} session_id
@@ -306,12 +546,12 @@ export class HttpTransport {
 			return new Response(
 				JSON.stringify({
 					jsonrpc: '2.0',
+					id: null,
 					error: {
 						code: -32000,
 						message:
 							'Conflict: Only one SSE stream is allowed per session',
 					},
-					id: null,
 				}),
 				{
 					headers: {
@@ -340,6 +580,7 @@ export class HttpTransport {
 				'Content-Type': 'text/event-stream',
 				'Cache-Control': 'no-cache',
 				Connection: 'keep-alive',
+				'X-Accel-Buffering': 'no',
 				'mcp-session-id': session_id,
 			},
 			status: 200,
@@ -347,149 +588,448 @@ export class HttpTransport {
 	}
 
 	/**
-	 *
-	 * @param {string} session_id
+	 * @param {Request} request
+	 * @param {unknown} [body]
+	 */
+	#is_per_request(request, body) {
+		const header_version = request.headers.get('mcp-protocol-version');
+		if (
+			header_version !== null &&
+			getPerRequestProtocolVersions().includes(header_version)
+		) {
+			return true;
+		}
+		if (typeof body !== 'object' || body === null || Array.isArray(body)) {
+			return false;
+		}
+		const params = /** @type {Record<string, any>} */ (body).params;
+		const meta = params?._meta;
+		return (
+			typeof meta === 'object' &&
+			meta !== null &&
+			!Array.isArray(meta) &&
+			PER_REQUEST_METADATA_KEYS.some((key) => Object.hasOwn(meta, key))
+		);
+	}
+
+	/**
+	 * @param {Record<string, any>} body
+	 * @param {Request} request
+	 * @param {string | number | null} id
+	 */
+	async #preflight_per_request(body, request, id) {
+		try {
+			validate_request_headers(request.headers, body);
+			const requested_version =
+				body.params?._meta?.['io.modelcontextprotocol/protocolVersion'];
+			const supported = getPerRequestProtocolVersions();
+			if (!supported.includes(requested_version)) {
+				return this.#json_rpc_error(
+					400,
+					id,
+					UNSUPPORTED_PROTOCOL_VERSION,
+					`Unsupported protocol version: ${String(requested_version)}`,
+					{ supported, requested: requested_version },
+				);
+			}
+			if (
+				!isPerRequestMethodAllowed(body.method) ||
+				!this.#server.hasMethod(body.method)
+			) {
+				return this.#json_rpc_error(
+					404,
+					id,
+					-32601,
+					`Method ${body.method} not found`,
+				);
+			}
+			if (
+				body.method === 'tools/call' &&
+				typeof body.params?.name === 'string'
+			) {
+				const args =
+					typeof body.params.arguments === 'object' &&
+					body.params.arguments !== null &&
+					!Array.isArray(body.params.arguments)
+						? body.params.arguments
+						: {};
+				await this.#server.validateToolCall(
+					body.params.name,
+					args,
+					(input_schema, tool_args) =>
+						validate_tool_parameter_headers(
+							request.headers,
+							input_schema,
+							tool_args,
+						),
+				);
+			}
+			return null;
+		} catch (error) {
+			if (error instanceof McpError) {
+				return this.#json_rpc_error(
+					400,
+					id,
+					error.code,
+					error.message,
+					error.data,
+				);
+			}
+			return this.#json_rpc_error(
+				500,
+				id,
+				-32603,
+				/** @type {Error} */ (error).message ?? 'Internal error',
+			);
+		}
+	}
+
+	/**
 	 * @param {Request} request
 	 * @param {AuthInfo | null} auth_info
 	 * @param {TCustom} [ctx]
 	 */
-	async #handle_post(session_id, request, auth_info, ctx) {
-		// Check Content-Type header
+	async #handle_post(request, auth_info, ctx) {
+		const header_is_per_request = this.#is_per_request(request);
 		const content_type = request.headers.get('content-type');
 		if (!content_type || !content_type.includes('application/json')) {
-			return new Response(
-				JSON.stringify({
-					jsonrpc: '2.0',
-					error: {
-						code: -32600,
-						message: 'Invalid Request',
-						data: 'Content-Type must be application/json',
-					},
-				}),
-				{
-					status: 415,
-					headers: {
-						'Content-Type': 'application/json',
-						'mcp-session-id': session_id,
-					},
-				},
+			const session_id = header_is_per_request
+				? undefined
+				: request.headers.get('mcp-session-id') ||
+					this.#options.getSessionId();
+			return this.#json_rpc_error(
+				415,
+				null,
+				-32600,
+				'Invalid Request',
+				'Content-Type must be application/json',
+				session_id,
 			);
 		}
 
+		/** @type {unknown} */
+		let parsed_body;
 		try {
-			const body = await request.clone().json();
-
-			/**
-			 * @type {ReadableStreamDefaultController | undefined}
-			 */
-			let controller;
-
-			// Create a short-lived stream that closes after sending the response
-			const stream = new ReadableStream({
-				start(_controller) {
-					controller = _controller;
-				},
-			});
+			parsed_body = await request.json();
+		} catch (error) {
+			const session_id = header_is_per_request
+				? undefined
+				: request.headers.get('mcp-session-id') ||
+					this.#options.getSessionId();
+			return this.#json_rpc_error(
+				400,
+				null,
+				-32700,
+				'Parse error',
+				/** @type {Error} */ (error).message,
+				session_id,
+			);
+		}
 
-			const session_id_storage = this.#session_id_storage;
+		const per_request = this.#is_per_request(request, parsed_body);
+		const session_id = per_request
+			? undefined
+			: request.headers.get('mcp-session-id') ||
+				this.#options.getSessionId();
+		if (
+			Array.isArray(parsed_body) ||
+			typeof parsed_body !== 'object' ||
+			parsed_body === null
+		) {
+			return this.#invalid_request(
+				session_id,
+				Array.isArray(parsed_body)
+					? 'JSON-RPC batch requests are not supported'
+					: 'Expected a JSON-RPC message object',
+			);
+		}
+		const body = /** @type {Record<string, any>} */ (parsed_body);
+		const valid_id =
+			typeof body.id === 'string' || typeof body.id === 'number';
+		const request_message =
+			body.jsonrpc === '2.0' &&
+			typeof body.method === 'string' &&
+			(body.id === undefined || valid_id);
+		const has_result = Object.hasOwn(body, 'result');
+		const has_error = Object.hasOwn(body, 'error');
+		const response_message =
+			body.jsonrpc === '2.0' && valid_id && has_result !== has_error;
+		if (!request_message && !response_message) {
+			return this.#invalid_request(
+				session_id,
+				'Expected a valid JSON-RPC request, notification, or response',
+				valid_id ? body.id : null,
+			);
+		}
+		if (per_request && response_message) {
+			return this.#invalid_request(
+				undefined,
+				'Per-request clients must not send JSON-RPC responses',
+				body.id,
+			);
+		}
+		if (per_request && request_message) {
+			const preflight = await this.#preflight_per_request(
+				body,
+				request,
+				valid_id ? body.id : null,
+			);
+			if (preflight) return preflight;
+		}
 
-			const messages = Array.isArray(body) ? body : [body];
+		const subscription_id =
+			body.method === 'subscriptions/listen' && valid_id
+				? /** @type {string | number} */ (body.id)
+				: undefined;
+		const subscription_origin =
+			subscription_id !== undefined || session_id === undefined
+				? crypto.randomUUID()
+				: session_id;
+		/** @type {{ id: string | number, registration: SubscriptionRegistration } | undefined} */
+		let subscription;
+		if (subscription_id !== undefined) {
+			/** @type {(registered: boolean) => void} */
+			let resolve = () => {};
+			const promise = /** @type {Promise<boolean>} */ (
+				new Promise((ready) => {
+					resolve = ready;
+				})
+			);
+			subscription = {
+				id: subscription_id,
+				registration: { promise, resolve },
+			};
+		}
+		const abort_controller = new AbortController();
+		/** @type {SubscriptionSink} */
+		const sink = {
+			controller: undefined,
+			state: 'open',
+			signal: abort_controller.signal,
+			subscription,
+		};
+		const manager = this.#subscription_manager;
+		const server_subscription_manager = this.#manager_for_sink(sink);
+		const register_sink = this.#register_subscription_sink.bind(this);
+		const delete_sink = this.#delete_subscription_sink.bind(this);
+		let released = false;
+		const release_sink = () => {
+			if (released) return;
+			released = true;
+			request.signal.removeEventListener('abort', on_request_abort);
+			const current = sink.subscription;
+			if (!current) return;
+			current.registration.resolve(false);
+			delete_sink(subscription_origin, current.id, sink);
+		};
+		/** @type {Promise<void> | undefined} */
+		let disconnecting;
+		/** @param {boolean} close_stream */
+		const disconnect = (close_stream) => {
+			if (disconnecting) return disconnecting;
+			disconnecting = (async () => {
+				sink.state = 'disconnected';
+				abort_controller.abort();
+				if (close_stream) {
+					try {
+						sink.controller?.close();
+					} catch {
+						// The response body may already have been cancelled.
+					}
+				}
+				const current = sink.subscription;
+				if (
+					!current ||
+					this.#subscription_sinks
+						.get(subscription_origin)
+						?.get(current.id) !== sink
+				) {
+					return;
+				}
+				const registered = await current.registration.promise;
+				delete_sink(subscription_origin, current.id, sink);
+				if (registered) {
+					await manager.close(
+						current.id,
+						subscription_origin,
+						'cancelled',
+					);
+				}
+			})();
+			return disconnecting;
+		};
+		const on_request_abort = () => {
+			void disconnect(true);
+		};
+		request.signal.addEventListener('abort', on_request_abort, {
+			once: true,
+		});
 
-			const handle = async () => {
-				const init_message = messages.find(
-					(/** @type {any} */ m) => m.method === 'initialize',
-				);
+		const stream = new ReadableStream({
+			start(controller) {
+				sink.controller = controller;
+				if (subscription_id !== undefined) {
+					register_sink(subscription_origin, subscription_id, sink);
+				}
+			},
+			cancel: () => disconnect(false),
+		});
+		if (request.signal.aborted) void disconnect(true);
 
-				const client_capabilities = init_message
+		const handle = async () => {
+			if (abort_controller.signal.aborted) {
+				release_sink();
+				return;
+			}
+			const init_message =
+				body.method === 'initialize' ? body : undefined;
+			const client_capabilities = session_id
+				? init_message
 					? init_message.params?.capabilities
 					: await this.#options.sessionManager.info
 							.getClientCapabilities(session_id)
-							.catch(() => undefined);
-				const client_info = init_message
+							.catch(() => undefined)
+				: undefined;
+			const client_info = session_id
+				? init_message
 					? init_message.params?.clientInfo
 					: await this.#options.sessionManager.info
 							.getClientInfo(session_id)
-							.catch(() => undefined);
-				const log_level = init_message
+							.catch(() => undefined)
+				: undefined;
+			const log_level = session_id
+				? init_message
 					? undefined
 					: await this.#options.sessionManager.info
 							.getLogLevel(session_id)
-							.catch(() => undefined);
-
-				const response = await this.#controller_storage.run(
-					controller,
-					() =>
-						session_id_storage.run(session_id, () =>
-							this.#server.receive(body, {
-								sessionId: session_id,
-								auth: auth_info ?? undefined,
+							.catch(() => undefined)
+				: undefined;
+			if (abort_controller.signal.aborted) {
+				release_sink();
+				return;
+			}
+
+			const receive = () =>
+				this.#server.receive(/** @type {any} */ (body), {
+					...(session_id ? { sessionId: session_id } : {}),
+					auth: auth_info ?? undefined,
+					...(session_id
+						? {
 								sessionInfo: {
 									clientCapabilities: client_capabilities,
 									clientInfo: client_info,
 									logLevel: log_level,
 								},
-								custom: ctx,
-							}),
-						),
-				);
+							}
+						: {}),
+					custom: ctx,
+					signal: abort_controller.signal,
+					subscriptionOrigin: subscription_origin,
+					subscriptionManager: server_subscription_manager,
+				});
+			const response = await this.#controller_storage.run(sink, () =>
+				session_id
+					? this.#session_id_storage.run(session_id, receive)
+					: receive(),
+			);
 
-				controller?.enqueue(
+			if (
+				sink.state === 'open' &&
+				!abort_controller.signal.aborted &&
+				response != null
+			) {
+				sink.controller?.enqueue(
 					this.#text_encoder.encode(
 						'event: message\ndata: ' +
 							JSON.stringify(response) +
 							'\n\n',
 					),
 				);
-				controller?.close();
-			};
+			}
+			if (sink.state !== 'disconnected') sink.controller?.close();
+			release_sink();
+		};
 
-			handle();
+		void handle().catch((error) => {
+			if (sink.state === 'open') {
+				sink.controller?.error(error);
+			} else if (sink.state === 'cancelled') {
+				try {
+					sink.controller?.close();
+				} catch {
+					// The cancellation may already have closed the stream.
+				}
+			}
+			release_sink();
+		});
 
-			const has_request = messages.some((message) => message.id != null);
+		const has_request = request_message && valid_id;
+		const response = new Response(has_request ? stream : null, {
+			headers: has_request
+				? {
+						'Content-Type': 'text/event-stream',
+						'Cache-Control': 'no-cache',
+						connection: 'keep-alive',
+						'X-Accel-Buffering': 'no',
+						...(session_id ? { 'mcp-session-id': session_id } : {}),
+					}
+				: undefined,
+			status: has_request ? 200 : 202,
+		});
+		if (subscription_id !== undefined) {
+			this.#subscription_responses.set(response, {
+				id: subscription_id,
+				origin: subscription_origin,
+			});
+		}
+		return response;
+	}
 
-			// Determine status code based on response type
-			// 202 Accepted for notifications/responses, 200 OK for standard requests
-			const status = !has_request ? 202 : 200;
+	/**
+	 * Gracefully complete one active per-request subscription.
+	 * @param {Response} response
+	 * @returns {Promise<boolean>}
+	 */
+	async closeSubscription(response) {
+		const subscription = this.#subscription_responses.get(response);
+		if (!subscription) return false;
+		this.#subscription_responses.delete(response);
+		const sink = this.#subscription_sinks
+			.get(subscription.origin)
+			?.get(subscription.id);
+		if (!sink) return false;
+		const registered = await sink.subscription?.registration.promise;
+		if (!registered) return false;
+		return this.#subscription_manager.close(
+			subscription.id,
+			subscription.origin,
+			'closed',
+		);
+	}
 
-			return new Response(has_request ? stream : null, {
-				headers: has_request
-					? {
-							'Content-Type': 'text/event-stream',
-							'Cache-Control': 'no-cache',
-							connection: 'keep-alive',
-							'mcp-session-id': session_id,
-						}
-					: undefined,
-				status,
-			});
-		} catch (error) {
-			// Handle JSON parsing errors
-			return new Response(
-				JSON.stringify({
-					jsonrpc: '2.0',
-					error: {
-						code: -32700,
-						message: 'Parse error',
-						data: /** @type {Error} */ (error).message,
-					},
-				}),
-				{
-					status: 400,
-					headers: {
-						'Content-Type': 'application/json',
-						'mcp-session-id': session_id,
-					},
-				},
-			);
+	/**
+	 * Close every active per-request subscription owned by this transport.
+	 */
+	async close() {
+		/** @type {Array<[string | number, string]>} */
+		const owned = [];
+		for (const [origin, sinks] of this.#subscription_sinks) {
+			for (const id of sinks.keys()) {
+				owned.push([id, origin]);
+			}
 		}
+		await Promise.all(
+			owned.map(([id, origin]) => this.#cancel_subscription(id, origin)),
+		);
 	}
 
 	/**
 	 *
 	 * @param {string} method
+	 * @param {string} [allow]
 	 * @returns
 	 */
-	#handle_default(method) {
+	#handle_default(method, allow = 'GET, POST, DELETE, OPTIONS') {
 		return new Response(
 			JSON.stringify({
 				jsonrpc: '2.0',
@@ -503,7 +1043,7 @@ export class HttpTransport {
 				status: 405,
 				headers: {
 					'Content-Type': 'application/json',
-					Allow: 'GET, POST, DELETE, OPTIONS',
+					Allow: allow,
 				},
 			},
 		);
@@ -517,6 +1057,10 @@ export class HttpTransport {
 	 */
 	async respond(request, ctx) {
 		const url = new URL(request.url);
+		const path_matches = this.#path === null || url.pathname === this.#path;
+		if (path_matches && !this.#allows_origin(request)) {
+			return new Response('Forbidden origin', { status: 403 });
+		}
 
 		/**
 		 * @type {AuthInfo | null}
@@ -546,14 +1090,15 @@ export class HttpTransport {
 		}
 
 		// Check if the request path matches the configured MCP path
-		if (url.pathname !== this.#path && this.#path !== null) {
+		if (!path_matches) {
 			return null;
 		}
 
 		const method = request.method;
-		const session_id =
-			request.headers.get('mcp-session-id') ||
-			this.#options.getSessionId();
+		const per_request_http_method =
+			getPerRequestProtocolVersions().includes(
+				request.headers.get('mcp-protocol-version') ?? '',
+			);
 
 		/**
 		 * @type {Response | null}
@@ -571,20 +1116,25 @@ export class HttpTransport {
 		}
 		// Handle DELETE request - disconnect session
 		else if (method === 'DELETE') {
-			response = await this.#handle_delete(session_id);
+			response = per_request_http_method
+				? this.#handle_default(method, 'POST, OPTIONS')
+				: await this.#handle_delete(
+						request.headers.get('mcp-session-id') ||
+							this.#options.getSessionId(),
+					);
 		}
 		// Handle GET request - establish long-lived connection for notifications
 		else if (method === 'GET') {
-			response = await this.#handle_get(session_id);
+			response = per_request_http_method
+				? this.#handle_default(method, 'POST, OPTIONS')
+				: await this.#handle_get(
+						request.headers.get('mcp-session-id') ||
+							this.#options.getSessionId(),
+					);
 		}
 		// Handle POST request - process message and respond through event stream
 		else if (method === 'POST') {
-			response = await this.#handle_post(
-				session_id,
-				request,
-				auth_info,
-				ctx,
-			);
+			response = await this.#handle_post(request, auth_info, ctx);
 		}
 		// Method not supported
 		else {