@zuplo/cli 7.8.6 → 7.8.8

package/node_modules/@modelcontextprotocol/server/dist/index.mjs

@@ -1,5 +1,5 @@
-import { a as seedClientIdentityFromEnvelope, d as createServerNotifier, f as DEFAULT_SSE_KEEP_ALIVE_MS, h as isCompletable, i as installModernOnlyHandlers, l as createListenRouter, m as completable, n as ResourceTemplate, o as serverIdentityOf, p as armSseKeepAlive, r as Server, s as DEFAULT_MAX_SUBSCRIPTIONS, t as McpServer, u as InMemoryServerEventBus } from "./mcp-DXXb3Vv3.mjs";
-import { $ as isTaskAugmentedRequestParams, At as LATEST_PROTOCOL_VERSION, B as scanXMcpHeaderDeclarations, Bt as TRACESTATE_META_KEY, Ct as CLIENT_CAPABILITIES_META_KEY, D as acceptedContent, Dt as INVALID_PARAMS, Et as INTERNAL_ERROR, Ft as RELATED_TASK_META_KEY, G as isInitializeRequest, Gt as resourceUrlFromServerUrl, H as assertCompleteRequestPrompt, I as classifyInboundRequest, It as SERVER_INFO_META_KEY, J as isJSONRPCErrorResponse, Jt as SdkHttpError, K as isInitializedNotification, Kt as SdkError, L as httpStatusForErrorCode, Lt as SUBSCRIPTION_ID_META_KEY, Mt as METHOD_NOT_FOUND, Nt as PARSE_ERROR, O as inputRequired, Ot as INVALID_REQUEST, P as LADDER_ERROR_HTTP_STATUS, Pt as PROTOCOL_VERSION_META_KEY, Q as isJSONRPCResultResponse, R as modernOnlyStrictRejection, Rt as SUPPORTED_PROTOCOL_VERSIONS, S as specTypeSchemas, St as BAGGAGE_META_KEY, Tt as DEFAULT_NEGOTIATED_PROTOCOL_VERSION, U as assertCompleteRequestResourceTemplate, Ut as requiredClientCapabilitiesForRequest, V as validateMcpParamHeaders, Vt as missingClientCapabilities, W as isCallToolResult, Wt as checkResourceAllowed, X as isJSONRPCRequest, Xt as OAuthErrorCode, Y as isJSONRPCNotification, Yt as OAuthError, Z as isJSONRPCResponse, _ as mergeCapabilities, a as UriTemplate, at as requestMetaOf, c as ReadBuffer, d as serializeMessage, dt as ResourceNotFoundError, et as parseJSONRPCMessage, f as getDisplayName, ft as UnsupportedProtocolVersionError, g as Protocol, h as DEFAULT_REQUEST_TIMEOUT_MSEC, i as InMemoryTransport, jt as LOG_LEVEL_META_KEY, k as inputResponse, kt as JSONRPC_VERSION, l as STDIO_DEFAULT_MAX_BUFFER_SIZE, lt as MissingRequiredClientCapabilityError, m as mediaTypeEssence, mt as ProtocolErrorCode, n as preloadSchemas, o as createFetchWithInit, p as isJsonContentType, pt as UrlElicitationRequiredError, q as isInputRequiredResult, qt as SdkErrorCode, t as fromJsonSchema$1, tt as JSONRPCMessageSchema, u as deserializeMessage, ut as ProtocolError, vt as SUPPORTED_MODERN_PROTOCOL_VERSIONS, wt as CLIENT_INFO_META_KEY, x as isSpecType, y as setNegotiatedProtocolVersion, z as validateStandardRequestHeaders, zt as TRACEPARENT_META_KEY } from "./src-CX2iR2pK.mjs";
+import { C as armSseKeepAlive, S as DEFAULT_SSE_KEEP_ALIVE_MS, T as isCompletable, _ as DEFAULT_MAX_SUBSCRIPTIONS, a as seedClientIdentityFromEnvelope, b as InMemoryServerEventBus, c as findScopeChallenge, d as buildOAuthProtectedResourceMetadata, f as getOAuthProtectedResourceMetadataUrl, g as verifyBearerToken, h as requireBearerAuth, i as installModernOnlyHandlers, l as requireScopes, m as bearerAuthChallengeResponse, n as ResourceTemplate, o as serverIdentityOf, p as oauthMetadataResponse, r as Server, s as createScopeChallengeResponse, t as McpServer, u as scopeChallengeResourceMetadataUrl, w as completable, x as createServerNotifier, y as createListenRouter } from "./mcp-Dw2OlZ1f.mjs";
+import { $ as isTaskAugmentedRequestParams, At as LATEST_PROTOCOL_VERSION, B as scanXMcpHeaderDeclarations, Bt as TRACESTATE_META_KEY, Ct as CLIENT_CAPABILITIES_META_KEY, D as acceptedContent, Dt as INVALID_PARAMS, Et as INTERNAL_ERROR, Ft as RELATED_TASK_META_KEY, G as isInitializeRequest, Gt as resourceUrlFromServerUrl, H as assertCompleteRequestPrompt, I as classifyInboundRequest, It as SERVER_INFO_META_KEY, J as isJSONRPCErrorResponse, Jt as SdkHttpError, K as isInitializedNotification, Kt as SdkError, L as httpStatusForErrorCode, Lt as SUBSCRIPTION_ID_META_KEY, Mt as METHOD_NOT_FOUND, Nt as PARSE_ERROR, O as inputRequired, Ot as INVALID_REQUEST, P as LADDER_ERROR_HTTP_STATUS, Pt as PROTOCOL_VERSION_META_KEY, Q as isJSONRPCResultResponse, R as modernOnlyStrictRejection, Rt as SUPPORTED_PROTOCOL_VERSIONS, S as specTypeSchemas, St as BAGGAGE_META_KEY, Tt as DEFAULT_NEGOTIATED_PROTOCOL_VERSION, U as assertCompleteRequestResourceTemplate, Ut as requiredClientCapabilitiesForRequest, V as validateMcpParamHeaders, Vt as missingClientCapabilities, W as isCallToolResult, Wt as checkResourceAllowed, X as isJSONRPCRequest, Xt as OAuthErrorCode, Y as isJSONRPCNotification, Yt as OAuthError, Z as isJSONRPCResponse, _ as mergeCapabilities, a as UriTemplate, at as requestMetaOf, c as ReadBuffer, d as serializeMessage, dt as ResourceNotFoundError, et as parseJSONRPCMessage, f as getDisplayName, ft as UnsupportedProtocolVersionError, g as Protocol, h as DEFAULT_REQUEST_TIMEOUT_MSEC, i as InMemoryTransport, jt as LOG_LEVEL_META_KEY, k as inputResponse, kt as JSONRPC_VERSION, l as STDIO_DEFAULT_MAX_BUFFER_SIZE, lt as MissingRequiredClientCapabilityError, m as mediaTypeEssence, mt as ProtocolErrorCode, n as preloadSchemas, o as createFetchWithInit, p as isJsonContentType, pt as UrlElicitationRequiredError, q as isInputRequiredResult, qt as SdkErrorCode, t as fromJsonSchema$1, tt as JSONRPCMessageSchema, u as deserializeMessage, ut as ProtocolError, vt as SUPPORTED_MODERN_PROTOCOL_VERSIONS, wt as CLIENT_INFO_META_KEY, x as isSpecType, y as setNegotiatedProtocolVersion, z as validateStandardRequestHeaders, zt as TRACEPARENT_META_KEY } from "./src-D-y6h4N7.mjs";
 import { DefaultJsonSchemaValidator } from "@modelcontextprotocol/server/_shims";
 
 //#region src/server/perRequestTransport.ts
