@fruggr/zendesk-mcp-server 3.3.0 → 3.4.0

package/dist/THIRD-PARTY-NOTICES.md

@@ -30,9 +30,9 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 ```
 
-## @modelcontextprotocol/core@2.2.0
+## @modelcontextprotocol/core@2.3.1
 
-License: MIT
+License: Apache-2.0
 
 ```
 The MCP project is undergoing a licensing transition from the MIT License to the Apache License, Version 2.0 ("Apache-2.0"). All new code and specification contributions to the project are licensed under Apache-2.0. Documentation contributions (excluding specifications) are licensed under CC-BY-4.0.
@@ -253,9 +253,9 @@ CC-BY-4.0. See https://creativecommons.org/licenses/by/4.0/legalcode for
 the full license text.
 ```
 
-## @modelcontextprotocol/node@2.1.0
+## @modelcontextprotocol/node@2.1.1
 
-License: MIT
+License: Apache-2.0
 
 ```
 The MCP project is undergoing a licensing transition from the MIT License to the Apache License, Version 2.0 ("Apache-2.0"). All new code and specification contributions to the project are licensed under Apache-2.0. Documentation contributions (excluding specifications) are licensed under CC-BY-4.0.
@@ -476,9 +476,9 @@ CC-BY-4.0. See https://creativecommons.org/licenses/by/4.0/legalcode for
 the full license text.
 ```
 
-## @modelcontextprotocol/server@2.2.0
+## @modelcontextprotocol/server@2.3.1
 
-License: MIT
+License: Apache-2.0
 
 ```
 The MCP project is undergoing a licensing transition from the MIT License to the Apache License, Version 2.0 ("Apache-2.0"). All new code and specification contributions to the project are licensed under Apache-2.0. Documentation contributions (excluding specifications) are licensed under CC-BY-4.0.
@@ -2629,7 +2629,7 @@ TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 ```
 
-## mdast-util-find-and-replace@3.0.2
+## mdast-util-find-and-replace@3.0.3
 
 License: MIT
 
@@ -5198,7 +5198,7 @@ The above copyright notice and this permission notice shall be included in all c
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 ```
 
-## zod@4.6.5
+## zod@4.6.6
 
 License: MIT
 

package/dist/{http-GIKJdf05.js → http-DU1dSrPe.js}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import { _ as __toESM, a as zendeskGet, d as createStartupError, f as errnoCode, g as __require, h as __exportAll, i as WebStandardStreamableHTTPServerTransport, l as getOAuthUrls, m as __commonJSMin, o as REQUEST_TIMEOUT_MS, r as silentLogger, s as deadlineSignal, t as createMcpServer, u as STARTUP_DOCS } from "./index.js";
-import { d as escapeHtml, l as requestedScope, n as configDir, o as generateCodeChallenge, s as generateCodeVerifier, u as supportedScopes } from "./token-persistence-BeetFqPF.js";
+import { C as __exportAll, S as __commonJSMin, T as __toESM, _ as OAuthErrorCode, a as silentLogger, b as errnoCode, c as deadlineSignal, d as DEFAULT_MAX_REQUEST_BODY_SIZE, f as WebStandardStreamableHTTPServerTransport, g as OAuthError, h as verifyBearerToken, m as isLegacyRequest, n as defaultServerFactory, o as zendeskGet, p as createMcpHandler, r as createRequestStateCodec, s as REQUEST_TIMEOUT_MS, t as createServerCaches, u as getOAuthUrls, v as STARTUP_DOCS, w as __require, y as createStartupError } from "./index.js";
+import { d as escapeHtml, l as requestedScope, n as configDir, o as generateCodeChallenge, s as generateCodeVerifier, u as supportedScopes } from "./token-persistence-r0v9RO3q.js";
 import * as util$1 from "node:util";
 import { format, inspect } from "node:util";
 import * as crypto$2 from "node:crypto";
@@ -16,7 +16,7 @@ import { AsyncLocalStorage } from "node:async_hooks";
 import { accessSync, chmodSync, constants, mkdirSync, readFileSync, renameSync, statSync, writeFileSync } from "node:fs";
 import { Http2ServerRequest, constants as constants$1 } from "http2";
 import crypto$1 from "crypto";
