@zuplo/cli 7.8.6 → 7.8.7

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

@@ -1,6 +1,6 @@
 const require_chunk = require('./chunk-Bnu9O96Y.cjs');
-const require_mcp = require('./mcp-D7GmuPnv.cjs');
-const require_src = require('./src-STyD_Vvf.cjs');
+const require_mcp = require('./mcp-DUcCQSTW.cjs');
+const require_src = require('./src-CgFsfg3E.cjs');
 let _modelcontextprotocol_server__shims = require("@modelcontextprotocol/server/_shims");
 let _modelcontextprotocol_core_internal = require("@modelcontextprotocol/core/internal");
 
@@ -248,6 +248,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
 /**
@@ -320,6 +373,8 @@ var WebStandardStreamableHTTPServerTransport = class {
 	_retryInterval;
 	_supportedProtocolVersions;
 	_keepAliveMs;
+	_maxRequestBodySize;
+	_scopeChallengeResolver;
 	sessionId;
 	onclose;
 	onerror;
@@ -336,6 +391,7 @@ var WebStandardStreamableHTTPServerTransport = class {
 		this._retryInterval = options.retryInterval;
 		this._supportedProtocolVersions = options.supportedProtocolVersions ?? _modelcontextprotocol_core_internal.SUPPORTED_PROTOCOL_VERSIONS;
 		this._keepAliveMs = options.keepAliveMs ?? require_mcp.DEFAULT_SSE_KEEP_ALIVE_MS;
+		this._maxRequestBodySize = resolveMaxRequestBodySize(options.maxRequestBodySize);
 	}
 	startKeepAlive(controller, encoder) {
 		if (this._closed) return void 0;
@@ -348,6 +404,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.
@@ -384,6 +444,11 @@ var WebStandardStreamableHTTPServerTransport = class {
 			}
 		});
 	}
+	async _checkScopeChallenge(messages, authInfo) {
+		if (!this._scopeChallengeResolver) return;
+		const challenge = await require_mcp.findScopeChallenge(messages.filter((message) => require_src.isJSONRPCRequest(message)), authInfo, this._scopeChallengeResolver);
+		return challenge === void 0 ? void 0 : require_mcp.createScopeChallengeResponse(challenge, require_mcp.scopeChallengeResourceMetadataUrl(authInfo));
+	}
 	/**
 	* Validates request headers for DNS rebinding protection.
 	* @returns Error response if validation fails, `undefined` if validation passes.
@@ -641,12 +706,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) => _modelcontextprotocol_core_internal.JSONRPCMessageSchema.parse(msg)) : [_modelcontextprotocol_core_internal.JSONRPCMessageSchema.parse(rawMessage)];
@@ -676,6 +751,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) => require_src.isJSONRPCRequest(element))) {
 				for (const message of messages) this.onmessage?.(message, {
 					authInfo: options?.authInfo,
@@ -965,7 +1048,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 {
@@ -976,7 +1059,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 = () => {
@@ -1033,8 +1117,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
@@ -1047,7 +1149,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;
@@ -1058,7 +1160,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" };
 			}
@@ -1078,9 +1182,7 @@ async function classifyEntryRequest(request, providedParsedBody, needsForward =
 		step: "classified",
 		outcome: require_src.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,
@@ -1148,7 +1250,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
@@ -1156,8 +1259,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";
 }
 /**
@@ -1206,6 +1310,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();
@@ -1224,7 +1329,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 || !require_src.SUPPORTED_MODERN_PROTOCOL_VERSIONS.includes(claimedRevision)) {
@@ -1237,8 +1342,7 @@ function createMcpHandler(factory, options = {}) {
 		}
 		const stdHeaderRejection = require_src.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}`));
@@ -1285,6 +1389,17 @@ function createMcpHandler(factory, options = {}) {
 				}
 			}
 		}
+		if (route.messageKind === "request" && product instanceof require_mcp.McpServer) try {
+			const challenge = await require_mcp.findScopeChallenge([route.message], authInfo, (context) => product.resolveScopeChallenge(context));
+			if (challenge !== void 0) {
+				product.close().catch(reportError);
+				return require_mcp.createScopeChallengeResponse(challenge, require_mcp.scopeChallengeResourceMetadataUrl(authInfo));
+			}
+		} catch (error) {
+			product.close().catch(reportError);
+			reportError(toError(error));
+			return internalServerErrorResponse(route.message.id);
+		}
 		require_src.setNegotiatedProtocolVersion(server, claimedRevision);
 		require_mcp.installModernOnlyHandlers(server, require_src.SUPPORTED_MODERN_PROTOCOL_VERSIONS);
 		if (meta !== void 0) require_mcp.seedClientIdentityFromEnvelope(server, {
@@ -1331,8 +1446,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");
@@ -1374,115 +1490,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 require_src.OAuthError(require_src.OAuthErrorCode.InvalidToken, "Missing Authorization header");
-	const [type, token] = authorizationHeader.split(" ");
-	if (type?.toLowerCase() !== "bearer" || !token) throw new require_src.OAuthError(require_src.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 require_src.OAuthError(require_src.OAuthErrorCode.InsufficientScope, "Insufficient scope");
-	}
-	if (typeof authInfo.expiresAt !== "number" || Number.isNaN(authInfo.expiresAt)) throw new require_src.OAuthError(require_src.OAuthErrorCode.InvalidToken, "Token has no expiration time");
-	else if (authInfo.expiresAt < Date.now() / 1e3) throw new require_src.OAuthError(require_src.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 require_src.OAuthError)) {
-		const serverError = new require_src.OAuthError(require_src.OAuthErrorCode.ServerError, "Internal Server Error");
-		return Response.json(serverError.toResponseObject(), { status: 500 });
-	}
-	switch (error.code) {
-		case require_src.OAuthErrorCode.InvalidToken: {
-			const challenge = buildWwwAuthenticateHeader(error.code, error.message, requiredScopes, resourceMetadataUrl);
-			return Response.json(error.toResponseObject(), {
-				status: 401,
-				headers: { "WWW-Authenticate": challenge }
-			});
-		}
-		case require_src.OAuthErrorCode.InsufficientScope: {
-			const challenge = buildWwwAuthenticateHeader(error.code, error.message, requiredScopes, resourceMetadataUrl);
-			return Response.json(error.toResponseObject(), {
-				status: 403,
-				headers: { "WWW-Authenticate": challenge }
-			});
-		}
-		case require_src.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
 /**
@@ -1553,120 +1560,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 require_src.OAuthError(require_src.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
 /**
@@ -1886,6 +1779,7 @@ Object.defineProperty(exports, 'CLIENT_INFO_META_KEY', {
     return _modelcontextprotocol_core_internal.CLIENT_INFO_META_KEY;
   }
 });
+exports.DEFAULT_MAX_REQUEST_BODY_SIZE = DEFAULT_MAX_REQUEST_BODY_SIZE;
 Object.defineProperty(exports, 'DEFAULT_NEGOTIATED_PROTOCOL_VERSION', {
   enumerable: true,
   get: function () {
@@ -2008,8 +1902,8 @@ exports.WebStandardStreamableHTTPServerTransport = WebStandardStreamableHTTPServ
 exports.acceptedContent = require_src.acceptedContent;
 exports.assertCompleteRequestPrompt = require_src.assertCompleteRequestPrompt;
 exports.assertCompleteRequestResourceTemplate = require_src.assertCompleteRequestResourceTemplate;
-exports.bearerAuthChallengeResponse = bearerAuthChallengeResponse;
-exports.buildOAuthProtectedResourceMetadata = buildOAuthProtectedResourceMetadata;
+exports.bearerAuthChallengeResponse = require_mcp.bearerAuthChallengeResponse;
+exports.buildOAuthProtectedResourceMetadata = require_mcp.buildOAuthProtectedResourceMetadata;
 exports.checkResourceAllowed = require_src.checkResourceAllowed;
 exports.classifyInboundRequest = require_src.classifyInboundRequest;
 exports.completable = require_mcp.completable;
@@ -2019,7 +1913,7 @@ exports.createRequestStateCodec = createRequestStateCodec;
 exports.deserializeMessage = require_src.deserializeMessage;
 exports.fromJsonSchema = fromJsonSchema;
 exports.getDisplayName = require_src.getDisplayName;
-exports.getOAuthProtectedResourceMetadataUrl = getOAuthProtectedResourceMetadataUrl;
+exports.getOAuthProtectedResourceMetadataUrl = require_mcp.getOAuthProtectedResourceMetadataUrl;
 exports.hostHeaderValidationResponse = hostHeaderValidationResponse;
 exports.inputRequired = require_src.inputRequired;
 exports.inputResponse = require_src.inputResponse;
@@ -2041,15 +1935,17 @@ exports.legacyStatelessFallback = legacyStatelessFallback;
 exports.localhostAllowedHostnames = localhostAllowedHostnames;
 exports.localhostAllowedOrigins = localhostAllowedOrigins;
 exports.mergeCapabilities = require_src.mergeCapabilities;
-exports.oauthMetadataResponse = oauthMetadataResponse;
+exports.oauthMetadataResponse = require_mcp.oauthMetadataResponse;
 exports.originValidationResponse = originValidationResponse;
 exports.parseJSONRPCMessage = require_src.parseJSONRPCMessage;
 exports.preloadSchemas = require_src.preloadSchemas;
-exports.requireBearerAuth = requireBearerAuth;
+exports.readRequestBody = readRequestBody;
+exports.requireBearerAuth = require_mcp.requireBearerAuth;
+exports.requireScopes = require_mcp.requireScopes;
 exports.resourceUrlFromServerUrl = require_src.resourceUrlFromServerUrl;
 exports.serializeMessage = require_src.serializeMessage;
 exports.specTypeSchemas = require_src.specTypeSchemas;
 exports.validateHostHeader = validateHostHeader;
 exports.validateOriginHeader = validateOriginHeader;
-exports.verifyBearerToken = verifyBearerToken;
+exports.verifyBearerToken = require_mcp.verifyBearerToken;
 //# sourceMappingURL=index.cjs.map