@orkestrel/mcp 0.0.25 → 0.0.27

package/dist/src/core/index.cjs

@@ -1,5 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 let _orkestrel_contract = require("@orkestrel/contract");
+let _orkestrel_codec = require("@orkestrel/codec");
 let _orkestrel_emitter = require("@orkestrel/emitter");
 let _orkestrel_tool = require("@orkestrel/tool");
 //#region src/core/constants.ts
@@ -50,6 +51,53 @@ var MCP_META_SUBSCRIPTION = "io.modelcontextprotocol/subscriptionId";
 * the extension defines no options, so presence is the entire declaration.
 */
 var MCP_EXTENSION_TASKS = "io.modelcontextprotocol/tasks";
+/**
+* The opening marker of the Base64 sentinel a standard MCP header value travels in.
+*
+* @remarks
+* The markers are LOWERCASE and exact, and this constant with {@link MCP_SENTINEL_SUFFIX} is
+* their ONE spelling in this package: {@link import('@orkestrel/mcp').encodeSentinel} builds a
+* sentinel from them and {@link import('@orkestrel/mcp').decodeSentinel} recognizes one by
+* them, so the two directions cannot drift apart.
+*/
+var MCP_SENTINEL_PREFIX = "=?base64?";
+/** The closing marker of the Base64 sentinel a standard MCP header value travels in. */
+var MCP_SENTINEL_SUFFIX = "?=";
+/**
+* The request-header prefix an `x-mcp-header` annotation projects a tool argument onto.
+*
+* @remarks
+* The full field name is this prefix followed by the annotation's own value verbatim, so
+* `x-mcp-header: 'Region'` becomes `Mcp-Param-Region`. HTTP field names are case-insensitive,
+* which is why {@link MCP_HEADER_ANNOTATION} values are unique case-insensitively within one
+* `inputSchema`.
+*/
+var MCP_PARAM_PREFIX = "Mcp-Param-";
+/**
+* The tool-schema annotation key naming the header one parameter projects into.
+*
+* @remarks
+* It is valid ONLY on a primitive property schema statically reachable from the `inputSchema`
+* root through `properties` keys alone. An occurrence anywhere else — under `items`, a
+* composition or conditional keyword, or a `$ref` target — makes the whole tool definition
+* invalid, which is what {@link import('@orkestrel/mcp').buildHeaderParameters} decides.
+*/
+var MCP_HEADER_ANNOTATION = "x-mcp-header";
+/**
+* The `tools/list` pages one modern `tools/call` walks to reach its own annotations.
+*
+* @remarks
+* The HTTP POST handler reads a called tool's {@link MCP_HEADER_ANNOTATION} annotations by
+* dispatching `tools/list` fresh on every `tools/call`, following `nextCursor` until the
+* named tool is found or the answer carries no cursor. The walk is bounded because its cost
+* is paid per call: at a page size of 100 this bound reaches 800 definitions, and a consumer
+* whose replacement `tools/list` pages more finely than that pays the extra dispatches on
+* every call it serves. The built-in listing answers the whole registry on one page and
+* never reaches the second. A definition further in than the walk reaches reads as no
+* definition, so its {@link MCP_PARAM_PREFIX} headers are forwarded untouched — the same
+* answer a name no served definition annotates receives.
+*/
+var MCP_LOOKUP_PAGES = 8;
 /** MCP reserved error: required HTTP metadata does not match the request body. */
 var MCP_HEADER_MISMATCH = -32020;
 /**
@@ -83,10 +131,11 @@ var DEFAULT_MCP_CACHE_TTL = 6e4;
 * One MiB admits ordinary JSON-RPC requests and substantial tool arguments; 16 KiB admits
 * extension-rich modern metadata and signed multi-round state; four MiB admits substantial
 * JSON tool output without allowing an unconfigured service to serialize arbitrary process
-* memory; 64 metadata keys admits the reserved keys plus many extensions; 128 concurrent
-* streams admits a busy service while bounding retained producers; depth 32 admits ordinary
-* JSON documents while rejecting stack-hostile nesting. Frozen so callers cannot alter the
-* defaults observed by later servers.
+* memory; 64 keys admits `_meta`'s reserved keys plus many extensions, and bounds a produced
+* result's breadth by the same leaf; 128 concurrent streams admits a busy service while
+* bounding retained producers; depth 32 admits ordinary JSON documents while rejecting
+* stack-hostile nesting. Frozen so callers cannot alter the defaults observed by later
+* servers.
 */
 var DEFAULT_MCP_LIMITS = Object.freeze({
 	message: 1048576,
@@ -432,17 +481,18 @@ function parseRequestContext(value, limits = {
 * This parser does not open the opaque continuation carrier; the configured
 * continuation port performs that boundary first. The protected
 * payload binds the authenticated principal, absolute expiry, ORIGINAL request id, version,
-* method, server-assigned key, tool name, argument digest, the exact issued elicitation
-* schema, and optional application state. Every member is required except application state:
-* a payload missing its schema cannot have its accepted response enforced, so it is refused
-* rather than admitted unenforced. Total over malformed or hostile input.
+* method, the exact round that was issued, tool name, argument digest, and optional
+* application state. Every member is required except application state: a payload missing its
+* round cannot have the client's answers enforced, so it is refused rather than admitted
+* unenforced. An EMPTY round is refused for the same reason — a retry against it would answer
+* no question at all. Total over malformed or hostile input.
 *
 * @param value - The opened canonical continuation value to parse
 * @returns The protected input state, or `undefined` when malformed
 *
 * @example
 * ```ts
-* parseMCPInputState('{"principal":"user-1","expiry":2000,"id":1,"version":"2026-07-28","method":"tools/call","key":"k","name":"reply","digest":"abc","schema":{"type":"object","properties":{}}}')
+* parseMCPInputState('{"principal":"user-1","expiry":2000,"id":1,"version":"2026-07-28","method":"tools/call","requests":{"k":{"method":"roots/list"}},"name":"reply","digest":"abc"}')
 * ```
 */
 function parseMCPInputState(value) {
@@ -455,26 +505,24 @@ function parseMCPInputState(value) {
 		const id = parsed["id"];
 		const version = parsed["version"];
 		const method = parsed["method"];
-		const key = parsed["key"];
+		const requests = parsed["requests"];
 		const name = parsed["name"];
 		const digest = parsed["digest"];
-		const schema = parsed["schema"];
 		const state = parsed["state"];
 		if (!(0, _orkestrel_contract.isString)(principal) || principal.length === 0 || !(0, _orkestrel_contract.isNumber)(expiry) || !Number.isFinite(expiry)) return;
 		if (!isJSONRPCId(id)) return void 0;
-		if (!(0, _orkestrel_contract.isString)(version) || !(0, _orkestrel_contract.isString)(method) || !(0, _orkestrel_contract.isString)(key) || !(0, _orkestrel_contract.isString)(name)) return;
+		if (!(0, _orkestrel_contract.isString)(version) || !(0, _orkestrel_contract.isString)(method) || !(0, _orkestrel_contract.isString)(name)) return void 0;
 		if (!(0, _orkestrel_contract.isString)(digest) || !(0, _orkestrel_contract.isUndefined)(state) && !(0, _orkestrel_contract.isJSONValue)(state)) return void 0;
-		if (!isMCPElicitSchema(schema)) return void 0;
+		if (!isMCPInputRequestMap(requests) || Object.keys(requests).length === 0) return void 0;
 		return {
 			principal,
 			expiry,
 			id,
 			version,
 			method,
-			key,
+			requests,
 			name,
 			digest,
-			schema,
 			...(0, _orkestrel_contract.isUndefined)(state) ? {} : { state }
 		};
 	} catch {
@@ -513,6 +561,68 @@ function isFormElicitationSupported(value) {
 	}
 }
 /**
+* Computes the capabilities one round of input requests needs and the client did not declare.
+*
+* @remarks
+* The protocol's rule is about SENDING: a server never issues a request kind the client's
+* declared capabilities exclude. So this reads the round rather than the method, and it
+* answers with the refusal's own payload — the `requiredCapabilities` record a
+* `MissingRequiredClientCapability` error carries, keyed by each missing capability, in the
+* `ClientCapabilities` shape the schema defines rather than as a list of names.
+*
+* Each kind maps to one declaration: `sampling/createMessage` to `sampling`, `roots/list` to
+* `roots`, a form elicitation to what {@link isFormElicitationSupported} accepts, and a
+* URL-mode elicitation to a record-valued `elicitation.url`. A request this package cannot
+* recognize needs nothing, because {@link import('./validators.js').isMCPInputRequestMap}
+* has already refused the round it would have travelled in. Total over hostile input.
+*
+* The `elicitation` value names the ARM the round needs, so a client can act on the refusal
+* by declaring exactly what the payload asks for. A missing URL arm answers `{ url: {} }`, a
+* missing form arm answers the empty record this package reads as form-only, and a round
+* needing both answers `{ form: {}, url: {} }`. An empty record for a URL round would name
+* the declaration a URL-capable client already sent, and refuse the identical round again.
+*
+* @param requests - The round the server is about to issue
+* @param capabilities - The client capability record the request declared
+* @returns The missing capabilities, or `undefined` when the client declared every one
+*
+* @example
+* ```ts
+* computeMissingCapabilities({ answer: { method: 'roots/list' } }, {}) // { roots: {} }
+* computeMissingCapabilities({ answer: { method: 'roots/list' } }, { roots: {} }) // undefined
+* ```
+*/
+function computeMissingCapabilities(requests, capabilities) {
+	const owned = (0, _orkestrel_contract.attempt)(() => (0, _orkestrel_contract.cloneJSONRecord)(capabilities));
+	const declared = owned.success ? owned.value : {};
+	const missing = {};
+	let formUndeclared = false;
+	let urlUndeclared = false;
+	for (const request of Object.values(requests)) {
+		if (request.method === "sampling/createMessage") {
+			if (!(0, _orkestrel_contract.isRecord)(declared["sampling"])) missing["sampling"] = {};
+			continue;
+		}
+		if (request.method === "roots/list") {
+			if (!(0, _orkestrel_contract.isRecord)(declared["roots"])) missing["roots"] = {};
+			continue;
+		}
+		const elicitation = declared["elicitation"];
+		if (request.params.mode === "url") {
+			if (!(0, _orkestrel_contract.isRecord)(elicitation) || !(0, _orkestrel_contract.isRecord)(elicitation["url"])) urlUndeclared = true;
+			continue;
+		}
+		if (!isFormElicitationSupported(declared)) formUndeclared = true;
+	}
+	if (formUndeclared && !urlUndeclared) missing["elicitation"] = {};
+	if (urlUndeclared && !formUndeclared) missing["elicitation"] = { url: {} };
+	if (formUndeclared && urlUndeclared) missing["elicitation"] = {
+		form: {},
+		url: {}
+	};
+	return Object.keys(missing).length === 0 ? void 0 : Object.freeze(missing);
+}
+/**
 * Determines whether a client capability record declares the stable Tasks extension.
 *
 * @remarks
@@ -780,7 +890,7 @@ async function digestJSON(value, limits) {
 	const serialized = serializeJSON(value, limits);
 	if (serialized === void 0) return void 0;
 	const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(serialized));
-	return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("");
+	return (0, _orkestrel_codec.encodeHex)(new Uint8Array(digest));
 }
 /**
 * Builds one official progress notification for the original request stream.
@@ -1355,6 +1465,321 @@ function decodeBoundedMessage(message, limits) {
 	return parsed.success ? parseJSONRPCMessage(parsed.value, limits) : void 0;
 }
 /**
+* Reads the value one standard MCP request header carries, decoding the Base64 sentinel.
+*
+* @remarks
+* The sentinel format is `=?base64?{Base64OfUTF8}?=`, spelled once as
+* {@link MCP_SENTINEL_PREFIX} and {@link MCP_SENTINEL_SUFFIX} and read from there by both
+* directions of the codec.
+* The markers alone decide whether a value is a sentinel: a value carrying the prefix and the
+* suffix is one, and its payload is then held to `decodeBase64` from `@orkestrel/codec` — the
+* canonical RFC 4648 § 4 grammar, which admits exactly one spelling per byte sequence — and to
+* well-formed UTF-8. A payload leaving a non-zero bit in the sextet its padding discards is a
+* second spelling of a byte, so it is refused: `=?base64?QR==?=` reaches for the byte
+* `=?base64?QQ==?=` spells canonically, and only the canonical spelling decodes. A malformed
+* payload answers `undefined` rather than falling back to the literal, because the protocol
+* requires a server to REJECT invalid characters, and a fallback would admit the very value
+* the rule exists to refuse. A value missing either marker is a literal and comes back
+* unchanged.
+*
+* `decodeUTF8` from `@orkestrel/codec` reads the bytes back as text: strict RFC 3629, where an
+* overlong, an encoded surrogate, a code point past U+10FFFF, and a truncated sequence each
+* answer `undefined` rather than a replacement character, and total, so the refusal arrives as
+* that value instead of as a throw. It also keeps a leading U+FEFF as a character of the
+* value, where the platform decoder consumes it as a byte order mark — which is what lets a
+* value leading with U+FEFF survive {@link encodeSentinel} and come back whole.
+*
+* {@link import('./validators.js').isStandardBase64} is a wider and separate rule: it names
+* JSON Schema `byte` membership for the blob, image, and audio content a peer sends, where
+* this package receives liberally. It does not govern this payload.
+*
+* Optional whitespace is excluded first, per RFC 9110 § 5.5: a recipient parses a field value
+* with its surrounding spaces and horizontal tabs removed, so a peer that padded a plain value
+* still matches the body. A value whose own leading or trailing whitespace is significant
+* cannot survive that, which is what {@link encodeSentinel} encodes it for.
+*
+* Total — never throws, whatever the input.
+*
+* @param value - The raw header field value the peer sent
+* @returns The carried value, or `undefined` when the sentinel's payload is invalid
+*
+* @example
+* ```ts
+* decodeSentinel('=?base64?Y2Fmw6k=?=') // 'café'
+* decodeSentinel('  search  ') // 'search' — optional whitespace excluded
+* decodeSentinel('=?base64?SGVsbG8?=') // undefined — invalid padding
+* decodeSentinel('=?base64?QR==?=') // undefined — a non-canonical spelling
+* ```
+*/
+function decodeSentinel(value) {
+	const field = value.replace(/^[ \t]+|[ \t]+$/g, "");
+	if (!(field.length >= 11 && field.startsWith("=?base64?") && field.endsWith("?="))) return field;
+	const payload = field.slice(MCP_SENTINEL_PREFIX.length, field.length - 2);
+	const bytes = (0, _orkestrel_codec.decodeBase64)(payload);
+	if (bytes === void 0) return void 0;
+	return (0, _orkestrel_codec.decodeUTF8)(bytes);
+}
+/**
+* Builds the wire form one standard MCP request header value must travel as.
+*
+* @remarks
+* The exact inverse of {@link decodeSentinel}, and its membership rule is stated as that
+* inverse rather than as a second list that could drift: a value travels LITERALLY when it is
+* plain printable ASCII — every code point in `U+0020`–`U+007E`, the RFC 9110 field-value
+* range this package admits — and {@link decodeSentinel} gives it back unchanged. Every other
+* value travels wrapped in {@link MCP_SENTINEL_PREFIX} and {@link MCP_SENTINEL_SUFFIX}, the
+* same markers the decode recognizes a sentinel by. `encodeBase64` from `@orkestrel/codec`
+* spells the payload, so the wire form carries the canonical spelling {@link decodeSentinel}
+* accepts.
+*
+* That one rule covers each row of the protocol's encoding table. A non-ASCII value and a
+* value carrying a control character fail the ASCII test. A value with leading or trailing
+* whitespace comes back trimmed, so it fails the round trip. A value already wearing the
+* sentinel markers decodes to something else, or to nothing, so it fails the round trip too
+* and is encoded rather than read back as a sentinel it never was.
+*
+* The bytes come from the platform `TextEncoder`, not from codec's `encodeUTF8`, and that is a
+* ruling rather than an oversight. `TextEncoder` is total: it spells ill-formed text — a lone
+* surrogate, which has no UTF-8 spelling — with the replacement character, so this function
+* answers a `string` for every input. `encodeUTF8` refuses that text with `undefined`, which
+* would widen this return to `string | undefined` and oblige every header projection to handle
+* a value it cannot send. The decode side carries no such tension, so it reads back through
+* codec's strict `decodeUTF8`.
+*
+* @param value - The value the header must carry
+* @returns The literal value, or its Base64 sentinel form
+*
+* @example
+* ```ts
+* encodeSentinel('search') // 'search'
+* encodeSentinel('café') // '=?base64?Y2Fmw6k=?='
+* ```
+*/
+function encodeSentinel(value) {
+	if (/^[ -~]*$/.test(value) && decodeSentinel(value) === value) return value;
+	return `${MCP_SENTINEL_PREFIX}${(0, _orkestrel_codec.encodeBase64)(new TextEncoder().encode(value))}?=`;
+}
+/**
+* Counts every {@link MCP_HEADER_ANNOTATION} key one JSON value carries, at any position.
+*
+* @remarks
+* The companion of {@link extractHeaderAnnotations}, which reads only the annotations a
+* `properties` chain reaches. Comparing the two answers is how
+* {@link buildHeaderParameters} decides reachability without a second walk that would have
+* to re-state which JSON Schema keywords are traversable: an annotation the reachable walk
+* did not read is one sitting under `items`, a composition or conditional keyword, a `$ref`
+* target, or any other position, and the protocol makes the whole tool definition invalid for
+* it.
+*
+* Iterative and ancestor-tracked, so a deeply nested or self-referential value terminates
+* rather than exhausting the stack. Total — never throws, whatever the input.
+*
+* @param value - The value to scan, normally a tool's `inputSchema`
+* @returns How many annotation keys the value carries
+*
+* @example
+* ```ts
+* countHeaderAnnotations({ properties: { region: { 'x-mcp-header': 'Region' } } }) // 1
+* ```
+*/
+function countHeaderAnnotations(value) {
+	let total = 0;
+	const seen = /* @__PURE__ */ new Set();
+	const pending = [value];
+	while (pending.length > 0) {
+		const node = pending.pop();
+		if ((0, _orkestrel_contract.isArray)(node)) {
+			if (seen.has(node)) continue;
+			seen.add(node);
+			for (const item of node) pending.push(item);
+			continue;
+		}
+		if (!(0, _orkestrel_contract.isRecord)(node) || seen.has(node)) continue;
+		seen.add(node);
+		for (const [key, member] of Object.entries(node)) if (key === "x-mcp-header") total += 1;
+		else pending.push(member);
+	}
+	return total;
+}
+/**
+* Reads every `x-mcp-header` annotation reachable from a schema node through `properties`.
+*
+* @remarks
+* Reachability is the protocol's own rule: an annotation counts only where a chain of
+* `properties` keys leads to it from the `inputSchema` root, so `path` is both the schema
+* position and the position the call's `arguments` carry the value at. A property named
+* `items` is reachable like any other, because the chain is read by key POSITION rather than
+* by key name.
+*
+* `undefined` means the definition is invalid rather than empty: a reachable annotation whose
+* value is not an {@link import('./validators.js').isFieldToken} token, one sitting on the
+* schema ROOT (which is no property), one on a leaf whose declared type is not an
+* {@link import('./validators.js').isMCPHeaderPrimitive} primitive, or a chain deeper than
+* `DEFAULT_MCP_LIMITS.depth` — which is also what makes a self-referential schema terminate.
+* A node that is not a record carries nothing and answers an empty list, because a leaf the
+* walk cannot read is not a violation.
+*
+* @param schema - The schema node to read
+* @param path - The `properties` keys already traversed; the root is called with `[]`
+* @returns The annotations reachable from this node, or `undefined` when one is invalid
+*
+* @example
+* ```ts
+* extractHeaderAnnotations({ properties: { region: { type: 'string', 'x-mcp-header': 'Region' } } }, [])
+* // → [{ name: 'Region', path: ['region'], primitive: 'string' }]
+* ```
+*/
+function extractHeaderAnnotations(schema, path) {
+	if (path.length > DEFAULT_MCP_LIMITS.depth) return void 0;
+	if (!(0, _orkestrel_contract.isRecord)(schema)) return [];
+	const found = [];
+	const annotation = schema[MCP_HEADER_ANNOTATION];
+	if (annotation !== void 0) {
+		if (path.length === 0 || !isFieldToken(annotation)) return void 0;
+		const primitive = schema["type"];
+		if (!isMCPHeaderPrimitive(primitive)) return void 0;
+		found.push({
+			name: annotation,
+			path,
+			primitive
+		});
+	}
+	const properties = schema["properties"];
+	if ((0, _orkestrel_contract.isRecord)(properties)) for (const [key, leaf] of Object.entries(properties)) {
+		const nested = extractHeaderAnnotations(leaf, [...path, key]);
+		if (nested === void 0) return void 0;
+		found.push(...nested);
+	}
+	return found;
+}
+/**
+* Builds the `x-mcp-header` projections one tool's `inputSchema` declares.
+*
+* @remarks
+* The single decision both sides of the protocol make about an annotated tool: an HTTP
+* CLIENT excludes a definition this refuses from the `tools/list` result it delivers, and a
+* SERVER recognizes exactly the `Mcp-Param-*` names this returns for its own definitions.
+*
+* `undefined` means the definition is invalid, and every rule the protocol states produces
+* it: a value that is not an RFC 9110 token, a non-primitive or untyped annotated leaf, a
+* name repeated case-insensitively within the schema, an annotation the `properties` chain
+* does not reach, and a schema that is not a record at all. An empty list is the valid answer
+* for a schema carrying no annotation.
+*
+* Total — never throws, and a cyclic or stack-hostile schema is refused rather than followed.
+*
+* @param schema - The tool's advertised `inputSchema`
+* @returns The declared projections, or `undefined` when the definition is invalid
+*
+* @example
+* ```ts
+* buildHeaderParameters({
+* 	type: 'object',
+* 	properties: { region: { type: 'string', 'x-mcp-header': 'Region' } },
+* }) // → [{ name: 'Region', path: ['region'], primitive: 'string' }]
+* ```
+*/
+function buildHeaderParameters(schema) {
+	if (!(0, _orkestrel_contract.isRecord)(schema)) return void 0;
+	const found = extractHeaderAnnotations(schema, []);
+	if (found === void 0 || found.length !== countHeaderAnnotations(schema)) return void 0;
+	const taken = /* @__PURE__ */ new Set();
+	for (const parameter of found) {
+		const key = parameter.name.toLowerCase();
+		if (taken.has(key)) return void 0;
+		taken.add(key);
+	}
+	return found;
+}
+/**
+* Renders one projected argument as the text its `Mcp-Param-*` header carries.
+*
+* @remarks
+* The protocol's conversion table, and the ONE place it is stated: a string travels as
+* itself, an integer in decimal, and a boolean as lowercase `true` or `false`. The value's
+* runtime shape must match the leaf's declared type, so a schema that declares `integer` and
+* an argument that supplies a string, a fraction, or a magnitude outside the IEEE 754 safe
+* range carries NOTHING — a header that cannot round-trip the body value is worse than an
+* absent one, and the tool's own argument validation owns the disagreement.
+*
+* @param value - The argument value read at the parameter's path
+* @param primitive - The leaf's declared type
+* @returns The header text, or `undefined` when the value cannot travel as that type
+*
+* @example
+* ```ts
+* renderHeaderValue(42, 'integer') // '42'
+* renderHeaderValue(false, 'boolean') // 'false'
+* ```
+*/
+function renderHeaderValue(value, primitive) {
+	if (primitive === "string") return (0, _orkestrel_contract.isString)(value) ? value : void 0;
+	if (primitive === "boolean") return (0, _orkestrel_contract.isBoolean)(value) ? value ? "true" : "false" : void 0;
+	return (0, _orkestrel_contract.isNumber)(value) && Number.isSafeInteger(value) ? String(value) : void 0;
+}
+/**
+* Builds the `Mcp-Param-*` request headers one `tools/call` carries.
+*
+* @remarks
+* The projection SEP-2243 requires of an HTTP client, and the same derivation a server runs
+* to know what the request should have carried. Each parameter's value is read at its exact
+* property path in the call's own `arguments`; an absent or `null` value omits its header
+* entirely, which is the protocol's distinction between "not supplied" and "supplied empty".
+* The rendered text then travels through {@link encodeSentinel}, so a value carrying
+* non-ASCII, control, or edge whitespace characters reaches the peer intact.
+*
+* @param parameters - The projections the tool's `inputSchema` declares
+* @param values - The call's `arguments` record
+* @returns The header field names and values, empty when nothing projects
+*
+* @example
+* ```ts
+* buildHeaderProjection(
+* 	[{ name: 'Region', path: ['region'], primitive: 'string' }],
+* 	{ region: 'us-west1' },
+* ) // → { 'Mcp-Param-Region': 'us-west1' }
+* ```
+*/
+function buildHeaderProjection(parameters, values) {
+	const headers = {};
+	for (const parameter of parameters) {
+		let carried = values;
+		for (const key of parameter.path) carried = (0, _orkestrel_contract.isRecord)(carried) ? carried[key] : void 0;
+		if (carried === void 0 || carried === null) continue;
+		const text = renderHeaderValue(carried, parameter.primitive);
+		if (text !== void 0) headers[`${MCP_PARAM_PREFIX}${parameter.name}`] = encodeSentinel(text);
+	}
+	return headers;
+}
+/**
+* Reads one named tool's advertised `inputSchema` out of a `tools/list` answer.
+*
+* @remarks
+* The answer is read as foreign data end to end — a dispatched response, an error envelope,
+* and a result whose `tools` member is absent or is not an array all read as "no schema"
+* rather than as a fault. That is what lets the HTTP POST handler ask its own dispatcher
+* which `Mcp-Param-*` names a `tools/call` may carry without narrowing anything first.
+*
+* @param response - The `tools/list` answer, normally a {@link JSONRPCResponse}
+* @param name - The tool whose schema to read
+* @returns The advertised `inputSchema`, or `undefined` when the answer carries none
+*
+* @example
+* ```ts
+* extractToolSchema(answer, 'search')?.['properties']
+* ```
+*/
+function extractToolSchema(response, name) {
+	const result = (0, _orkestrel_contract.isRecord)(response) ? response["result"] : void 0;
+	const tools = (0, _orkestrel_contract.isRecord)(result) ? result["tools"] : void 0;
+	if (!(0, _orkestrel_contract.isArray)(tools)) return void 0;
+	for (const tool of tools) {
+		if (!(0, _orkestrel_contract.isRecord)(tool) || tool["name"] !== name) continue;
+		const schema = tool["inputSchema"];
+		return (0, _orkestrel_contract.isRecord)(schema) ? schema : void 0;
+	}
+}
+/**
 * Reads the request id an inbound `notifications/cancelled` names — the inverse of
 * {@link buildCancelledNotification}.
 *
@@ -1670,6 +2095,48 @@ function isStandardBase64(value) {
 	return (0, _orkestrel_contract.isString)(value) && /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(value);
 }
 /**
+* Determines whether a value is one RFC 9110 field token.
+*
+* @remarks
+* A token is one or more `tchar`: the ASCII letters, the digits, and
+* ``!#$%&'*+-.^_`|~``. That set already excludes the empty string, whitespace, a colon, a
+* control character, and every non-ASCII code point, so it is the whole constraint an
+* `x-mcp-header` annotation's value must satisfy — the value is appended verbatim to
+* {@link MCP_PARAM_PREFIX} and must survive as an HTTP field name.
+*
+* @param value - The unknown value to inspect
+* @returns Whether the value is a non-empty RFC 9110 token
+*
+* @example
+* ```ts
+* isFieldToken('Region') // true
+* isFieldToken('My Region') // false
+* ```
+*/
+function isFieldToken(value) {
+	return (0, _orkestrel_contract.isString)(value) && /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/.test(value);
+}
+/**
+* Determines whether a value is a JSON Schema type an `x-mcp-header` annotation may sit on.
+*
+* @remarks
+* `number` is refused deliberately: a JSON number has no interoperable decimal text form, so
+* a header carrying one could not be compared with the body byte for byte. `integer` renders
+* exactly, and the server compares it numerically.
+*
+* @param value - The unknown value to inspect
+* @returns Whether the value is one of `'string'`, `'integer'`, or `'boolean'`
+*
+* @example
+* ```ts
+* isMCPHeaderPrimitive('integer') // true
+* isMCPHeaderPrimitive('number') // false
+* ```
+*/
+function isMCPHeaderPrimitive(value) {
+	return value === "string" || value === "integer" || value === "boolean";
+}
+/**
 * Determines whether a value is one absolute URI under RFC 3986 syntax.
 *
 * @remarks
@@ -2793,7 +3260,7 @@ function isMCPElicitRequest(value) {
 * Determines whether a value is one legal embedded multi-round-trip request.
 *
 * @param value - The unknown value to inspect
-* @returns `true` for elicitation, deprecated sampling, or deprecated roots requests
+* @returns `true` for an embedded elicitation, sampling, or roots request
 *
 * @example
 * ```ts
@@ -2814,7 +3281,7 @@ function isMCPInputRequest(value) {
 	}
 }
 /**
-* Determines whether a value is a server-keyed map of embedded input requests.
+* Determines whether a value is a consumer-keyed map of embedded input requests.
 *
 * @param value - The unknown value to inspect
 * @returns `true` when every own value is a legal {@link MCPInputRequest}
@@ -2968,6 +3435,187 @@ function isElicitContent(value, schema) {
 	}
 }
 /**
+* Determines whether a value is one filesystem root a client exposes.
+*
+* @remarks
+* The dated schema declares `uri` with `format: uri`, so this applies the same RFC 3986
+* check {@link isAbsoluteURI} gives every other `format: uri` field the package validates,
+* including a URL-mode elicitation's `url`. Total over hostile input.
+*
+* @param value - The unknown value to inspect
+* @returns `true` when `value` carries an absolute `uri` and an optional string `name`
+*
+* @example
+* ```ts
+* isMCPRoot({ uri: 'file:///workspace', name: 'workspace' }) // true
+* isMCPRoot({ uri: 'workspace' }) // false — the schema declares `format: uri`
+* ```
+*/
+function isMCPRoot(value) {
+	const owned = (0, _orkestrel_contract.attempt)(() => (0, _orkestrel_contract.cloneJSONRecord)(value));
+	if (!owned.success) return false;
+	try {
+		const root = owned.value;
+		const name = root["name"];
+		const metadata = root["_meta"];
+		if (!isAbsoluteURI(root["uri"])) return false;
+		if (!(0, _orkestrel_contract.isUndefined)(name) && !(0, _orkestrel_contract.isString)(name)) return false;
+		return (0, _orkestrel_contract.isUndefined)(metadata) || isMCPMetaObject(metadata);
+	} catch {
+		return false;
+	}
+}
+/**
+* Determines whether a value is one client answer to an embedded `roots/list` request.
+*
+* @remarks
+* The dated schema requires the `roots` array, and each root is checked by
+* {@link isMCPRoot}. Total over hostile input.
+*
+* @param value - The unknown value to inspect
+* @returns `true` when `value` carries an array of valid roots
+*
+* @example
+* ```ts
+* isMCPRootResult({ roots: [{ uri: 'file:///workspace' }] }) // true
+* isMCPRootResult({ roots: {} }) // false — the schema requires an array
+* ```
+*/
+function isMCPRootResult(value) {
+	const owned = (0, _orkestrel_contract.attempt)(() => (0, _orkestrel_contract.cloneJSONRecord)(value));
+	if (!owned.success) return false;
+	try {
+		const result = owned.value;
+		const roots = result["roots"];
+		const metadata = result["_meta"];
+		if (!Array.isArray(roots) || !roots.every((root) => isMCPRoot(root))) return false;
+		return (0, _orkestrel_contract.isUndefined)(metadata) || isMCPMetaObject(metadata);
+	} catch {
+		return false;
+	}
+}
+/**
+* Determines whether a value is one block a sampling completion may carry.
+*
+* @remarks
+* The schema's `SamplingMessageContentBlock`: the text, image, and audio blocks
+* {@link isMCPContent} also admits, plus `tool_use` and `tool_result`. The resource arms of
+* {@link isMCPContent} are refused, because the schema leaves them out of a sampling
+* completion. A `tool_result` carries ordinary {@link isMCPContent} blocks and an open
+* `structuredContent`, which the schema constrains to no shape at all. Total over hostile
+* input.
+*
+* @param value - The unknown value to inspect
+* @returns `true` when `value` is one legal sampling content block
+*
+* @example
+* ```ts
+* isMCPSampleContent({ type: 'text', text: 'Paris' }) // true
+* isMCPSampleContent({ type: 'tool_use', id: 'c1', name: 'lookup', input: {} }) // true
+* isMCPSampleContent({ type: 'resource_link', name: 'doc', uri: 'file:///doc' }) // false
+* ```
+*/
+function isMCPSampleContent(value) {
+	const owned = (0, _orkestrel_contract.attempt)(() => (0, _orkestrel_contract.cloneJSONRecord)(value));
+	if (!owned.success) return false;
+	try {
+		const block = owned.value;
+		const metadata = block["_meta"];
+		if (!(0, _orkestrel_contract.isUndefined)(metadata) && !isMCPMetaObject(metadata)) return false;
+		if (block["type"] === "tool_use") return (0, _orkestrel_contract.isString)(block["id"]) && (0, _orkestrel_contract.isString)(block["name"]) && (0, _orkestrel_contract.isRecord)(block["input"]);
+		if (block["type"] === "tool_result") {
+			const carried = block["content"];
+			const failed = block["isError"];
+			if (!Array.isArray(carried) || !carried.every((entry) => isMCPContent(entry))) return false;
+			if (!(0, _orkestrel_contract.isUndefined)(failed) && !(0, _orkestrel_contract.isBoolean)(failed)) return false;
+			return (0, _orkestrel_contract.isString)(block["toolUseId"]);
+		}
+		if (!isMCPContent(block)) return false;
+		return block.type === "text" || block.type === "image" || block.type === "audio";
+	} catch {
+		return false;
+	}
+}
+/**
+* Determines whether a value is one client answer to an embedded sampling request.
+*
+* @remarks
+* The schema's `CreateMessageResult` types `content` as an `anyOf` over one
+* {@link isMCPSampleContent} block or an ARRAY of them, so both are admitted here: a
+* tool-using model answers with `tool_use` and `tool_result` blocks, and a model answering in
+* several parts answers with the array. `stopReason` stays an open string because the schema
+* names four values and permits any other a provider reports. Total over hostile input.
+*
+* @param value - The unknown value to inspect
+* @returns `true` when `value` has the sampling-completion shape
+*
+* @example
+* ```ts
+* isMCPSampleResult({
+* 	role: 'assistant',
+* 	content: { type: 'text', text: 'Paris' },
+* 	model: 'test-model',
+* }) // true
+* isMCPSampleResult({
+* 	role: 'assistant',
+* 	content: [{ type: 'text', text: 'Paris' }],
+* 	model: 'test-model',
+* }) // true
+* ```
+*/
+function isMCPSampleResult(value) {
+	const owned = (0, _orkestrel_contract.attempt)(() => (0, _orkestrel_contract.cloneJSONRecord)(value));
+	if (!owned.success) return false;
+	try {
+		const result = owned.value;
+		const role = result["role"];
+		const content = result["content"];
+		const reason = result["stopReason"];
+		const metadata = result["_meta"];
+		if (role !== "user" && role !== "assistant") return false;
+		if (!(0, _orkestrel_contract.isString)(result["model"])) return false;
+		if (!(Array.isArray(content) ? content : [content]).every((block) => isMCPSampleContent(block))) return false;
+		if (!(0, _orkestrel_contract.isUndefined)(reason) && !(0, _orkestrel_contract.isString)(reason)) return false;
+		return (0, _orkestrel_contract.isUndefined)(metadata) || isMCPMetaObject(metadata);
+	} catch {
+		return false;
+	}
+}
+/**
+* Determines whether a response answers the exact embedded request that was issued.
+*
+* @remarks
+* A response carries no `method` of its own, so the ISSUED request selects which arm applies
+* — the same way {@link isElicitContent} takes the issued schema rather than trusting the
+* content to describe itself. A form elicitation is checked twice: once for the response
+* shape and once, on `accept`, for the content against the schema that round issued. A
+* URL-mode elicitation issues no schema, so only the shape is checked. A request this
+* package cannot recognize admits NOTHING, because an unrecognized question has no correct
+* answer. Total over hostile responses and hostile requests alike.
+*
+* @param value - The client's answer to check
+* @param request - The exact {@link MCPInputRequest} that was issued under the same key
+* @returns `true` when the answer is legal for that request
+*
+* @example
+* ```ts
+* isMCPInputResponse({ roots: [] }, { method: 'roots/list' }) // true
+* isMCPInputResponse({ roots: [] }, { method: 'sampling/createMessage', params: {} }) // false
+* ```
+*/
+function isMCPInputResponse(value, request) {
+	if (!isMCPInputRequest(request)) return false;
+	try {
+		if (request.method === "roots/list") return isMCPRootResult(value);
+		if (request.method === "sampling/createMessage") return isMCPSampleResult(value);
+		if (!isMCPElicitResult(value)) return false;
+		if (value.action !== "accept" || !isMCPElicitForm(request.params)) return true;
+		return isElicitContent(value.content ?? {}, request.params.requestedSchema);
+	} catch {
+		return false;
+	}
+}
+/**
 * Determines whether a value is an MCP input-required result.
 *
 * @remarks
@@ -4293,13 +4941,7 @@ var MCPServer = class {
 		if (captured === void 0) return buildJSONRPCError(request.id, JSONRPC_INTERNAL_ERROR, "Server resource manager returned invalid or oversized contents");
 		if (isMCPInputResult(captured[0])) {
 			const input = captured[0];
-			return buildJSONRPCResult(request.id, {
-				...input,
-				_meta: {
-					...input["_meta"] ?? {},
-					[MCP_META_SERVER]: this.#options.identity
-				}
-			});
+			return this.#forward(input, request);
 		}
 		if (!Array.isArray(captured[0]) || !captured[0].every((entry) => isMCPResourceContents(entry))) return buildJSONRPCError(request.id, JSONRPC_INTERNAL_ERROR, "Server resource manager returned invalid or oversized contents");
 		const result = buildModernResult({ contents: captured[0] }, this.#options.identity, this.#options.cache?.ttl ?? 6e4, this.#options.cache?.scope);
@@ -4361,13 +5003,7 @@ var MCPServer = class {
 		if (captured === void 0) return buildJSONRPCError(request.id, JSONRPC_INTERNAL_ERROR, "Server prompt manager returned an invalid or oversized result");
 		if (isMCPInputResult(captured[0])) {
 			const input = captured[0];
-			return buildJSONRPCResult(request.id, {
-				...input,
-				_meta: {
-					...input["_meta"] ?? {},
-					[MCP_META_SERVER]: this.#options.identity
-				}
-			});
+			return this.#forward(input, request);
 		}
 		if (!isMCPPromptGetResult(captured[0])) return buildJSONRPCError(request.id, JSONRPC_INTERNAL_ERROR, "Server prompt manager returned an invalid or oversized result");
 		const result = captured[0];
@@ -4521,21 +5157,46 @@ var MCPServer = class {
 		});
 		if (digest === void 0) return buildJSONRPCError(id, JSONRPC_INVALID_PARAMS, "Invalid params: tool arguments are too large or unsafe");
 		if (params?.["requestState"] !== void 0 || params?.["inputResponses"] !== void 0) return this.#retry(request, name, digest, args, options);
-		const elicitation = await configured.elicit({
+		const selected = await configured.selector({
 			request,
 			name,
 			arguments: args
 		}, options);
-		if (elicitation === void 0) return void 0;
-		const form = this.#form(elicitation);
+		if (selected === void 0) return void 0;
+		const round = this.#round(selected);
 		const context = parseRequestContext(request, {
 			bytes: this.#limits.message,
 			depth: this.#limits.depth
 		});
-		if (form === void 0) return buildJSONRPCError(id, JSONRPC_INVALID_PARAMS, "Invalid params: elicitation policy returned an invalid form or continuation context");
-		if (context === void 0 || !isFormElicitationSupported(context.capabilities)) return buildJSONRPCError(id, MCP_MISSING_CAPABILITY, "Server requires the elicitation capability for this request", { requiredCapabilities: { elicitation: {} } });
+		if (round === void 0) return buildJSONRPCError(id, JSONRPC_INVALID_PARAMS, "Invalid params: input policy returned an invalid round or continuation context");
+		const refusal = this.#gate(round, context, id);
+		if (refusal !== void 0) return refusal;
 		const principal = await configured.principal(request, options);
-		return this.#required(request, name, digest, form, principal, id, void 0);
+		return this.#required(request, name, digest, round, principal, id, void 0);
+	}
+	#gate(round, context, id) {
+		if (context === void 0) return buildJSONRPCError(id, JSONRPC_INVALID_PARAMS, "Invalid params: malformed modern request metadata");
+		const missing = computeMissingCapabilities(round.requests, context.capabilities);
+		if (missing === void 0) return void 0;
+		return buildJSONRPCError(id, MCP_MISSING_CAPABILITY, "Server requires a client capability this request did not declare", { requiredCapabilities: missing });
+	}
+	#forward(input, request) {
+		const requests = input.inputRequests;
+		if (requests !== void 0) {
+			const context = parseRequestContext(request, {
+				bytes: this.#limits.message,
+				depth: this.#limits.depth
+			});
+			const refusal = this.#gate({ requests }, context, request.id);
+			if (refusal !== void 0) return refusal;
+		}
+		return buildJSONRPCResult(request.id, {
+			...input,
+			_meta: {
+				...input["_meta"] ?? {},
+				[MCP_META_SERVER]: this.#options.identity
+			}
+		});
 	}
 	async #retry(request, name, digest, args, options) {
 		const configured = this.#options.input;
@@ -4548,55 +5209,66 @@ var MCPServer = class {
 			bytes: this.#limits.message,
 			depth: this.#limits.depth
 		});
-		if (context === void 0 || !isFormElicitationSupported(context.capabilities)) return buildJSONRPCError(id, MCP_MISSING_CAPABILITY, "Server requires the elicitation capability for this request", { requiredCapabilities: { elicitation: {} } });
+		if (context === void 0) return buildJSONRPCError(id, JSONRPC_INVALID_PARAMS, "Invalid params: malformed modern request metadata");
 		const verified = await configured.continuation.open(requestState);
 		if (verified === void 0) return buildJSONRPCError(id, JSONRPC_INVALID_PARAMS, "Invalid params: request state could not be recovered");
 		if (!isBoundedString(verified, this.#limits.state) || verified.length === 0) return this.#contain(/* @__PURE__ */ new Error("Continuation port opened a value outside the configured state bound"), id);
 		const state = parseMCPInputState(verified);
 		if (state === void 0) return this.#contain(/* @__PURE__ */ new Error("Continuation port opened a malformed protected payload"), id);
-		const response = inputResponses[state.key];
-		if (state.expiry <= Date.now() || state.id === id || state.version !== context.version || state.method !== request.method || state.name !== name || state.digest !== digest || !Object.hasOwn(inputResponses, state.key)) return buildJSONRPCError(id, JSONRPC_INVALID_PARAMS, "Invalid params: request state could not be verified for this retry");
-		if (!isMCPElicitResult(response) || response.action === "accept" && !isElicitContent(response.content ?? {}, state.schema)) return buildJSONRPCError(id, JSONRPC_INVALID_PARAMS, "Invalid params: the elicitation response is missing or malformed");
+		if (state.expiry <= Date.now() || state.id === id || state.version !== context.version || state.method !== request.method || state.name !== name || state.digest !== digest) return buildJSONRPCError(id, JSONRPC_INVALID_PARAMS, "Invalid params: request state could not be verified for this retry");
+		const responses = this.#answers(state.requests, inputResponses);
+		if (responses === void 0) return buildJSONRPCError(id, JSONRPC_INVALID_PARAMS, "Invalid params: an input response is missing or malformed");
 		const principal = await configured.principal(request, options);
 		if (!(0, _orkestrel_contract.isString)(principal) || principal.length === 0 || state.principal !== principal) return buildJSONRPCError(id, JSONRPC_INVALID_PARAMS, "Invalid params: request state could not be verified for this retry");
-		const elicitation = await configured.elicit({
+		const selected = await configured.selector({
 			request,
 			name,
 			arguments: args,
-			response,
+			responses,
 			...state.state !== void 0 ? { state: state.state } : {}
 		}, options);
 		if (state.expiry <= Date.now()) return buildJSONRPCError(id, JSONRPC_INVALID_PARAMS, "Invalid params: request state could not be verified for this retry");
-		if (elicitation === void 0) return void 0;
-		const form = this.#form(elicitation);
-		if (form === void 0) return buildJSONRPCError(id, JSONRPC_INVALID_PARAMS, "Invalid params: elicitation policy returned an invalid form or continuation context");
-		return this.#required(request, name, digest, form, principal, state.id, state.expiry);
+		if (selected === void 0) return void 0;
+		const round = this.#round(selected);
+		if (round === void 0) return buildJSONRPCError(id, JSONRPC_INVALID_PARAMS, "Invalid params: input policy returned an invalid round or continuation context");
+		const refusal = this.#gate(round, context, id);
+		if (refusal !== void 0) return refusal;
+		return this.#required(request, name, digest, round, principal, state.id, state.expiry);
+	}
+	#answers(requests, responses) {
+		const answered = {};
+		for (const [key, issued] of Object.entries(requests)) {
+			const response = responses[key];
+			if (!Object.hasOwn(responses, key) || !isMCPInputResponse(response, issued)) return void 0;
+			answered[key] = response;
+		}
+		return Object.freeze(answered);
 	}
-	#form(elicitation) {
-		const owned = snapshotJSON(elicitation, {
+	#round(round) {
+		const owned = snapshotJSON(round, {
 			bytes: this.#limits.content,
 			keys: this.#limits.keys,
 			depth: this.#limits.depth
 		});
 		if (owned === void 0 || !(0, _orkestrel_contract.isRecord)(owned[0])) return void 0;
-		const form = owned[0]["request"];
+		const requests = owned[0]["requests"];
 		const state = owned[0]["state"];
-		if (!isMCPElicitForm(form) || !(0, _orkestrel_contract.isUndefined)(state) && !(0, _orkestrel_contract.isJSONValue)(state)) return void 0;
-		return (0, _orkestrel_contract.isUndefined)(state) ? { request: form } : {
-			request: form,
+		if (!isMCPInputRequestMap(requests) || Object.keys(requests).length === 0) return void 0;
+		if (!(0, _orkestrel_contract.isUndefined)(state) && !(0, _orkestrel_contract.isJSONValue)(state)) return void 0;
+		return (0, _orkestrel_contract.isUndefined)(state) ? { requests } : {
+			requests,
 			state
 		};
 	}
-	async #required(request, name, digest, form, principal, origin, previous) {
+	async #required(request, name, digest, round, principal, origin, previous) {
 		const id = request.id;
 		const configured = this.#options.input;
 		const context = parseRequestContext(request, {
 			bytes: this.#limits.message,
 			depth: this.#limits.depth
 		});
-		if (configured === void 0 || context === void 0 || !(0, _orkestrel_contract.isString)(principal) || principal.length === 0 || !Number.isFinite(configured.ttl) || configured.ttl <= 0) return buildJSONRPCError(id, JSONRPC_INVALID_PARAMS, "Invalid params: elicitation policy returned an invalid form or continuation context");
+		if (configured === void 0 || context === void 0 || !(0, _orkestrel_contract.isString)(principal) || principal.length === 0 || !Number.isFinite(configured.ttl) || configured.ttl <= 0) return buildJSONRPCError(id, JSONRPC_INVALID_PARAMS, "Invalid params: input policy returned an invalid round or continuation context");
 		if (previous !== void 0 && previous <= Date.now()) return buildJSONRPCError(id, JSONRPC_INVALID_PARAMS, "Invalid params: request state could not be verified for this retry");
-		const key = crypto.randomUUID();
 		const expiry = Date.now() + configured.ttl;
 		const protectedState = {
 			principal,
@@ -4604,11 +5276,10 @@ var MCPServer = class {
 			id: origin,
 			version: context.version,
 			method: request.method,
-			key,
+			requests: round.requests,
 			name,
 			digest,
-			schema: form.request.requestedSchema,
-			...form.state !== void 0 ? { state: form.state } : {}
+			...round.state !== void 0 ? { state: round.state } : {}
 		};
 		if (!isBoundedJSON(protectedState, {
 			bytes: this.#limits.state,
@@ -4624,13 +5295,7 @@ var MCPServer = class {
 		if (expiry <= Date.now() || previous !== void 0 && previous <= Date.now()) return buildJSONRPCError(id, JSONRPC_INVALID_PARAMS, previous === void 0 ? "Invalid params: request state expired before it could be issued" : "Invalid params: request state could not be verified for this retry");
 		return buildJSONRPCResult(id, {
 			resultType: "input_required",
-			inputRequests: { [key]: {
-				method: "elicitation/create",
-				params: {
-					...form.request,
-					mode: "form"
-				}
-			} },
+			inputRequests: round.requests,
 			requestState,
 			_meta: { [MCP_META_SERVER]: this.#options.identity }
 		});
@@ -5045,7 +5710,7 @@ var MCPClient = class {
 			name,
 			arguments: args,
 			...input === void 0 ? {} : {
-				requestState: input.state,
+				...input.state === void 0 ? {} : { requestState: input.state },
 				inputResponses: input.responses
 			}
 		}, this.#timeout, void 0, options));
@@ -5595,7 +6260,9 @@ exports.MCPTextStreamController = MCPTextStreamController;
 exports.MCP_EXTENSION_TASKS = MCP_EXTENSION_TASKS;
 exports.MCP_FALLBACK_VERSION = MCP_FALLBACK_VERSION;
 exports.MCP_HANDSHAKE_VERSION = MCP_HANDSHAKE_VERSION;
+exports.MCP_HEADER_ANNOTATION = MCP_HEADER_ANNOTATION;
 exports.MCP_HEADER_MISMATCH = MCP_HEADER_MISMATCH;
+exports.MCP_LOOKUP_PAGES = MCP_LOOKUP_PAGES;
 exports.MCP_META_CAPABILITIES = MCP_META_CAPABILITIES;
 exports.MCP_META_CLIENT = MCP_META_CLIENT;
 exports.MCP_META_SERVER = MCP_META_SERVER;
@@ -5603,6 +6270,9 @@ exports.MCP_META_SUBSCRIPTION = MCP_META_SUBSCRIPTION;
 exports.MCP_META_VERSION = MCP_META_VERSION;
 exports.MCP_MISSING_CAPABILITY = MCP_MISSING_CAPABILITY;
 exports.MCP_MODERN_VERSION = MCP_MODERN_VERSION;
+exports.MCP_PARAM_PREFIX = MCP_PARAM_PREFIX;
+exports.MCP_SENTINEL_PREFIX = MCP_SENTINEL_PREFIX;
+exports.MCP_SENTINEL_SUFFIX = MCP_SENTINEL_SUFFIX;
 exports.MCP_UNSUPPORTED_VERSION = MCP_UNSUPPORTED_VERSION;
 exports.SUPPORTED_LEGACY_PROTOCOL_VERSIONS = SUPPORTED_LEGACY_PROTOCOL_VERSIONS;
 exports.SUPPORTED_MCP_VERSIONS = SUPPORTED_MCP_VERSIONS;
@@ -5612,6 +6282,8 @@ exports.bindServer = bindServer;
 exports.buildCallOutcome = buildCallOutcome;
 exports.buildCancelledNotification = buildCancelledNotification;
 exports.buildDiscoverResult = buildDiscoverResult;
+exports.buildHeaderParameters = buildHeaderParameters;
+exports.buildHeaderProjection = buildHeaderProjection;
 exports.buildInitializeResult = buildInitializeResult;
 exports.buildJSONRPCError = buildJSONRPCError;
 exports.buildJSONRPCResult = buildJSONRPCResult;
@@ -5623,14 +6295,20 @@ exports.buildSubscriptionFilter = buildSubscriptionFilter;
 exports.buildSubscriptionResult = buildSubscriptionResult;
 exports.buildToolCall = buildToolCall;
 exports.buildToolDescriptors = buildToolDescriptors;
+exports.computeMissingCapabilities = computeMissingCapabilities;
+exports.countHeaderAnnotations = countHeaderAnnotations;
 exports.createDuplexClientTransport = createDuplexClientTransport;
 exports.createMCPClient = createMCPClient;
 exports.createMCPLegacy = createMCPLegacy;
 exports.createMCPLegacyClientTransport = createMCPLegacyClientTransport;
 exports.createMCPServer = createMCPServer;
 exports.decodeBoundedMessage = decodeBoundedMessage;
+exports.decodeSentinel = decodeSentinel;
 exports.digestJSON = digestJSON;
+exports.encodeSentinel = encodeSentinel;
 exports.extractContentText = extractContentText;
+exports.extractHeaderAnnotations = extractHeaderAnnotations;
+exports.extractToolSchema = extractToolSchema;
 exports.inferEra = inferEra;
 exports.inferRequestVersion = inferRequestVersion;
 exports.inferVersion = inferVersion;
@@ -5638,6 +6316,7 @@ exports.isAbsoluteURI = isAbsoluteURI;
 exports.isBoundedJSON = isBoundedJSON;
 exports.isBoundedString = isBoundedString;
 exports.isElicitContent = isElicitContent;
+exports.isFieldToken = isFieldToken;
 exports.isFormElicitationSupported = isFormElicitationSupported;
 exports.isInitializeRequest = isInitializeRequest;
 exports.isJSONObject = isJSONObject;
@@ -5666,10 +6345,12 @@ exports.isMCPElicitResult = isMCPElicitResult;
 exports.isMCPElicitSchema = isMCPElicitSchema;
 exports.isMCPElicitURL = isMCPElicitURL;
 exports.isMCPError = isMCPError;
+exports.isMCPHeaderPrimitive = isMCPHeaderPrimitive;
 exports.isMCPIcon = isMCPIcon;
 exports.isMCPIdentity = isMCPIdentity;
 exports.isMCPInputRequest = isMCPInputRequest;
 exports.isMCPInputRequestMap = isMCPInputRequestMap;
+exports.isMCPInputResponse = isMCPInputResponse;
 exports.isMCPInputResult = isMCPInputResult;
 exports.isMCPLegacyResult = isMCPLegacyResult;
 exports.isMCPLegacyVersion = isMCPLegacyVersion;
@@ -5692,6 +6373,10 @@ exports.isMCPResourceTemplate = isMCPResourceTemplate;
 exports.isMCPResourceTemplatePage = isMCPResourceTemplatePage;
 exports.isMCPResult = isMCPResult;
 exports.isMCPResultMetaObject = isMCPResultMetaObject;
+exports.isMCPRoot = isMCPRoot;
+exports.isMCPRootResult = isMCPRootResult;
+exports.isMCPSampleContent = isMCPSampleContent;
+exports.isMCPSampleResult = isMCPSampleResult;
 exports.isMCPServerCapabilities = isMCPServerCapabilities;
 exports.isMCPStringArguments = isMCPStringArguments;
 exports.isMCPSubscriptionFilter = isMCPSubscriptionFilter;
@@ -5718,6 +6403,7 @@ exports.parseJSONRPCMessage = parseJSONRPCMessage;
 exports.parseMCPInputState = parseMCPInputState;
 exports.parseRequestContext = parseRequestContext;
 exports.readCancelledId = readCancelledId;
+exports.renderHeaderValue = renderHeaderValue;
 exports.sendStream = sendStream;
 exports.serializeJSON = serializeJSON;
 exports.snapshotJSON = snapshotJSON;