-//#region node_modules/.pnpm/@hono+node-server@1.19.17_hono@4.13.12/node_modules/@hono/node-server/dist/index.mjs
+//#region node_modules/.pnpm/@hono+node-server@1.19.17_hono@4.13.13/node_modules/@hono/node-server/dist/index.mjs
 var RequestError = class extends Error {
 	constructor(message, options) {
 		super(message, options);
@@ -504,7 +504,7 @@ var getRequestListener = (fetchCallback, options = {}) => {
 	};
 };
 //#endregion
-//#region node_modules/.pnpm/@modelcontextprotocol+node@2.1.0_@modelcontextprotocol+server@2.2.0_hono@4.13.12/node_modules/@modelcontextprotocol/node/dist/index.mjs
+//#region node_modules/.pnpm/@modelcontextprotocol+node@2.1.1_@modelcontextprotocol+server@2.3.1/node_modules/@modelcontextprotocol/node/dist/index.mjs
 /**
 * Server transport for Streamable HTTP: this implements the MCP Streamable HTTP transport specification.
 * It supports both SSE streaming and direct HTTP responses.
@@ -543,8 +543,12 @@ var getRequestListener = (fetchCallback, options = {}) => {
 *
 * @example Using with a pre-parsed request body (e.g. Express)
 * ```ts source="./streamableHttp.examples.ts#NodeStreamableHTTPServerTransport_express"
-* app.post('/mcp', (req, res) => {
-*     transport.handleRequest(req, res, req.body);
+* app.post('/mcp', async (req, res) => {
+*     // Stateless example: create a server and a transport per request.
+*     const server = new McpServer({ name: 'my-server', version: '1.0.0' });
+*     const transport = new NodeStreamableHTTPServerTransport({ sessionIdGenerator: undefined });
+*     await server.connect(transport);
+*     await transport.handleRequest(req, res, req.body);
 * });
 * ```
 */
@@ -663,6 +667,185 @@ var NodeStreamableHTTPServerTransport = class {
 		this._webStandardTransport.closeStandaloneSSEStream();
 	}
 };