@@ -246,6 +246,59 @@ async function invoke(server, message, ctx) {
 	});
 }
 
+//#endregion
+//#region src/server/requestBody.ts
+/** Default upper bound, in bytes, on a request body read by the HTTP entry points (4 MiB). */
+const DEFAULT_MAX_REQUEST_BODY_SIZE = 4 * 1024 * 1024;
+/** Upper bound on the number of messages accepted in one JSON-RPC batch array. */
+const MAX_BATCH_SIZE = 100;
+/** The message answered with 413 for a request body over `maxBytes`. */
+function requestBodyTooLargeMessage(maxBytes) {
+	return `Payload Too Large: Request body must not exceed ${maxBytes} bytes`;
+}
+/**
+* Resolves a `maxRequestBodySize` option to the bound to apply: the default when
+* omitted, otherwise the value itself, which must be a positive finite number of
+* bytes (a `RangeError` is thrown at configuration time for anything else).
+*/
+function resolveMaxRequestBodySize(value) {
+	if (value === void 0) return DEFAULT_MAX_REQUEST_BODY_SIZE;
+	if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) throw new RangeError(`maxRequestBodySize must be a positive number of bytes, got ${String(value)}`);
+	return value;
+}
+/**
+* Reads a request body as text, up to `maxBytes` (default
+* {@linkcode DEFAULT_MAX_REQUEST_BODY_SIZE}). A declared `Content-Length` over the
+* limit is refused without reading anything; otherwise the read stops as soon as
+* more than the limit has arrived. Stream failures propagate.
+*/
+async function readRequestBody(request, maxBytes = DEFAULT_MAX_REQUEST_BODY_SIZE) {
+	if (Number(request.headers.get("content-length")) > maxBytes) return { tooLarge: true };
+	if (request.body === null) return {
+		tooLarge: false,
+		text: ""
+	};
+	const reader = request.body.getReader();
+	const decoder = new TextDecoder();
+	let received = 0;
+	let text = "";
+	try {
+		for (;;) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			received += value.byteLength;
+			if (received > maxBytes) return { tooLarge: true };
+			text += decoder.decode(value, { stream: true });
+		}
+	} finally {
+		reader.releaseLock();
+	}
+	return {
+		tooLarge: false,
+		text: text + decoder.decode()
+	};
+}
+
 //#endregion
 //#region src/server/streamableHttp.ts
 /**
@@ -318,6 +371,8 @@ var WebStandardStreamableHTTPServerTransport = class {
 	_retryInterval;
 	_supportedProtocolVersions;
 	_keepAliveMs;
+	_maxRequestBodySize;
+	_scopeChallengeResolver;
 	sessionId;
 	onclose;
 	onerror;
@@ -334,6 +389,7 @@ var WebStandardStreamableHTTPServerTransport = class {
 		this._retryInterval = options.retryInterval;
 		this._supportedProtocolVersions = options.supportedProtocolVersions ?? SUPPORTED_PROTOCOL_VERSIONS;
 		this._keepAliveMs = options.keepAliveMs ?? DEFAULT_SSE_KEEP_ALIVE_MS;
+		this._maxRequestBodySize = resolveMaxRequestBodySize(options.maxRequestBodySize);
 	}
 	startKeepAlive(controller, encoder) {
 		if (this._closed) return void 0;
@@ -346,6 +402,10 @@ var WebStandardStreamableHTTPServerTransport = class {
 		});
 		return timer;
 	}
+	/** Sets the scope challenge resolver for parsed JSON-RPC requests. */
+	setScopeChallengeResolver(resolver) {
+		this._scopeChallengeResolver = resolver;
+	}
 	/**
 	* 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.
@@ -382,6 +442,11 @@ var WebStandardStreamableHTTPServerTransport = class {
 			}
 		});
 	}
+	async _checkScopeChallenge(messages, authInfo) {
+		if (!this._scopeChallengeResolver) return;
+		const challenge = await findScopeChallenge(messages.filter((message) => isJSONRPCRequest(message)), authInfo, this._scopeChallengeResolver);
+		return challenge === void 0 ? void 0 : createScopeChallengeResponse(challenge, scopeChallengeResourceMetadataUrl(authInfo));
+	}
 	/**
 	* Validates request headers for DNS rebinding protection.
 	* @returns Error response if validation fails, `undefined` if validation passes.
@@ -639,12 +704,22 @@ var WebStandardStreamableHTTPServerTransport = class {
 			const request = req;
 			let rawMessage;
 			if (options?.parsedBody === void 0) try {
-				rawMessage = await req.json();
+				const body = await readRequestBody(req, this._maxRequestBodySize);
+				if (body.tooLarge) {
+					const message = requestBodyTooLargeMessage(this._maxRequestBodySize);
+					this.onerror?.(new Error(message));
+					return this.createJsonErrorResponse(413, -32e3, message);
+				}
+				rawMessage = JSON.parse(body.text);
 			} catch (error) {
 				this.onerror?.(error);
 				return this.createJsonErrorResponse(400, -32700, "Parse error: Invalid JSON");
 			}
 			else rawMessage = options.parsedBody;
+			if (Array.isArray(rawMessage) && rawMessage.length > MAX_BATCH_SIZE) {
+				this.onerror?.(/* @__PURE__ */ new Error(`Invalid Request: Batch must not exceed ${MAX_BATCH_SIZE} messages`));
+				return this.createJsonErrorResponse(400, -32600, `Invalid Request: Batch must not exceed ${MAX_BATCH_SIZE} messages`);
+			}
 			let messages;
 			try {
 				messages = Array.isArray(rawMessage) ? rawMessage.map((msg) => JSONRPCMessageSchema.parse(msg)) : [JSONRPCMessageSchema.parse(rawMessage)];
@@ -674,6 +749,14 @@ var WebStandardStreamableHTTPServerTransport = class {
 				if (protocolError) return protocolError;
 			}
 			if (this._closed) return this.createJsonErrorResponse(404, -32001, "Session not found");
+			let scopeChallengeResponse;
+			try {
+				scopeChallengeResponse = await this._checkScopeChallenge(messages, options?.authInfo);
+			} catch (error) {
+				this.onerror?.(error);
+				return this.createJsonErrorResponse(500, -32603, "Internal server error");
+			}
+			if (scopeChallengeResponse) return scopeChallengeResponse;
 			if (!messages.some((element) => isJSONRPCRequest(element))) {
 				for (const message of messages) this.onmessage?.(message, {
 					authInfo: options?.authInfo,
@@ -963,7 +1046,7 @@ function internalServerErrorResponse(id = null) {
 * The entry passes its own `onerror` here when expanding the default, so
 * legacy-leg failures are never silently swallowed.
 */
-function createLegacyStatelessFallback(factory, onerror, keepAliveMs) {
+function createLegacyStatelessFallback(factory, onerror, keepAliveMs, maxRequestBodySize) {
 	return async (request, options) => {
 		if (request.method.toUpperCase() !== "POST") return jsonRpcErrorResponse(405, -32e3, "Method not allowed.");
 		try {
@@ -974,7 +1057,8 @@ function createLegacyStatelessFallback(factory, onerror, keepAliveMs) {
 			});
 			const transport = new WebStandardStreamableHTTPServerTransport({
 				sessionIdGenerator: void 0,
-				...keepAliveMs !== void 0 && { keepAliveMs }
+				...keepAliveMs !== void 0 && { keepAliveMs },
+				...maxRequestBodySize !== void 0 && { maxRequestBodySize }
 			});
 			await product.connect(transport);
 			const teardown = () => {
@@ -1031,8 +1115,26 @@ function createLegacyStatelessFallback(factory, onerror, keepAliveMs) {
 		}
 	};
 }
-function legacyStatelessFallback(factory, onerror) {
-	return createLegacyStatelessFallback(factory, onerror);
+function legacyStatelessFallback(factory, onerror, options) {
+	return createLegacyStatelessFallback(factory, onerror, void 0, resolveMaxRequestBodySize(options?.maxRequestBodySize));
+}
+/**
+* Read the SEP-2243 standard request headers off the inbound request.
+*
+* Both halves of the standard-header story need them — the body-primary
+* classifier for its cross-check cells, and
+* {@linkcode validateStandardRequestHeaders} for the presence half — and a
+* header read at one site but not the other is precisely how a required header
+* goes unenforced: that divergence is what let a modern POST omitting
+* `MCP-Protocol-Version` be served. Read them here once so a header added to
+* {@linkcode InboundHttpRequest} reaches both sites together.
+*/
+function standardHeadersOf(request) {
+	return {
+		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
+	};
 }
 /**
 * The entry's classification step: read the request body exactly once (unless
@@ -1045,7 +1147,7 @@ function legacyStatelessFallback(factory, onerror) {
 * the body-preserving clone is then skipped and `forwardRequest` is the
 * (consumed) input request.
 */
-async function classifyEntryRequest(request, providedParsedBody, needsForward = true) {
+async function classifyEntryRequest(request, providedParsedBody, needsForward = true, maxRequestBodySize = DEFAULT_MAX_REQUEST_BODY_SIZE) {
 	const httpMethod = request.method.toUpperCase();
 	let body;
 	let parsedBody = providedParsedBody;
@@ -1056,7 +1158,9 @@ async function classifyEntryRequest(request, providedParsedBody, needsForward =
 			if (needsForward) forwardRequest = request.clone();
 			let bodyText;
 			try {
-				bodyText = await request.text();
+				const read = await readRequestBody(request, maxRequestBodySize);
+				if (read.tooLarge) return { step: "body-too-large" };
+				bodyText = read.text;
 			} catch {
 				return { step: "unreadable-body" };
 			}
@@ -1076,9 +1180,7 @@ async function classifyEntryRequest(request, providedParsedBody, needsForward =
 		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,
+			...standardHeadersOf(request),
 			...body !== void 0 && { body }
 		}),
 		body,
@@ -1146,7 +1248,8 @@ async function classifyEntryRequest(request, providedParsedBody, needsForward =
 *   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
+*   envelope (`-32602`), header/body mismatches (`-32020`), and a POST body
+*   over the size limit (413). 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
@@ -1154,8 +1257,9 @@ async function classifyEntryRequest(request, providedParsedBody, needsForward =
 *   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);
+async function isLegacyRequest(request, parsedBody, options) {
+	const maxRequestBodySize = resolveMaxRequestBodySize(options?.maxRequestBodySize);
+	const classified = await classifyEntryRequest(parsedBody === void 0 && request.method.toUpperCase() === "POST" ? request.clone() : request, parsedBody, false, maxRequestBodySize);
 	return classified.step === "no-json-body" || classified.step === "classified" && classified.outcome.kind === "legacy";
 }
 /**
@@ -1204,6 +1308,7 @@ async function isLegacyRequest(request, parsedBody) {
 */
 function createMcpHandler(factory, options = {}) {
 	const { legacy, onerror, responseMode } = options;
+	const maxRequestBodySize = resolveMaxRequestBodySize(options.maxRequestBodySize);
 	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();
@@ -1222,7 +1327,7 @@ function createMcpHandler(factory, options = {}) {
 		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 : createLegacyStatelessFallback(factory, reportError, options.keepAliveMs);
+	const legacyHandler = legacy === "reject" ? void 0 : createLegacyStatelessFallback(factory, reportError, options.keepAliveMs, maxRequestBodySize);
 	async function serveModern(route, request, authInfo) {
 		const claimedRevision = route.classification.revision;
 		if (claimedRevision === void 0 || !SUPPORTED_MODERN_PROTOCOL_VERSIONS.includes(claimedRevision)) {
@@ -1235,8 +1340,7 @@ function createMcpHandler(factory, options = {}) {
 		}
 		const stdHeaderRejection = validateStandardRequestHeaders({
 			httpMethod: request.method,
-			mcpMethodHeader: request.headers.get("mcp-method") ?? void 0,
-			mcpNameHeader: request.headers.get("mcp-name") ?? void 0
+			...standardHeadersOf(request)
 		}, route);
 		if (stdHeaderRejection !== void 0) {
 			reportError(/* @__PURE__ */ new Error(`Rejected inbound request (${stdHeaderRejection.cell}): ${stdHeaderRejection.message}`));
@@ -1283,6 +1387,17 @@ function createMcpHandler(factory, options = {}) {
 				}
 			}
 		}
+		if (route.messageKind === "request" && product instanceof McpServer) try {
+			const challenge = await findScopeChallenge([route.message], authInfo, (context) => product.resolveScopeChallenge(context));
+			if (challenge !== void 0) {
+				product.close().catch(reportError);
+				return createScopeChallengeResponse(challenge, scopeChallengeResourceMetadataUrl(authInfo));
+			}
+		} catch (error) {
+			product.close().catch(reportError);
+			reportError(toError(error));
+			return internalServerErrorResponse(route.message.id);
+		}
 		setNegotiatedProtocolVersion(server, claimedRevision);
 		installModernOnlyHandlers(server, SUPPORTED_MODERN_PROTOCOL_VERSIONS);
 		if (meta !== void 0) seedClientIdentityFromEnvelope(server, {
@@ -1329,8 +1444,9 @@ function createMcpHandler(factory, options = {}) {
 			reportError(/* @__PURE__ */ new Error("Unsupported Media Type: Content-Type must be application/json"));
 			return jsonRpcErrorResponse(415, -32e3, "Unsupported Media Type: Content-Type must be application/json");
 		}
-		const classified = await classifyEntryRequest(request, requestOptions?.parsedBody);
+		const classified = await classifyEntryRequest(request, requestOptions?.parsedBody, true, maxRequestBodySize);
 		if (classified.step === "unreadable-body") return jsonRpcErrorResponse(400, -32700, "Parse error: the request body could not be read");
+		if (classified.step === "body-too-large") return jsonRpcErrorResponse(413, -32e3, requestBodyTooLargeMessage(maxRequestBodySize));
 		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");
@@ -1372,115 +1488,6 @@ function createMcpHandler(factory, options = {}) {
 	};
 }
 
-//#endregion
-//#region src/server/middleware/bearerAuth.ts
-function headerQuotedValue(value) {
-	return value.replaceAll(/[\\"]/g, String.raw`\$&`).replaceAll(/[^\u0020-\u007E]/g, " ");
-}
-function buildWwwAuthenticateHeader(errorCode, description, requiredScopes, resourceMetadataUrl) {
-	let header = `Bearer error="${headerQuotedValue(errorCode)}", error_description="${headerQuotedValue(description)}"`;
-	if (requiredScopes.length > 0) header += `, scope="${requiredScopes.join(" ")}"`;
-	if (resourceMetadataUrl) header += `, resource_metadata="${resourceMetadataUrl}"`;
-	return header;
-}
-/**
-* Validate a raw `Authorization` header value as a Bearer token and return
-* the verified {@link AuthInfo}.
-*
-* The runtime-neutral core of Bearer authentication: it parses the header,
-* runs the verifier, enforces `requiredScopes`, and rejects tokens without an
-* expiration or past it. On any failure it throws an {@link OAuthError} —
-* pass that to {@link bearerAuthChallengeResponse} for the matching HTTP
-* answer, or use {@link requireBearerAuth} to get both steps as one call.
-*
-* Framework adapters build on this: `requireBearerAuth` from
-* `@modelcontextprotocol/express` feeds it `req.headers.authorization`.
-*/
-async function verifyBearerToken(authorizationHeader, options) {
-	const { verifier, requiredScopes = [] } = options;
-	if (!authorizationHeader) throw new OAuthError(OAuthErrorCode.InvalidToken, "Missing Authorization header");
-	const [type, token] = authorizationHeader.split(" ");
-	if (type?.toLowerCase() !== "bearer" || !token) throw new OAuthError(OAuthErrorCode.InvalidToken, "Invalid Authorization header format, expected 'Bearer TOKEN'");
-	const authInfo = await verifier.verifyAccessToken(token);
-	if (requiredScopes.length > 0) {
-		if (!requiredScopes.every((scope) => authInfo.scopes.includes(scope))) throw new OAuthError(OAuthErrorCode.InsufficientScope, "Insufficient scope");
-	}
-	if (typeof authInfo.expiresAt !== "number" || Number.isNaN(authInfo.expiresAt)) throw new OAuthError(OAuthErrorCode.InvalidToken, "Token has no expiration time");
-	else if (authInfo.expiresAt < Date.now() / 1e3) throw new OAuthError(OAuthErrorCode.InvalidToken, "Token has expired");
-	return authInfo;
-}
-/**
-* Build the HTTP answer for a Bearer authentication failure.
-*
-* Maps an {@link OAuthError} to its status — `401` for `invalid_token` and
-* `403` for `insufficient_scope` (both carrying the `WWW-Authenticate: Bearer …`
-* challenge, with `resource_metadata` when configured so clients can discover
-* the Authorization Server), `500` for `server_error`, `400` for anything
-* else. A non-`OAuthError` value answers `500 server_error`. The body is the
-* OAuth error JSON.
-*/
-function bearerAuthChallengeResponse(error, options) {
-	const { requiredScopes = [], resourceMetadataUrl } = options ?? {};
-	if (!(error instanceof OAuthError)) {
-		const serverError = new OAuthError(OAuthErrorCode.ServerError, "Internal Server Error");
-		return Response.json(serverError.toResponseObject(), { status: 500 });
-	}
-	switch (error.code) {
-		case OAuthErrorCode.InvalidToken: {
-			const challenge = buildWwwAuthenticateHeader(error.code, error.message, requiredScopes, resourceMetadataUrl);
-			return Response.json(error.toResponseObject(), {
-				status: 401,
-				headers: { "WWW-Authenticate": challenge }
-			});
-		}
-		case OAuthErrorCode.InsufficientScope: {
-			const challenge = buildWwwAuthenticateHeader(error.code, error.message, requiredScopes, resourceMetadataUrl);
-			return Response.json(error.toResponseObject(), {
-				status: 403,
-				headers: { "WWW-Authenticate": challenge }
-			});
-		}
-		case OAuthErrorCode.ServerError: return Response.json(error.toResponseObject(), { status: 500 });
-		default: return Response.json(error.toResponseObject(), { status: 400 });
-	}
-}
-/**
-* Require a valid Bearer token on web-standard requests.
-*
-* The framework-free counterpart of `requireBearerAuth` from
-* `@modelcontextprotocol/express`, for hosts whose HTTP surface is a
-* `fetch(request)` handler — Cloudflare Workers, Deno, Bun, Hono. The
-* returned gate resolves to the verified {@link AuthInfo}, or to the
-* ready-to-return challenge `Response` when the request must be refused.
-*
-* @example
-* ```ts source="./bearerAuth.examples.ts#requireBearerAuth_fetchGate"
-* const gate = requireBearerAuth({ verifier, requiredScopes: ['mcp'] });
-*
-* async function fetchHandler(request: Request): Promise<Response> {
-*     const auth: AuthInfo | Response = await gate(request);
-*     if (auth instanceof Response) return auth;
-*     return handler.fetch(request, { authInfo: auth });
-* }
-* ```
-*/
-function requireBearerAuth(options) {
-	const { verifier, requiredScopes = [], resourceMetadataUrl } = options;
-	const resolved = {
-		verifier,
-		requiredScopes,
-		resourceMetadataUrl
-	};
-	return async (request) => {
-		const [authorizationHeader] = (request.headers.get("authorization") ?? "").split(",");
-		try {
-			return await verifyBearerToken(authorizationHeader || void 0, resolved);
-		} catch (error) {
-			return bearerAuthChallengeResponse(error, resolved);
-		}
-	};
-}
-
 //#endregion
 //#region src/server/middleware/hostHeaderValidation.ts
 /**
@@ -1551,120 +1558,6 @@ function hostHeaderValidationResponse(req, allowedHostnames) {
 	});
 }
 
-//#endregion
-//#region src/server/middleware/oauthMetadata.ts
-function checkIssuerUrl(issuer, allowInsecure) {
-	if (issuer.protocol !== "https:" && issuer.hostname !== "localhost" && issuer.hostname !== "127.0.0.1" && !allowInsecure) throw new Error("Issuer URL must be HTTPS");
-	if (issuer.hash) throw new Error(`Issuer URL must not have a fragment: ${issuer}`);
-	if (issuer.search) throw new Error(`Issuer URL must not have a query string: ${issuer}`);
-}
-/**
-* Derive the RFC 9728 Protected Resource Metadata document from
-* {@link AuthMetadataOptions}, validating the Authorization Server issuer URL
-* (HTTPS required outside localhost) in the process.
-*
-* `oauthMetadataResponse` and the Express `mcpAuthMetadataRouter` both build
-* on this; use it directly when serving the document through your own
-* routing — or call it once at startup to fail fast on a misconfigured
-* issuer before any request arrives.
-*/
-function buildOAuthProtectedResourceMetadata(options) {
-	checkIssuerUrl(new URL(options.oauthMetadata.issuer), options.dangerouslyAllowInsecureIssuerUrl);
-	return {
-		resource: options.resourceServerUrl.href,
-		authorization_servers: [options.oauthMetadata.issuer],
-		scopes_supported: options.scopesSupported,
-		resource_name: options.resourceName,
-		resource_documentation: options.serviceDocumentationUrl?.href
-	};
-}
-/**
-* Builds the RFC 9728 Protected Resource Metadata URL for a given MCP server
-* URL by inserting `/.well-known/oauth-protected-resource` ahead of the path.
-*
-* @example
-* ```ts
-* getOAuthProtectedResourceMetadataUrl(new URL('https://api.example.com/mcp'))
-* // → 'https://api.example.com/.well-known/oauth-protected-resource/mcp'
-* ```
-*/
-function getOAuthProtectedResourceMetadataUrl(serverUrl) {
-	return new URL(protectedResourceMetadataPath(serverUrl), serverUrl).href;
-}
-/** The RFC 9728 path-aware well-known path for a resource URL. */
-function protectedResourceMetadataPath(resourceServerUrl) {
-	const rsPath = stripTrailingSlash(resourceServerUrl.pathname);
-	return `/.well-known/oauth-protected-resource${rsPath === "/" ? "" : rsPath}`;
-}
-function stripTrailingSlash(path) {
-	return path.length > 1 && path.endsWith("/") ? path.slice(0, -1) : path;
-}
-const ALLOWED_METHODS = "GET, HEAD, OPTIONS";
-function metadataDocumentResponse(request, metadata) {
-	if (request.method === "OPTIONS") {
-		const requestedHeaders = request.headers.get("access-control-request-headers");
-		return new Response(null, {
-			status: 204,
-			headers: {
-				"Access-Control-Allow-Origin": "*",
-				"Access-Control-Allow-Methods": ALLOWED_METHODS,
-				...requestedHeaders === null ? {} : {
-					"Access-Control-Allow-Headers": requestedHeaders,
-					Vary: "Access-Control-Request-Headers"
-				}
-			}
-		});
-	}
-	if (request.method !== "GET" && request.method !== "HEAD") {
-		const error = new OAuthError(OAuthErrorCode.MethodNotAllowed, `The method ${request.method} is not allowed for this endpoint`);
-		return Response.json(error.toResponseObject(), {
-			status: 405,
-			headers: {
-				Allow: ALLOWED_METHODS,
-				"Access-Control-Allow-Origin": "*"
-			}
-		});
-	}
-	const response = Response.json(metadata, { headers: { "Access-Control-Allow-Origin": "*" } });
-	return request.method === "HEAD" ? new Response(null, {
-		status: response.status,
-		headers: response.headers
-	}) : response;
-}
-/**
-* Serve the two OAuth discovery documents an MCP server acting as a Resource
-* Server exposes, from a web-standard `fetch(request)` handler:
-*
-*  - `/.well-known/oauth-protected-resource[/<path>]` — RFC 9728 Protected
-*    Resource Metadata, derived from the supplied options (path-aware: the
-*    resource URL's path is reflected in the route).
-*  - `/.well-known/oauth-authorization-server` — RFC 8414 Authorization
-*    Server Metadata, passed through verbatim.
-*
-* Returns the matched document `Response` (JSON with permissive CORS, `405`
-* with an `Allow` header for non-GET methods, `204` for CORS preflight), or
-* `undefined` when the request path is neither well-known route — fall
-* through to your own routing. The framework-free counterpart of
-* `mcpAuthMetadataRouter` from `@modelcontextprotocol/express`; pair it with
-* `requireBearerAuth` and `getOAuthProtectedResourceMetadataUrl` so
-* unauthenticated clients can discover the AS from the `401` challenge.
-*
-* @example
-* ```ts source="./oauthMetadata.examples.ts#oauthMetadataResponse_fetchHandler"
-* async function fetchHandler(request: Request): Promise<Response> {
-*     return oauthMetadataResponse(request, options) ?? serveMcp(request);
-* }
-* ```
-*/
-function oauthMetadataResponse(request, options) {
-	const requestPath = stripTrailingSlash(new URL(request.url).pathname);
-	if (requestPath === protectedResourceMetadataPath(options.resourceServerUrl)) return metadataDocumentResponse(request, buildOAuthProtectedResourceMetadata(options));
-	if (requestPath === "/.well-known/oauth-authorization-server") {
-		buildOAuthProtectedResourceMetadata(options);
-		return metadataDocumentResponse(request, options.oauthMetadata);
-	}
-}
-
 //#endregion
 //#region src/server/middleware/originValidation.ts
 /**
@@ -1866,5 +1759,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, 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, Protocol, ProtocolError, ProtocolErrorCode, RELATED_TASK_META_KEY, ReadBuffer, ResourceNotFoundError, ResourceTemplate, SERVER_INFO_META_KEY, 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, bearerAuthChallengeResponse, buildOAuthProtectedResourceMetadata, checkResourceAllowed, classifyInboundRequest, completable, createFetchWithInit, createMcpHandler, createRequestStateCodec, deserializeMessage, fromJsonSchema, getDisplayName, getOAuthProtectedResourceMetadataUrl, hostHeaderValidationResponse, inputRequired, inputResponse, isCallToolResult, isCompletable, isInitializeRequest, isInitializedNotification, isInputRequiredResult, isJSONRPCErrorResponse, isJSONRPCNotification, isJSONRPCRequest, isJSONRPCResponse, isJSONRPCResultResponse, isJsonContentType, isLegacyRequest, isSpecType, isTaskAugmentedRequestParams, legacyStatelessFallback, localhostAllowedHostnames, localhostAllowedOrigins, mergeCapabilities, oauthMetadataResponse, originValidationResponse, parseJSONRPCMessage, preloadSchemas, requireBearerAuth, resourceUrlFromServerUrl, serializeMessage, specTypeSchemas, validateHostHeader, validateOriginHeader, verifyBearerToken };
+export { BAGGAGE_META_KEY, CLIENT_CAPABILITIES_META_KEY, CLIENT_INFO_META_KEY, DEFAULT_MAX_REQUEST_BODY_SIZE, 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, Protocol, ProtocolError, ProtocolErrorCode, RELATED_TASK_META_KEY, ReadBuffer, ResourceNotFoundError, ResourceTemplate, SERVER_INFO_META_KEY, 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, bearerAuthChallengeResponse, buildOAuthProtectedResourceMetadata, checkResourceAllowed, classifyInboundRequest, completable, createFetchWithInit, createMcpHandler, createRequestStateCodec, deserializeMessage, fromJsonSchema, getDisplayName, getOAuthProtectedResourceMetadataUrl, hostHeaderValidationResponse, inputRequired, inputResponse, isCallToolResult, isCompletable, isInitializeRequest, isInitializedNotification, isInputRequiredResult, isJSONRPCErrorResponse, isJSONRPCNotification, isJSONRPCRequest, isJSONRPCResponse, isJSONRPCResultResponse, isJsonContentType, isLegacyRequest, isSpecType, isTaskAugmentedRequestParams, legacyStatelessFallback, localhostAllowedHostnames, localhostAllowedOrigins, mergeCapabilities, oauthMetadataResponse, originValidationResponse, parseJSONRPCMessage, preloadSchemas, readRequestBody, requireBearerAuth, requireScopes, resourceUrlFromServerUrl, serializeMessage, specTypeSchemas, validateHostHeader, validateOriginHeader, verifyBearerToken };
 //# sourceMappingURL=index.mjs.map