@fruggr/zendesk-mcp-server 3.3.1 → 3.4.0

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { createRequire } from "node:module";
 import { parseArgs } from "node:util";
-import { randomUUID } from "node:crypto";
+import { randomBytes, randomUUID } from "node:crypto";
 import minpath, { dirname, join } from "node:path";
 import { fileURLToPath, fileURLToPath as urlToPath, pathToFileURL } from "node:url";
 import minproc, { default as process$2 } from "node:process";
@@ -39,7 +39,7 @@ var __toESM$1 = (mod, isNodeMode, target) => (target = mod != null ? __create$1(
 }) : target, mod));
 var __require = /* #__PURE__ */ (() => createRequire(import.meta.url))();
 //#endregion
-//#region node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/util.js
+//#region node_modules/.pnpm/zod@4.6.6/node_modules/zod/v4/core/util.js
 function getEnumValues(entries) {
 	const numericValues = Object.values(entries).filter((v) => typeof v === "number");
 	return Object.entries(entries).filter(([k, _]) => numericValues.indexOf(+k) === -1).map(([_, v]) => v);
@@ -189,7 +189,7 @@ const allowsEval = /* @__PURE__*/ cached$1(() => {
 		return false;
 	}
 });
-function isPlainObject$3(o) {
+function isPlainObject$9(o) {
 	if (isObject(o) === false) return false;
 	const ctor = o.constructor;
 	if (ctor === void 0) return true;
@@ -200,7 +200,7 @@ function isPlainObject$3(o) {
 	return true;
 }
 function shallowClone(o) {
-	if (isPlainObject$3(o)) return { ...o };
+	if (isPlainObject$9(o)) return { ...o };
 	if (Array.isArray(o)) return [...o];
 	if (o instanceof Map) return new Map(o);
 	if (o instanceof Set) return new Set(o);
@@ -288,7 +288,7 @@ function omit(schema, mask) {
 	}));
 }
 function extend$1(schema, shape) {
-	if (!isPlainObject$3(shape)) throw new Error("Invalid input to extend: expected a plain object");
+	if (!isPlainObject$9(shape)) throw new Error("Invalid input to extend: expected a plain object");
 	const checks = schema._zod.def.checks;
 	if (checks && checks.length > 0) {
 		const existingShape = sourceShape(schema);
@@ -303,7 +303,7 @@ function extended(schema, shape) {
 	return newShape;
 }
 function safeExtend(schema, shape) {
-	if (!isPlainObject$3(shape)) throw new Error("Invalid input to safeExtend: expected a plain object");
+	if (!isPlainObject$9(shape)) throw new Error("Invalid input to safeExtend: expected a plain object");
 	return clone$1(schema, mergeDefs(schema._zod.def, { shape: extended(schema, shape) }));
 }
 function merge$2(a, b) {
@@ -364,6 +364,17 @@ function prefixIssues(path, issues) {
 function unwrapMessage(message) {
 	return typeof message === "string" ? message : message?.message;
 }
+/** The leading size checks of `defChecks` that set an upper bound, each paired with it. */
+function sizeCaps(defChecks) {
+	const caps = [];
+	for (const ch of defChecks ?? []) {
+		const d = ch._zod.def;
+		if (!/_(length|size)$|_equals$/.test(d.check)) break;
+		const max = d.maximum ?? d.length ?? d.size;
+		if (max >= 0) caps.push([max, ch]);
+	}
+	return caps;
+}
 function attachSchema(issues, start, inst) {
 	var _a;
 	for (let i = start; i < issues.length; i++) (_a = issues[i]).schema ?? (_a.schema = inst);
@@ -580,7 +591,7 @@ function constantCatch(value) {
 	return fn;
 }
 //#endregion
-//#region node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/core.js
+//#region node_modules/.pnpm/zod@4.6.6/node_modules/zod/v4/core/core.js
 var _a$4;
 /** A special constant with type `never` */
 const NEVER = /*@__PURE__*/ Object.freeze({ status: "aborted" });
@@ -688,7 +699,7 @@ function config(newConfig) {
 	return globalConfig;
 }
 //#endregion
-//#region node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/doc.js
+//#region node_modules/.pnpm/zod@4.6.6/node_modules/zod/v4/core/doc.js
 var Doc = class {
 	constructor(args = [], closed = {}) {
 		this.content = [];
@@ -722,7 +733,7 @@ var Doc = class {
 	}
 };
 //#endregion
-//#region node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/memoizer.js
+//#region node_modules/.pnpm/zod@4.6.6/node_modules/zod/v4/core/memoizer.js
 var $ZodCyclicError = class extends Error {
 	constructor() {
 		super(`Cannot parse a reference cycle that closes through a transform`);
@@ -984,7 +995,7 @@ function isBackEdge(ctx, value) {
 	return backEdges !== void 0 && isRef(value) && backEdges.has(value);
 }
 //#endregion
-//#region node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/regexes.js
+//#region node_modules/.pnpm/zod@4.6.6/node_modules/zod/v4/core/regexes.js
 /**
 * @deprecated CUID v1 is deprecated by its authors due to information leakage
 * (timestamps embedded in the id). Use {@link cuid2} instead.
@@ -1059,7 +1070,7 @@ const _null$2 = /^null$/i;
 const lowercase = /^[^A-Z]*$/;
 const uppercase = /^[^a-z]*$/;
 //#endregion
-//#region node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/checks.js
+//#region node_modules/.pnpm/zod@4.6.6/node_modules/zod/v4/core/checks.js
 const $ZodCheck = /*@__PURE__*/ $constructor("$ZodCheck", (inst, def) => {
 	var _a;
 	inst._zod ?? (inst._zod = {});
@@ -1355,7 +1366,7 @@ const $ZodCheckOverwrite = /*@__PURE__*/ $constructor("$ZodCheckOverwrite", (ins
 	};
 });
 //#endregion
-//#region node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/errors.js
+//#region node_modules/.pnpm/zod@4.6.6/node_modules/zod/v4/core/errors.js
 function _getMessage() {
 	const internals = this._zod;
 	internals.message ?? (internals.message = JSON.stringify(internals.def, jsonStringifyReplacer, 2));
@@ -1471,7 +1482,7 @@ function formatError(error, mapper = (issue) => issue.message) {
 	return fieldErrors;
 }
 //#endregion
-//#region node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/parse.js
+//#region node_modules/.pnpm/zod@4.6.6/node_modules/zod/v4/core/parse.js
 function finalizeParams(callee, params) {
 	return {
 		callee: params?.callee ?? callee,
@@ -1674,14 +1685,14 @@ const _safeDecodeAsync = (_Err) => async (schema, value, _ctx) => {
 	return _safeParseAsync(_Err)(schema, value, _ctx);
 };
 //#endregion
-//#region node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/versions.js
+//#region node_modules/.pnpm/zod@4.6.6/node_modules/zod/v4/core/versions.js
 const version = {
 	major: 4,
 	minor: 6,
-	patch: 5
+	patch: 6
 };
 //#endregion
-//#region node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/schemas.js
+//#region node_modules/.pnpm/zod@4.6.6/node_modules/zod/v4/core/schemas.js
 const $ZodType = /*@__PURE__*/ $constructor("$ZodType", (inst, def) => {
 	var _a;
 	inst ?? (inst = {});
@@ -2243,6 +2254,26 @@ const $ZodNever = /*@__PURE__*/ $constructor("$ZodNever", (inst, def) => {
 		return payload;
 	};
 });
+function capSize(inst, size) {
+	const caps = sizeCaps(inst._zod.def.checks);
+	if (!caps.length) return;
+	const cap = Math.min(...caps.map((c) => c[0]));
+	const parse = inst._zod.parse;
+	inst._zod.parse = (payload, ctx) => {
+		const n = size(payload.value);
+		if (n > cap && !ctx?.skipChecks && ctx?.direction !== "backward") {
+			for (const [max, ch] of sizeCaps(inst._zod.def.checks)) if (n > max && ch._zod.def.when(payload)) {
+				const start = payload.issues.length;
+				ch._zod.check(payload);
+				payload.issues[start].continue = false;
+				attachSchema(payload.issues, start, inst);
+				return payload;
+			}
+		}
+		return parse(payload, ctx);
+	};
+}
+const arraySize = (input) => Array.isArray(input) ? input.length : -1;
 function handleArrayResult(result, final, index) {
 	if (result.issues.length) final.issues.push(...prefixIssues(index, result.issues));
 	final.value[index] = result.value;
@@ -2280,6 +2311,7 @@ const $ZodArray = /*@__PURE__*/ $constructor("$ZodArray", (inst, def) => {
 		if (proms.length) return Promise.all(proms).then(() => payload);
 		return payload;
 	};
+	capSize(inst, arraySize);
 });
 function handlePropertyResult(result, final, key, input, optin, optout) {
 	const isPresent = key in input;
@@ -2388,7 +2420,7 @@ const $ZodObject = /*@__PURE__*/ $constructor("$ZodObject", (inst, def) => {
 		}
 		return propValues;
 	});
-	const isObject$2 = isObject;
+	const isObject$1 = isObject;
 	const catchall = def.catchall;
 	let value;
 	const memo = globalConfig.memoizer;
@@ -2396,7 +2428,7 @@ const $ZodObject = /*@__PURE__*/ $constructor("$ZodObject", (inst, def) => {
 	inst._zod.parse = (payload, ctx) => {
 		value ?? (value = _normalized.value);
 		const input = payload.value;
-		if (!isObject$2(input)) {
+		if (!isObject$1(input)) {
 			payload.issues.push({
 				expected: "object",
 				code: "invalid_type",
@@ -2526,7 +2558,7 @@ const $ZodObjectJIT = /*@__PURE__*/ $constructor("$ZodObjectJIT", (inst, def) =>
 		return doc.compile();
 	};
 	let fastpass;
-	const isObject$1 = isObject;
+	const isObject$2 = isObject;
 	const jit = !globalConfig.jitless;
 	const fastEnabled = jit && allowsEval.value;
 	const catchall = def.catchall;
@@ -2534,7 +2566,7 @@ const $ZodObjectJIT = /*@__PURE__*/ $constructor("$ZodObjectJIT", (inst, def) =>
 	inst._zod.parse = (payload, ctx) => {
 		value ?? (value = _normalized.value);
 		const input = payload.value;
-		if (!isObject$1(input)) {
+		if (!isObject$2(input)) {
 			payload.issues.push({
 				expected: "object",
 				code: "invalid_type",
@@ -2698,7 +2730,7 @@ function mergeValues(a, b) {
 		valid: true,
 		data: a
 	};
-	if (isPlainObject$3(a) && isPlainObject$3(b)) {
+	if (isPlainObject$9(a) && isPlainObject$9(b)) {
 		const bKeys = Object.keys(b);
 		const sharedKeys = Object.keys(a).filter((key) => bKeys.indexOf(key) !== -1);
 		const newObj = {
@@ -2791,7 +2823,7 @@ const $ZodRecord = /*@__PURE__*/ $constructor("$ZodRecord", (inst, def) => {
 	memo?.attach(inst);
 	inst._zod.parse = (payload, ctx) => {
 		const input = payload.value;
-		if (!isPlainObject$3(input)) {
+		if (!isPlainObject$9(input)) {
 			payload.issues.push({
 				expected: "record",
 				code: "invalid_type",
@@ -3198,7 +3230,7 @@ function handleRefineResult(result, payload, input, inst) {
 	}
 }
 //#endregion
-//#region node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/compile.js
+//#region node_modules/.pnpm/zod@4.6.6/node_modules/zod/v4/core/compile.js
 /** @internal Sentinel the compiled fast path returns when validation fails. */
 const INVALID = Symbol.for("zod.compile.invalid");
 const FALLBACK_FLAG = Symbol.for("zod.compile.fallback");
@@ -4183,9 +4215,13 @@ function generateNullableCheck(doc, ctx, schema, accessor, buildsValue = true) {
 	doc.write(`}`);
 	return outputVar;
 }
+function generateSizeGate(doc, schema, size) {
+	for (const [max, check] of sizeCaps(schema._zod.def.checks)) doc.write(`if (${size} > ${numericOperand(max, check._zod.def.check)}) return INVALID;`);
+}
 function generateArrayCheck(doc, ctx, schema, accessor, buildsValue = true) {
 	const def = schema._zod.def;
 	doc.write(`if (!Array.isArray(${accessor})) return INVALID;`);
+	generateSizeGate(doc, schema, `${accessor}.length`);
 	const outputVar = buildsValue ? newVar(ctx) : null;
 	const iVar = newVar(ctx);
 	const elemVar = newVar(ctx);
@@ -4432,7 +4468,7 @@ function generateIntersectionCheck(doc, ctx, schema, accessor) {
 }
 function generateRecordCheck(doc, ctx, schema, accessor) {
 	const def = schema._zod.def;
-	const isPlainObjectConst = addConstant(ctx, isPlainObject$3);
+	const isPlainObjectConst = addConstant(ctx, isPlainObject$9);
 	doc.write(`if (!${isPlainObjectConst}(${accessor})) return INVALID;`);
 	const outputVar = newVar(ctx);
 	const kVar = newVar(ctx);
@@ -4522,6 +4558,7 @@ function literalPropertyKey(ctx, key) {
 function generateMapCheck(doc, ctx, schema, accessor) {
 	const def = schema._zod.def;
 	doc.write(`if (!(${accessor} instanceof Map)) return INVALID;`);
+	generateSizeGate(doc, schema, `${accessor}.size`);
 	const outputVar = newVar(ctx);
 	const kVar = newVar(ctx);
 	const valVar = newVar(ctx);
@@ -4538,6 +4575,7 @@ function generateMapCheck(doc, ctx, schema, accessor) {
 function generateSetCheck(doc, ctx, schema, accessor) {
 	const def = schema._zod.def;
 	doc.write(`if (!(${accessor} instanceof Set)) return INVALID;`);
+	generateSizeGate(doc, schema, `${accessor}.size`);
 	const outputVar = newVar(ctx);
 	const valVar = newVar(ctx);
 	doc.write(`const ${outputVar} = new Set();`);
@@ -4677,7 +4715,7 @@ function generateTransformCheck(doc, ctx, schema, accessor) {
 	return accessor;
 }
 //#endregion
-//#region node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/locales/en.js
+//#region node_modules/.pnpm/zod@4.6.6/node_modules/zod/v4/locales/en.js
 const error = () => {
 	const Sizable = {
 		string: {
@@ -4785,7 +4823,7 @@ function en_default() {
 	return { localeError: error() };
 }
 //#endregion
-//#region node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/registries.js
+//#region node_modules/.pnpm/zod@4.6.6/node_modules/zod/v4/core/registries.js
 var _a$3;
 var $ZodRegistry = class {
 	constructor() {
@@ -4832,7 +4870,7 @@ function registry() {
 (_a$3 = globalThis).__zod_globalRegistry ?? (_a$3.__zod_globalRegistry = registry());
 const globalRegistry = globalThis.__zod_globalRegistry;
 //#endregion
-//#region node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/api.js
+//#region node_modules/.pnpm/zod@4.6.6/node_modules/zod/v4/core/api.js
 function snapshotChecks(def) {
 	if (def.checks) def.checks = [...def.checks];
 	return def;
@@ -5361,7 +5399,7 @@ function _check(fn, params) {
 	return ch;
 }
 //#endregion
-//#region node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/to-json-schema.js
+//#region node_modules/.pnpm/zod@4.6.6/node_modules/zod/v4/core/to-json-schema.js
 function assignProps(target, ...sources) {
 	for (const source of sources) for (const key of Reflect.ownKeys(source)) if (Object.prototype.propertyIsEnumerable.call(source, key)) assignProp(target, key, source[key]);
 	return target;
@@ -5805,7 +5843,7 @@ const createStandardJSONSchemaMethod = (schema, io, processors = {}) => (params)
 	return finalize(ctx, schema);
 };
 //#endregion
-//#region node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/core/json-schema-processors.js
+//#region node_modules/.pnpm/zod@4.6.6/node_modules/zod/v4/core/json-schema-processors.js
 const narrowMin = (agg, key, value) => {
 	if (agg[key] === void 0 || value > agg[key]) agg[key] = value;
 };
@@ -6451,7 +6489,7 @@ function toJSONSchema(input, params) {
 	return finalize(ctx, input);
 }
 //#endregion
-//#region node_modules/.pnpm/zod@4.6.5/node_modules/zod/compile.js
+//#region node_modules/.pnpm/zod@4.6.6/node_modules/zod/compile.js
 let compiling = false;
 globalConfig.postProcessor = (inst) => {
 	if (compiling) return;
@@ -6480,7 +6518,7 @@ globalConfig.postProcessor = (inst) => {
 	inst._zod.run = shim;
 };
 //#endregion
-//#region node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/classic/errors.js
+//#region node_modules/.pnpm/zod@4.6.6/node_modules/zod/v4/classic/errors.js
 const _installedErrorProtos = /* @__PURE__ */ new WeakSet([Object.prototype, Error.prototype]);
 function _lazyMethod(proto, key, make) {
 	Object.defineProperty(proto, key, {
@@ -6530,7 +6568,7 @@ const initializer = (inst, issues) => {
 };
 const ZodRealError = /*@__PURE__*/ $constructor("ZodError", initializer, void 0, { Parent: Error });
 //#endregion
-//#region node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/classic/parse.js
+//#region node_modules/.pnpm/zod@4.6.6/node_modules/zod/v4/classic/parse.js
 const parse$10 = /* @__PURE__ */ _parse(ZodRealError);
 const parseAsync = /* @__PURE__ */ _parseAsync(ZodRealError);
 const safeParse = /* @__PURE__ */ _safeParse(ZodRealError);
@@ -6544,7 +6582,7 @@ const safeDecode = /* @__PURE__ */ _safeDecode(ZodRealError);
 const safeEncodeAsync = /* @__PURE__ */ _safeEncodeAsync(ZodRealError);
 const safeDecodeAsync = /* @__PURE__ */ _safeDecodeAsync(ZodRealError);
 //#endregion
-//#region node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/classic/schemas.js
+//#region node_modules/.pnpm/zod@4.6.6/node_modules/zod/v4/classic/schemas.js
 function _ensureDefaultLocale() {
 	if (!globalConfig.localeError) config(en_default());
 }
@@ -7479,7 +7517,7 @@ function preprocess$1(fn, schema) {
 	});
 }
 //#endregion
-//#region node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/classic/compat.js
+//#region node_modules/.pnpm/zod@4.6.6/node_modules/zod/v4/classic/compat.js
 /** @deprecated Use the raw string literal codes instead, e.g. "invalid_type". */
 const ZodIssueCode = {
 	invalid_type: "invalid_type",
@@ -7498,7 +7536,7 @@ const ZodIssueCode = {
 var ZodFirstPartyTypeKind;
 ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
 //#endregion
-//#region node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/classic/iso.js
+//#region node_modules/.pnpm/zod@4.6.6/node_modules/zod/v4/classic/iso.js
 function datetime(params) {
 	return /* @__PURE__ */ _isoDateTime(ZodISODateTime, params);
 }
@@ -7506,7 +7544,7 @@ function date(params) {
 	return /* @__PURE__ */ _isoDate(ZodISODate, params);
 }
 //#endregion
-//#region node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/classic/coerce.js
+//#region node_modules/.pnpm/zod@4.6.6/node_modules/zod/v4/classic/coerce.js
 function number$1(params) {
 	return /* @__PURE__ */ _coercedNumber(ZodNumber, params);
 }
@@ -7933,8 +7971,8 @@ const loadConfig = (argv = process.argv.slice(2)) => {
 		readOnly: cli.readOnly ?? false,
 		namespaces,
 		tools: cli.tools,
-		topology: cli.topology ?? true,
-		promotedArticles: cli.promotedArticles ?? true,
+		topology: cli.topology,
+		promotedArticles: cli.promotedArticles,
 		hcResourceScheme,
 		dev: cli.dev ?? false,
 		printTools: cli.printTools ?? false,
@@ -7944,388 +7982,6 @@ const loadConfig = (argv = process.argv.slice(2)) => {
 	});
 };
 //#endregion
-//#region src/constants.ts
-const positiveIntEnv = (name, fallback) => {
-	const raw = readEnv(name).value;
-	if (raw === void 0 || raw.trim() === "") return fallback;
-	const parsed = Number(raw);
-	return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : fallback;
-};
-const CHARACTER_LIMIT = positiveIntEnv("RESPONSE_CHARACTER_LIMIT", 25e3);
-const ARTICLE_RESOURCES_SCAN_MAX_PAGES = positiveIntEnv("ARTICLE_RESOURCES_SCAN_MAX_PAGES", 20);
-const DEFAULT_CALLBACK_PORT = 27439;
-const MAX_ATTACHMENT_BYTES = positiveIntEnv("ATTACHMENT_MAX_BYTES", 5242880);
-const MAX_EMBEDDED_IMAGE_COUNT = positiveIntEnv("EMBEDDED_IMAGES_MAX", 10);
-const STDIO_MAX_MESSAGE_BYTES = 10485760;
-const MESSAGE_CONTENT_BUDGET_BYTES = 10420224;
-const MAX_RESPONSE_BYTES = Math.min(positiveIntEnv("RESPONSE_MAX_BYTES", MESSAGE_CONTENT_BUDGET_BYTES), MESSAGE_CONTENT_BUDGET_BYTES);
-const MAX_BASE64_INPUT_CHARS = MESSAGE_CONTENT_BUDGET_BYTES;
-const MAX_BASE64_INPUT_MB = Number.parseFloat((MAX_BASE64_INPUT_CHARS / 4 * 3 / 1048576).toFixed(2));
-const MAX_COMMENT_PAGES = positiveIntEnv("COMMENT_MAX_PAGES", 10);
-const TICKET_FIELD_SCAN_MAX_PAGES = positiveIntEnv("TICKET_FIELD_SCAN_MAX_PAGES", 10);
-const REORDER_CONFIRM_THRESHOLD = positiveIntEnv("REORDER_CONFIRM_THRESHOLD", 20);
-const getBaseUrl = (subdomain) => `https://${subdomain}.zendesk.com/api/v2`;
-const getHelpCenterBaseUrl = (subdomain) => `https://${subdomain}.zendesk.com/api/v2/help_center`;
-const getOAuthUrls = (subdomain) => ({
-	authorizeUrl: `https://${subdomain}.zendesk.com/oauth/authorizations/new`,
-	tokenUrl: `https://${subdomain}.zendesk.com/oauth/tokens`
-});
-//#endregion
-//#region src/client/retry.ts
-const MAX_ATTEMPTS = 3;
-const BASE_DELAY_MS = 250;
-const MAX_DELAY_MS = 4e3;
-const REQUEST_TIMEOUT_MS = 3e4;
-const TRANSFER_TIMEOUT_MS = 12e4;
-/**
-* A deadline for one attempt. The abort surfaces as a `TimeoutError` whose `code`
-* is numeric, not a syscall string, so it classifies as `unknown`: a GET is
-* retried, a write is not — the request may have arrived before the deadline.
-*/
-const deadlineSignal = (timeoutMs) => AbortSignal.timeout(timeoutMs);
-const MAX_RETRY_AFTER_MS = 5e3;
-const POLICIES = {
-	GET: {
-		network: "any",
-		serverErrors: true
-	},
-	DELETE: {
-		network: "pre-send",
-		serverErrors: false
-	},
-	POST: {
-		network: "pre-send",
-		serverErrors: false
-	},
-	PUT: {
-		network: "pre-send",
-		serverErrors: false
-	}
-};
-const DELAY_SECONDS = /^\d+$/;
-const HTTP_DATE_START = /^[A-Za-z]/;
-const NON_ASCII = /[^ -~]/g;
-const TOKEN_SEGMENT = /\/token\/[^/]+/;
-const URL_IN_TEXT = /[a-z][a-z0-9+.-]*:\/\/\S+/gi;
-const PRE_SEND_CODES = /* @__PURE__ */ new Set([
-	"ENOTFOUND",
-	"EAI_AGAIN",
-	"ECONNREFUSED",
-	"UND_ERR_CONNECT_TIMEOUT"
-]);
-const defaultRetryDeps = {
-	sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
-	random: Math.random
-};
-/** Non-ASCII bytes break `node:http` headers, so client error text stays ASCII. */
-const toAscii = (text) => text.replace(NON_ASCII, "?");
-/**
-* Identifies the request without leaking a credential: uploads carry an upload
-* token in the query string, and an attachment `content_url` carries a download
-* token as a path segment (`/attachments/token/<token>/`).
-*/
-const describeTarget = (url) => {
-	const { origin, pathname } = new URL(url);
-	return `${origin}${pathname.replace(TOKEN_SEGMENT, "/token/[redacted]")}`;
-};
-/** First `code` in the cause chain, inspecting 5 levels so a cycle cannot hang. */
-const errorCode = (err) => {
-	let current = err;
-	for (let depth = 0; depth < 5 && current !== null && typeof current === "object"; depth += 1) {
-		const { code, cause } = current;
-		if (typeof code === "string") return code;
-		current = cause;
-	}
-};
-const classifyNetworkError = (err) => PRE_SEND_CODES.has(errorCode(err)) ? "pre-send" : "unknown";
-const UNINFORMATIVE_NAMES = /* @__PURE__ */ new Set(["Error", "TypeError"]);
-/**
-* The client refuses to replay a write that may have landed — but the caller is
-* an LLM whose reflex on a failed tool call is to try again, which would undo
-* that. So a failed write says whether it may have taken effect. ASCII only,
-* same rule as the rest of the message.
-*/
-const MAY_HAVE_APPLIED_NOTE = "The write may already have been applied. Check the current state before retrying, or you may duplicate it.";
-const NEVER_SENT_NOTE = "The request never reached Zendesk, so nothing was applied. Retrying is safe.";
-const REFUSED_NOTE = "Zendesk refused the request, so nothing was applied. Retrying is safe.";
-/** Only a write can be duplicated by a replay, so only a write carries a note. */
-const writeNote = (method, note) => method === "GET" ? "" : ` ${note}`;
-/**
-* A cause message can quote the URL it failed on — Node's `fetch` refuses a URL
-* carrying credentials by printing the whole thing, query string included — which
-* would smuggle back exactly what `describeTarget` drops. Same treatment for both,
-* so one function owns what a URL may look like in our output.
-*/
-const redactUrls = (text) => text.replace(URL_IN_TEXT, (found) => {
-	try {
-		return new URL(found).origin === "null" ? "[url]" : describeTarget(found);
-	} catch {
-		return "[url]";
-	}
-});
-const failureDetail = (cause) => {
-	if (!(cause instanceof Error)) return redactUrls(String(cause));
-	const message = redactUrls(cause.message);
-	const code = errorCode(cause);
-	if (code !== void 0) return `${code}: ${message}`;
-	return UNINFORMATIVE_NAMES.has(cause.name) ? message : `${cause.name}: ${message}`;
-};
-const networkErrorMessage = (method, target, attempts, cause) => {
-	const base = `Network error on ${method} ${target} after ${attempts === 1 ? "1 attempt" : `${attempts} attempts`}: ${failureDetail(cause)}`;
-	const note = classifyNetworkError(cause) === "pre-send" ? NEVER_SENT_NOTE : MAY_HAVE_APPLIED_NOTE;
-	return toAscii(method === "GET" ? base : `${base}.${writeNote(method, note)}`);
-};
-const createZendeskNetworkError = (method, target, attempts, cause) => Object.assign(new Error(networkErrorMessage(method, target, attempts, cause), { cause }), {
-	name: "ZendeskNetworkError",
-	method,
-	target,
-	attempts
-});
-/** Exponential backoff with equal jitter: half the window fixed, half random. */
-const computeBackoffMs = (attempt, random) => {
-	const window = Math.min(BASE_DELAY_MS * 2 ** (attempt - 1), MAX_DELAY_MS);
-	return Math.round(window / 2 + window * random() / 2);
-};
-/** `Retry-After` in ms — delay-seconds or HTTP-date. */
-const parseRetryAfter = (header, now = Date.now()) => {
-	if (header === null) return void 0;
-	const value = header.trim();
-	if (DELAY_SECONDS.test(value)) return Number(value) * 1e3;
-	if (!HTTP_DATE_START.test(value)) return void 0;
-	const date = Date.parse(value);
-	if (Number.isNaN(date)) return void 0;
-	return Math.max(0, date - now);
-};
-/**
-* How long to wait before replaying this response, or undefined to accept it.
-* `Retry-After` wins over backoff wherever it appears — Zendesk sends it on a 503
-* during maintenance as well as on a 429 — and a value past the cap means the
-* response is surfaced rather than parking the call for that long.
-*/
-const retryDelayFor = (response, policy, attempt, random) => {
-	if (!(response.status === 429 || response.status >= 500 && policy.serverErrors)) return void 0;
-	const retryAfter = parseRetryAfter(response.headers.get("retry-after"));
-	if (retryAfter === void 0) return computeBackoffMs(attempt, random);
-	return retryAfter > MAX_RETRY_AFTER_MS ? void 0 : retryAfter;
-};
-/**
-* Runs `attempt` until it succeeds, hits a terminal outcome, or spends the
-* attempt budget. Returns the last response for the caller to inspect (a
-* non-ok status is still the caller's to turn into a `ZendeskApiError`), and
-* throws `ZendeskNetworkError` when no response was ever obtained.
-*/
-const fetchWithRetry = async (attempt, method, target, deps = defaultRetryDeps) => {
-	const policy = POLICIES[method];
-	for (let tries = 1;; tries += 1) {
-		const last = tries >= MAX_ATTEMPTS;
-		let response;
-		try {
-			response = await attempt();
-		} catch (err) {
-			const replayable = policy.network === "any" || classifyNetworkError(err) === policy.network;
-			if (last || !replayable) throw createZendeskNetworkError(method, target, tries, err);
-			await deps.sleep(computeBackoffMs(tries, deps.random));
-			continue;
-		}
-		if (last) return response;
-		const delayMs = retryDelayFor(response, policy, tries, deps.random);
-		if (delayMs === void 0) return response;
-		await response.text().catch(() => void 0);
-		await deps.sleep(delayMs);
-	}
-};
-//#endregion
-//#region src/client/zendesk-api.ts
-var ZendeskApiError = class ZendeskApiError extends Error {
-	status;
-	statusText;
-	body;
-	method;
-	constructor(status, statusText, body, method) {
-		super(ZendeskApiError.buildMessage(status, statusText, body, method));
-		this.status = status;
-		this.statusText = statusText;
-		this.body = body;
-		this.method = method;
-		this.name = "ZendeskApiError";
-	}
-	static buildMessage(status, statusText, body, method) {
-		switch (status) {
-			case 401: return "Authentication failed. Your Zendesk token may be expired or invalid. Re-authenticate to get a new token.";
-			case 403: return "Permission denied. Your Zendesk account does not have access to this resource.";
-			case 404: return `Resource not found. Please verify the ID is correct. (${statusText})`;
-			case 422: return `Validation error: ${body}`;
-			case 429: return `Rate limit exceeded. Please wait before making more requests.${writeNote(method, REFUSED_NOTE)}`;
-			default: {
-				const message = `Zendesk API error ${status}: ${statusText}. ${body}`;
-				return status >= 500 ? `${message}${writeNote(method, MAY_HAVE_APPLIED_NOTE)}` : message;
-			}
-		}
-	}
-};
-const buildAuthHeader = (token) => `Bearer ${token}`;
-const buildUrl = (base, path, params) => {
-	const url = new URL(`${base}${path}`);
-	if (params) for (const [key, value] of Object.entries(params)) url.searchParams.set(key, value);
-	return url.toString();
-};
-const performFetch = (method, url, init, timeoutMs = REQUEST_TIMEOUT_MS) => fetchWithRetry(() => fetch(url, {
-	...init,
-	method,
-	signal: deadlineSignal(timeoutMs)
-}), method, describeTarget(url));
-const executeRequest = async (url, token, options = {}) => {
-	const { method = "GET", body } = options;
-	const headers = {
-		Authorization: buildAuthHeader(token),
-		Accept: "application/json"
-	};
-	if (body) headers["Content-Type"] = "application/json";
-	const init = { headers };
-	if (body) init.body = JSON.stringify(body);
-	const response = await performFetch(method, url, init);
-	if (!response.ok) {
-		const responseBody = await response.text();
-		throw new ZendeskApiError(response.status, response.statusText, responseBody, method);
-	}
-	if (response.status === 204) return {};
-	return response.json();
-};
-const zendeskGet = (subdomain, token, path, params) => {
-	const url = buildUrl(getBaseUrl(subdomain), path, params);
-	return executeRequest(url, token);
-};
-const zendeskPost = (subdomain, token, path, body) => {
-	const url = buildUrl(getBaseUrl(subdomain), path);
-	return executeRequest(url, token, {
-		method: "POST",
-		body
-	});
-};
-const zendeskPut = (subdomain, token, path, body) => {
-	const url = buildUrl(getBaseUrl(subdomain), path);
-	return executeRequest(url, token, {
-		method: "PUT",
-		body
-	});
-};
-const helpCenterGet = (subdomain, token, path, params) => {
-	const url = buildUrl(getHelpCenterBaseUrl(subdomain), path, params);
-	return executeRequest(url, token);
-};
-const helpCenterPost = (subdomain, token, path, body) => {
-	const url = buildUrl(getHelpCenterBaseUrl(subdomain), path);
-	return executeRequest(url, token, {
-		method: "POST",
-		body
-	});
-};
-const helpCenterPut = (subdomain, token, path, body) => {
-	const url = buildUrl(getHelpCenterBaseUrl(subdomain), path);
-	return executeRequest(url, token, {
-		method: "PUT",
-		body
-	});
-};
-const helpCenterDelete = (subdomain, token, path) => {
-	const url = buildUrl(getHelpCenterBaseUrl(subdomain), path);
-	return executeRequest(url, token, { method: "DELETE" });
-};
-const fetchZendeskBinary = async (subdomain, token, contentUrl) => {
-	const expectedHost = `${subdomain}.zendesk.com`;
-	const headers = {};
-	if (new URL(contentUrl).hostname === expectedHost) headers["Authorization"] = buildAuthHeader(token);
-	const response = await performFetch("GET", contentUrl, { headers }, TRANSFER_TIMEOUT_MS);
-	if (!response.ok) {
-		const body = await response.text();
-		throw new ZendeskApiError(response.status, response.statusText, body, "GET");
-	}
-	const contentType = response.headers.get("content-type") ?? "application/octet-stream";
-	const arrayBuffer = await response.arrayBuffer();
-	return {
-		data: Buffer.from(arrayBuffer),
-		contentType
-	};
-};
-const zendeskUpload = async (subdomain, token, filename, data, contentType, uploadToken) => {
-	const params = { filename };
-	if (uploadToken) params["token"] = uploadToken;
-	const url = buildUrl(getBaseUrl(subdomain), "/uploads", params);
-	const response = await performFetch("POST", url, {
-		headers: {
-			Authorization: buildAuthHeader(token),
-			"Content-Type": contentType
-		},
-		body: data
-	}, TRANSFER_TIMEOUT_MS);
-	if (!response.ok) {
-		const responseBody = await response.text();
-		throw new ZendeskApiError(response.status, response.statusText, responseBody, "POST");
-	}
-	return response.json();
-};
-const helpCenterUpload = async (subdomain, token, path, formData) => {
-	const url = buildUrl(getHelpCenterBaseUrl(subdomain), path);
-	const response = await performFetch("POST", url, {
-		headers: { Authorization: buildAuthHeader(token) },
-		body: formData
-	}, TRANSFER_TIMEOUT_MS);
-	if (!response.ok) {
-		const responseBody = await response.text();
-		throw new ZendeskApiError(response.status, response.statusText, responseBody, "POST");
-	}
-	return response.json();
-};
-//#endregion
-//#region src/client/brands.ts
-const BRAND_SUBDOMAIN = /^[a-z0-9][a-z0-9-]*$/;
-/**
-* Fetch every brand of the account (cursor-paginated). `page[size]` is sent on
-* the FIRST request too: without it Zendesk falls back to OFFSET pagination,
-* which answers without `meta.after_cursor`, and the loop below would stop
-* after page 1 — a brand past the first 100 would resolve as Unknown.
-*/
-const fetchAllBrands = async (subdomain, token) => {
-	const brands = [];
-	let cursor;
-	do {
-		const response = await zendeskGet(subdomain, token, "/brands", {
-			"page[size]": String(100),
-			...cursor ? { "page[after]": cursor } : {}
-		});
-		brands.push(...response.brands ?? []);
-		const meta = response.meta;
-		if (meta?.has_more) {
-			if (!meta.after_cursor || meta.after_cursor === cursor) throw new Error("GET /brands reported more pages but returned no usable after_cursor (missing or identical to the cursor just sent). Cannot continue pagination safely.");
-			cursor = meta.after_cursor;
-		} else cursor = void 0;
-	} while (cursor);
-	return brands;
-};
-const createBrandSubdomainResolver = (subdomain, getToken) => {
-	let cached;
-	const brands = () => {
-		if (!cached || Date.now() - cached.at >= 3e5) {
-			const promise = (async () => fetchAllBrands(subdomain, await getToken()))();
-			cached = {
-				at: Date.now(),
-				promise
-			};
-			promise.catch(() => {
-				cached = void 0;
-			});
-		}
-		return cached.promise;
-	};
-	return async (idOrSubdomain) => {
-		const all = await brands();
-		const brand = all.find((b) => String(b.id) === idOrSubdomain) ?? all.find((b) => b.subdomain.toLowerCase() === idOrSubdomain.toLowerCase());
-		if (!brand) throw new Error(`Unknown brand "${idOrSubdomain}": no brand with that id or subdomain exists on this account; call list_brands to see the available brands.`);
-		if (!BRAND_SUBDOMAIN.test(brand.subdomain)) throw new Error(`Brand ${brand.id} has an unexpected subdomain; refusing to send a request to it.`);
-		return brand.subdomain;
-	};
-};
-//#endregion
 //#region node_modules/.pnpm/@modelcontextprotocol+server@2.3.1/node_modules/@modelcontextprotocol/server/dist/chunk-Br0eD_fh.mjs
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -10433,6 +10089,26 @@ var SdkHttpError = class extends SdkError {
 		return this.data.statusText;
 	}
 };
+/**
+* Inbound request methods whose processing structurally requires a client
+* capability, keyed by method, valued by the capabilities required.
+*
+* Currently empty: none of the request methods served on the 2026-07-28
+* registry unconditionally requires a client capability. Entries appear here
+* when such methods exist — for example requests whose handling embeds
+* elicitation or sampling input requests (the input-request engine), or
+* opt-in subscription delivery. Handler-conditional requirements (a specific
+* tool that needs sampling) are not expressible as a static method table and
+* are enforced at the point the requirement arises instead.
+*/
+const REQUIRED_CLIENT_CAPABILITIES_BY_METHOD = {};
+/**
+* The client capabilities a request method structurally requires, or
+* `undefined` when the method has no static requirement.
+*/
+function requiredClientCapabilitiesForRequest(method) {
+	return Object.hasOwn(REQUIRED_CLIENT_CAPABILITIES_BY_METHOD, method) ? REQUIRED_CLIENT_CAPABILITIES_BY_METHOD[method] : void 0;
+}
 function isPlainObject$7(value) {
 	return value !== null && typeof value === "object" && !Array.isArray(value);
 }
@@ -10515,6 +10191,13 @@ function missingClientCapabilities(required, declared) {
 * are ISO dates, so lexicographic comparison orders them chronologically.
 */
 const FIRST_MODERN_PROTOCOL_VERSION = "2026-07-28";
+/**
+* Modern-era protocol revisions this SDK can negotiate via `server/discover`.
+* Deliberately separate from {@linkcode SUPPORTED_PROTOCOL_VERSIONS} (the legacy
+* `initialize` list), so adding a revision here can never leak a modern version
+* string into a 2025-era handshake. Internal — not part of the public API surface.
+*/
+const SUPPORTED_MODERN_PROTOCOL_VERSIONS = [FIRST_MODERN_PROTOCOL_VERSION];
 /** Whether the given protocol revision belongs to the modern (2026-07-28+) era. */
 function isModernProtocolVersion(version) {
 	return version >= FIRST_MODERN_PROTOCOL_VERSION;
@@ -14099,6 +13782,66 @@ function isExtensionReusedRequestMethod(method) {
 	return method === "tasks/get" || method === "tasks/cancel";
 }
 const ALL_CODECS = [rev2025Codec, rev2026Codec];
+/**
+* Per-request `_meta` envelope claim helpers (protocol revision 2026-07-28).
+*
+* Pure, value-returning helpers used by the inbound HTTP classifier
+* (`classifyInboundRequest`): claim detection and envelope validation with
+* self-identifying issues. The envelope schema itself stays the wire layer's
+* single source of truth (`RequestMetaEnvelopeSchema`); this module only maps
+* its outcomes into the shapes the validation ladder emits.
+*
+* Claim detection is deliberately narrow: a message claims the 2026-07-28
+* envelope mechanism if and only if the reserved protocol-version `_meta` key
+* is present in `params._meta`. Other reserved keys (client info, client
+* capabilities, log level), a bare `progressToken`, or unrelated keys under
+* the `io.modelcontextprotocol/` prefix do NOT constitute a claim on their
+* own — but once the claim key is present, a malformed envelope is a
+* validation error, never a silent fall back to legacy handling.
+*
+* The wire-exact envelope schema, the required-key set, and the per-key issue
+* mapping live in the wire layer (the 2026-era codec's `validateEnvelopeMeta`).
+* This module never reaches into a per-revision wire module directly.
+*/
+function isPlainObject$3(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+/** The `_meta` object of a message's params, when present. */
+function requestMetaOf(params) {
+	if (!isPlainObject$3(params)) return void 0;
+	const meta = params["_meta"];
+	return isPlainObject$3(meta) ? meta : void 0;
+}
+/**
+* Whether a message's params carry the per-request envelope claim: the
+* reserved protocol-version `_meta` key is present (regardless of whether the
+* rest of the envelope is valid — validation is a separate, later step).
+*/
+function hasEnvelopeClaim(params) {
+	const meta = requestMetaOf(params);
+	return meta !== void 0 && "io.modelcontextprotocol/protocolVersion" in meta;
+}
+/**
+* The protocol version named by a message's envelope claim, when the claim is
+* present and carries a string value. A present claim with a non-string value
+* still counts as a claim ({@linkcode hasEnvelopeClaim}); it surfaces as a
+* validation issue instead of a version.
+*/
+function envelopeClaimVersion(params) {
+	const value = requestMetaOf(params)?.[PROTOCOL_VERSION_META_KEY];
+	return typeof value === "string" ? value : void 0;
+}
+/**
+* Validates a request's `_meta` object as a 2026-07-28 per-request envelope
+* and reports problems as self-identifying issues (which key, what problem).
+*
+* Returns an empty array when the envelope is valid. Missing required keys are
+* reported first (as `problem: 'missing'`), then schema violations inside
+* present keys, in a stable order.
+*/
+function validateEnvelopeMeta(meta) {
+	return codecForVersion(MODERN_WIRE_REVISION).validateEnvelopeMeta(meta);
+}
 var schemas_exports = /* @__PURE__ */ __exportAll({
 	AnnotationsSchema: () => AnnotationsSchema,
 	AudioContentSchema: () => AudioContentSchema,
@@ -14303,6 +14046,8 @@ function assertCompleteRequestPrompt(request) {
 function assertCompleteRequestResourceTemplate(request) {
 	if (request.params.ref.type !== "ref/resource") throw new TypeError(`Expected CompleteRequestResourceTemplate, but got ${request.params.ref.type}`);
 }
+/** The fixed prefix every custom-parameter header carries. */
+const MCP_PARAM_HEADER_PREFIX = "Mcp-Param-";
 /** The schema-extension property name a tool's `inputSchema` carries. */
 const X_MCP_HEADER_KEY = "x-mcp-header";
 /**
@@ -14425,8 +14170,566 @@ const OBJECT_VALUED_SUBSCHEMA_KEYWORDS = /* @__PURE__ */ new Set([
 function pathName(path) {
 	return path.length === 0 ? "<root>" : path.join(".");
 }
+const BASE64_SENTINEL_PREFIX = "=?base64?";
+const BASE64_SENTINEL_SUFFIX = "?=";
+const BASE64_CANONICAL = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
+const CANONICAL_DECIMAL = /^-?\d+(\.\d+)?$/;
+/**
+* Convert a primitive argument value to its string representation per the
+* spec's type-conversion rules: strings pass through, integers and numbers
+* become their decimal string, booleans become lowercase `'true'` / `'false'`.
+* Non-finite numbers and integers outside the safe range are refused (the
+* caller treats `undefined` as "do not emit a header for this value").
+*/
+function mcpParamPrimitiveToString(value) {
+	if (typeof value === "string") return value;
+	if (typeof value === "boolean") return value ? "true" : "false";
+	if (typeof value === "number") {
+		if (!Number.isFinite(value)) return void 0;
+		if (Number.isInteger(value) && !Number.isSafeInteger(value)) return void 0;
+		return String(value);
+	}
+}
+function base64ToUtf8(b64) {
+	const bin = atob(b64);
+	const bytes = new Uint8Array(bin.length);
+	for (let i = 0; i < bin.length; i++) bytes[i] = bin.codePointAt(i);
+	return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+}
+/**
+* Decode an `Mcp-Param-*` header value: when it carries the Base64 sentinel,
+* the payload is decoded as UTF-8; otherwise the value is returned as-is.
+* Returns `undefined` when the sentinel is present but the payload is not
+* canonical Base64 (or not valid UTF-8) — the spec requires servers to reject
+* such values.
+*/
+function decodeMcpParamValue(value) {
+	if (!(value.startsWith(BASE64_SENTINEL_PREFIX) && value.endsWith(BASE64_SENTINEL_SUFFIX))) return value;
+	const b64 = value.slice(9, value.length - 2);
+	if (!BASE64_CANONICAL.test(b64)) return void 0;
+	try {
+		return base64ToUtf8(b64);
+	} catch {
+		return;
+	}
+}
+function valueAtPath(root, path) {
+	let node = root;
+	for (const key of path) {
+		if (node === null || typeof node !== "object") return void 0;
+		node = node[key];
+	}
+	return node;
+}
+/**
+* The header/body comparison the server performs at tool-resolution time.
+*
+* For each `x-mcp-header` declaration on the named tool: when the body
+* `arguments` carries a value, the matching `Mcp-Param-{Name}` header MUST be
+* present and decode to an equal value; when the body value is `null` or
+* absent the server MUST NOT expect the header (a present header is ignored).
+* A sentinel-carrying header whose payload is not canonical Base64 / valid
+* UTF-8 is rejected as invalid characters.
+*
+* Integer-typed declarations are compared numerically (the spec's SHOULD —
+* `42.0` and `42` are equal); everything else is compared as decoded strings.
+*
+* Returns `undefined` when every check passes, or an
+* {@linkcode InboundLadderRejection} carrying the same `-32020`
+* (`HeaderMismatch`) shape the inbound classifier emits for the
+* standard-header cross-checks — `400 Bad Request` with the disagreeing pair
+* in `data.mismatch`.
+*/
+function validateMcpParamHeaders(declarations, args, headers) {
+	for (const decl of declarations) {
+		const headerKey = `${MCP_PARAM_HEADER_PREFIX}${decl.headerName}`;
+		const headerValue = headers.get(headerKey);
+		const bodyRaw = valueAtPath(args, decl.path);
+		if (bodyRaw === void 0 || bodyRaw === null) continue;
+		const bodyString = mcpParamPrimitiveToString(bodyRaw);
+		if (bodyString === void 0) continue;
+		if (headerValue === null) return paramHeaderMismatchRejection("param-header-missing", headerKey, `the body carries ${pathName(decl.path)}=${JSON.stringify(bodyRaw)} but the ${headerKey} header is absent`);
+		const decoded = decodeMcpParamValue(headerValue);
+		if (decoded === void 0) return paramHeaderMismatchRejection("param-header-invalid-encoding", headerKey, `the ${headerKey} header carries an invalid Base64 sentinel value`);
+		if (!((decl.type === "integer" || decl.type === "number") && CANONICAL_DECIMAL.test(decoded) && typeof bodyRaw === "number" ? Number(decoded) === bodyRaw : decoded === bodyString)) return paramHeaderMismatchRejection("param-header-mismatch", headerKey, `the ${headerKey} header decodes to ${JSON.stringify(decoded)} but the body carries ${pathName(decl.path)}=${JSON.stringify(bodyRaw)}`);
+	}
+}
+/**
+* Build the `-32020` (`HeaderMismatch`) rejection for an `Mcp-Param-*`
+* disagreement. Same shape as the inbound classifier's standard-header
+* cross-check mismatch (HTTP `400`, `data.mismatch` naming the disagreeing
+* pair, `settled: true`); only the rung differs because this check runs at the
+* pre-dispatch step against a known tool's schema rather than at the edge.
+*/
+function paramHeaderMismatchRejection(cell, header, body) {
+	return {
+		kind: "reject",
+		rung: "param-header-validation",
+		cell,
+		httpStatus: 400,
+		code: HEADER_MISMATCH_ERROR_CODE,
+		message: `Bad Request: the request headers and body disagree: ${body}`,
+		data: { mismatch: {
+			header,
+			body
+		} },
+		settled: true
+	};
+}
+/**
+* Inbound HTTP request classification and the inbound validation ladder
+* (protocol revision 2026-07-28).
+*
+* `classifyInboundRequest` is the body-primary era predicate for an HTTP
+* entry that serves both protocol eras on one endpoint. It is evaluated
+* exactly once, at the entry boundary, on the already-parsed request body:
+*
+* - `initialize` is a legacy-era request by definition (the modern era has no
+*   `initialize` handshake) — unless it carries a valid envelope claim naming
+*   a modern revision, in which case the claim wins and the request is
+*   classified like any other enveloped request (the modern era then answers
+*   it with method-not-found, exactly like every other method it does not
+*   define).
+* - A request whose `params._meta` carries the reserved protocol-version key
+*   claims the per-request envelope mechanism and classifies into the era the
+*   named revision belongs to (a malformed envelope behind a present claim is
+*   a validation error, never a silent fall back to legacy handling).
+* - A request without a claim is legacy-era traffic.
+* - The `MCP-Protocol-Version` header is a cross-check only *for
+*   classification*: it never upgrades or downgrades a body-derived
+*   classification, and a disagreement between header and body is an explicit
+*   ladder outcome. Its absence likewise never changes the era — but the spec
+*   requires the header on every modern *request* POST, so a
+*   modern-classified request that omits it is refused one rung later, by
+*   {@linkcode validateStandardRequestHeaders}, not here. Notification POSTs
+*   are exempt (see the next bullet), and that rung enforces presence on
+*   requests only.
+* - Notifications carry no envelope claim of their own under the current
+*   spec, so for notification POSTs without a body claim the modern header is
+*   determinative; the `Mcp-Method` header is validated against the body when
+*   the message classifies modern and is never enforced on legacy traffic.
+*   A notification that does carry a claim is treated body-primary like a
+*   request, and a malformed claim is rejected the same way a request's
+*   malformed claim is — never silently resolved against the header.
+*   The notification-POST header cross-checks here are an SDK-defensive
+*   posture, not a spec requirement: the spec leaves header rules for posted
+*   notifications undefined (core client notifications do not occur over
+*   Streamable HTTP); applying the request rules symmetrically is what an
+*   ecosystem custom-notification POST expects, and the −32020 cells stay
+*   passing for them.
+* - `GET`/`DELETE` (and any other non-`POST` method) are body-less 2025-era
+*   session operations: the modern era is `POST`-only, so they are routed to
+*   legacy serving when it is configured and rejected otherwise.
+* - Array (batch) bodies are classified element-wise: an array containing a
+*   modern-claiming or invalid element is rejected, an all-legacy array is
+*   legacy traffic unchanged, and a single-element array is still an array.
+*
+* The classifier returns plain values (it never throws and never touches a
+* transport): a routing outcome (`legacy`/`modern`) or a ladder rejection
+* carrying the JSON-RPC error to emit and the HTTP status to emit it with.
+* Legacy routing outcomes deliberately carry NO `MessageClassification` —
+* legacy and hand-wired traffic is never classified, which keeps its
+* dispatch behavior byte-identical to today's.
+*
+* Error codes for the modern-path rejection cells follow the published
+* conformance suite (and the spec text it asserts):
+*
+* - A header/body cross-check mismatch (the `MCP-Protocol-Version` header
+*   disagreeing with the body, or the `Mcp-Method` header disagreeing with the
+*   body method) is rejected with `-32020` (`HeaderMismatch`) on HTTP 400.
+* - A request whose protocol-version header names a modern revision but whose
+*   body carries no `_meta` envelope claim — including an envelope present but
+*   missing the required protocol-version key — is rejected with `-32602`
+*   (invalid params) naming the missing key(s), on HTTP 400.
+*
+* Should a future spec revision or conformance release change these
+* assignments, the affected cells are re-derived against that release; the
+* `settled` flag on {@linkcode InboundLadderRejection} stays available to mark
+* a cell provisional again while such a change is in flight.
+*/
+/**
+* The error code emitted for header/body cross-check mismatches: the
+* `MCP-Protocol-Version` header disagreeing with the body's envelope claim (or
+* with the body's classification), and the `Mcp-Method` header disagreeing
+* with the body method.
+*
+* `-32020` is the draft schema's `HEADER_MISMATCH` constant (the SEP-2243
+* `HeaderMismatch` code; the spec requires HTTP 400 for it), as also asserted
+* by the published conformance suite for header-validation failures. It has no
+* {@linkcode ProtocolErrorCode} member because it is not part of the 2025-era
+* wire vocabulary; the validation ladder is its only emitter.
+*/
+const HEADER_MISMATCH_ERROR_CODE = -32020;
 ProtocolErrorCode.InvalidRequest, ProtocolErrorCode.UnsupportedProtocolVersion, ProtocolErrorCode.InvalidParams, ProtocolErrorCode.MethodNotFound, ProtocolErrorCode.InvalidParams, ProtocolErrorCode.MissingRequiredClientCapability;
-ProtocolErrorCode.ParseError, ProtocolErrorCode.InvalidRequest, ProtocolErrorCode.MethodNotFound, ProtocolErrorCode.UnsupportedProtocolVersion, ProtocolErrorCode.MissingRequiredClientCapability;
+/**
+* HTTP status for ladder-originated JSON-RPC error codes.
+*
+* Keyed on origin, not on the bare code: this table only applies to errors
+* the ladder (or a pre-handler protocol gate) produced. Errors produced by
+* request handlers — whatever their code — stay in-band on HTTP 200, and are
+* never mapped to an HTTP status by this table; in particular `-32603` and
+* domain-specific codes never become a blanket 500. The single exception is
+* `MissingRequiredClientCapability` (-32021) — see
+* {@linkcode httpStatusForErrorCode}.
+*
+* `-32602` (invalid params) deliberately has NO entry: the only invalid-params
+* rejection that maps to HTTP 400 is the classifier's own envelope rung
+* short-circuit, which carries its HTTP status directly. A dispatch- or
+* handler-produced invalid-params error is always in-band.
+*/
+const LADDER_ERROR_HTTP_STATUS = {
+	[ProtocolErrorCode.ParseError]: 400,
+	[ProtocolErrorCode.InvalidRequest]: 400,
+	[ProtocolErrorCode.MethodNotFound]: 404,
+	[ProtocolErrorCode.UnsupportedProtocolVersion]: 400,
+	[ProtocolErrorCode.MissingRequiredClientCapability]: 400,
+	[HEADER_MISMATCH_ERROR_CODE]: 400
+};
+/**
+* The HTTP status to answer a JSON-RPC error with, keyed on the error's
+* origin. `in-band` errors (anything produced by a request handler) are
+* HTTP 200 — the JSON-RPC error response is the payload, not an HTTP
+* failure — with ONE exception: `MissingRequiredClientCapability` (-32021),
+* whose 400 the spec mandates on the error itself with no origin condition,
+* and which the SDK genuinely produces after dispatch (the `input_required`
+* capability gate). A handler relaying some downstream peer's `-32020`/`-32022`
+* is NOT that peer's spec error and stays in-band like every other handler
+* code. `ladder` errors map through {@linkcode LADDER_ERROR_HTTP_STATUS}.
+*
+* The per-request transport intentionally does NOT delegate to this function:
+* its `?? 400` ladder fallback is only correct for entry-gate codes known to
+* the table, and would wrongly map dispatch-window errors outside it (a
+* window `-32602` must stay in-band on 200). The transport indexes the table
+* directly; keep the two in agreement when editing either.
+*/
+function httpStatusForErrorCode(code, origin) {
+	if (origin === "in-band") return code === ProtocolErrorCode.MissingRequiredClientCapability ? 400 : 200;
+	return LADDER_ERROR_HTTP_STATUS[code] ?? 400;
+}
+function rejection(rung, cell, httpStatus, error, settled) {
+	return {
+		kind: "reject",
+		rung,
+		cell,
+		httpStatus,
+		code: error.code,
+		message: error.message,
+		...error.data !== void 0 && { data: error.data },
+		settled
+	};
+}
+function crossCheckMismatch(cell, header, body, rung = "era-classification") {
+	return rejection(rung, cell, 400, new ProtocolError(HEADER_MISMATCH_ERROR_CODE, `Bad Request: the request headers and body disagree: ${body}`, { mismatch: {
+		header,
+		body
+	} }), true);
+}
+/**
+* The methods whose body carries a `params.name` / `params.uri` /
+* `params.taskId` value the `Mcp-Name` header must mirror, and which body
+* field supplies it. The core rows come from SEP-2243 § Standard Request
+* Headers (`Required For` column); the `tasks/*` rows come from SEP-2663's
+* Streamable HTTP binding ("the client MUST set the `Mcp-Name` header to the
+* value of `params.taskId`" for `tasks/get` / `tasks/update` /
+* `tasks/cancel`, so intermediaries can route every request for a task to the
+* instance holding its state). Shared by the client transport (header
+* emission) and the server ladder (validation) so both sides derive from one
+* table.
+*/
+const MCP_NAME_HEADER_SOURCE = {
+	"tools/call": "name",
+	"prompts/get": "name",
+	"resources/read": "uri",
+	"tasks/get": "taskId",
+	"tasks/update": "taskId",
+	"tasks/cancel": "taskId"
+};
+/**
+* Resolve the `Mcp-Name` source for one request against
+* {@linkcode MCP_NAME_HEADER_SOURCE}: which body field the header mirrors for
+* `method`, and the string value that field carries in `params`.
+*
+* Returns `undefined` when `method` is off-table (no `Mcp-Name` is emitted or
+* required). Otherwise `value` is the field's string value, or `undefined`
+* when `params` is not a plain object or the field is absent / not a string —
+* the client emits no header then, and the server leaves that body to the
+* rungs further down the ladder.
+*
+* `method` is peer-supplied on the server and caller-supplied on the client,
+* so the table lookup is `Object.hasOwn`-guarded against `Object.prototype`
+* collisions (`constructor`, `toString`, …). Shared by the client transport
+* (emission) and {@linkcode validateStandardRequestHeaders} (validation) so
+* the extraction — not just the table — cannot drift between the two sides.
+*/
+function mcpNameSource(method, params) {
+	const field = Object.hasOwn(MCP_NAME_HEADER_SOURCE, method) ? MCP_NAME_HEADER_SOURCE[method] : void 0;
+	if (field === void 0) return;
+	const raw = isPlainObject$2(params) ? params[field] : void 0;
+	return {
+		field,
+		value: typeof raw === "string" ? raw : void 0
+	};
+}
+/** Strip RFC 9110 optional whitespace (SP / HTAB) around a field value in linear time. */
+function stripHttpOws(value) {
+	let start = 0;
+	while (start < value.length) {
+		const code = value.codePointAt(start);
+		if (code !== 9 && code !== 32) break;
+		start += 1;
+	}
+	let end = value.length;
+	while (end > start) {
+		const code = value.codePointAt(end - 1);
+		if (code !== 9 && code !== 32) break;
+		end -= 1;
+	}
+	return start === 0 && end === value.length ? value : value.slice(start, end);
+}
+/**
+* SEP-2243 standard-header server-side validation, evaluated by the HTTP
+* entry on a modern-classified request immediately after
+* {@linkcode classifyInboundRequest} returns a modern route.
+*
+* Returns the `-32020` (`HeaderMismatch`) ladder rejection (HTTP `400`,
+* `standard-header-validation` rung — the same shape
+* {@linkcode classifyInboundRequest} already emits on the edge
+* `era-classification` rung for the `MCP-Protocol-Version` and
+* `Mcp-Method` *mismatch* cells) when:
+*
+* - the required `MCP-Protocol-Version` header is absent (SEP-2243 requires it
+*   on every modern *request* POST, and lists it first among the required
+*   standard headers — so a request missing it *and* `Mcp-Method` is answered
+*   by this cell);
+* - the required `Mcp-Method` header is absent;
+* - the required `Mcp-Name` header is absent on a `tools/call`,
+*   `prompts/get`, `resources/read`, or (per SEP-2663's Streamable HTTP
+*   binding) `tasks/get` / `tasks/update` / `tasks/cancel` request whose
+*   body carries the `params.name` / `params.uri` / `params.taskId` value
+*   the header mirrors;
+* - the `Mcp-Name` header carries an invalid `=?base64?…?=` sentinel; or
+* - the (decoded) `Mcp-Name` value disagrees with the body's
+*   `params.name` / `params.uri` / `params.taskId`.
+*
+* Returns `undefined` (pass) for notifications (the spec table reads
+* "All requests"), for methods that have no `Mcp-Name` source, and when the
+* headers agree with the body. Never enforced on legacy traffic — the entry
+* only calls this on a modern route.
+*
+* Kept separate from {@linkcode classifyInboundRequest} so that a body-only
+* call to the classifier (no headers passed) keeps routing a modern request
+* unchanged: the classifier remains a pure body-primary router, and this
+* function is the presence/`Mcp-Name` half of the standard-header rung the
+* entry layers on top. That separation is what lets the missing
+* `MCP-Protocol-Version` cell live here without disturbing the body-primary
+* rule — classification still resolves from the body (a proxy stripping the
+* header must not change the era), and only this rung refuses to serve it.
+*/
+function validateStandardRequestHeaders(request, route) {
+	if (route.messageKind !== "request") return;
+	const method = route.message.method;
+	if (request.protocolVersionHeader === void 0) {
+		const claimed = route.classification.revision;
+		return crossCheckMismatch("version-header-missing", "(missing)", claimed === void 0 ? "the body carries a modern per-request envelope but the required MCP-Protocol-Version header is absent" : `the body envelope names protocol version ${claimed} but the required MCP-Protocol-Version header is absent`, "standard-header-validation");
+	}
+	if (request.mcpMethodHeader === void 0) return crossCheckMismatch("method-header-missing", "(missing)", `the body names method ${method} but the required Mcp-Method header is absent`, "standard-header-validation");
+	const source = mcpNameSource(method, route.message.params);
+	if (source === void 0) return;
+	const { field: sourceField, value: bodyValue } = source;
+	if (request.mcpNameHeader === void 0) {
+		if (bodyValue === void 0) return;
+		return crossCheckMismatch("name-header-missing", "(missing)", `the body carries params.${sourceField}="${bodyValue}" but the required Mcp-Name header is absent`, "standard-header-validation");
+	}
+	const normalizedNameHeader = stripHttpOws(request.mcpNameHeader);
+	const decoded = decodeMcpParamValue(normalizedNameHeader);
+	if (decoded === void 0) return crossCheckMismatch("name-header-invalid-encoding", normalizedNameHeader, "the Mcp-Name header carries an invalid Base64 sentinel value", "standard-header-validation");
+	if (bodyValue !== void 0 && decoded !== bodyValue) return crossCheckMismatch("name-header-mismatch", normalizedNameHeader, `the body carries params.${sourceField}="${bodyValue}" but the Mcp-Name header names "${decoded}"`, "standard-header-validation");
+}
+function isPlainObject$2(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function classificationForClaim(claimedVersion) {
+	if (claimedVersion === void 0) return { era: "modern" };
+	return {
+		era: isModernProtocolVersion(claimedVersion) ? "modern" : "legacy",
+		revision: claimedVersion
+	};
+}
+/**
+* Whether a request's params carry a per-request envelope claim that is both
+* well-formed and names a modern protocol revision.
+*
+* Used by the `initialize` precedence rule: only such a claim overrides the
+* `initialize` ⇒ legacy-handshake classification — a request carrying a valid
+* modern envelope is a modern request regardless of its method name, and the
+* modern era then answers `initialize` exactly like any other method it does
+* not define (method-not-found). A malformed claim, or one naming a pre-2026
+* revision, keeps the legacy-handshake routing unchanged.
+*
+* Exported on the core internal barrel for the stdio serving entry, which
+* applies the same precedence rule to a connection's opening message; not
+* public API.
+*/
+function carriesValidModernEnvelopeClaim(params) {
+	if (!hasEnvelopeClaim(params)) return false;
+	const claimedVersion = envelopeClaimVersion(params);
+	if (claimedVersion === void 0 || !isModernProtocolVersion(claimedVersion)) return false;
+	const meta = requestMetaOf(params);
+	return meta !== void 0 && validateEnvelopeMeta(meta).length === 0;
+}
+function classifyBatch(body) {
+	if (body.length === 0) return rejection("jsonrpc-shape", "empty-batch", 400, new ProtocolError(ProtocolErrorCode.InvalidRequest, "Bad Request: empty JSON-RPC batch"), true);
+	for (const element of body) {
+		if (hasEnvelopeClaim(isPlainObject$2(element) ? element["params"] : void 0)) return rejection("jsonrpc-shape", "batch-with-modern-element", 400, new ProtocolError(ProtocolErrorCode.InvalidRequest, "Bad Request: JSON-RPC batches may not contain requests for protocol revision 2026-07-28 or later"), true);
+		if (!(isJSONRPCRequest(element) || isJSONRPCNotification(element) || isJSONRPCResultResponse(element) || isJSONRPCErrorResponse(element))) return rejection("jsonrpc-shape", "batch-with-invalid-element", 400, new ProtocolError(ProtocolErrorCode.InvalidRequest, "Bad Request: JSON-RPC batch contains an invalid message"), true);
+	}
+	return {
+		kind: "legacy",
+		reason: "batch"
+	};
+}
+function classifyRequestBody(request, body) {
+	const params = body.params;
+	const method = body.method;
+	const headerVersion = request.protocolVersionHeader;
+	const headerNamesModern = headerVersion !== void 0 && isModernProtocolVersion(headerVersion);
+	if (method === "initialize" && !carriesValidModernEnvelopeClaim(params)) {
+		if (headerNamesModern) return crossCheckMismatch("initialize-with-modern-header", headerVersion, "an initialize request (legacy handshake) was sent with a modern MCP-Protocol-Version header");
+		const requestedVersion = isPlainObject$2(params) && typeof params["protocolVersion"] === "string" ? params["protocolVersion"] : void 0;
+		return {
+			kind: "legacy",
+			reason: "initialize",
+			...requestedVersion !== void 0 && { requestedVersion }
+		};
+	}
+	if (hasEnvelopeClaim(params)) {
+		const meta = requestMetaOf(params);
+		const firstIssue = (meta === void 0 ? [] : validateEnvelopeMeta(meta))[0];
+		if (firstIssue !== void 0) return rejection("envelope", "envelope-invalid", 400, new ProtocolError(ProtocolErrorCode.InvalidParams, `Invalid _meta envelope for protocol revision 2026-07-28: ${firstIssue.key}: ${firstIssue.problem}`, { envelope: firstIssue }), true);
+		const claimedVersion = envelopeClaimVersion(params);
+		if (headerVersion !== void 0 && claimedVersion !== void 0 && headerVersion !== claimedVersion) return crossCheckMismatch("header-body-version-mismatch", headerVersion, `the body envelope names protocol version ${claimedVersion} but the MCP-Protocol-Version header names ${headerVersion}`);
+		if (request.mcpMethodHeader !== void 0 && request.mcpMethodHeader !== method) return crossCheckMismatch("method-header-mismatch", request.mcpMethodHeader, `the body names method ${method} but the Mcp-Method header names ${request.mcpMethodHeader}`);
+		return {
+			kind: "modern",
+			messageKind: "request",
+			message: body,
+			classification: classificationForClaim(claimedVersion)
+		};
+	}
+	if (headerNamesModern) {
+		const meta = requestMetaOf(params);
+		const missingFromEnvelope = validateEnvelopeMeta(meta ?? {}).filter((issue) => issue.problem === "missing").map((issue) => issue.key);
+		const missing = meta === void 0 ? ["_meta"] : missingFromEnvelope.length > 0 ? missingFromEnvelope : [PROTOCOL_VERSION_META_KEY];
+		return rejection("envelope", "modern-header-without-claim", 400, new ProtocolError(ProtocolErrorCode.InvalidParams, `Invalid params: the MCP-Protocol-Version header names protocol revision ${headerVersion}, but the request is missing the required per-request envelope key(s): ${missing.join(", ")}`, { envelope: { missing } }), true);
+	}
+	return {
+		kind: "legacy",
+		reason: "no-claim",
+		...headerVersion !== void 0 && { requestedVersion: headerVersion }
+	};
+}
+function classifyNotificationBody(request, body) {
+	const params = body.params;
+	const method = body.method;
+	const headerVersion = request.protocolVersionHeader;
+	const headerNamesModern = headerVersion !== void 0 && isModernProtocolVersion(headerVersion);
+	if (hasEnvelopeClaim(params)) {
+		const claimedVersion = envelopeClaimVersion(params);
+		if (claimedVersion === void 0) {
+			const meta = requestMetaOf(params);
+			const claimIssue = (meta === void 0 ? [] : validateEnvelopeMeta(meta)).find((issue) => issue.key === "io.modelcontextprotocol/protocolVersion") ?? {
+				key: "io.modelcontextprotocol/protocolVersion",
+				problem: "expected a protocol version string"
+			};
+			return rejection("envelope", "notification-envelope-invalid", 400, new ProtocolError(ProtocolErrorCode.InvalidParams, `Invalid _meta envelope for protocol revision 2026-07-28: ${claimIssue.key}: ${claimIssue.problem}`, { envelope: claimIssue }), true);
+		}
+		if (headerVersion !== void 0 && headerVersion !== claimedVersion) return crossCheckMismatch("notification-header-body-version-mismatch", headerVersion, `the notification envelope names protocol version ${claimedVersion} but the MCP-Protocol-Version header names ${headerVersion}`);
+		const classification = classificationForClaim(claimedVersion);
+		if (classification.era === "modern" && request.mcpMethodHeader !== void 0 && request.mcpMethodHeader !== method) return crossCheckMismatch("notification-method-header-mismatch", request.mcpMethodHeader, `the notification body names method ${method} but the Mcp-Method header names ${request.mcpMethodHeader}`);
+		return {
+			kind: "modern",
+			messageKind: "notification",
+			message: body,
+			classification
+		};
+	}
+	if (headerNamesModern) {
+		if (request.mcpMethodHeader !== void 0 && request.mcpMethodHeader !== method) return crossCheckMismatch("notification-method-header-mismatch", request.mcpMethodHeader, `the notification body names method ${method} but the Mcp-Method header names ${request.mcpMethodHeader}`);
+		return {
+			kind: "modern",
+			messageKind: "notification",
+			message: body,
+			classification: {
+				era: "modern",
+				revision: headerVersion
+			}
+		};
+	}
+	return {
+		kind: "legacy",
+		reason: "notification",
+		...headerVersion !== void 0 && { requestedVersion: headerVersion }
+	};
+}
+/**
+* Classifies one inbound HTTP request for dual-era serving.
+*
+* The body-primary predicate, evaluated once at the entry boundary: see the
+* module documentation for the rules. Returns a routing outcome (`legacy` or
+* `modern`) or a ladder rejection; it never throws.
+*/
+function classifyInboundRequest(request) {
+	request = {
+		...request,
+		...request.protocolVersionHeader !== void 0 && { protocolVersionHeader: stripHttpOws(request.protocolVersionHeader) },
+		...request.mcpMethodHeader !== void 0 && { mcpMethodHeader: stripHttpOws(request.mcpMethodHeader) },
+		...request.mcpNameHeader !== void 0 && { mcpNameHeader: stripHttpOws(request.mcpNameHeader) }
+	};
+	if (request.httpMethod.toUpperCase() !== "POST") return {
+		kind: "legacy",
+		reason: "http-method"
+	};
+	const body = request.body;
+	if (Array.isArray(body)) return classifyBatch(body);
+	if (isJSONRPCResultResponse(body) || isJSONRPCErrorResponse(body)) return {
+		kind: "legacy",
+		reason: "response"
+	};
+	if (isPlainObject$2(body) && isJSONRPCRequest(body)) return classifyRequestBody(request, body);
+	if (isPlainObject$2(body) && isJSONRPCNotification(body)) return classifyNotificationBody(request, body);
+	return rejection("jsonrpc-shape", "invalid-json-rpc-body", 400, new ProtocolError(ProtocolErrorCode.InvalidRequest, "Bad Request: the request body is not a valid JSON-RPC message"), true);
+}
+/**
+* The rejection a modern-only endpoint (no legacy serving configured)
+* answers a legacy-classified request with.
+*
+* - Envelope-less requests (including `initialize`) are answered with the
+*   unsupported-protocol-version error carrying the endpoint's supported
+*   versions and echoing the version the request named (when it named one —
+*   `requested` is omitted rather than fabricated when the request named no
+*   version at all), so a legacy client can discover what the endpoint serves
+*   from the error alone.
+* - Posted responses and batch arrays are invalid requests on the modern era.
+* - Non-`POST` methods are not allowed.
+* - Legacy-classified notifications return `undefined`: the caller answers
+*   202 with no body and does not dispatch the notification (accept-and-drop).
+*/
+function modernOnlyStrictRejection(route, supportedVersions) {
+	switch (route.reason) {
+		case "http-method": return rejection("http-method", "modern-only-method-not-allowed", 405, new ProtocolError(-32e3, "Method not allowed."), true);
+		case "batch": return rejection("jsonrpc-shape", "modern-only-batch-not-supported", 400, new ProtocolError(ProtocolErrorCode.InvalidRequest, "Bad Request: JSON-RPC batches are not supported by this endpoint"), true);
+		case "response": return rejection("jsonrpc-shape", "modern-only-response-post", 400, new ProtocolError(ProtocolErrorCode.InvalidRequest, "Bad Request: JSON-RPC responses cannot be posted to this endpoint"), true);
+		case "notification": return;
+		case "initialize":
+		case "no-claim": {
+			const requested = route.requestedVersion;
+			return rejection("era-classification", "modern-only-missing-envelope", 400, requested === void 0 ? new ProtocolError(ProtocolErrorCode.UnsupportedProtocolVersion, "Unsupported protocol version: the request did not name a protocol version", { supported: [...supportedVersions] }) : new UnsupportedProtocolVersionError({
+				supported: [...supportedVersions],
+				requested
+			}), true);
+		}
+	}
+}
 /**
 * Internal Zod schema utilities for protocol handling.
 * These are used internally by the SDK for protocol message validation.
@@ -15119,6 +15422,17 @@ function withRequestStateValue(ctx, value) {
 		}
 	};
 }
+let writeNegotiatedProtocolVersion;
+/**
+* Package-internal write channel for a {@linkcode Protocol} instance's
+* negotiated protocol version, for callers outside the class hierarchy:
+* tests and the (future) modern-era server entry that marks a factory
+* instance modern at binding time. Exported on the core internal barrel
+* only — never public API.
+*/
+function setNegotiatedProtocolVersion(instance, version) {
+	writeNegotiatedProtocolVersion(instance, version);
+}
 /**
 * Implements MCP protocol framing on top of a pluggable transport, including
 * features like request/response linking, notifications, and progress.
@@ -15145,7 +15459,11 @@ var Protocol = class {
 	* (`Client.connect`, `Server._oninitialize`).
 	*/
 	_negotiatedProtocolVersion;
-	static {}
+	static {
+		writeNegotiatedProtocolVersion = (instance, version) => {
+			instance._negotiatedProtocolVersion = version;
+		};
+	}
 	_supportedProtocolVersions;
 	/**
 	* Callback for when the connection is closed for any reason.
@@ -15872,7 +16190,7 @@ function mergeCapabilities(base, additional) {
 	}
 	return result;
 }
-function isPlainObject$2(value) {
+function isPlainObject$8(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 /**
@@ -15886,12 +16204,12 @@ function isPlainObject$2(value) {
 function partitionInputResponses(inputResponses) {
 	const accepted = {};
 	const droppedKeys = [];
-	if (!isPlainObject$2(inputResponses)) return {
+	if (!isPlainObject$8(inputResponses)) return {
 		accepted,
 		droppedKeys
 	};
 	for (const [key, entry] of Object.entries(inputResponses)) {
-		if (!isPlainObject$2(entry) || "method" in entry || "result" in entry) {
+		if (!isPlainObject$8(entry) || "method" in entry || "result" in entry) {
 			droppedKeys.push(key);
 			continue;
 		}
@@ -23559,6 +23877,409 @@ function armSseKeepAlive(intervalMs, onTick) {
 	timer.unref?.();
 	return timer;
 }
+/**
+* A `ServerEventBus` backed by an in-process listener set.
+*
+* `publish()` delivers synchronously to the live listener set (a listener
+* unsubscribing itself mid-dispatch is safe; the entry's listen-router
+* listeners never unsubscribe peers). A throwing listener does not stop
+* delivery to the others.
+*/
+var InMemoryServerEventBus = class {
+	_listeners = /* @__PURE__ */ new Set();
+	/**
+	* @param onerror - Optional callback for errors thrown by listeners
+	*   during dispatch.
+	*/
+	constructor(onerror) {
+		this.onerror = onerror;
+	}
+	publish(event) {
+		for (const listener of this._listeners) try {
+			listener(event);
+		} catch (error) {
+			this.onerror?.(error instanceof Error ? error : new Error(String(error)));
+		}
+	}
+	subscribe(listener) {
+		this._listeners.add(listener);
+		let live = true;
+		return () => {
+			if (!live) return;
+			live = false;
+			this._listeners.delete(listener);
+		};
+	}
+	/** The number of currently registered listeners (test/introspection only — the routers track capacity via their own open-subscription set). */
+	get listenerCount() {
+		return this._listeners.size;
+	}
+};
+/** Build a {@linkcode ServerNotifier} over a bus. */
+function createServerNotifier(bus) {
+	return {
+		toolsChanged: () => bus.publish({ kind: "tools_list_changed" }),
+		promptsChanged: () => bus.publish({ kind: "prompts_list_changed" }),
+		resourcesChanged: () => bus.publish({ kind: "resources_list_changed" }),
+		resourceUpdated: (uri) => bus.publish({
+			kind: "resource_updated",
+			uri
+		})
+	};
+}
+/**
+* Whether a `subscriptions/listen` filter accepts a given change event.
+*
+* Pure: no I/O, no mutation. The filter governs ONLY the four
+* subscription-gated change types — non-gated notifications never reach the
+* bus and are not modeled here.
+*
+* `resource_updated` matches only when `resourceSubscriptions` is present and
+* contains the event's URI exactly (per the spec: "for these resource URIs").
+*/
+function listenFilterAccepts(filter, event) {
+	switch (event.kind) {
+		case "tools_list_changed": return filter.toolsListChanged === true;
+		case "prompts_list_changed": return filter.promptsListChanged === true;
+		case "resources_list_changed": return filter.resourcesListChanged === true;
+		case "resource_updated": return filter.resourceSubscriptions !== void 0 && filter.resourceSubscriptions.includes(event.uri);
+	}
+}
+/**
+* The honored subset of a requested filter: keeps only the fields the client
+* explicitly opted in to (drops `false` and absent fields), narrowed against
+* the server's declared capabilities when supplied. The serving entry sends
+* this back in `notifications/subscriptions/acknowledged` so the ack reflects
+* what the server can actually deliver.
+*
+* - `toolsListChanged` is honored only when `capabilities.tools.listChanged`
+*   is advertised; likewise `promptsListChanged` / `resourcesListChanged`.
+* - `resourceSubscriptions` is honored only when
+*   `capabilities.resources.subscribe` is advertised.
+*
+* `capabilities` is optional on this pure helper for test convenience only —
+* both wired routers REQUIRE capabilities at the call site (the HTTP router's
+* `serve()` takes a required parameter; `StdioListenRouter.serve()` throws
+* before `setServerCapabilities()` was called), so the fail-open
+* `undefined → honor everything` branch is never reachable on a wired entry.
+*/
+function honoredSubset(requested, capabilities) {
+	const honored = {};
+	const allow = (bit) => capabilities === void 0 || bit === true;
+	if (requested.toolsListChanged === true && allow(capabilities?.tools?.listChanged)) honored.toolsListChanged = true;
+	if (requested.promptsListChanged === true && allow(capabilities?.prompts?.listChanged)) honored.promptsListChanged = true;
+	if (requested.resourcesListChanged === true && allow(capabilities?.resources?.listChanged)) honored.resourcesListChanged = true;
+	if (requested.resourceSubscriptions !== void 0 && requested.resourceSubscriptions.length > 0 && allow(capabilities?.resources?.subscribe)) honored.resourceSubscriptions = [...requested.resourceSubscriptions];
+	return honored;
+}
+/** Map a {@linkcode ServerEvent} onto its wire notification `{method, params}`. */
+function serverEventToNotification(event) {
+	switch (event.kind) {
+		case "tools_list_changed": return { method: "notifications/tools/list_changed" };
+		case "prompts_list_changed": return { method: "notifications/prompts/list_changed" };
+		case "resources_list_changed": return { method: "notifications/resources/list_changed" };
+		case "resource_updated": return {
+			method: "notifications/resources/updated",
+			params: { uri: event.uri }
+		};
+	}
+}
+/** Default capacity guard: refuse a new subscription when this many are already open. */
+const DEFAULT_MAX_SUBSCRIPTIONS = 1024;
+function jsonRpcError(id, code, message) {
+	return Response.json({
+		jsonrpc: "2.0",
+		error: {
+			code,
+			message
+		},
+		id
+	}, { status: 200 });
+}
+/** Stamp the subscription id onto a notification's `_meta`. Non-mutating. */
+function stampSubscriptionId(notification, subscriptionId) {
+	return {
+		method: notification.method,
+		params: {
+			...notification.params,
+			_meta: {
+				...notification.params?._meta,
+				[SUBSCRIPTION_ID_META_KEY]: subscriptionId
+			}
+		}
+	};
+}
+/**
+* Read the requested filter off a `subscriptions/listen` request body.
+* Returns the validated filter, or `undefined` when `params.notifications`
+* is absent or fails the schema (the caller answers `-32602` — the spec
+* marks `notifications` REQUIRED on the listen request).
+*/
+function parseListenFilter(message) {
+	const outcome = codecForVersion(MODERN_WIRE_REVISION).validateRequest("subscriptions/listen", message);
+	return outcome.ok ? outcome.value.params?.notifications : void 0;
+}
+function createListenRouter(options) {
+	const { bus, onerror } = options;
+	const maxSubscriptions = options.maxSubscriptions ?? 1024;
+	const keepAliveMs = options.keepAliveMs ?? 15e3;
+	const open = /* @__PURE__ */ new Set();
+	function serve(message, signal, capabilities, serverInfo) {
+		if (open.size >= maxSubscriptions) {
+			onerror?.(/* @__PURE__ */ new Error(`subscriptions/listen refused: subscription limit reached (${maxSubscriptions})`));
+			return jsonRpcError(message.id, -32603, "Subscription limit reached");
+		}
+		const filter = parseListenFilter(message);
+		if (filter === void 0) return jsonRpcError(message.id, -32602, "Invalid params: 'notifications' is required and must be a valid SubscriptionFilter");
+		const honored = honoredSubset(filter, capabilities);
+		const subscriptionId = message.id;
+		const encoder = new TextEncoder();
+		let controller;
+		let closed = false;
+		let unsubscribe;
+		let keepAliveTimer;
+		let abortCleanup;
+		const writeFrame = (frame) => {
+			if (closed) return;
+			try {
+				controller.enqueue(encoder.encode(frame));
+			} catch (error) {
+				onerror?.(error instanceof Error ? error : new Error(String(error)));
+			}
+		};
+		const writeNotification = (method, params) => {
+			writeFrame(`event: message\ndata: ${JSON.stringify({
+				jsonrpc: "2.0",
+				method,
+				params
+			})}\n\n`);
+		};
+		const teardown = (graceful) => {
+			if (closed) return;
+			if (graceful) writeFrame(`event: message\ndata: ${JSON.stringify({
+				jsonrpc: "2.0",
+				id: subscriptionId,
+				result: {
+					resultType: "complete",
+					_meta: {
+						[SUBSCRIPTION_ID_META_KEY]: subscriptionId,
+						[SERVER_INFO_META_KEY]: serverInfo
+					}
+				}
+			})}\n\n`);
+			closed = true;
+			try {
+				unsubscribe?.();
+			} catch (error) {
+				onerror?.(error instanceof Error ? error : new Error(String(error)));
+			}
+			if (keepAliveTimer !== void 0) clearInterval(keepAliveTimer);
+			abortCleanup?.();
+			open.delete(teardown);
+			try {
+				controller.close();
+			} catch {}
+		};
+		const readable = new ReadableStream({
+			start(streamController) {
+				controller = streamController;
+				const ack = stampSubscriptionId({
+					method: "notifications/subscriptions/acknowledged",
+					params: { notifications: honored }
+				}, subscriptionId);
+				writeNotification(ack.method, ack.params);
+				if (Object.keys(honored).length === 0) {
+					teardown(true);
+					return;
+				}
+				unsubscribe = bus.subscribe((event) => {
+					if (closed || !listenFilterAccepts(honored, event)) return;
+					const note = stampSubscriptionId(serverEventToNotification(event), subscriptionId);
+					writeNotification(note.method, note.params);
+				});
+				keepAliveTimer = armSseKeepAlive(keepAliveMs, () => writeFrame(": keepalive\n\n"));
+				open.add(teardown);
+			},
+			cancel() {
+				teardown(false);
+			}
+		});
+		if (signal !== void 0) if (signal.aborted) teardown(false);
+		else {
+			const onAbort = () => teardown(false);
+			signal.addEventListener("abort", onAbort, { once: true });
+			abortCleanup = () => signal.removeEventListener("abort", onAbort);
+		}
+		return new Response(readable, {
+			status: 200,
+			headers: {
+				"Content-Type": "text/event-stream",
+				"Cache-Control": "no-cache, no-transform",
+				Connection: "keep-alive",
+				"X-Accel-Buffering": "no"
+			}
+		});
+	}
+	return {
+		serve,
+		closeAll() {
+			for (const teardown of open) teardown(true);
+		},
+		get openCount() {
+			return open.size;
+		}
+	};
+}
+const CHANGE_NOTIFICATION_METHODS = /* @__PURE__ */ new Set([
+	"notifications/tools/list_changed",
+	"notifications/prompts/list_changed",
+	"notifications/resources/list_changed",
+	"notifications/resources/updated"
+]);
+/**
+* Per-connection listen state for the stdio entry. One instance is held by
+* `serveStdio` for the connection lifetime; it routes inbound
+* `subscriptions/listen` / `notifications/cancelled` and rewrites outbound
+* change notifications onto the active subscriptions. No bus — the long-lived
+* pinned instance's existing `send*ListChanged()` calls feed straight into
+* `routeOutbound()`.
+*/
+var StdioListenRouter = class {
+	/** Active subscriptions, keyed by the listen request's JSON-RPC id verbatim. */
+	_subs = /* @__PURE__ */ new Map();
+	/**
+	* The serving instance's declared capabilities. Filled in by the entry
+	* once the modern instance is constructed (the router is created before
+	* the instance exists), so the acknowledged filter is narrowed against
+	* what the server can actually deliver.
+	*/
+	_serverCapabilities;
+	/**
+	* The serving instance's identity, stamped onto the graceful-close
+	* results' `_meta` (the spec's `SubscriptionsListenResultMetaObject` extends
+	* `ResultMetaObject`). Handed over together with the capabilities.
+	*/
+	_serverInfo;
+	constructor(_maxSubscriptions = DEFAULT_MAX_SUBSCRIPTIONS, serverCapabilities, serverInfo) {
+		this._maxSubscriptions = _maxSubscriptions;
+		this._serverCapabilities = serverCapabilities;
+		this._serverInfo = serverInfo;
+	}
+	/**
+	* Record the serving instance's declared capabilities and identity once
+	* it has been constructed. Called by `serveStdio`'s connect path;
+	* subsequent `serve()` calls narrow the honored filter against the
+	* capabilities, and `teardownAll()` stamps the identity.
+	*/
+	setServerCapabilities(capabilities, serverInfo) {
+		this._serverCapabilities = capabilities;
+		if (serverInfo !== void 0) this._serverInfo = serverInfo;
+	}
+	/** Whether `id` is an active listen subscription on this connection. */
+	has(id) {
+		return this._subs.has(id);
+	}
+	/**
+	* Serve one inbound `subscriptions/listen` request: registers the
+	* subscription and returns the stamped acknowledged notification (or, on
+	* capacity / params rejection, the in-band JSON-RPC error response).
+	*
+	* @throws when called before {@linkcode setServerCapabilities} (or the
+	* constructor) has supplied the serving instance's capabilities. Honoring a
+	* filter without knowing the server's advertised capabilities would fail
+	* open (deliver unadvertised types); the entry guarantees capabilities are
+	* set before any listen request is routed here.
+	*/
+	serve(message) {
+		if (this._serverCapabilities === void 0) throw new Error("StdioListenRouter.serve() called before setServerCapabilities(); refusing to honor a filter without capabilities");
+		if (this._subs.size >= this._maxSubscriptions) return {
+			jsonrpc: "2.0",
+			id: message.id,
+			error: {
+				code: -32603,
+				message: "Subscription limit reached"
+			}
+		};
+		const filter = parseListenFilter(message);
+		if (filter === void 0) return {
+			jsonrpc: "2.0",
+			id: message.id,
+			error: {
+				code: -32602,
+				message: "Invalid params: 'notifications' is required and must be a valid SubscriptionFilter"
+			}
+		};
+		const honored = honoredSubset(filter, this._serverCapabilities);
+		this._subs.set(message.id, honored);
+		return stampSubscriptionId({
+			method: "notifications/subscriptions/acknowledged",
+			params: { notifications: honored }
+		}, message.id);
+	}
+	/**
+	* Tear down one subscription (inbound `notifications/cancelled`). Returns
+	* `true` when a subscription was removed. After this call NOTHING further
+	* is delivered for that subscription id (the post-cancel hardening).
+	*/
+	cancel(id) {
+		return this._subs.delete(id);
+	}
+	/**
+	* Route an outbound notification through the active subscriptions.
+	*
+	* - For a subscription-gated change notification, returns one stamped copy
+	*   per subscription that opted in to it (an empty array means it is
+	*   dropped — the modern era never delivers an un-requested change type).
+	* - For any other outbound message, returns `'passthrough'` (the entry
+	*   forwards it as-is).
+	*/
+	routeOutbound(message) {
+		if (!CHANGE_NOTIFICATION_METHODS.has(message.method)) return "passthrough";
+		const uriParam = message.params?.["uri"];
+		const uri = typeof uriParam === "string" ? uriParam : void 0;
+		const event = notificationToServerEvent(message.method, uri);
+		const out = [];
+		for (const [subscriptionId, filter] of this._subs) if (listenFilterAccepts(filter, event)) out.push(stampSubscriptionId({
+			method: message.method,
+			params: message.params ?? {}
+		}, subscriptionId));
+		return out;
+	}
+	/**
+	* Server-side graceful teardown of every active subscription: returns the
+	* empty `subscriptions/listen` JSON-RPC result for each subscription id —
+	* the spec's graceful-close signal, `_meta` carrying the subscription id
+	* and the serving instance's identity — for the entry to emit before
+	* closing the wire. Clears the set so nothing further is delivered.
+	*/
+	teardownAll() {
+		const out = [];
+		for (const id of this._subs.keys()) out.push({
+			jsonrpc: "2.0",
+			id,
+			result: {
+				resultType: "complete",
+				_meta: {
+					[SUBSCRIPTION_ID_META_KEY]: id,
+					...this._serverInfo !== void 0 && { ["io.modelcontextprotocol/serverInfo"]: this._serverInfo }
+				}
+			}
+		});
+		this._subs.clear();
+		return out;
+	}
+};
+function notificationToServerEvent(method, uri) {
+	switch (method) {
+		case "notifications/tools/list_changed": return { kind: "tools_list_changed" };
+		case "notifications/prompts/list_changed": return { kind: "prompts_list_changed" };
+		case "notifications/resources/list_changed": return { kind: "resources_list_changed" };
+		default: return {
+			kind: "resource_updated",
+			uri: uri ?? ""
+		};
+	}
+}
 function comparableResource(value) {
 	const text = String(value);
 	const hash = text.indexOf("#");
@@ -23877,6 +24598,41 @@ const INPUT_REQUIRED_CAPABLE_METHODS = /* @__PURE__ */ new Set([
 	"prompts/get",
 	"resources/read"
 ]);
+let writeClientIdentity;
+let installDiscoverHandler;
+let readServerIdentity;
+/**
+* Package-internal: backfills the connection-scoped client-identity fields of a
+* per-request server instance from the request's validated `_meta` envelope, so the
+* (deprecated) {@linkcode Server.getClientCapabilities} / {@linkcode Server.getClientVersion}
+* accessors keep answering on instances that never see an `initialize` handshake.
+* Not public API.
+*/
+function seedClientIdentityFromEnvelope(server, identity) {
+	writeClientIdentity(server, identity);
+}
+/**
+* Package-internal: installs the modern-only `server/discover` handler on an instance
+* the HTTP entry has marked as serving the 2026-07-28 era, and makes sure the modern
+* revisions the entry serves appear in the instance's supported-versions list (so the
+* discover advertisement and version-mismatch errors name them). Idempotent.
+* Hand-constructed instances are unaffected: nothing else calls this, so they keep
+* answering `-32601` unless their own supported-versions list opts into a modern
+* revision. Not public API.
+*/
+function installModernOnlyHandlers(server, servedModernVersions) {
+	installDiscoverHandler(server, servedModernVersions);
+}
+/**
+* Package-internal: the instance's implementation identity, for the serving
+* entries to stamp onto entry-built results (the `subscriptions/listen`
+* graceful-close result — built outside the encode seam, but the spec's
+* `SubscriptionsListenResultMetaObject` extends `ResultMetaObject`, so it carries
+* the serverInfo SHOULD like every other result). Not public API.
+*/
+function serverIdentityOf(server) {
+	return readServerIdentity(server);
+}
 /**
 * An MCP server on top of a pluggable transport.
 *
@@ -23887,7 +24643,18 @@ const INPUT_REQUIRED_CAPABLE_METHODS = /* @__PURE__ */ new Set([
 var Server = class extends Protocol {
 	_clientCapabilities;
 	_clientVersion;
-	static {}
+	static {
+		writeClientIdentity = (server, identity) => {
+			if (identity.clientCapabilities !== void 0) server._clientCapabilities = identity.clientCapabilities;
+			if (identity.clientInfo !== void 0) server._clientVersion = identity.clientInfo;
+		};
+		installDiscoverHandler = (server, servedModernVersions) => {
+			const missing = servedModernVersions.filter((version) => !server._supportedProtocolVersions.includes(version));
+			if (missing.length > 0) server._supportedProtocolVersions = [...server._supportedProtocolVersions, ...missing];
+			server.setRequestHandler("server/discover", () => server._ondiscover());
+		};
+		readServerIdentity = (server) => server._serverInfo;
+	}
 	_capabilities;
 	_instructions;
 	_jsonSchemaValidator;
@@ -25184,6 +25951,245 @@ function unwrapOptionalSchema(schema) {
 }
 //#endregion
 //#region node_modules/.pnpm/@modelcontextprotocol+server@2.3.1/node_modules/@modelcontextprotocol/server/dist/index.mjs
+/**
+* The per-request micro-transport: a real, connected `Transport` whose whole
+* lifetime is one HTTP exchange. See the module documentation for the
+* response shapes it produces.
+*/
+var PerRequestHTTPServerTransport = class {
+	onclose;
+	onerror;
+	onmessage;
+	_classification;
+	_responseMode;
+	_started = false;
+	_used = false;
+	_closed = false;
+	_terminalDelivered = false;
+	/**
+	* `true` only while the inbound message is being delivered synchronously
+	* to the connected protocol layer. The pre-handler gates (the era
+	* registry gate, the edge→instance handoff check, the missing-handler
+	* rejection) answer inside this window; request handlers always run
+	* after it (the protocol layer defers them to a microtask). An error
+	* sent inside the window is therefore ladder-originated, and an error
+	* sent after it is handler-produced.
+	*/
+	_dispatchWindowOpen = false;
+	_requestId;
+	_deferredResponse;
+	_sse;
+	_abortCleanup;
+	_keepAliveMs;
+	constructor(options) {
+		this._classification = options.classification;
+		this._responseMode = options.responseMode ?? "auto";
+		this._keepAliveMs = options.keepAliveMs ?? 15e3;
+	}
+	async start() {
+		if (this._started) throw new Error("PerRequestHTTPServerTransport is already started");
+		this._started = true;
+	}
+	/**
+	* Serves the single exchange: delivers the classified message to the
+	* connected server instance and resolves with the HTTP response.
+	*
+	* Throws when called a second time (the transport is strictly
+	* single-use), or before a server has been connected to the transport.
+	* The returned promise rejects with a connection-closed error when the
+	* transport is closed before a response was produced (for example because
+	* the client disconnected).
+	*/
+	async handleMessage(message, extra) {
+		if (this._used) throw new Error("PerRequestHTTPServerTransport serves exactly one exchange; construct a new transport per request");
+		if (!this._started || this.onmessage === void 0) throw new Error("PerRequestHTTPServerTransport is not connected: connect a server to this transport before handling a message");
+		if (this._closed) throw new Error("PerRequestHTTPServerTransport is closed");
+		this._used = true;
+		const signal = extra?.request?.signal;
+		if (signal?.aborted) {
+			await this.close();
+			throw new SdkError(SdkErrorCode.ConnectionClosed, "The request was aborted before it could be handled");
+		}
+		const messageExtra = {
+			classification: this._classification,
+			...extra?.request !== void 0 && { request: extra.request },
+			...extra?.authInfo !== void 0 && { authInfo: extra.authInfo }
+		};
+		if (isJSONRPCRequest(message)) {
+			this._requestId = message.id;
+			let resolve;
+			let reject;
+			const promise = new Promise((promiseResolve, promiseReject) => {
+				resolve = promiseResolve;
+				reject = promiseReject;
+			});
+			this._deferredResponse = {
+				promise,
+				resolve,
+				reject,
+				settled: false
+			};
+			if (signal !== void 0) {
+				const onAbort = () => void this.close();
+				signal.addEventListener("abort", onAbort, { once: true });
+				this._abortCleanup = () => signal.removeEventListener("abort", onAbort);
+			}
+			this._dispatchWindowOpen = true;
+			try {
+				this.onmessage(message, messageExtra);
+			} finally {
+				this._dispatchWindowOpen = false;
+			}
+			if (this._responseMode === "sse" && !this._closed && !this._deferredResponse.settled) this.upgradeToSse();
+			return promise;
+		}
+		this.onmessage(message, messageExtra);
+		return new Response(null, { status: 202 });
+	}
+	async send(message, options) {
+		if (this._closed) return;
+		const isResponse = isJSONRPCResultResponse(message) || isJSONRPCErrorResponse(message);
+		const relatedId = isResponse ? message.id : options?.relatedRequestId;
+		if (this._requestId === void 0 || relatedId === void 0 || relatedId !== this._requestId) {
+			if (isResponse) this.onerror?.(/* @__PURE__ */ new Error(`Received a response for an unknown request id: ${String(message.id)}`));
+			return;
+		}
+		if (isResponse) {
+			if (this._terminalDelivered) return;
+			this._terminalDelivered = true;
+			const errorCode = isJSONRPCErrorResponse(message) ? message.error.code : void 0;
+			const ladderStatus = errorCode !== void 0 && (this._dispatchWindowOpen || errorCode === ProtocolErrorCode.MissingRequiredClientCapability) ? LADDER_ERROR_HTTP_STATUS[errorCode] : void 0;
+			if (ladderStatus !== void 0 && this._sse === void 0) {
+				this.settleResponse(Response.json(message, {
+					status: ladderStatus,
+					headers: { "Content-Type": "application/json" }
+				}));
+				queueMicrotask(() => void this.close());
+				return;
+			}
+			if (this._sse !== void 0 || this._responseMode === "sse") {
+				if (this._sse === void 0) this.upgradeToSse();
+				this.writeMessageFrame(message);
+				this.finalizeStream();
+				return;
+			}
+			this.settleResponse(Response.json(message, {
+				status: 200,
+				headers: { "Content-Type": "application/json" }
+			}));
+			queueMicrotask(() => void this.close());
+			return;
+		}
+		if (this._responseMode === "json") return;
+		if (this._sse === void 0) this.upgradeToSse();
+		this.writeMessageFrame(message);
+	}
+	/**
+	* Writes an SSE comment frame (a keep-alive heartbeat). Dropped when the
+	* exchange is not currently streaming.
+	*/
+	writeCommentFrame(comment) {
+		if (this._closed || this._sse === void 0 || this._sse.closed) return;
+		const frame = comment.split("\n").map((line) => `: ${line}`).join("\n");
+		this.writeFrame(`${frame}\n\n`);
+	}
+	async close() {
+		if (this._closed) return;
+		this._closed = true;
+		this._abortCleanup?.();
+		this._abortCleanup = void 0;
+		if (this._sse?.keepAliveTimer !== void 0) clearInterval(this._sse.keepAliveTimer);
+		if (this._sse !== void 0 && !this._sse.closed) {
+			this._sse.closed = true;
+			try {
+				this._sse.controller.close();
+			} catch {}
+		}
+		if (this._deferredResponse !== void 0 && !this._deferredResponse.settled) {
+			this._deferredResponse.settled = true;
+			this._deferredResponse.reject(new SdkError(SdkErrorCode.ConnectionClosed, "Connection closed before a response was produced"));
+		}
+		this.onclose?.();
+	}
+	settleResponse(response) {
+		if (this._deferredResponse === void 0 || this._deferredResponse.settled) return;
+		this._deferredResponse.settled = true;
+		this._deferredResponse.resolve(response);
+	}
+	upgradeToSse() {
+		let controller;
+		const readable = new ReadableStream({
+			start: (streamController) => {
+				controller = streamController;
+			},
+			cancel: () => {
+				this.close();
+			}
+		});
+		this._sse = {
+			controller,
+			encoder: new TextEncoder(),
+			closed: false
+		};
+		this._sse.keepAliveTimer = armSseKeepAlive(this._keepAliveMs, () => this.writeCommentFrame("keepalive"));
+		this.settleResponse(new Response(readable, {
+			status: 200,
+			headers: {
+				"Content-Type": "text/event-stream",
+				"Cache-Control": "no-cache, no-transform",
+				Connection: "keep-alive",
+				"X-Accel-Buffering": "no"
+			}
+		}));
+	}
+	finalizeStream() {
+		if (this._sse?.keepAliveTimer !== void 0) clearInterval(this._sse.keepAliveTimer);
+		if (this._sse !== void 0 && !this._sse.closed) {
+			this._sse.closed = true;
+			try {
+				this._sse.controller.close();
+			} catch {}
+		}
+		queueMicrotask(() => void this.close());
+	}
+	writeMessageFrame(message) {
+		this.writeFrame(`event: message\ndata: ${JSON.stringify(message)}\n\n`);
+	}
+	writeFrame(frame) {
+		if (this._sse === void 0 || this._sse.closed) return;
+		try {
+			this._sse.controller.enqueue(this._sse.encoder.encode(frame));
+		} catch (error) {
+			this.onerror?.(/* @__PURE__ */ new Error(`Failed to write to the response stream: ${error}`));
+		}
+	}
+};
+/**
+* Serves one classified inbound message on the given server instance and
+* returns the HTTP response for the exchange.
+*
+* The instance is connected to a fresh single-exchange transport, the message
+* is injected through the normal transport message path, and whatever the
+* dispatch layer produces (the handler result, a protocol-level rejection, or
+* streamed related messages followed by the result) is captured as the
+* returned `Response`. For request exchanges, teardown rides the transport's
+* close chain once the terminal response has been delivered; notification
+* exchanges resolve with the 202 response immediately and do NOT run the
+* close chain — the transport stays connected until the caller closes it or
+* drops the per-request instance, which is the caller's choice either way.
+*/
+async function invoke(server, message, ctx) {
+	const transport = new PerRequestHTTPServerTransport({
+		classification: ctx.classification,
+		...ctx.responseMode !== void 0 && { responseMode: ctx.responseMode },
+		...ctx.keepAliveMs !== void 0 && { keepAliveMs: ctx.keepAliveMs }
+	});
+	await server.connect(transport);
+	return transport.handleMessage(message, {
+		...ctx.request !== void 0 && { request: ctx.request },
+		...ctx.authInfo !== void 0 && { authInfo: ctx.authInfo }
+	});
+}
 /** Default upper bound, in bytes, on a request body read by the HTTP entry points (4 MiB). */
 const DEFAULT_MAX_REQUEST_BODY_SIZE = 4194304;
 /** Upper bound on the number of messages accepted in one JSON-RPC batch array. */
@@ -25934,6 +26940,995 @@ var WebStandardStreamableHTTPServerTransport = class {
 		}
 	}
 };
+/**
+* The JSON-RPC id to echo on an entry-built error response: the body's `id`
+* when the body is a single JSON-RPC request whose id is a string or number,
+* `null` otherwise. Error responses must carry the id of the request they
+* correspond to whenever it could be read; `null` is reserved for the cases
+* where no single request id is determinable — unparseable bodies, body-less
+* methods, notifications, posted responses and batch arrays.
+*/
+function echoableRequestId(body) {
+	if (body === null || typeof body !== "object" || Array.isArray(body)) return null;
+	const { method, id } = body;
+	if (typeof method !== "string") return null;
+	return typeof id === "string" || typeof id === "number" ? id : null;
+}
+function jsonRpcErrorResponse(httpStatus, code, message, data, id = null) {
+	return Response.json({
+		jsonrpc: "2.0",
+		error: {
+			code,
+			message,
+			...data !== void 0 && { data }
+		},
+		id
+	}, { status: httpStatus });
+}
+function rejectionResponse(rejection, id = null) {
+	return jsonRpcErrorResponse(rejection.httpStatus, rejection.code, rejection.message, rejection.data, id);
+}
+function toError$1(value) {
+	return value instanceof Error ? value : new Error(String(value));
+}
+function internalServerErrorResponse(id = null) {
+	return jsonRpcErrorResponse(500, -32603, "Internal server error", void 0, id);
+}
+/** Throws when the factory returned an instance that is still connected to another exchange. */
+function assertNotServing(server) {
+	if (server.transport !== void 0) throw new Error("The factory returned an instance that is still serving another request. Return a new instance for each request.");
+}
+/**
+* The entry's default legacy serving (`legacy: 'stateless'`): per-request
+* stateless serving of 2025-era traffic using the same factory as the modern
+* path. Exported as a standalone building block for hand-wired compositions
+* (for example mounting legacy stateless serving on its own route next to a
+* strict modern endpoint).
+*
+* Each POST is served by a fresh instance from the factory connected to a
+* fresh streamable HTTP transport constructed with only
+* `sessionIdGenerator: undefined` — the established stateless idiom, unchanged.
+* Because serving is per-request and stateless, GET and DELETE (2025 session
+* operations) are answered with `405` / `Method not allowed.`, exactly like the
+* canonical stateless example.
+*
+* The optional `onerror` callback receives factory and serving failures on
+* this leg (reporting only — the response stays the 500 internal-error body).
+* The entry passes its own `onerror` here when expanding the default, so
+* legacy-leg failures are never silently swallowed.
+*/
+function createLegacyStatelessFallback(factory, onerror, keepAliveMs, maxRequestBodySize) {
+	return async (request, options) => {
+		if (request.method.toUpperCase() !== "POST") return jsonRpcErrorResponse(405, -32e3, "Method not allowed.");
+		try {
+			const product = await factory({
+				era: "legacy",
+				...options?.authInfo !== void 0 && { authInfo: options.authInfo },
+				requestInfo: request
+			});
+			const transport = new WebStandardStreamableHTTPServerTransport({
+				sessionIdGenerator: void 0,
+				...keepAliveMs !== void 0 && { keepAliveMs },
+				...maxRequestBodySize !== void 0 && { maxRequestBodySize }
+			});
+			await product.connect(transport);
+			const teardown = () => {
+				transport.close().catch(() => {});
+				product.close().catch(() => {});
+			};
+			request.signal?.addEventListener("abort", teardown, { once: true });
+			const response = await transport.handleRequest(request, {
+				...options?.authInfo !== void 0 && { authInfo: options.authInfo },
+				...options?.parsedBody !== void 0 && { parsedBody: options.parsedBody }
+			});
+			if (response.body === null || mediaTypeEssence(response.headers.get("content-type")) !== "text/event-stream") {
+				teardown();
+				return response;
+			}
+			const reader = response.body.getReader();
+			let toreDown = false;
+			const completeExchange = () => {
+				if (!toreDown) {
+					toreDown = true;
+					teardown();
+				}
+			};
+			const monitoredBody = new ReadableStream({
+				pull: async (controller) => {
+					try {
+						const { done, value } = await reader.read();
+						if (done) {
+							completeExchange();
+							controller.close();
+							return;
+						}
+						if (value !== void 0) controller.enqueue(value);
+					} catch (error) {
+						completeExchange();
+						controller.error(error);
+					}
+				},
+				cancel: (reason) => {
+					completeExchange();
+					return reader.cancel(reason).catch(() => {});
+				}
+			});
+			return new Response(monitoredBody, {
+				status: response.status,
+				statusText: response.statusText,
+				headers: response.headers
+			});
+		} catch (error) {
+			try {
+				onerror?.(toError$1(error));
+			} catch {}
+			return internalServerErrorResponse(echoableRequestId(options?.parsedBody));
+		}
+	};
+}
+/**
+* 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
+* a pre-parsed body is supplied) and classify the request with
+* {@linkcode classifyInboundRequest}. This is the single code path behind both
+* {@linkcode createMcpHandler}'s routing and the exported
+* {@linkcode isLegacyRequest} predicate, so the two can never disagree.
+*
+* Pass `needsForward: false` when the caller never reads `forwardRequest` —
+* the body-preserving clone is then skipped and `forwardRequest` is the
+* (consumed) input request.
+*/
+async function classifyEntryRequest(request, providedParsedBody, needsForward = true, maxRequestBodySize = DEFAULT_MAX_REQUEST_BODY_SIZE) {
+	const httpMethod = request.method.toUpperCase();
+	let body;
+	let parsedBody = providedParsedBody;
+	let forwardRequest = request;
+	let unparseable = false;
+	if (httpMethod === "POST") {
+		if (parsedBody === void 0) {
+			if (needsForward) forwardRequest = request.clone();
+			let bodyText;
+			try {
+				const read = await readRequestBody(request, maxRequestBodySize);
+				if (read.tooLarge) return { step: "body-too-large" };
+				bodyText = read.text;
+			} catch {
+				return { step: "unreadable-body" };
+			}
+			try {
+				body = bodyText.length === 0 ? void 0 : JSON.parse(bodyText);
+			} catch {
+				unparseable = true;
+			}
+			if (!unparseable && body !== void 0) parsedBody = body;
+		} else body = parsedBody;
+		if (unparseable || body === void 0) return {
+			step: "no-json-body",
+			forwardRequest
+		};
+	}
+	return {
+		step: "classified",
+		outcome: classifyInboundRequest({
+			httpMethod,
+			...standardHeadersOf(request),
+			...body !== void 0 && { body }
+		}),
+		body,
+		parsedBody,
+		forwardRequest
+	};
+}
+/**
+* Whether {@linkcode createMcpHandler} would route this request to its legacy
+* (2025-era) serving rather than the modern (2026-07-28) path.
+*
+* Call it with just the request: `await isLegacyRequest(request)`. For a
+* `POST` the body is read from an internal clone, so the request you pass
+* stays fully readable for whichever handler you route it to — no second
+* argument is needed. (In a Node `(req, res)` handler, build that `Request`
+* with `toWebRequest(req)` from `@modelcontextprotocol/node`; behind a body
+* parser, which has already drained the Node stream, build it as
+* `toWebRequest(req, req.body)` so the bytes come from the parsed body —
+* either way the predicate still takes just the request.) The optional
+* `parsedBody` is a perf escape hatch for a body you already hold parsed:
+* pass it and the predicate classifies from the value directly, reading and
+* cloning nothing. It is needed, not just faster, when the request's own
+* body was already read — the internal clone is then impossible (cloning a
+* used body throws a `TypeError`), so such a single-argument call rejects
+* instead of guessing.
+*
+* This is the entry's own classification step exported as a predicate — it
+* runs exactly the code `createMcpHandler` runs to make the routing decision,
+* not a re-implementation — so a hand-wired composition that branches on it
+* can never disagree with the entry. It is classification only: hand-wired
+* compositions must validate Content-Type themselves (415 for POSTs whose
+* media type is not `application/json`, via {@linkcode isJsonContentType})
+* before dispatching either leg — routing the legacy leg into the SDK
+* transports gets their built-in check, but a custom modern leg has none. Use it to keep an existing legacy
+* deployment (for example a sessionful streamable HTTP wiring) serving 2025
+* traffic next to a strict modern endpoint, now that the entry has no
+* handler-valued `legacy` option:
+*
+* ```ts
+* import { createMcpHandler, isLegacyRequest } from '@modelcontextprotocol/server';
+*
+* const modern = createMcpHandler(factory, { legacy: 'reject' });
+*
+* export default {
+*     async fetch(request: Request): Promise<Response> {
+*         if (await isLegacyRequest(request)) {
+*             // e.g. an existing sessionful WebStandardStreamableHTTPServerTransport wiring
+*             return myExistingLegacyHandler(request);
+*         }
+*         return modern.fetch(request);
+*     }
+* };
+* ```
+*
+* Semantics (identical to the entry's routing):
+*
+* - Returns `true` only for requests with no per-request `_meta` envelope
+*   claim: claim-less POSTs (including the `initialize` handshake and 2025-era
+*   notification POSTs without a modern protocol-version header), body-less
+*   GET/DELETE session operations, all-legacy JSON-RPC batch arrays, posted
+*   JSON-RPC responses, and POSTs whose body is empty or not valid JSON.
+* - Returns `false` for everything the modern path answers, including its
+*   validation-ladder rejections: a request carrying the envelope claim (even
+*   one naming a revision the endpoint does not serve — the modern path
+*   answers it with the unsupported-protocol-version error), a malformed
+*   envelope behind a present claim (answered `-32602`), a request whose
+*   `MCP-Protocol-Version` header names a modern revision but that lacks the
+*   envelope (`-32602`), 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
+*   envelope claim, so they are never legacy; a hand-built claim-less POST to
+*   a method named `server/discover` has no claim and classifies legacy,
+*   exactly as the entry itself routes it.
+*/
+async function isLegacyRequest(request, parsedBody, 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";
+}
+/**
+* Creates an HTTP handler that serves the 2026-07-28 protocol revision from a
+* per-request server factory and, by default, falls back to old-school
+* stateless serving for 2025-era traffic. Pass `legacy: 'reject'` for a
+* modern-only strict endpoint.
+*
+* Mounting: `handler.fetch` is the web-standard face (Cloudflare Workers,
+* Deno, Bun, Hono's `c.req.raw`); for Express/Fastify/plain `node:http`, wrap
+* the handler once with `toNodeHandler(handler)` from
+* `@modelcontextprotocol/node`. When mounting bare on a fetch-native runtime,
+* put Origin/Host validation in front of the handler — the entry itself is
+* deliberately validation-free:
+*
+* ```ts
+* import { hostHeaderValidationResponse, originValidationResponse, localhostAllowedHostnames, localhostAllowedOrigins } from '@modelcontextprotocol/server';
+*
+* export default {
+*     async fetch(request: Request): Promise<Response> {
+*         const rejected =
+*             hostHeaderValidationResponse(request, localhostAllowedHostnames()) ??
+*             originValidationResponse(request, localhostAllowedOrigins());
+*         return rejected ?? handler.fetch(request);
+*     }
+* };
+* ```
+*
+* Use ONE factory for both legs: the same tools/resources/prompts definition
+* backs the modern path and the stateless legacy fallback, so the two eras can
+* never drift apart. To keep an existing legacy deployment (for example a
+* sessionful streamable HTTP wiring) serving 2025 traffic instead of the
+* stateless fallback, route in user land with {@linkcode isLegacyRequest} in
+* front of a strict handler — see that predicate's documentation for the
+* pattern. Power users composing transport-neutral routing can also use the
+* exported building blocks directly: {@linkcode classifyInboundRequest} for
+* the era decision and `PerRequestHTTPServerTransport` for single-exchange
+* serving — such compositions must reject POSTs whose Content-Type media type
+* is not `application/json` (415) before parsing the body, using
+* {@linkcode isJsonContentType}; neither building block performs this
+* validation itself.
+*
+* The entry performs no token verification: `authInfo` given to `fetch` is
+* passed through to handlers and the factory as-is and is never derived from
+* request headers.
+*/
+function createMcpHandler(factory, options = {}) {
+	const { legacy, onerror, responseMode } = options;
+	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();
+	let closed = false;
+	const reportError = (error) => {
+		try {
+			onerror?.(error);
+		} catch {}
+	};
+	const bus = options.bus ?? new InMemoryServerEventBus(reportError);
+	const notify = createServerNotifier(bus);
+	const listenRouter = createListenRouter({
+		bus,
+		maxSubscriptions: options.maxSubscriptions ?? 1024,
+		keepAliveMs: options.keepAliveMs ?? 15e3,
+		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, maxRequestBodySize);
+	async function serveModern(route, request, authInfo) {
+		const claimedRevision = route.classification.revision;
+		if (claimedRevision === void 0 || !SUPPORTED_MODERN_PROTOCOL_VERSIONS.includes(claimedRevision)) {
+			const error = new UnsupportedProtocolVersionError({
+				supported: [...SUPPORTED_MODERN_PROTOCOL_VERSIONS],
+				requested: claimedRevision ?? "unknown"
+			});
+			reportError(error);
+			return jsonRpcErrorResponse(400, error.code, error.message, error.data, echoableRequestId(route.message));
+		}
+		const stdHeaderRejection = validateStandardRequestHeaders({
+			httpMethod: request.method,
+			...standardHeadersOf(request)
+		}, route);
+		if (stdHeaderRejection !== void 0) {
+			reportError(/* @__PURE__ */ new Error(`Rejected inbound request (${stdHeaderRejection.cell}): ${stdHeaderRejection.message}`));
+			return rejectionResponse(stdHeaderRejection, echoableRequestId(route.message));
+		}
+		const meta = route.messageKind === "request" ? requestMetaOf(route.message.params) : void 0;
+		const declaredClientCapabilities = meta?.[CLIENT_CAPABILITIES_META_KEY];
+		if (route.messageKind === "request") {
+			const required = requiredClientCapabilitiesForRequest(route.message.method);
+			if (required !== void 0) {
+				const missing = missingClientCapabilities(required, declaredClientCapabilities);
+				if (missing !== void 0) {
+					const error = new MissingRequiredClientCapabilityError({ requiredCapabilities: missing });
+					reportError(error);
+					return jsonRpcErrorResponse(httpStatusForErrorCode(error.code, "ladder"), error.code, error.message, error.data, route.message.id);
+				}
+			}
+		}
+		const product = await factory({
+			era: "modern",
+			...authInfo !== void 0 && { authInfo },
+			requestInfo: request
+		});
+		const server = product instanceof McpServer ? product.server : product;
+		assertNotServing(server);
+		if (route.messageKind === "request" && route.message.method === "subscriptions/listen") {
+			const capabilities = server.getCapabilities();
+			const serverInfo = serverIdentityOf(server);
+			product.close().catch(reportError);
+			return listenRouter.serve(route.message, request.signal, capabilities, serverInfo);
+		}
+		if (route.messageKind === "request" && route.message.method === "tools/call" && product instanceof McpServer) {
+			const callParams = route.message.params;
+			const toolName = typeof callParams?.name === "string" ? callParams.name : void 0;
+			const inputSchema = toolName === void 0 ? void 0 : product.toolInputSchemaJson(toolName);
+			if (inputSchema !== void 0) {
+				const scan = scanXMcpHeaderDeclarations(inputSchema);
+				if (scan.valid && scan.declarations.length > 0) {
+					const rejection = validateMcpParamHeaders(scan.declarations, callParams?.arguments, request.headers);
+					if (rejection !== void 0) {
+						product.close().catch(reportError);
+						reportError(/* @__PURE__ */ new Error(`Rejected inbound request (${rejection.cell}): ${rejection.message}`));
+						return rejectionResponse(rejection, route.message.id);
+					}
+				}
+			}
+		}
+		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$1(error));
+			return internalServerErrorResponse(route.message.id);
+		}
+		assertNotServing(server);
+		setNegotiatedProtocolVersion(server, claimedRevision);
+		installModernOnlyHandlers(server, SUPPORTED_MODERN_PROTOCOL_VERSIONS);
+		if (meta !== void 0) seedClientIdentityFromEnvelope(server, {
+			clientInfo: meta[CLIENT_INFO_META_KEY],
+			clientCapabilities: declaredClientCapabilities
+		});
+		const previousOnClose = server.onclose;
+		inflight.add(server);
+		const onExchangeClose = () => {
+			inflight.delete(server);
+			if (server.onclose === onExchangeClose) server.onclose = previousOnClose;
+			previousOnClose?.();
+		};
+		server.onclose = onExchangeClose;
+		try {
+			const response = await invoke(product, route.message, {
+				classification: route.classification,
+				request,
+				...authInfo !== void 0 && { authInfo },
+				...responseMode !== void 0 && { responseMode },
+				...options.keepAliveMs !== void 0 && { keepAliveMs: options.keepAliveMs }
+			});
+			if (route.messageKind === "notification") queueMicrotask(() => void server.close().catch(() => {}));
+			return response;
+		} catch (error) {
+			if (error instanceof SdkError && error.code === SdkErrorCode.ConnectionClosed) return new Response(null, { status: 499 });
+			await server.close().catch(() => {});
+			inflight.delete(server);
+			reportError(toError$1(error));
+			return internalServerErrorResponse(echoableRequestId(route.message));
+		}
+	}
+	async function serveLegacyRoute(route, forwardRequest, authInfo, parsedBody) {
+		if (legacyHandler !== void 0) return legacyHandler(forwardRequest, {
+			...authInfo !== void 0 && { authInfo },
+			...parsedBody !== void 0 && { parsedBody }
+		});
+		const strict = modernOnlyStrictRejection(route, SUPPORTED_MODERN_PROTOCOL_VERSIONS);
+		if (strict === void 0) return new Response(null, { status: 202 });
+		reportError(/* @__PURE__ */ new Error(`Rejected 2025-era request on a modern-only endpoint (${strict.cell}): ${strict.message}`));
+		return rejectionResponse(strict, echoableRequestId(parsedBody));
+	}
+	async function handle(request, requestOptions) {
+		const authInfo = requestOptions?.authInfo;
+		if (request.method.toUpperCase() === "POST" && !isJsonContentType(request.headers.get("content-type"))) {
+			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, 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");
+		}
+		const { outcome, body, parsedBody, forwardRequest } = classified;
+		try {
+			switch (outcome.kind) {
+				case "reject":
+					reportError(/* @__PURE__ */ new Error(`Rejected inbound request (${outcome.cell}): ${outcome.message}`));
+					return rejectionResponse(outcome, echoableRequestId(body));
+				case "modern": return await serveModern(outcome, request, authInfo);
+				case "legacy": return await serveLegacyRoute(outcome, forwardRequest, authInfo, parsedBody);
+			}
+		} catch (error) {
+			reportError(toError$1(error));
+			return internalServerErrorResponse(echoableRequestId(body));
+		}
+	}
+	const fetchFace = async (request, requestOptions) => {
+		if (closed) throw new Error("This MCP handler has been closed");
+		try {
+			return await handle(request, requestOptions);
+		} catch (error) {
+			reportError(toError$1(error));
+			return internalServerErrorResponse(echoableRequestId(requestOptions?.parsedBody));
+		}
+	};
+	return {
+		fetch: fetchFace,
+		notify,
+		bus,
+		close: async () => {
+			closed = true;
+			listenRouter.closeAll();
+			const closing = [...inflight].map((server) => server.close().catch(() => {}));
+			inflight.clear();
+			await Promise.all(closing);
+		}
+	};
+}
+const PREFIX = "v1.";
+function bytesToBase64Url(bytes) {
+	let bin = "";
+	for (const b of bytes) bin += String.fromCodePoint(b);
+	return btoa(bin).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/, "");
+}
+function constantTimeTagEqual(a, b) {
+	if (a.length !== b.length) return false;
+	let r = 0;
+	for (let i = 0; i < a.length; i++) r |= a.codePointAt(i) ^ b.codePointAt(i);
+	return r === 0;
+}
+function base64UrlToBytes(s) {
+	const b64 = s.replaceAll("-", "+").replaceAll("_", "/");
+	const bin = atob(b64);
+	const bytes = new Uint8Array(bin.length);
+	for (let i = 0; i < bin.length; i++) bytes[i] = bin.codePointAt(i);
+	return bytes;
+}
+/**
+* Create an opt-in HMAC-SHA256 codec for the multi-round-trip `requestState`
+* (protocol revision 2026-07-28).
+*
+* `requestState` round-trips through the client and is attacker-controlled
+* input on re-entry. The SDK applies no protection of its own; this helper is
+* the convenience implementation of the spec's integrity MUST so authors don't
+* hand-roll HMAC. Wire shape:
+*
+*     "v1." b64url({"p":<payload>,"exp":<unixSeconds>,"b":<bindTag>?}) "." b64url(mac)
+*
+* where `bindTag` is `b64url(HMAC(key, "mcp.requestState.bind:" + bind(ctx))[:16])`
+* — the binding value is never embedded raw.
+*
+* The codec is **signed, not encrypted**: the body is integrity-protected but
+* the client can base64url-decode it and read the payload (`p`) in clear. Do
+* not put secrets in the payload; use an AEAD construction if confidentiality
+* is required. The handler reads its payload back via the typed
+* `ctx.mcpReq.requestState<T>()` accessor — the seam has already run `verify`
+* (integrity proven, payload decoded) by the time the handler is entered.
+*
+* Verification is fail-closed and constant-time (WebCrypto `subtle.verify` for
+* the body MAC; a fixed-length XOR-accumulator compare for the bind tag).
+* See `examples/mrtr/server.ts` for a worked end-to-end example.
+*
+* Design comparison (mcp.d `secureRequestState`, the peer SDK's reference
+* implementation): mcp.d additionally offers an AES-256-GCM encrypted mode and
+* derives independent cipher / bind-HMAC sub-keys from the operator secret via
+* HKDF-SHA256, with an auto-generated per-process ephemeral key when none is
+* supplied. This codec deliberately ships only the signed mode and a single
+* keyed HMAC (domain-separated by input prefix) — HKDF sub-key derivation and
+* an encrypted mode are intentionally out of scope for the initial release.
+*/
+function createRequestStateCodec$1(options) {
+	const subtle = globalThis.crypto?.subtle;
+	if (subtle === void 0) throw new TypeError("createRequestStateCodec requires the Web Crypto API (globalThis.crypto.subtle); see https://ts.sdk.modelcontextprotocol.io/v2/troubleshooting for the Node.js polyfill instructions");
+	const keyBytes = typeof options.key === "string" ? new TextEncoder().encode(options.key) : Uint8Array.from(options.key);
+	if (keyBytes.byteLength < 32) throw new RangeError(`createRequestStateCodec: key must be at least 32 bytes (got ${keyBytes.byteLength})`);
+	const ttlSeconds = options.ttlSeconds ?? 600;
+	if (!Number.isFinite(ttlSeconds)) throw new RangeError("createRequestStateCodec: ttlSeconds must be a finite number");
+	const bind = options.bind;
+	let cryptoKey;
+	const importedKey = () => cryptoKey ??= subtle.importKey("raw", keyBytes, {
+		name: "HMAC",
+		hash: "SHA-256"
+	}, false, ["sign", "verify"]);
+	const utf8 = new TextEncoder();
+	const BIND_LABEL = "mcp.requestState.bind:";
+	const bindTag = async (value) => {
+		return bytesToBase64Url(new Uint8Array(await subtle.sign("HMAC", await importedKey(), utf8.encode(BIND_LABEL + value))).slice(0, 16));
+	};
+	return {
+		async mint(payload, ctx) {
+			const envelope = {
+				p: payload,
+				exp: Math.floor(Date.now() / 1e3) + ttlSeconds
+			};
+			if (bind !== void 0) {
+				if (ctx === void 0) throw new TypeError("createRequestStateCodec: mint() requires ctx when a bind callback is configured");
+				envelope.b = await bindTag(bind(ctx));
+			}
+			const body = bytesToBase64Url(utf8.encode(JSON.stringify(envelope)));
+			return `${PREFIX}${body}.${bytesToBase64Url(new Uint8Array(await subtle.sign("HMAC", await importedKey(), utf8.encode(PREFIX + body))))}`;
+		},
+		async verify(state, ctx) {
+			const dot = state.lastIndexOf(".");
+			if (!state.startsWith(PREFIX) || dot <= 3) throw new Error("malformed");
+			const body = state.slice(3, dot);
+			let macBytes;
+			try {
+				macBytes = base64UrlToBytes(state.slice(dot + 1));
+			} catch {
+				throw new Error("malformed");
+			}
+			if (!await subtle.verify("HMAC", await importedKey(), macBytes, utf8.encode(PREFIX + body))) throw new Error("mac");
+			let envelope;
+			try {
+				envelope = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(base64UrlToBytes(body)));
+			} catch {
+				throw new Error("malformed");
+			}
+			if (typeof envelope.exp !== "number" || envelope.exp < Math.floor(Date.now() / 1e3)) throw new Error("expired");
+			if (bind !== void 0) {
+				const expected = await bindTag(bind(ctx));
+				if (envelope.b === void 0 || !constantTimeTagEqual(envelope.b, expected)) throw new Error("bind");
+			} else if (envelope.b !== void 0) throw new Error("bind");
+			return envelope.p;
+		}
+	};
+}
+//#endregion
+//#region src/constants.ts
+const positiveIntEnv = (name, fallback) => {
+	const raw = readEnv(name).value;
+	if (raw === void 0 || raw.trim() === "") return fallback;
+	const parsed = Number(raw);
+	return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : fallback;
+};
+const CHARACTER_LIMIT = positiveIntEnv("RESPONSE_CHARACTER_LIMIT", 25e3);
+const ARTICLE_RESOURCES_SCAN_MAX_PAGES = positiveIntEnv("ARTICLE_RESOURCES_SCAN_MAX_PAGES", 20);
+const DEFAULT_CALLBACK_PORT = 27439;
+const MAX_ATTACHMENT_BYTES = positiveIntEnv("ATTACHMENT_MAX_BYTES", 5242880);
+const MAX_EMBEDDED_IMAGE_COUNT = positiveIntEnv("EMBEDDED_IMAGES_MAX", 10);
+const MESSAGE_CONTENT_BUDGET_BYTES = 10420224;
+const MAX_RESPONSE_BYTES = Math.min(positiveIntEnv("RESPONSE_MAX_BYTES", MESSAGE_CONTENT_BUDGET_BYTES), MESSAGE_CONTENT_BUDGET_BYTES);
+const MAX_BASE64_INPUT_CHARS = MESSAGE_CONTENT_BUDGET_BYTES;
+const MAX_BASE64_INPUT_MB = Number.parseFloat((MAX_BASE64_INPUT_CHARS / 4 * 3 / 1048576).toFixed(2));
+const MAX_COMMENT_PAGES = positiveIntEnv("COMMENT_MAX_PAGES", 10);
+const TICKET_FIELD_SCAN_MAX_PAGES = positiveIntEnv("TICKET_FIELD_SCAN_MAX_PAGES", 10);
+const REORDER_CONFIRM_THRESHOLD = positiveIntEnv("REORDER_CONFIRM_THRESHOLD", 20);
+const getBaseUrl = (subdomain) => `https://${subdomain}.zendesk.com/api/v2`;
+const getHelpCenterBaseUrl = (subdomain) => `https://${subdomain}.zendesk.com/api/v2/help_center`;
+const getOAuthUrls = (subdomain) => ({
+	authorizeUrl: `https://${subdomain}.zendesk.com/oauth/authorizations/new`,
+	tokenUrl: `https://${subdomain}.zendesk.com/oauth/tokens`
+});
+//#endregion
+//#region src/client/retry.ts
+const MAX_ATTEMPTS = 3;
+const BASE_DELAY_MS = 250;
+const MAX_DELAY_MS = 4e3;
+const REQUEST_TIMEOUT_MS = 3e4;
+const TRANSFER_TIMEOUT_MS = 12e4;
+/**
+* A deadline for one attempt. The abort surfaces as a `TimeoutError` whose `code`
+* is numeric, not a syscall string, so it classifies as `unknown`: a GET is
+* retried, a write is not — the request may have arrived before the deadline.
+*/
+const deadlineSignal = (timeoutMs) => AbortSignal.timeout(timeoutMs);
+const MAX_RETRY_AFTER_MS = 5e3;
+const POLICIES = {
+	GET: {
+		network: "any",
+		serverErrors: true
+	},
+	DELETE: {
+		network: "pre-send",
+		serverErrors: false
+	},
+	POST: {
+		network: "pre-send",
+		serverErrors: false
+	},
+	PUT: {
+		network: "pre-send",
+		serverErrors: false
+	}
+};
+const DELAY_SECONDS = /^\d+$/;
+const HTTP_DATE_START = /^[A-Za-z]/;
+const NON_ASCII = /[^ -~]/g;
+const TOKEN_SEGMENT = /\/token\/[^/]+/;
+const URL_IN_TEXT = /[a-z][a-z0-9+.-]*:\/\/\S+/gi;
+const PRE_SEND_CODES = /* @__PURE__ */ new Set([
+	"ENOTFOUND",
+	"EAI_AGAIN",
+	"ECONNREFUSED",
+	"UND_ERR_CONNECT_TIMEOUT"
+]);
+const defaultRetryDeps = {
+	sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+	random: Math.random
+};
+/** Non-ASCII bytes break `node:http` headers, so client error text stays ASCII. */
+const toAscii = (text) => text.replace(NON_ASCII, "?");
+/**
+* Identifies the request without leaking a credential: uploads carry an upload
+* token in the query string, and an attachment `content_url` carries a download
+* token as a path segment (`/attachments/token/<token>/`).
+*/
+const describeTarget = (url) => {
+	const { origin, pathname } = new URL(url);
+	return `${origin}${pathname.replace(TOKEN_SEGMENT, "/token/[redacted]")}`;
+};
+/** First `code` in the cause chain, inspecting 5 levels so a cycle cannot hang. */
+const errorCode = (err) => {
+	let current = err;
+	for (let depth = 0; depth < 5 && current !== null && typeof current === "object"; depth += 1) {
+		const { code, cause } = current;
+		if (typeof code === "string") return code;
+		current = cause;
+	}
+};
+const classifyNetworkError = (err) => PRE_SEND_CODES.has(errorCode(err)) ? "pre-send" : "unknown";
+const UNINFORMATIVE_NAMES = /* @__PURE__ */ new Set(["Error", "TypeError"]);
+/**
+* The client refuses to replay a write that may have landed — but the caller is
+* an LLM whose reflex on a failed tool call is to try again, which would undo
+* that. So a failed write says whether it may have taken effect. ASCII only,
+* same rule as the rest of the message.
+*/
+const MAY_HAVE_APPLIED_NOTE = "The write may already have been applied. Check the current state before retrying, or you may duplicate it.";
+const NEVER_SENT_NOTE = "The request never reached Zendesk, so nothing was applied. Retrying is safe.";
+const REFUSED_NOTE = "Zendesk refused the request, so nothing was applied. Retrying is safe.";
+/** Only a write can be duplicated by a replay, so only a write carries a note. */
+const writeNote = (method, note) => method === "GET" ? "" : ` ${note}`;
+/**
+* A cause message can quote the URL it failed on — Node's `fetch` refuses a URL
+* carrying credentials by printing the whole thing, query string included — which
+* would smuggle back exactly what `describeTarget` drops. Same treatment for both,
+* so one function owns what a URL may look like in our output.
+*/
+const redactUrls = (text) => text.replace(URL_IN_TEXT, (found) => {
+	try {
+		return new URL(found).origin === "null" ? "[url]" : describeTarget(found);
+	} catch {
+		return "[url]";
+	}
+});
+const failureDetail = (cause) => {
+	if (!(cause instanceof Error)) return redactUrls(String(cause));
+	const message = redactUrls(cause.message);
+	const code = errorCode(cause);
+	if (code !== void 0) return `${code}: ${message}`;
+	return UNINFORMATIVE_NAMES.has(cause.name) ? message : `${cause.name}: ${message}`;
+};
+const networkErrorMessage = (method, target, attempts, cause) => {
+	const base = `Network error on ${method} ${target} after ${attempts === 1 ? "1 attempt" : `${attempts} attempts`}: ${failureDetail(cause)}`;
+	const note = classifyNetworkError(cause) === "pre-send" ? NEVER_SENT_NOTE : MAY_HAVE_APPLIED_NOTE;
+	return toAscii(method === "GET" ? base : `${base}.${writeNote(method, note)}`);
+};
+const createZendeskNetworkError = (method, target, attempts, cause) => Object.assign(new Error(networkErrorMessage(method, target, attempts, cause), { cause }), {
+	name: "ZendeskNetworkError",
+	method,
+	target,
+	attempts
+});
+/** Exponential backoff with equal jitter: half the window fixed, half random. */
+const computeBackoffMs = (attempt, random) => {
+	const window = Math.min(BASE_DELAY_MS * 2 ** (attempt - 1), MAX_DELAY_MS);
+	return Math.round(window / 2 + window * random() / 2);
+};
+/** `Retry-After` in ms — delay-seconds or HTTP-date. */
+const parseRetryAfter = (header, now = Date.now()) => {
+	if (header === null) return void 0;
+	const value = header.trim();
+	if (DELAY_SECONDS.test(value)) return Number(value) * 1e3;
+	if (!HTTP_DATE_START.test(value)) return void 0;
+	const date = Date.parse(value);
+	if (Number.isNaN(date)) return void 0;
+	return Math.max(0, date - now);
+};
+/**
+* How long to wait before replaying this response, or undefined to accept it.
+* `Retry-After` wins over backoff wherever it appears — Zendesk sends it on a 503
+* during maintenance as well as on a 429 — and a value past the cap means the
+* response is surfaced rather than parking the call for that long.
+*/
+const retryDelayFor = (response, policy, attempt, random) => {
+	if (!(response.status === 429 || response.status >= 500 && policy.serverErrors)) return void 0;
+	const retryAfter = parseRetryAfter(response.headers.get("retry-after"));
+	if (retryAfter === void 0) return computeBackoffMs(attempt, random);
+	return retryAfter > MAX_RETRY_AFTER_MS ? void 0 : retryAfter;
+};
+/**
+* Runs `attempt` until it succeeds, hits a terminal outcome, or spends the
+* attempt budget. Returns the last response for the caller to inspect (a
+* non-ok status is still the caller's to turn into a `ZendeskApiError`), and
+* throws `ZendeskNetworkError` when no response was ever obtained.
+*/
+const fetchWithRetry = async (attempt, method, target, deps = defaultRetryDeps) => {
+	const policy = POLICIES[method];
+	for (let tries = 1;; tries += 1) {
+		const last = tries >= MAX_ATTEMPTS;
+		let response;
+		try {
+			response = await attempt();
+		} catch (err) {
+			const replayable = policy.network === "any" || classifyNetworkError(err) === policy.network;
+			if (last || !replayable) throw createZendeskNetworkError(method, target, tries, err);
+			await deps.sleep(computeBackoffMs(tries, deps.random));
+			continue;
+		}
+		if (last) return response;
+		const delayMs = retryDelayFor(response, policy, tries, deps.random);
+		if (delayMs === void 0) return response;
+		await response.text().catch(() => void 0);
+		await deps.sleep(delayMs);
+	}
+};
+//#endregion
+//#region src/client/zendesk-api.ts
+var ZendeskApiError = class ZendeskApiError extends Error {
+	status;
+	statusText;
+	body;
+	method;
+	constructor(status, statusText, body, method) {
+		super(ZendeskApiError.buildMessage(status, statusText, body, method));
+		this.status = status;
+		this.statusText = statusText;
+		this.body = body;
+		this.method = method;
+		this.name = "ZendeskApiError";
+	}
+	static buildMessage(status, statusText, body, method) {
+		switch (status) {
+			case 401: return "Authentication failed. Your Zendesk token may be expired or invalid. Re-authenticate to get a new token.";
+			case 403: return "Permission denied. Your Zendesk account does not have access to this resource.";
+			case 404: return `Resource not found. Please verify the ID is correct. (${statusText})`;
+			case 422: return `Validation error: ${body}`;
+			case 429: return `Rate limit exceeded. Please wait before making more requests.${writeNote(method, REFUSED_NOTE)}`;
+			default: {
+				const message = `Zendesk API error ${status}: ${statusText}. ${body}`;
+				return status >= 500 ? `${message}${writeNote(method, MAY_HAVE_APPLIED_NOTE)}` : message;
+			}
+		}
+	}
+};
+const buildAuthHeader = (token) => `Bearer ${token}`;
+const buildUrl = (base, path, params) => {
+	const url = new URL(`${base}${path}`);
+	if (params) for (const [key, value] of Object.entries(params)) url.searchParams.set(key, value);
+	return url.toString();
+};
+const performFetch = (method, url, init, timeoutMs = REQUEST_TIMEOUT_MS) => fetchWithRetry(() => fetch(url, {
+	...init,
+	method,
+	signal: deadlineSignal(timeoutMs)
+}), method, describeTarget(url));
+const executeRequest = async (url, token, options = {}) => {
+	const { method = "GET", body } = options;
+	const headers = {
+		Authorization: buildAuthHeader(token),
+		Accept: "application/json"
+	};
+	if (body) headers["Content-Type"] = "application/json";
+	const init = { headers };
+	if (body) init.body = JSON.stringify(body);
+	const response = await performFetch(method, url, init);
+	if (!response.ok) {
+		const responseBody = await response.text();
+		throw new ZendeskApiError(response.status, response.statusText, responseBody, method);
+	}
+	if (response.status === 204) return {};
+	return response.json();
+};
+const zendeskGet = (subdomain, token, path, params) => {
+	const url = buildUrl(getBaseUrl(subdomain), path, params);
+	return executeRequest(url, token);
+};
+const zendeskPost = (subdomain, token, path, body) => {
+	const url = buildUrl(getBaseUrl(subdomain), path);
+	return executeRequest(url, token, {
+		method: "POST",
+		body
+	});
+};
+const zendeskPut = (subdomain, token, path, body) => {
+	const url = buildUrl(getBaseUrl(subdomain), path);
+	return executeRequest(url, token, {
+		method: "PUT",
+		body
+	});
+};
+const helpCenterGet = (subdomain, token, path, params) => {
+	const url = buildUrl(getHelpCenterBaseUrl(subdomain), path, params);
+	return executeRequest(url, token);
+};
+const helpCenterPost = (subdomain, token, path, body) => {
+	const url = buildUrl(getHelpCenterBaseUrl(subdomain), path);
+	return executeRequest(url, token, {
+		method: "POST",
+		body
+	});
+};
+const helpCenterPut = (subdomain, token, path, body) => {
+	const url = buildUrl(getHelpCenterBaseUrl(subdomain), path);
+	return executeRequest(url, token, {
+		method: "PUT",
+		body
+	});
+};
+const helpCenterDelete = (subdomain, token, path) => {
+	const url = buildUrl(getHelpCenterBaseUrl(subdomain), path);
+	return executeRequest(url, token, { method: "DELETE" });
+};
+const fetchZendeskBinary = async (subdomain, token, contentUrl) => {
+	const expectedHost = `${subdomain}.zendesk.com`;
+	const headers = {};
+	if (new URL(contentUrl).hostname === expectedHost) headers["Authorization"] = buildAuthHeader(token);
+	const response = await performFetch("GET", contentUrl, { headers }, TRANSFER_TIMEOUT_MS);
+	if (!response.ok) {
+		const body = await response.text();
+		throw new ZendeskApiError(response.status, response.statusText, body, "GET");
+	}
+	const contentType = response.headers.get("content-type") ?? "application/octet-stream";
+	const arrayBuffer = await response.arrayBuffer();
+	return {
+		data: Buffer.from(arrayBuffer),
+		contentType
+	};
+};
+const zendeskUpload = async (subdomain, token, filename, data, contentType, uploadToken) => {
+	const params = { filename };
+	if (uploadToken) params["token"] = uploadToken;
+	const url = buildUrl(getBaseUrl(subdomain), "/uploads", params);
+	const response = await performFetch("POST", url, {
+		headers: {
+			Authorization: buildAuthHeader(token),
+			"Content-Type": contentType
+		},
+		body: data
+	}, TRANSFER_TIMEOUT_MS);
+	if (!response.ok) {
+		const responseBody = await response.text();
+		throw new ZendeskApiError(response.status, response.statusText, responseBody, "POST");
+	}
+	return response.json();
+};
+const helpCenterUpload = async (subdomain, token, path, formData) => {
+	const url = buildUrl(getHelpCenterBaseUrl(subdomain), path);
+	const response = await performFetch("POST", url, {
+		headers: { Authorization: buildAuthHeader(token) },
+		body: formData
+	}, TRANSFER_TIMEOUT_MS);
+	if (!response.ok) {
+		const responseBody = await response.text();
+		throw new ZendeskApiError(response.status, response.statusText, responseBody, "POST");
+	}
+	return response.json();
+};
+//#endregion
+//#region src/client/brands.ts
+const BRAND_SUBDOMAIN = /^[a-z0-9][a-z0-9-]*$/;
+/**
+* Fetch every brand of the account (cursor-paginated). `page[size]` is sent on
+* the FIRST request too: without it Zendesk falls back to OFFSET pagination,
+* which answers without `meta.after_cursor`, and the loop below would stop
+* after page 1 — a brand past the first 100 would resolve as Unknown.
+*/
+const fetchAllBrands = async (subdomain, token) => {
+	const brands = [];
+	let cursor;
+	do {
+		const response = await zendeskGet(subdomain, token, "/brands", {
+			"page[size]": String(100),
+			...cursor ? { "page[after]": cursor } : {}
+		});
+		brands.push(...response.brands ?? []);
+		const meta = response.meta;
+		if (meta?.has_more) {
+			if (!meta.after_cursor || meta.after_cursor === cursor) throw new Error("GET /brands reported more pages but returned no usable after_cursor (missing or identical to the cursor just sent). Cannot continue pagination safely.");
+			cursor = meta.after_cursor;
+		} else cursor = void 0;
+	} while (cursor);
+	return brands;
+};
+const createBrandSubdomainResolver = (subdomain, getToken) => {
+	let cached;
+	const brands = () => {
+		if (!cached || Date.now() - cached.at >= 3e5) {
+			const promise = (async () => fetchAllBrands(subdomain, await getToken()))();
+			cached = {
+				at: Date.now(),
+				promise
+			};
+			promise.catch(() => {
+				cached = void 0;
+			});
+		}
+		return cached.promise;
+	};
+	return async (idOrSubdomain) => {
+		const all = await brands();
+		const brand = all.find((b) => String(b.id) === idOrSubdomain) ?? all.find((b) => b.subdomain.toLowerCase() === idOrSubdomain.toLowerCase());
+		if (!brand) throw new Error(`Unknown brand "${idOrSubdomain}": no brand with that id or subdomain exists on this account; call list_brands to see the available brands.`);
+		if (!BRAND_SUBDOMAIN.test(brand.subdomain)) throw new Error(`Brand ${brand.id} has an unexpected subdomain; refusing to send a request to it.`);
+		return brand.subdomain;
+	};
+};
 //#endregion
 //#region node_modules/.pnpm/cheerio@1.2.0/node_modules/cheerio/dist/esm/options.js
 const defaultOpts$2 = { _useHtmlParser2: false };
@@ -103710,7 +105705,6 @@ const countWords = (text) => {
 	return trimmed.split(WHITESPACE_RUN).length;
 };
 const textOf = (html) => {
-	if (!html) return "";
 	return load(`<div>${html}</div>`, null, false)("div").first().text();
 };
 const parseSections = (html) => {
@@ -103826,14 +105820,8 @@ const htmlToMdProcessor = unified().use(rehypeParse, { fragment: true }).use(reh
 	emphasis: "_"
 });
 const mdToHtmlProcessor = unified().use(remarkParse).use(remarkGfm).use(remarkRehype, { allowDangerousHtml: true }).use(rehypeRaw).use(rehypeStringify);
-const htmlToMarkdown = (html) => {
-	if (!html) return "";
-	return String(htmlToMdProcessor.processSync(html));
-};
-const markdownToHtml = (markdown) => {
-	if (!markdown) return "";
-	return String(mdToHtmlProcessor.processSync(markdown));
-};
+const htmlToMarkdown = (html) => String(htmlToMdProcessor.processSync(html));
+const markdownToHtml = (markdown) => String(mdToHtmlProcessor.processSync(markdown));
 //#endregion
 //#region src/utils/formatting.ts
 const truncateIfNeeded = (text, advice = "Use pagination or filters to reduce results.") => {
@@ -107808,12 +109796,6 @@ const SEVERITY = {
 	warn: 2,
 	error: 3
 };
-const MCP_LEVEL = {
-	debug: "debug",
-	info: "info",
-	warn: "warning",
-	error: "error"
-};
 const REDACTED_KEYS = /* @__PURE__ */ new Set([
 	"token",
 	"accesstoken",
@@ -107862,37 +109844,21 @@ const silentLogger = {
 	debug: noop,
 	info: noop,
 	warn: noop,
-	error: noop,
-	attachServer: noop
+	error: noop
 };
 const createLogger = (level) => {
 	const min = SEVERITY[level];
-	let server;
 	const emit = (lvl, event, fields) => {
 		if (SEVERITY[lvl] < min) return;
-		const safe = sanitise(fields);
 		try {
-			console.error(formatLine(lvl, event, safe));
-		} catch {}
-		if (server) try {
-			server.sendLoggingMessage({
-				level: MCP_LEVEL[lvl],
-				logger: "zendesk-mcp-server",
-				data: {
-					...safe,
-					event
-				}
-			}).catch(noop);
+			console.error(formatLine(lvl, event, sanitise(fields)));
 		} catch {}
 	};
 	return {
 		debug: (event, fields) => emit("debug", event, fields),
 		info: (event, fields) => emit("info", event, fields),
 		warn: (event, fields) => emit("warn", event, fields),
-		error: (event, fields) => emit("error", event, fields),
-		attachServer: (s) => {
-			server = s;
-		}
+		error: (event, fields) => emit("error", event, fields)
 	};
 };
 //#endregion
@@ -107915,16 +109881,13 @@ const readPackageInfo = () => {
 	let dir = dirname(fileURLToPath(import.meta.url));
 	for (let depth = 0; depth < 8; depth++) {
 		try {
-			const raw = JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
-			if (raw && typeof raw === "object") {
-				const pkg = raw;
-				if (typeof pkg.name === "string" && typeof pkg.version === "string") {
-					cached = {
-						name: pkg.name,
-						version: pkg.version
-					};
-					return cached;
-				}
+			const pkg = JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
+			if (typeof pkg?.name === "string" && typeof pkg.version === "string") {
+				cached = {
+					name: pkg.name,
+					version: pkg.version
+				};
+				return cached;
 			}
 		} catch {}
 		const parent = dirname(dir);
@@ -107935,6 +109898,19 @@ const readPackageInfo = () => {
 	return cached;
 };
 //#endregion
+//#region src/utils/request-state.ts
+/**
+* `requestState` round-trips through the client, so it comes back as
+* attacker-controlled input: the spec requires integrity protection and binding
+* to the user. Every server verifies it with this codec (`requestState.verify`)
+* and handlers mint state only through it. Bound to the method and the
+* principal, so state minted for one grant or one method is refused elsewhere.
+*/
+const createRequestStateCodec = ({ key = randomBytes(32), principal = () => "" }) => createRequestStateCodec$1({
+	key,
+	bind: (ctx) => `${ctx.mcpReq.method}\0${principal()}`
+});
+//#endregion
 //#region src/server.ts
 /**
 * Invoke a tool handler, notifying `onUnauthorized` when Zendesk rejects the
@@ -107997,24 +109973,29 @@ const registerProxyTool = (server, toolName, title, tools, readOnlyMode, onUnaut
 	}, async (args) => dispatch(args));
 };
 /**
-* Build the bare `McpServer` — identity, capabilities, `instructions` and the
-* logging sink — with no tools or resources registered yet. Split out from
-* `createMcpServer` so the dev reload (`dev/reload.ts`) can keep this
-* long-lived shell (and its transport/session) alive while swapping the toolset
-* underneath it via `registerToolset`.
+* Build the bare `McpServer` — identity, `instructions` — with no tools or
+* resources registered yet. Split out from `createMcpServer` so the dev reload
+* (`dev/reload.ts`) can keep this long-lived shell (and its transport/session)
+* alive while swapping the toolset underneath it via `registerToolset`.
 */
-const createServerShell = (config, logger = silentLogger) => {
+const createServerShell = (config, requestStateCodec = createRequestStateCodec({})) => {
 	const pkg = readPackageInfo();
 	const instructions = buildInstructions(config);
-	const server = new McpServer({
+	return new McpServer({
 		name: pkg.name,
 		version: pkg.version
 	}, {
-		capabilities: { logging: {} },
-		...instructions ? { instructions } : {}
+		...instructions ? { instructions } : {},
+		requestState: { verify: (state, ctx) => requestStateCodec.verify(state, ctx) }
 	});
-	logger.attachServer(server);
-	return server;
+};
+const createServerCaches = (config, getToken, onUnauthorized) => {
+	const resolveBrandSubdomain = createBrandSubdomainResolver(config.subdomain, getToken);
+	return {
+		resolveBrandSubdomain,
+		topology: helpCenterContextEnabled(config) ? createTopologyProvider(getToken, config.subdomain, onUnauthorized, config.brandIds, firstBrandSubdomainResolver(config, resolveBrandSubdomain)) : void 0,
+		articles: articleResourceEnabled(config) ? createArticleResourcesProvider(getToken, config.subdomain, onUnauthorized, resourceBrandResolver(config, resolveBrandSubdomain), config.brandIds) : void 0
+	};
 };
 /**
 * Lazily resolve the Help Center subdomain the topology resource pins to: the
@@ -108051,8 +110032,8 @@ const resourceBrandResolver = (config, resolveBrandSubdomain) => {
 * without dropping the transport. `tools` is passed in (not built here) so the
 * reload path can hand over freshly re-imported definitions.
 */
-const registerToolset = (server, { config, getToken, resolveBrandSubdomain, onUnauthorized, logger = silentLogger }, tools) => {
-	const sharedResolver = resolveBrandSubdomain ?? createBrandSubdomainResolver(config.subdomain, getToken);
+const registerToolset = (server, { config, getToken, caches, onUnauthorized, logger = silentLogger }, tools) => {
+	const { topology, articles } = caches ?? createServerCaches(config, getToken, onUnauthorized);
 	const registered = [];
 	const dispose = () => {
 		for (const handle of registered) handle.remove();
@@ -108088,20 +110069,16 @@ const registerToolset = (server, { config, getToken, resolveBrandSubdomain, onUn
 				throw new Error(`Unsupported tool mode: ${String(unhandled)}`);
 			}
 		}
-		if (helpCenterContextEnabled(config)) {
-			const topology = createTopologyProvider(getToken, config.subdomain, onUnauthorized, config.brandIds, firstBrandSubdomainResolver(config, sharedResolver));
-			registered.push(server.registerResource("help-center-topology", topologyResourceUri(config), {
-				title: "Zendesk Help Center topology",
-				description: "Active locales, category → section tree, visibility segments, permission groups, and your role. Useful context when creating or editing content; admin-only sections (permission groups, user segments) are marked unavailable rather than empty when your role lacks Guide-admin rights.",
-				mimeType: "text/markdown"
-			}, async (uri) => ({ contents: [{
-				uri: uri.toString(),
-				mimeType: "text/markdown",
-				text: await topology.read()
-			}] })));
-		}
-		if (articleResourceEnabled(config)) {
-			const articles = createArticleResourcesProvider(getToken, config.subdomain, onUnauthorized, resourceBrandResolver(config, sharedResolver), config.brandIds);
+		if (topology) registered.push(server.registerResource("help-center-topology", topologyResourceUri(config), {
+			title: "Zendesk Help Center topology",
+			description: "Active locales, category → section tree, visibility segments, permission groups, and your role. Useful context when creating or editing content; admin-only sections (permission groups, user segments) are marked unavailable rather than empty when your role lacks Guide-admin rights.",
+			mimeType: "text/markdown"
+		}, async (uri) => ({ contents: [{
+			uri: uri.toString(),
+			mimeType: "text/markdown",
+			text: await topology.read()
+		}] })));
+		if (articles) {
 			const listPromotedEnabled = promotedArticlesEnabled(config);
 			const template = new ResourceTemplate(articleResourceUriTemplate(config), { list: async () => {
 				if (!listPromotedEnabled) return { resources: [] };
@@ -108144,7 +110121,7 @@ const registerToolset = (server, { config, getToken, resolveBrandSubdomain, onUn
 		dispose();
 		throw err;
 	}
-	logger.info("tools_registered", {
+	logger.debug("tools_registered", {
 		count: filteredTools.length,
 		mode: config.mode
 	});
@@ -108153,24 +110130,27 @@ const registerToolset = (server, { config, getToken, resolveBrandSubdomain, onUn
 		dispose
 	};
 };
-const createMcpServer = (config, getToken, logger = silentLogger, onUnauthorized) => {
-	const server = createServerShell(config, logger);
-	const resolveBrandSubdomain = createBrandSubdomainResolver(config.subdomain, getToken);
+const createMcpServer = (config, getToken, logger = silentLogger, onUnauthorized, { caches = createServerCaches(config, getToken, onUnauthorized), requestStateCodec } = {}) => {
+	const server = createServerShell(config, requestStateCodec);
 	const tools = createAllTools({
 		subdomain: config.subdomain,
 		brandIds: config.brandIds,
-		resolveBrandSubdomain,
+		resolveBrandSubdomain: caches.resolveBrandSubdomain,
 		getToken
 	});
 	registerToolset(server, {
 		config,
 		getToken,
-		resolveBrandSubdomain,
+		caches,
 		onUnauthorized,
 		logger
 	}, tools);
 	return server;
 };
+const defaultServerFactory = ({ config, getToken, logger, onUnauthorized, caches, requestStateCodec }) => createMcpServer(config, getToken, logger, onUnauthorized, {
+	...caches ? { caches } : {},
+	requestStateCodec
+});
 //#endregion
 //#region node_modules/.pnpm/@modelcontextprotocol+server@2.3.1/node_modules/@modelcontextprotocol/server/dist/stdio.mjs
 /**
@@ -108296,12 +110276,485 @@ var StdioServerTransport = class {
 		});
 	}
 };
+/**
+* How long the probe-discard path waits for the probe instance to answer the
+* requests it was delivered before closing it. The wait normally settles as
+* soon as the DiscoverResult is handed to the wire (or immediately, when a
+* delivered cancellation already settled the probe); the bound is a backstop
+* so no edge can ever hold the connection's inbound pump indefinitely behind
+* the discard.
+*/
+const DISCARD_ANSWER_TIMEOUT_MS = 3e3;
+/**
+* The transport a pinned instance is connected to: a thin channel that writes
+* through to the entry-owned wire transport and receives the messages the
+* entry forwards. The wire transport itself is never handed to an instance —
+* that is what lets the entry discard an optimistic probe instance (close the
+* channel) without tearing down the connection.
+*/
+var StdioConnectionChannel = class {
+	onclose;
+	onerror;
+	onmessage;
+	_closed = false;
+	/** Request ids the entry delivered to the instance that the instance has not yet answered. */
+	_pendingRequests = /* @__PURE__ */ new Set();
+	_drainWaiters = [];
+	constructor(_wire, _onInstanceClose, _outboundIntercept) {
+		this._wire = _wire;
+		this._onInstanceClose = _onInstanceClose;
+		this._outboundIntercept = _outboundIntercept;
+	}
+	async start() {}
+	async send(message, options) {
+		if (isJSONRPCResultResponse(message) || isJSONRPCErrorResponse(message)) {
+			const { id } = message;
+			if (id !== void 0) this._settle(id);
+		}
+		if (this._closed) return;
+		if (this._outboundIntercept?.(message) === "handled") return;
+		return this._wire.send(message, options);
+	}
+	setProtocolVersion = (version) => {
+		this._wire.setProtocolVersion?.(version);
+	};
+	/** Forwards one inbound message to the connected instance. */
+	deliver(message, extra) {
+		if (this._closed) return;
+		if (isJSONRPCRequest(message)) this._pendingRequests.add(message.id);
+		else if (isJSONRPCNotification(message) && message.method === "notifications/cancelled") {
+			const cancelledId = message.params?.requestId;
+			if (cancelledId !== void 0) this._settle(cancelledId);
+		}
+		this.onmessage?.(message, extra);
+	}
+	/**
+	* Resolves once every request delivered to the instance has been answered
+	* through {@linkcode send}, settled by a delivered cancellation, or the
+	* channel has been closed and nothing further can be answered. The wait is
+	* bounded by `timeoutMs` as a backstop so no edge can hold the caller
+	* indefinitely; resolves `false` only when the bound elapsed with requests
+	* still unanswered. Used by the probe-discard path so a probe request the
+	* entry accepted is never silently dropped.
+	*/
+	async whenRequestsAnswered(timeoutMs) {
+		if (this._closed || this._pendingRequests.size === 0) return true;
+		return await new Promise((resolve) => {
+			const waiter = () => {
+				clearTimeout(timer);
+				resolve(true);
+			};
+			const timer = setTimeout(() => {
+				this._drainWaiters = this._drainWaiters.filter((pending) => pending !== waiter);
+				resolve(false);
+			}, timeoutMs);
+			this._drainWaiters.push(waiter);
+		});
+	}
+	async close() {
+		if (this._closed) return;
+		this._closed = true;
+		this._pendingRequests.clear();
+		this._releaseDrainWaiters();
+		try {
+			this._onInstanceClose();
+		} finally {
+			this.onclose?.();
+		}
+	}
+	_settle(id) {
+		this._pendingRequests.delete(id);
+		if (this._pendingRequests.size === 0) this._releaseDrainWaiters();
+	}
+	_releaseDrainWaiters() {
+		const waiters = this._drainWaiters;
+		this._drainWaiters = [];
+		for (const waiter of waiters) waiter();
+	}
+};
+/**
+* Classifies one message of the opening exchange with the same body-primary
+* rules the HTTP entry applies per request: `initialize` is the legacy
+* handshake unless it carries a valid modern envelope claim; a present claim
+* is validated (never silently ignored); a claim-less message is 2025-era
+* traffic. There is no header layer on stdio, so the body is the only signal.
+*/
+function classifyOpeningMessage(message) {
+	const params = message.params;
+	if (message.method === "initialize" && !carriesValidModernEnvelopeClaim(params)) {
+		const requestedVersion = params !== null && typeof params === "object" && typeof params.protocolVersion === "string" ? params.protocolVersion : void 0;
+		return {
+			kind: "legacy",
+			reason: "initialize",
+			...requestedVersion !== void 0 && { requestedVersion }
+		};
+	}
+	if (!hasEnvelopeClaim(params)) return {
+		kind: "legacy",
+		reason: "no-claim"
+	};
+	const meta = requestMetaOf(params);
+	const firstIssue = (meta === void 0 ? [] : validateEnvelopeMeta(meta))[0];
+	if (firstIssue !== void 0) return {
+		kind: "invalid-envelope",
+		issue: firstIssue
+	};
+	const claimedVersion = envelopeClaimVersion(params);
+	if (claimedVersion === void 0 || !SUPPORTED_MODERN_PROTOCOL_VERSIONS.includes(claimedVersion)) return {
+		kind: "unsupported-revision",
+		requested: claimedVersion ?? "unknown"
+	};
+	return {
+		kind: "modern",
+		revision: claimedVersion,
+		classification: {
+			era: "modern",
+			revision: claimedVersion
+		}
+	};
+}
+/**
+* Serves MCP over stdio from a server factory, owning the era decision for
+* the connection: the opening exchange selects the era, ONE instance from the
+* factory is pinned for the connection lifetime, and everything after passes
+* straight through to it. See the module documentation for the opening rules.
+*
+* ```ts
+* import { serveStdio } from '@modelcontextprotocol/server/stdio';
+*
+* serveStdio(() => {
+*     const server = new McpServer({ name: 'my-server', version: '1.0.0' }, { capabilities: { tools: {} } });
+*     // register tools/resources/prompts once — the same factory serves both eras
+*     return server;
+* });
+* ```
+*/
+function serveStdio(factory, options = {}) {
+	const legacyMode = options.legacy ?? "serve";
+	const wire = options.transport ?? new StdioServerTransport();
+	let state = { phase: "opening" };
+	/** Channel currently being discarded (its close must not tear the connection down). */
+	let discarding;
+	let closing = false;
+	/**
+	* Whether the connection has been torn down (`handle.close()` or the wire
+	* closing). The opening arms re-check this after every await: a close can
+	* race factory construction, and the continuation must neither resurrect
+	* the connection state nor keep a late-resolved instance around.
+	*/
+	const isTornDown = () => closing || state.phase === "closed";
+	const reportError = (error) => {
+		try {
+			options.onerror?.(error);
+		} catch {}
+	};
+	const writeErrorResponse = (id, code, message, data) => wire.send({
+		jsonrpc: "2.0",
+		id,
+		error: {
+			code,
+			message,
+			...data !== void 0 && { data }
+		}
+	}).catch((error) => reportError(toError(error)));
+	/**
+	* Entry-handled `subscriptions/listen` for this connection: holds the
+	* active subscriptions, serves inbound listen / cancelled-of-listen
+	* before the pinned instance is consulted, and rewrites the instance's
+	* outbound change notifications onto the active subscriptions. Only
+	* consulted on a modern-pinned connection — on a legacy connection
+	* change notifications pass straight through (the 2025 unsolicited
+	* delivery model is unchanged).
+	*/
+	const listenRouter = new StdioListenRouter(options.maxSubscriptions ?? 1024);
+	/** Outbound intercept installed on a modern instance's channel. */
+	const modernOutboundIntercept = (message) => {
+		if (!isJSONRPCNotification(message)) return void 0;
+		const routed = listenRouter.routeOutbound(message);
+		if (routed === "passthrough") return void 0;
+		for (const stamped of routed) wire.send({
+			jsonrpc: "2.0",
+			...stamped
+		}).catch((error) => reportError(toError(error)));
+		return "handled";
+	};
+	/**
+	* Entry-handled inbound listen routing for a modern-pinned connection.
+	* Returns `true` when the message was served at the entry and must NOT
+	* be delivered to the pinned instance.
+	*/
+	const tryServeListen = async (message) => {
+		if (isJSONRPCRequest(message) && message.method === "subscriptions/listen") {
+			const meta = requestMetaOf(message.params);
+			const issue = hasEnvelopeClaim(message.params) ? (meta === void 0 ? [] : validateEnvelopeMeta(meta))[0] : {
+				key: "_meta",
+				problem: "the per-request envelope is required on protocol revision 2026-07-28"
+			};
+			const claimedVersion = envelopeClaimVersion(message.params);
+			let reply;
+			if (issue !== void 0) reply = {
+				jsonrpc: "2.0",
+				id: message.id,
+				error: {
+					code: -32602,
+					message: `Invalid _meta envelope: ${issue.key}: ${issue.problem}`
+				}
+			};
+			else if (claimedVersion === void 0 || !SUPPORTED_MODERN_PROTOCOL_VERSIONS.includes(claimedVersion)) {
+				const error = new UnsupportedProtocolVersionError({
+					supported: [...SUPPORTED_MODERN_PROTOCOL_VERSIONS],
+					requested: claimedVersion ?? "unknown"
+				});
+				reply = {
+					jsonrpc: "2.0",
+					id: message.id,
+					error: {
+						code: error.code,
+						message: error.message,
+						data: error.data
+					}
+				};
+			} else reply = listenRouter.serve(message);
+			await wire.send("error" in reply ? reply : {
+				jsonrpc: "2.0",
+				method: reply.method,
+				params: reply.params
+			}).catch((error) => reportError(toError(error)));
+			return true;
+		}
+		if (isJSONRPCNotification(message) && message.method === "notifications/cancelled") {
+			const cancelledId = message.params?.requestId;
+			if (cancelledId !== void 0 && listenRouter.cancel(cancelledId)) return true;
+		}
+		return false;
+	};
+	/** Answers a 2025-era request the entry will not serve (the modern-only rejection cells). */
+	const answerLegacyRejection = (request, reason, requestedVersion) => {
+		const rejection = modernOnlyStrictRejection({
+			kind: "legacy",
+			reason,
+			...requestedVersion !== void 0 && { requestedVersion }
+		}, SUPPORTED_MODERN_PROTOCOL_VERSIONS);
+		if (rejection === void 0) return Promise.resolve();
+		reportError(/* @__PURE__ */ new Error(`Rejected 2025-era request on a modern-only stdio connection (${rejection.cell}): ${rejection.message}`));
+		return writeErrorResponse(request.id, rejection.code, rejection.message, rejection.data);
+	};
+	const onInstanceClosed = (channel) => {
+		if (closing || channel === discarding) return;
+		closeAll();
+	};
+	const connectInstance = async (era, revision) => {
+		const product = await factory({ era });
+		const server = product instanceof McpServer ? product.server : product;
+		if (era === "modern") {
+			setNegotiatedProtocolVersion(server, revision);
+			installModernOnlyHandlers(server, SUPPORTED_MODERN_PROTOCOL_VERSIONS);
+			listenRouter.setServerCapabilities(server.getCapabilities(), serverIdentityOf(server));
+		}
+		const channel = new StdioConnectionChannel(wire, () => onInstanceClosed(channel), era === "modern" ? modernOutboundIntercept : void 0);
+		await product.connect(channel);
+		return {
+			product,
+			channel
+		};
+	};
+	/** Closes an instance whose factory resolved only after the connection was torn down. */
+	const disposeLateInstance = (instance) => instance.product.close().catch((error) => reportError(toError(error)));
+	const discardProbeInstance = async (instance) => {
+		discarding = instance.channel;
+		try {
+			if (!await instance.channel.whenRequestsAnswered(DISCARD_ANSWER_TIMEOUT_MS)) reportError(/* @__PURE__ */ new Error(`Discarded the probe instance with requests still unanswered after ${DISCARD_ANSWER_TIMEOUT_MS}ms; continuing with the fallback`));
+			await instance.product.close();
+		} catch (error) {
+			reportError(toError(error));
+		} finally {
+			discarding = void 0;
+		}
+	};
+	const processMessage = async (message) => {
+		if (state.phase === "closed") return;
+		if (state.phase === "pinned") {
+			if (state.era === "modern" && isJSONRPCRequest(message) && message.method === "initialize" && !carriesValidModernEnvelopeClaim(message.params)) {
+				await answerLegacyRejection(message, "initialize", message.params !== null && typeof message.params === "object" && typeof message.params.protocolVersion === "string" ? message.params.protocolVersion : void 0);
+				return;
+			}
+			if (state.era === "modern" && await tryServeListen(message)) return;
+			if (isTornDown()) return;
+			state.instance.channel.deliver(message);
+			return;
+		}
+		if (!isJSONRPCRequest(message) && !isJSONRPCNotification(message)) {
+			reportError(/* @__PURE__ */ new Error("Discarded a JSON-RPC response received before the connection negotiated an era"));
+			return;
+		}
+		const opening = classifyOpeningMessage(message);
+		switch (opening.kind) {
+			case "invalid-envelope": {
+				const detail = `Invalid _meta envelope for protocol revision 2026-07-28: ${opening.issue.key}: ${opening.issue.problem}`;
+				if (isJSONRPCRequest(message)) await writeErrorResponse(message.id, ProtocolErrorCode.InvalidParams, detail, { envelope: opening.issue });
+				else reportError(/* @__PURE__ */ new Error(`Discarded a notification with a malformed envelope: ${detail}`));
+				return;
+			}
+			case "unsupported-revision":
+				if (isJSONRPCRequest(message)) {
+					const error = new UnsupportedProtocolVersionError({
+						supported: [...SUPPORTED_MODERN_PROTOCOL_VERSIONS],
+						requested: opening.requested
+					});
+					reportError(error);
+					await writeErrorResponse(message.id, error.code, error.message, error.data);
+				} else reportError(/* @__PURE__ */ new Error(`Discarded a notification claiming unsupported protocol revision ${opening.requested}`));
+				return;
+			case "modern":
+				if (isJSONRPCRequest(message) && message.method === "server/discover") {
+					if (state.phase === "probe") {
+						state.instance.channel.deliver(message, { classification: opening.classification });
+						return;
+					}
+					const instance = await connectInstance("modern", opening.revision);
+					if (isTornDown()) {
+						await disposeLateInstance(instance);
+						return;
+					}
+					state = {
+						phase: "probe",
+						instance
+					};
+					instance.channel.deliver(message, { classification: opening.classification });
+					return;
+				}
+				if (state.phase === "probe") {
+					if (isJSONRPCNotification(message)) {
+						state.instance.channel.deliver(message, { classification: opening.classification });
+						return;
+					}
+					state = {
+						phase: "pinned",
+						era: "modern",
+						instance: state.instance
+					};
+				} else {
+					const instance = await connectInstance("modern", opening.revision);
+					if (isTornDown()) {
+						await disposeLateInstance(instance);
+						return;
+					}
+					state = {
+						phase: "pinned",
+						era: "modern",
+						instance
+					};
+				}
+				if (await tryServeListen(message)) return;
+				if (isTornDown()) return;
+				state.instance.channel.deliver(message, { classification: opening.classification });
+				return;
+			case "legacy": {
+				if (legacyMode === "reject") {
+					if (isJSONRPCRequest(message)) await answerLegacyRejection(message, opening.reason, opening.requestedVersion);
+					return;
+				}
+				if (state.phase === "probe") {
+					await discardProbeInstance(state.instance);
+					if (isTornDown()) return;
+					state = { phase: "opening" };
+				}
+				const instance = await connectInstance("legacy");
+				if (isTornDown()) {
+					await disposeLateInstance(instance);
+					return;
+				}
+				state = {
+					phase: "pinned",
+					era: "legacy",
+					instance
+				};
+				state.instance.channel.deliver(message);
+				return;
+			}
+		}
+	};
+	const queue = [];
+	let pumping = false;
+	const pump = async () => {
+		if (pumping) return;
+		pumping = true;
+		try {
+			while (queue.length > 0) {
+				const message = queue.shift();
+				try {
+					await processMessage(message);
+				} catch (error) {
+					if (isJSONRPCRequest(message)) await writeErrorResponse(message.id, ProtocolErrorCode.InternalError, "Internal server error");
+					reportError(toError(error));
+				}
+			}
+		} finally {
+			pumping = false;
+		}
+	};
+	const closeAll = async () => {
+		if (closing || state.phase === "closed") return;
+		closing = true;
+		const current = state;
+		state = { phase: "closed" };
+		for (const result of listenRouter.teardownAll()) await wire.send(result).catch((error) => reportError(toError(error)));
+		if (current.phase === "probe" || current.phase === "pinned") await current.instance.product.close().catch((error) => reportError(toError(error)));
+		await wire.close().catch((error) => reportError(toError(error)));
+	};
+	wire.onmessage = (message) => {
+		queue.push(message);
+		pump();
+	};
+	wire.onerror = (error) => {
+		reportError(error);
+		if (state.phase === "probe" || state.phase === "pinned") state.instance.channel.onerror?.(error);
+	};
+	wire.onclose = () => {
+		if (closing || state.phase === "closed") return;
+		closing = true;
+		const current = state;
+		state = { phase: "closed" };
+		if (current.phase === "probe" || current.phase === "pinned") current.instance.product.close().catch((error) => reportError(toError(error)));
+	};
+	const started = wire.start().catch((error) => {
+		reportError(toError(error));
+		throw error;
+	});
+	started.catch(() => {});
+	return { close: async () => {
+		await started.catch(() => {});
+		await closeAll();
+	} };
+}
+function toError(value) {
+	return value instanceof Error ? value : new Error(String(value));
+}
 //#endregion
 //#region src/transports/stdio.ts
-const startStdioTransport = async (server, logger = silentLogger) => {
-	const transport = new StdioServerTransport(void 0, void 0, { maxBufferSize: STDIO_MAX_MESSAGE_BYTES });
-	await server.connect(transport);
+/**
+* Serve MCP over stdio, both protocol eras: the SDK entry picks the era from the
+* client's opening exchange and pins one server from `build` per connection (a
+* `server/discover` probe that falls back to `initialize` builds one more, then
+* drops it).
+*/
+const startStdioTransport = (build, logger = silentLogger, options = {}) => {
+	const requestStateCodec = createRequestStateCodec({});
+	const handle = serveStdio(() => {
+		let server;
+		server = build({
+			requestStateCodec,
+			notifyResourceUpdated: (uri) => {
+				server?.server.sendResourceUpdated({ uri }).catch(() => void 0);
+			}
+		});
+		return server;
+	}, {
+		transport: options.transport ?? new StdioServerTransport(void 0, void 0, { maxBufferSize: 10485760 }),
+		onerror: (error) => logger.warn("stdio_transport_error", { error: error.message })
+	});
 	logger.info("stdio_transport_ready");
+	return handle;
 };
 //#endregion
 //#region src/dev/reload.ts
@@ -108353,19 +110806,19 @@ const loadFreshTools = async (ctx) => {
 * only matters after an edit); `reload()` disposes the current generation and
 * registers a fresh one.
 */
-const createReloadableServer = (config, getToken, logger = silentLogger, onUnauthorized, loadTools = loadFreshTools) => {
-	const server = createServerShell(config, logger);
-	const resolveBrandSubdomain = createBrandSubdomainResolver(config.subdomain, getToken);
+const createReloadableServer = (config, getToken, logger = silentLogger, onUnauthorized, loadTools = loadFreshTools, requestStateCodec) => {
+	const server = createServerShell(config, requestStateCodec);
+	const caches = createServerCaches(config, getToken, onUnauthorized);
 	const ctx = {
 		subdomain: config.subdomain,
 		brandIds: config.brandIds,
-		resolveBrandSubdomain,
+		resolveBrandSubdomain: caches.resolveBrandSubdomain,
 		getToken
 	};
 	const params = {
 		config,
 		getToken,
-		resolveBrandSubdomain,
+		caches,
 		onUnauthorized,
 		logger
 	};
@@ -108402,7 +110855,7 @@ const createReloadableServer = (config, getToken, logger = silentLogger, onUnaut
 const registerReloadTool = (server, reload, logger = silentLogger) => {
 	server.registerTool("reload_tools", {
 		title: "Reload tools from source (dev)",
-		description: "Dev only. Re-imports the Zendesk tool modules from source and re-registers them on this live session, so tool code you just edited takes effect without restarting the server or reconnecting the client. Call it once at the end of an edit cycle, before testing your changes; the refreshed tool list is announced via tools/list_changed. Only the tool modules (tickets, search, help_center, users) are reloaded — edits to shared infrastructure (HTTP client, shared definitions, server wiring) still require a full restart. Takes no arguments and makes no Zendesk API calls.",
+		description: "Dev only. Re-imports the Zendesk tool modules from source and re-registers them on this live session, so tool code you just edited takes effect without restarting the server or reconnecting the client. Call it once at the end of an edit cycle, before testing your changes; the refreshed tool list is announced via tools/list_changed (a client on the 2026-07-28 revision receives it only on an open subscriptions/listen stream; otherwise call tools/list again). Only the tool modules (tickets, search, help_center, users) are reloaded — edits to shared infrastructure (HTTP client, shared definitions, server wiring) still require a full restart. Takes no arguments and makes no Zendesk API calls.",
 		inputSchema: object({}).strict(),
 		annotations: {
 			readOnlyHint: false,
@@ -108416,7 +110869,7 @@ const registerReloadTool = (server, reload, logger = silentLogger) => {
 			logger.info("tools_reloaded", { count });
 			return { content: [{
 				type: "text",
-				text: `Reloaded ${count} tool(s) from source. The updated tool list is now live (tools/list_changed sent).`
+				text: `Reloaded ${count} tool(s) from source. The updated tool list is now live (tools/list_changed sent; if your client did not receive it, call tools/list again).`
 			}] };
 		} catch (err) {
 			const message = err instanceof Error ? err.message : String(err);
@@ -108434,21 +110887,23 @@ const registerReloadTool = (server, reload, logger = silentLogger) => {
 /**
 * Start the stdio server in dev mode: the normal toolset plus a persistent
 * `reload_tools` tool that hot-reloads edited tool code on demand. stdio only —
-* HTTP builds a per-session server per request, so there is no long-lived
+* HTTP builds a server per session or per request, so there is no long-lived
 * server to hot-swap.
 *
-* Returns the running server so the caller can close it on shutdown: dev mode
+* Returns the transport handle so the caller can close it on shutdown: dev mode
 * runs over the same stdio transport as normal mode and must exit the same way
 * when the client disconnects.
 */
 /* v8 ignore start -- runtime bootstrap: binds the reload tool to a real stdio
 transport; the reload machinery it wires up is covered by dev-reload.test.ts */
-const startDevServer = async (config, getToken, logger = silentLogger, onUnauthorized) => {
-	const { server, reload } = createReloadableServer(config, getToken, logger, onUnauthorized);
-	registerReloadTool(server, reload, logger);
-	await startStdioTransport(server, logger);
+const startDevServer = (config, getToken, logger = silentLogger, onUnauthorized) => {
+	const handle = startStdioTransport(({ requestStateCodec }) => {
+		const { server, reload } = createReloadableServer(config, getToken, logger, onUnauthorized, loadFreshTools, requestStateCodec);
+		registerReloadTool(server, reload, logger);
+		return server;
+	}, logger);
 	logger.info("dev_mode_enabled");
-	return server;
+	return handle;
 };
 /* v8 ignore stop */
 //#endregion
@@ -108600,7 +111055,7 @@ const installShutdown = (options) => {
 //#endregion
 //#region src/index.ts
 const buildStdioTokenStore = async (config, logger) => {
-	const { createTokenStore } = await import("./token-store-BLAkLLQO.js");
+	const { createTokenStore } = await import("./token-store-DyO12sbo.js");
 	return createTokenStore({
 		subdomain: config.subdomain,
 		oauthClientId: config.oauthClientId,
@@ -108608,11 +111063,15 @@ const buildStdioTokenStore = async (config, logger) => {
 		readOnly: config.readOnly
 	}, logger);
 };
-const connectStdio = async (config, tokenStore, logger) => {
+const connectStdio = (config, tokenStore, logger) => {
 	if (config.dev) return startDevServer(config, tokenStore.getToken, logger, tokenStore.invalidate);
-	const server = createMcpServer(config, tokenStore.getToken, logger, tokenStore.invalidate);
-	await startStdioTransport(server, logger);
-	return server;
+	return startStdioTransport((extras) => defaultServerFactory({
+		config,
+		getToken: tokenStore.getToken,
+		logger,
+		onUnauthorized: tokenStore.invalidate,
+		...extras
+	}), logger);
 };
 const main = async () => {
 	const config = loadConfig();
@@ -108629,19 +111088,19 @@ const main = async () => {
 	const logger = createLogger(config.logLevel);
 	if (config.transport === "stdio") {
 		const tokenStore = await buildStdioTokenStore(config, logger);
-		const server = await connectStdio(config, tokenStore, logger);
+		const stdio = connectStdio(config, tokenStore, logger);
 		installShutdown({
 			watchStdin: true,
 			logger,
 			cleanup: async () => {
-				await server.close();
+				await stdio.close();
 				tokenStore.dispose();
 			}
 		});
 		return;
 	}
 	if (config.dev) logger.warn("dev_mode_ignored_http");
-	const { startHttpTransport } = await import("./http-BYYYoQaK.js");
+	const { startHttpTransport } = await import("./http-DU1dSrPe.js");
 	const http = await startHttpTransport(config, logger);
 	installShutdown({
 		watchStdin: false,
@@ -108655,4 +111114,4 @@ main().catch((error) => {
 	process.exit(1);
 });
 //#endregion
-export { __commonJSMin$1 as _, verifyBearerToken as a, __toESM$1 as b, zendeskGet as c, DEFAULT_CALLBACK_PORT as d, getOAuthUrls as f, readEnv as g, errnoCode as h, WebStandardStreamableHTTPServerTransport as i, REQUEST_TIMEOUT_MS as l, createStartupError as m, readPackageInfo as n, OAuthError as o, STARTUP_DOCS as p, silentLogger as r, OAuthErrorCode as s, createMcpServer as t, deadlineSignal as u, __exportAll$1 as v, __require as y };
+export { __exportAll$1 as C, __commonJSMin$1 as S, __toESM$1 as T, OAuthErrorCode as _, silentLogger as a, errnoCode as b, deadlineSignal as c, DEFAULT_MAX_REQUEST_BODY_SIZE as d, WebStandardStreamableHTTPServerTransport as f, OAuthError as g, verifyBearerToken as h, readPackageInfo as i, DEFAULT_CALLBACK_PORT as l, isLegacyRequest as m, defaultServerFactory as n, zendeskGet as o, createMcpHandler as p, createRequestStateCodec as r, REQUEST_TIMEOUT_MS as s, createServerCaches as t, getOAuthUrls as u, STARTUP_DOCS as v, __require as w, readEnv as x, createStartupError as y };