+/**
+* The rejection {@linkcode toWebRequest} produces for a body over the size
+* limit, recognisable by `name` and `status` without matching message text.
+*/
+var RequestBodyTooLargeError = class extends Error {
+	status = 413;
+	constructor(maxBytes) {
+		super(`Payload Too Large: Request body must not exceed ${maxBytes} bytes`);
+		this.name = "RequestBodyTooLargeError";
+	}
+};
+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;
+}
+/**
+* Adapts a web-standard MCP handler (`handler.fetch`) to a Node.js
+* `(req, res, parsedBody?)` request handler. The returned function converts the
+* Node request to a web-standard `Request`, calls `handler.fetch`, then writes
+* the `Response` back to `res` (honoring write backpressure for streamed SSE
+* responses).
+*
+* `req.auth` is forwarded as the handler's pass-through `authInfo`. A function
+* third argument (Express's `next`) is ignored, never treated as a body.
+*
+* Pass `{ onerror }` to observe the adapter-level error fallback (request
+* conversion / `handler.fetch` throw) before the `500` response is written.
+*/
+function toNodeHandler(handler, opts) {
+	const maxRequestBodySize = resolveMaxRequestBodySize(opts?.maxRequestBodySize);
+	return async (req, res, parsedBody) => {
+		if (typeof parsedBody === "function") parsedBody = void 0;
+		let finished = false;
+		const abort = new AbortController();
+		res.on("close", () => {
+			if (!finished) abort.abort();
+		});
+		if (res.destroyed === true) abort.abort();
+		let response;
+		try {
+			const request = await toWebRequest(req, parsedBody, {
+				signal: abort.signal,
+				maxRequestBodySize
+			});
+			response = await handler.fetch(request, {
+				...req.auth !== void 0 && { authInfo: req.auth },
+				...parsedBody !== void 0 && { parsedBody }
+			});
+		} catch (error) {
+			if (error instanceof RequestBodyTooLargeError) response = Response.json({
+				jsonrpc: "2.0",
+				error: {
+					code: -32e3,
+					message: error.message
+				},
+				id: null
+			}, {
+				status: 413,
+				headers: { connection: "close" }
+			});
+			else {
+				try {
+					opts?.onerror?.(error instanceof Error ? error : new Error(String(error)));
+				} catch {}
+				response = internalServerErrorResponse(echoableRequestId(parsedBody));
+			}
+		}
+		const headers = {};
+		for (const [name, value] of response.headers) headers[name] = value;
+		res.writeHead(response.status, headers);
+		if (response.body === null) {
+			finished = true;
+			res.end();
+			return;
+		}
+		let drainResolve;
+		const releaseDrainWait = () => {
+			drainResolve?.();
+			drainResolve = void 0;
+		};
+		res.on("drain", releaseDrainWait);
+		const closed = new Promise((resolve) => {
+			abort.signal.addEventListener("abort", () => resolve(), { once: true });
+		});
+		try {
+			for await (const chunk of response.body) {
+				if (abort.signal.aborted) break;
+				if (res.write(chunk) === false) await Promise.race([new Promise((resolve) => {
+					drainResolve = resolve;
+				}), closed]);
+			}
+		} catch {}
+		finished = true;
+		res.end();
+	};
+}
+function singleHeaderValue(value) {
+	return Array.isArray(value) ? value[0] : value;
+}
+/**
+* Convert a Node.js `IncomingMessage` (duck-typed — an Express `req` works) to
+* the web-standard `Request` that `handler.fetch()` and `isLegacyRequest()`
+* take. This is the conversion {@linkcode toNodeHandler} performs internally,
+* exported for hand-wired compositions:
+*
+* ```ts
+* const probe = await toWebRequest(req, req.body);
+* await ((await isLegacyRequest(probe)) ? legacy(req, res) : modern(req, res, req.body));
+* ```
+*
+* With no `parsedBody` the Node stream is read to completion (up to
+* `maxRequestBodySize`, 4 MiB by default — a longer body rejects with an error
+* carrying `name: 'RequestBodyTooLargeError'` and `status: 413`) — read the
+* body from the returned `Request` afterwards, not from `req`. When a body
+* parser already consumed the stream (`express.json()`), pass the parsed value
+* as `parsedBody` and nothing is read from `req`.
+*/
+async function toWebRequest(req, parsedBody, options) {
+	const maxRequestBodySize = resolveMaxRequestBodySize(options?.maxRequestBodySize);
+	const method = (req.method ?? "GET").toUpperCase();
+	const url = `http://${singleHeaderValue(req.headers["host"]) ?? singleHeaderValue(req.headers[":authority"]) ?? "localhost"}${req.url ?? "/"}`;
+	const headers = new Headers();
+	for (const [name, value] of Object.entries(req.headers)) {
+		if (value === void 0 || name.startsWith(":")) continue;
+		if (Array.isArray(value)) for (const item of value) headers.append(name, item);
+		else headers.set(name, value);
+	}
+	let body;
+	if (method !== "GET" && method !== "HEAD") if (parsedBody === void 0) {
+		if (Number(singleHeaderValue(req.headers["content-length"])) > maxRequestBodySize) throw new RequestBodyTooLargeError(maxRequestBodySize);
+		const decoder = new TextDecoder();
+		let collected = "";
+		let received = 0;
+		for await (const chunk of req) {
+			received += typeof chunk === "string" ? new TextEncoder().encode(chunk).byteLength : chunk.byteLength;
+			if (received > maxRequestBodySize) throw new RequestBodyTooLargeError(maxRequestBodySize);
+			collected += typeof chunk === "string" ? chunk : decoder.decode(chunk, { stream: true });
+		}
+		collected += decoder.decode();
+		if (collected.length > 0) body = collected;
+	} else {
+		const serialized = JSON.stringify(parsedBody);
+		headers.delete("content-encoding");
+		headers.delete("transfer-encoding");
+		if (serialized === void 0) headers.delete("content-length");
+		else {
+			body = serialized;
+			headers.set("content-length", String(new TextEncoder().encode(serialized).byteLength));
+		}
+	}
+	return new Request(url, {
+		method,
+		headers,
+		...options?.signal !== void 0 && { signal: options.signal },
+		...body !== void 0 && { body }
+	});
+}
+/**
+* The JSON-RPC id to echo on an adapter-built error response: the body's `id`
+* when the body is a single JSON-RPC request whose id is a string or number,
+* `null` otherwise.
+*/
+function echoableRequestId(body) {
+	if (body === null || typeof body !== "object" || Array.isArray(body)) return null;
+	const { method, id } = body;
+	if (typeof method !== "string") return null;
+	return typeof id === "string" || typeof id === "number" ? id : null;
+}
+function internalServerErrorResponse(id) {
+	return Response.json({
+		jsonrpc: "2.0",
+		error: {
+			code: -32603,
+			message: "Internal server error"
+		},
+		id
+	}, { status: 500 });
+}
 //#endregion
 //#region node_modules/.pnpm/jose@6.2.12/node_modules/jose/dist/webapi/lib/buffer_utils.js
 const encoder$1 = new TextEncoder();
@@ -2820,7 +3003,8 @@ const deriveKeySet = (master) => {
 			kid: kidFor(master, "at-rest"),
 			key: createSecretKey(derive(master, "at-rest"))
 		},
-		cookieKey: derive(master, "cookie").toString("base64url")
+		cookieKey: derive(master, "cookie").toString("base64url"),
+		requestState: derive(master, "request-state")
 	};
 };
 const deriveKeyRing = (raw) => {
@@ -36178,16 +36362,16 @@ const resolveMasterSecret = (input, logger = silentLogger) => {
 //#endregion
 //#region src/auth/server/authorization-server.ts
 const decoder = new TextDecoder();
-const asVerified = (claims, issuer, resource) => {
-	const audiences = Array.isArray(claims.aud) ? claims.aud : [claims.aud];
-	if (!(claims.iss === issuer && audiences.includes(resource) && typeof claims.exp === "number" && claims.exp * 1e3 > Date.now() && typeof claims.zd === "string" && typeof claims.gid === "string")) return void 0;
+const asVerified = (claims, issuer) => {
+	if (!(claims.iss === issuer && typeof claims.exp === "number" && typeof claims.zd === "string" && typeof claims.gid === "string")) return void 0;
 	return {
 		zendeskAccessToken: claims.zd,
 		grantId: claims.gid,
 		clientId: String(claims.client_id),
 		subject: String(claims.sub),
 		canWrite: typeof claims.scope === "string" && claims.scope.split(" ").includes("write"),
-		expiresAt: claims.exp
+		expiresAt: claims.exp,
+		resource: typeof claims.aud === "string" ? claims.aud : void 0
 	};
 };
 const createAuthorizationServer = (options) => {
@@ -36252,11 +36436,12 @@ const createAuthorizationServer = (options) => {
 		const keySet = ring.find((set) => set.accessToken.kid === kid);
 		if (!keySet) return void 0;
 		const { plaintext } = await compactDecrypt(bearer, keySet.accessToken.key);
-		return asVerified(JSON.parse(decoder.decode(plaintext)), issuer, resource);
+		return asVerified(JSON.parse(decoder.decode(plaintext)), issuer);
 	};
 	return {
 		issuer,
 		resource,
+		requestStateKey: ring[0].requestState,
 		protectedResourceMetadata: {
 			resource,
 			authorization_servers: [issuer],
@@ -36322,6 +36507,47 @@ const prepareAuthorizationServer = async (config, logger = silentLogger) => {
 	});
 };
 //#endregion
+//#region src/utils/grant-registry.ts
+const createGrantRegistry = ({ idleTimeoutMs, now = Date.now, onCloseError = () => void 0 }) => {
+	const slots = /* @__PURE__ */ new Map();
+	const drop = async (grantId, slot) => {
+		slots.delete(grantId);
+		try {
+			await slot.entry.close();
+		} catch (error) {
+			onCloseError(grantId, error);
+		}
+	};
+	return {
+		acquire: (grantId, subject, create) => {
+			const existing = slots.get(grantId);
+			if (existing && existing.subject !== subject) return void 0;
+			const slot = existing ?? {
+				subject,
+				entry: create(),
+				lastActivityAt: now()
+			};
+			slot.lastActivityAt = now();
+			slots.set(grantId, slot);
+			return slot.entry;
+		},
+		close: async (grantId, entry) => {
+			const slot = slots.get(grantId);
+			if (slot && (entry === void 0 || slot.entry === entry)) await drop(grantId, slot);
+		},
+		sweep: async () => {
+			const cutoff = now() - idleTimeoutMs;
+			for (const [grantId, slot] of [...slots]) if (slots.get(grantId) === slot && slot.lastActivityAt <= cutoff) await drop(grantId, slot);
+		},
+		closeAll: async () => {
+			await Promise.all([...slots].map(([grantId, slot]) => drop(grantId, slot)));
+		},
+		get size() {
+			return slots.size;
+		}
+	};
+};
+//#endregion
 //#region src/transports/http.ts
 const WILDCARD_HOSTS = /* @__PURE__ */ new Set([
 	"0.0.0.0",
@@ -36340,7 +36566,7 @@ const DEFAULT_BROWSER_MCP_CLIENT_ORIGINS = [
 	"https://grok.com"
 ];
 const CORS_ALLOWED_METHODS = "GET, POST, DELETE, OPTIONS";
-const CORS_ALLOWED_HEADERS = "Authorization, Content-Type, Accept, mcp-session-id, mcp-protocol-version, last-event-id";
+const CORS_ALLOWED_HEADERS = "Authorization, Content-Type, Accept, mcp-session-id, mcp-protocol-version, last-event-id, mcp-method, mcp-name";
 const CORS_EXPOSE_HEADERS = "mcp-session-id";
 const CORS_MAX_AGE = "600";
 const LOCALHOST_HOSTNAMES = /* @__PURE__ */ new Set([
@@ -36414,11 +36640,36 @@ const resolvePublicUrl = (config, logger = silentLogger) => {
 	return `http://${config.host}:${config.port}`;
 };
 const MISSING_BEARER_MESSAGE = "Missing or invalid access token. Sign in through this server: its OAuth authorization server is named in the protected resource metadata.";
-const extractBearer = (request) => {
+const SPACES = / +/;
+/**
+* The access token on this request, or `undefined` when it must be refused.
+* The SDK parses the header and checks the audience against our `/mcp`
+* resource (`expectedResource`) and the expiry; decrypting and every other
+* claim stay with the authorization server.
+*/
+const authenticate = async (request, as) => {
 	const header = request.headers["authorization"];
-	if (typeof header !== "string") return void 0;
-	if (!header.toLowerCase().startsWith("bearer ")) return void 0;
-	return header.slice(7).trim();
+	const verifier = { verifyAccessToken: async (bearer) => {
+		const token = await as.verifyAccessToken(bearer);
+		if (!token) throw new OAuthError(OAuthErrorCode.InvalidToken, "Invalid access token");
+		return {
+			token: bearer,
+			clientId: token.clientId,
+			scopes: [],
+			expiresAt: token.expiresAt,
+			...token.resource && URL.canParse(token.resource) && { resource: new URL(token.resource) },
+			extra: { verified: token }
+		};
+	} };
+	try {
+		const normalized = typeof header === "string" ? header.replace(SPACES, " ") : void 0;
+		return (await verifyBearerToken(normalized, {
+			verifier,
+			expectedResource: new URL(as.resource)
+		})).extra?.["verified"];
+	} catch {
+		return;
+	}
 };
 const PROTECTED_RESOURCE_PATHS = ["/.well-known/oauth-protected-resource/mcp", "/.well-known/oauth-protected-resource"];
 const sendJson = (res, status, body) => {
@@ -36451,6 +36702,8 @@ const sendUnauthorized = (res, issuer) => {
 	const wwwAuthenticate = `Bearer resource_metadata="${issuer}${PROTECTED_RESOURCE_PATHS[0]}", error="invalid_token", error_description="${MISSING_BEARER_MESSAGE}"`;
 	sendJsonRpcError(res, 401, -32e3, MISSING_BEARER_MESSAGE, { "WWW-Authenticate": wwwAuthenticate });
 };
+const asNodeRequest = (req) => req;
+const isListenRequest = (body) => typeof body === "object" && body !== null && body.method === "subscriptions/listen";
 const MAX_BODY_BYTES = 4194304;
 const readJsonBody = (req, maxBodyBytes) => new Promise((resolve) => {
 	const chunks = [];
@@ -36521,22 +36774,26 @@ const startHttpTransport = async (config, logger = silentLogger, options = {}) =
 	const sessions = /* @__PURE__ */ new Map();
 	const idleTimeoutMs = options.sessionIdleTimeoutMs ?? SESSION_IDLE_TIMEOUT_MS;
 	const maxBodyBytes = options.maxBodyBytes ?? 4194304;
-	const dispatchToSession = async (req, res, sessionId, token) => {
+	const serverFactory = options.serverFactory ?? defaultServerFactory;
+	const grants = createGrantRegistry({
+		idleTimeoutMs,
+		onCloseError: (grantId, err) => logger.warn("grant_close_failed", {
+			grantId,
+			error: err instanceof Error ? err.message : String(err)
+		})
+	});
+	const effectiveConfig = (token) => !config.readOnly && token.canWrite ? config : {
+		...config,
+		readOnly: true
+	};
+	const dispatchToSession = async (req, res, sessionId, token, body) => {
 		const session = sessions.get(sessionId);
 		if (!session || session.subject !== token.subject) return false;
 		if (session.canWrite && !token.canWrite) return false;
 		session.auth.zendeskToken = token.zendeskAccessToken;
 		session.auth.grantId = token.grantId;
 		session.lastActivityAt = Date.now();
-		const body = req.method === "POST" ? await readJsonBody(req, maxBodyBytes) : {
-			ok: true,
-			value: void 0
-		};
-		if (!body.ok) {
-			respondBodyError(req, res, body);
-			return true;
-		}
-		await session.transport.handleRequest(req, res, body.value);
+		await session.transport.handleRequest(req, res, body);
 		return true;
 	};
 	const openSession = async (req, res, body, token, as) => {
@@ -36544,11 +36801,20 @@ const startHttpTransport = async (config, logger = silentLogger, options = {}) =
 			zendeskToken: token.zendeskAccessToken,
 			grantId: token.grantId
 		};
-		const canWrite = !config.readOnly && token.canWrite;
-		const server = createMcpServer(canWrite ? config : {
-			...config,
-			readOnly: true
-		}, () => auth.zendeskToken, logger, () => void as.revokeGrant(auth.grantId));
+		const sessionConfig = effectiveConfig(token);
+		const server = serverFactory({
+			config: sessionConfig,
+			getToken: () => auth.zendeskToken,
+			logger,
+			onUnauthorized: () => void as.revokeGrant(auth.grantId),
+			requestStateCodec: createRequestStateCodec({
+				key: as.requestStateKey,
+				principal: () => auth.grantId
+			}),
+			notifyResourceUpdated: (uri) => {
+				server.server.sendResourceUpdated({ uri }).catch(() => void 0);
+			}
+		});
 		const transport = new NodeStreamableHTTPServerTransport({
 			sessionIdGenerator: () => randomUUID(),
 			onsessioninitialized: (newId) => {
@@ -36556,7 +36822,7 @@ const startHttpTransport = async (config, logger = silentLogger, options = {}) =
 					transport,
 					auth,
 					subject: token.subject,
-					canWrite,
+					canWrite: !sessionConfig.readOnly,
 					lastActivityAt: Date.now(),
 					close: async () => {
 						await transport.close();
@@ -36571,25 +36837,97 @@ const startHttpTransport = async (config, logger = silentLogger, options = {}) =
 		await server.connect(transport);
 		await transport.handleRequest(req, res, body);
 	};
-	const handleMcpRequest = async (req, res, as) => {
-		const bearer = extractBearer(req);
-		const token = bearer ? await as.verifyAccessToken(bearer) : void 0;
-		if (!token) {
+	const createGrantEntry = (token, as) => {
+		const { grantId } = token;
+		const auth = { zendeskToken: token.zendeskAccessToken };
+		const getToken = () => auth.zendeskToken;
+		const onUnauthorized = () => {
+			entry.revoked = true;
+			as.revokeGrant(grantId);
+		};
+		const caches = createServerCaches(config, getToken, onUnauthorized);
+		const requestStateCodec = createRequestStateCodec({
+			key: as.requestStateKey,
+			principal: () => grantId
+		});
+		const handler = createMcpHandler(({ authInfo }) => {
+			const verified = authInfo?.extra?.["verified"];
+			if (!verified) throw new Error("2026-07-28 request without a verified token");
+			return serverFactory({
+				config: effectiveConfig(verified),
+				getToken,
+				logger,
+				onUnauthorized,
+				caches,
+				requestStateCodec,
+				notifyResourceUpdated: (uri) => handler.notify.resourceUpdated(uri)
+			});
+		}, {
+			legacy: "reject",
+			onerror: (err) => logger.debug("mcp_request_rejected", { error: err.message })
+		});
+		const entry = {
+			auth,
+			revoked: false,
+			inFlight: 0,
+			handle: toNodeHandler(handler),
+			close: () => handler.close()
+		};
+		return entry;
+	};
+	const serveModern = async (req, res, body, token, as) => {
+		const entry = grants.acquire(token.grantId, token.subject, () => createGrantEntry(token, as));
+		if (!entry) {
 			sendUnauthorized(res, as.issuer);
 			return;
 		}
+		entry.auth.zendeskToken = token.zendeskAccessToken;
+		const request = asNodeRequest(req);
+		request.auth = {
+			token: "",
+			clientId: token.clientId,
+			scopes: [],
+			expiresAt: token.expiresAt,
+			extra: { verified: token }
+		};
+		const counted = !isListenRequest(body);
+		if (counted) entry.inFlight += 1;
+		try {
+			await entry.handle(request, res, body);
+		} finally {
+			if (counted) entry.inFlight -= 1;
+			if (entry.revoked && entry.inFlight === 0) await grants.close(token.grantId, entry);
+		}
+	};
+	const serveLegacy = async (req, res, body, token, as) => {
 		const sessionId = typeof req.headers["mcp-session-id"] === "string" ? req.headers["mcp-session-id"] : void 0;
-		if (sessionId && await dispatchToSession(req, res, sessionId, token)) return;
+		if (sessionId && await dispatchToSession(req, res, sessionId, token, body)) return;
 		if (req.method !== "POST") {
 			sendJsonRpcError(res, 400, -32e3, "No active session; initialize via POST first.");
 			return;
 		}
-		const body = await readJsonBody(req, maxBodyBytes);
-		if (!body.ok) {
-			respondBodyError(req, res, body);
+		await openSession(req, res, body, token, as);
+	};
+	const handleMcpRequest = async (req, res, as) => {
+		const token = await authenticate(req, as);
+		if (!token) {
+			sendUnauthorized(res, as.issuer);
+			return;
+		}
+		let body;
+		if (req.method === "POST") {
+			const read = await readJsonBody(req, maxBodyBytes);
+			if (!read.ok) {
+				respondBodyError(req, res, read);
+				return;
+			}
+			body = read.value;
+		}
+		if (body !== void 0 && !await isLegacyRequest(await toWebRequest(asNodeRequest(req), body), body)) {
+			await serveModern(req, res, body, token, as);
 			return;
 		}
-		await openSession(req, res, body.value, token, as);
+		await serveLegacy(req, res, body, token, as);
 	};
 	const route = async (req, res, as) => {
 		const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
@@ -36658,6 +36996,7 @@ const startHttpTransport = async (config, logger = silentLogger, options = {}) =
 				});
 			}
 		}
+		await grants.sweep();
 	};
 	const sweeper = setInterval(() => void sweepIdleSessions(), options.sweepIntervalMs ?? SESSION_SWEEP_INTERVAL_MS);
 	sweeper.unref();
@@ -36667,6 +37006,7 @@ const startHttpTransport = async (config, logger = silentLogger, options = {}) =
 			clearInterval(sweeper);
 			await Promise.all([...sessions.values()].map((session) => session.close()));
 			sessions.clear();
+			await grants.closeAll();
 			httpServer.closeAllConnections();
 			await new Promise((resolve, reject) => {
 				httpServer.close((err) => err ? reject(err) : resolve());