@orkestrel/mcp 0.0.26 → 0.0.28

package/dist/src/core/index.js

@@ -1,9 +1,11 @@
-import { arrayOf, attempt, cloneJSONRecord, cloneJSONValue, isArray, isBoolean, isFiniteNumber, isInteger, isJSONValue, isNumber, isRecord, isString, isUndefined, sanitizeBudget } from "@orkestrel/contract";
+import { arrayOf, attempt, cloneJSONRecord, cloneJSONValue, isArray, isBoolean, isFiniteNumber, isInteger, isJSONValue, isNumber, isRecord, isString, isUndefined, parseJSON, sanitizeBudget } from "@orkestrel/contract";
+import { decodeBase64, decodeUTF8, encodeBase64, encodeHex } from "@orkestrel/codec";
+import { createSSEParser } from "@orkestrel/sse";
 import { Emitter } from "@orkestrel/emitter";
 import { Tool } from "@orkestrel/tool";
 //#region src/core/constants.ts
 /**
-* The revision offered and defaulted to in the legacy `initialize` handshake.
+* Names the revision offered and defaulted to in the legacy `initialize` handshake.
 *
 * @remarks
 * This is deliberately a legacy revision, and the newest one supported. 2026-07-28 is stateless
@@ -11,12 +13,12 @@ import { Tool } from "@orkestrel/tool";
 * it is asking to negotiate a revision with no negotiation.
 */
 var MCP_HANDSHAKE_VERSION = "2025-11-25";
-/** The older legacy revision the optional legacy decorator accepts and an adapter can pin. */
+/** Names the older legacy revision the optional legacy decorator accepts and an adapter can pin. */
 var MCP_FALLBACK_VERSION = "2025-06-18";
-/** The modern revision offered by an unpinned client during discovery. */
+/** Names the modern revision offered by an unpinned client during discovery. */
 var MCP_MODERN_VERSION = "2026-07-28";
 /**
-* The modern MCP protocol revisions a bare server accepts and advertises.
+* Lists the modern MCP protocol revisions a bare server accepts and advertises.
 *
 * @remarks
 * Frozen in discovery-advertisement order. Legacy revisions are absent because
@@ -24,22 +26,25 @@ var MCP_MODERN_VERSION = "2026-07-28";
 * decorator own them.
 */
 var SUPPORTED_MODERN_PROTOCOL_VERSIONS = Object.freeze([MCP_MODERN_VERSION]);
-/** The protocol revisions accepted by the optional legacy decorator. */
+/** Lists the protocol revisions accepted by the optional legacy decorator. */
 var SUPPORTED_LEGACY_PROTOCOL_VERSIONS = Object.freeze([MCP_HANDSHAKE_VERSION, MCP_FALLBACK_VERSION]);
-/** The protocol revisions the `isMCPVersion` guard admits, spanning the modern and legacy eras. */
+/**
+* Lists the protocol revisions the `isMCPVersion` guard admits, spanning the modern and legacy
+* eras.
+*/
 var SUPPORTED_MCP_VERSIONS = Object.freeze([...SUPPORTED_MODERN_PROTOCOL_VERSIONS, ...SUPPORTED_LEGACY_PROTOCOL_VERSIONS]);
-/** Reserved modern `_meta` key carrying the request's protocol revision. */
+/** Names the reserved modern `_meta` key carrying the request's protocol revision. */
 var MCP_META_VERSION = "io.modelcontextprotocol/protocolVersion";
-/** Reserved modern `_meta` key carrying the client's open capability record. */
+/** Names the reserved modern `_meta` key carrying the client's open capability record. */
 var MCP_META_CAPABILITIES = "io.modelcontextprotocol/clientCapabilities";
-/** Reserved modern `_meta` key carrying the optional client identity. */
+/** Names the reserved modern `_meta` key carrying the optional client identity. */
 var MCP_META_CLIENT = "io.modelcontextprotocol/clientInfo";
-/** Reserved modern `_meta` key carrying the server identity on results. */
+/** Names the reserved modern `_meta` key carrying the server identity on results. */
 var MCP_META_SERVER = "io.modelcontextprotocol/serverInfo";
-/** Reserved modern `_meta` key carrying a `subscriptions/listen` request id. */
+/** Names the reserved modern `_meta` key carrying a `subscriptions/listen` request id. */
 var MCP_META_SUBSCRIPTION = "io.modelcontextprotocol/subscriptionId";
 /**
-* The reserved extension key identifying the stable Tasks extension.
+* Names the reserved extension key identifying the stable Tasks extension.
 *
 * @remarks
 * The ONE spelling of it in this package, and the identity of the immutable snapshot dated
@@ -49,10 +54,107 @@ 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";
-/** MCP reserved error: required HTTP metadata does not match the request body. */
+/**
+* Names 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?";
+/** Names the closing marker of the Base64 sentinel a standard MCP header value travels in. */
+var MCP_SENTINEL_SUFFIX = "?=";
+/**
+* Names 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-";
+/**
+* Names the Streamable-HTTP transport header that carries the MCP session id.
+*
+* @remarks
+* A STATEFUL server sends it on the `initialize` reply, and
+* {@link import('./transports/HTTPClientTransport.js').HTTPClientTransport} echoes it as a
+* request header on every subsequent request, so a client passes that server's session
+* validation unchanged.
+*/
+var MCP_SESSION_HEADER = "mcp-session-id";
+/**
+* Names the Streamable-HTTP transport header carrying the MCP protocol version.
+*
+* @remarks
+* A modern request derives it from its own `_meta`; a legacy request echoes the revision the
+* `initialize` result negotiated on each subsequent request.
+*/
+var MCP_PROTOCOL_VERSION_HEADER = "mcp-protocol-version";
+/**
+* Names the modern Streamable-HTTP request header carrying the JSON-RPC method.
+*
+* @remarks
+* It is stamped on every modern request and on no legacy request.
+*/
+var MCP_METHOD_HEADER = "mcp-method";
+/**
+* Names the modern Streamable-HTTP request header carrying a named target.
+*
+* @remarks
+* The HTTP client transport stamps it only for `tools/call`, from that request's `params.name`,
+* in the Base64 sentinel form whenever the name cannot ride as plain ASCII.
+*/
+var MCP_NAME_HEADER = "mcp-name";
+/**
+* Identifies 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";
+/**
+* Names the WebSocket subprotocol `createWebSocketClientTransport` requests by default —
+* `'mcp'`, which `createWebSocketServer` selects when the client offers it. Per RFC 6455
+* §4.1 a client MUST fail the connection if the server returns
+* a subprotocol it did not request; Node ≥ 22 (undici) enforces this strictly, so the
+* default bakes the correct value in. Override `WebSocketClientTransportOptions.protocols`
+* only when connecting to a foreign server that speaks a different subprotocol (or `[]`
+* for no subprotocol negotiation at all).
+*
+* @remarks
+* The client sends it in `Sec-WebSocket-Protocol` and the server echoes it in its `101`
+* handshake, so an MCP WebSocket endpoint is distinguishable from any other WebSocket on the
+* same path. The default WebSocket upgrade path is the same `'/mcp'` the HTTP transport mounts
+* at — the upgrade is selected by the `Upgrade: websocket` header, not a separate path.
+*/
+var MCP_WEBSOCKET_SUBPROTOCOL = "mcp";
+/**
+* Bounds 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;
+/** Names the MCP reserved error for required HTTP metadata that does not match the request body. */
 var MCP_HEADER_MISMATCH = -32020;
 /**
-* MCP reserved error: an operation needs a client capability that was not declared.
+* Names the MCP reserved error for an operation needing a client capability that was not
+* declared.
 *
 * @remarks
 * The GENERIC code for the whole condition, not one capability's code. This server answers
@@ -65,10 +167,10 @@ var MCP_HEADER_MISMATCH = -32020;
 * schema is what a peer implements against.
 */
 var MCP_MISSING_CAPABILITY = -32021;
-/** MCP reserved error: a request names an unsupported protocol revision. */
+/** Names the MCP reserved error for a request naming an unsupported protocol revision. */
 var MCP_UNSUPPORTED_VERSION = -32022;
 /**
-* Default modern result freshness lifetime in milliseconds.
+* Sets the default modern result freshness lifetime in milliseconds.
 *
 * @remarks
 * `ttlMs` is required on cacheable results, while zero means immediately stale
@@ -76,16 +178,18 @@ var MCP_UNSUPPORTED_VERSION = -32022;
 */
 var DEFAULT_MCP_CACHE_TTL = 6e4;
 /**
-* Secure server bounds used when the matching `limit` option leaf is absent or malformed.
+* Sets the secure server bounds used when the matching `limit` option leaf is absent or
+* malformed.
 *
 * @remarks
 * 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,
@@ -97,7 +201,7 @@ var DEFAULT_MCP_LIMITS = Object.freeze({
 	depth: 32
 });
 /**
-* The one empty argument record every argument-less modern `tools/call` runs with.
+* Holds the one empty argument record every argument-less modern `tools/call` runs with.
 *
 * @remarks
 * Frozen and null-prototype, and SHARED: two calls that name no `arguments` receive the same
@@ -111,16 +215,17 @@ var DEFAULT_MCP_LIMITS = Object.freeze({
 * `arguments.constructor` is `undefined` here rather than a function.
 */
 var EMPTY_MCP_ARGUMENTS = Object.freeze(Object.create(null));
-/** JSON-RPC 2.0 reserved error: invalid JSON was received (the message did not parse). */
+/** Names the JSON-RPC 2.0 reserved error for invalid JSON received (the message did not parse). */
 var JSONRPC_PARSE_ERROR = -32700;
-/** JSON-RPC 2.0 reserved error: the payload was not a valid Request object. */
+/** Names the JSON-RPC 2.0 reserved error for a payload that was not a valid Request object. */
 var JSONRPC_INVALID_REQUEST = -32600;
-/** JSON-RPC 2.0 reserved error: the requested method does not exist. */
+/** Names the JSON-RPC 2.0 reserved error for a requested method that does not exist. */
 var JSONRPC_METHOD_NOT_FOUND = -32601;
-/** JSON-RPC 2.0 reserved error: the method's parameters were invalid. */
+/** Names the JSON-RPC 2.0 reserved error for a method's invalid parameters. */
 var JSONRPC_INVALID_PARAMS = -32602;
 /**
-* JSON-RPC 2.0 reserved error: the server failed while handling an otherwise valid request.
+* Names the JSON-RPC 2.0 reserved error for a server that failed while handling an otherwise
+* valid request.
 *
 * @remarks
 * The code every MODERN internal fault answers with — a provider, handler, continuation,
@@ -130,7 +235,7 @@ var JSONRPC_INVALID_PARAMS = -32602;
 */
 var JSONRPC_INTERNAL_ERROR = -32603;
 /**
-* JSON-RPC 2.0 implementation-defined server error (the `-32000` to `-32099` range).
+* Names the JSON-RPC 2.0 implementation-defined server error (the `-32000` to `-32099` range).
 *
 * @remarks
 * Retained for the LEGACY branch alone. A modern fault answers
@@ -138,21 +243,27 @@ var JSONRPC_INTERNAL_ERROR = -32603;
 * already characterized against it.
 */
 var JSONRPC_SERVER_ERROR = -32e3;
-/** The default client name reported in the MCP `initialize` handshake (`clientInfo.name`). */
-var DEFAULT_MCP_CLIENT_NAME = "taverna";
-/** The default client version reported in the MCP `initialize` handshake (`clientInfo.version`). */
+/**
+* Supplies the default client name reported in the MCP `initialize` handshake
+* (`clientInfo.name`).
+*/
+var DEFAULT_MCP_CLIENT_NAME = "@orkestrel/mcp";
+/**
+* Supplies the default client version reported in the MCP `initialize` handshake
+* (`clientInfo.version`).
+*/
 var DEFAULT_MCP_CLIENT_VERSION = "1.0.0";
 /**
-* The default per-request deadline (ms) an `MCPClient` applies when `options.timeout`
+* Sets the default per-request deadline (ms) an `MCPClient` applies when `options.timeout`
 * is unset — a request the remote server does not answer within it rejects.
 */
 var DEFAULT_MCP_REQUEST_TIMEOUT = 3e4;
-/** The default number of subscription frames retained while no client read is parked. */
+/** Sets the default number of subscription frames retained while no client read is parked. */
 var DEFAULT_MCP_SUBSCRIPTION_CAPACITY = 64;
 //#endregion
 //#region src/core/errors.ts
 /**
-* A Model Context Protocol error preserving its machine-readable numeric code and
+* Preserves a Model Context Protocol error's machine-readable numeric code and
 * optional structured context.
 *
 * @remarks
@@ -195,7 +306,7 @@ var MCPError = class extends Error {
 * Determines whether an unknown value is an {@link MCPError}.
 *
 * @param value - The unknown value to inspect
-* @returns `true` only when the value is an `MCPError`
+* @returns True if the value is an `MCPError`; false otherwise
 *
 * @example
 * ```ts
@@ -431,49 +542,48 @@ 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) {
 	try {
 		if (!isString(value)) return void 0;
-		const parsed = JSON.parse(value);
+		const parsed = parseJSON(value);
 		if (!isRecord(parsed)) return void 0;
 		const principal = parsed["principal"];
 		const expiry = parsed["expiry"];
 		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 (!isString(principal) || principal.length === 0 || !isNumber(expiry) || !Number.isFinite(expiry)) return;
 		if (!isJSONRPCId(id)) return void 0;
-		if (!isString(version) || !isString(method) || !isString(key) || !isString(name)) return;
+		if (!isString(version) || !isString(method) || !isString(name)) return void 0;
 		if (!isString(digest) || !isUndefined(state) && !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,
 			...isUndefined(state) ? {} : { state }
 		};
 	} catch {
@@ -491,15 +601,15 @@ function parseMCPInputState(value) {
 * does not authorize a form request. Total over hostile input.
 *
 * @param value - The client capability record to inspect
-* @returns `true` when form-mode elicitation is declared
+* @returns True if form-mode elicitation is declared; false otherwise
 *
 * @example
 * ```ts
-* isFormElicitationSupported({ elicitation: {} }) // true — implicit form mode
-* isFormElicitationSupported({ elicitation: { url: {} } }) // false
+* supportsFormElicitation({ elicitation: {} }) // true — implicit form mode
+* supportsFormElicitation({ elicitation: { url: {} } }) // false
 * ```
 */
-function isFormElicitationSupported(value) {
+function supportsFormElicitation(value) {
 	const owned = attempt(() => cloneJSONRecord(value));
 	if (!owned.success) return false;
 	try {
@@ -512,6 +622,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 supportsFormElicitation} 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 = attempt(() => 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 (!isRecord(declared["sampling"])) missing["sampling"] = {};
+			continue;
+		}
+		if (request.method === "roots/list") {
+			if (!isRecord(declared["roots"])) missing["roots"] = {};
+			continue;
+		}
+		const elicitation = declared["elicitation"];
+		if (request.params.mode === "url") {
+			if (!isRecord(elicitation) || !isRecord(elicitation["url"])) urlUndeclared = true;
+			continue;
+		}
+		if (!supportsFormElicitation(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
@@ -528,16 +700,16 @@ function isFormElicitationSupported(value) {
 * the request in hand. Total over hostile input.
 *
 * @param value - The client capability record to inspect
-* @returns `true` when the tasks extension is declared as the schema's empty object
+* @returns True if the tasks extension is declared as the schema's empty object; false otherwise
 *
 * @example
 * ```ts
-* isTaskSupported({ extensions: { 'io.modelcontextprotocol/tasks': {} } }) // true
-* isTaskSupported({ extensions: {} }) // false — the key is the declaration
-* isTaskSupported({ extensions: { 'io.modelcontextprotocol/tasks': { on: true } } }) // false
+* supportsTask({ extensions: { 'io.modelcontextprotocol/tasks': {} } }) // true
+* supportsTask({ extensions: {} }) // false — the key is the declaration
+* supportsTask({ extensions: { 'io.modelcontextprotocol/tasks': { on: true } } }) // false
 * ```
 */
-function isTaskSupported(value) {
+function supportsTask(value) {
 	const owned = attempt(() => cloneJSONRecord(value));
 	if (!owned.success) return false;
 	try {
@@ -779,7 +951,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 encodeHex(new Uint8Array(digest));
 }
 /**
 * Builds one official progress notification for the original request stream.
@@ -814,7 +986,7 @@ function buildProgressNotification(token, progress) {
 * rather than as a violation.
 *
 * Only write one on a carrier that accepts a client-initiated notification — see
-* {@link import('./types.js').MCPClientTransportInterface.duplex}. On Streamable HTTP the
+* {@link import('./types.js').MCPMessageTransportInterface.duplex}. On Streamable HTTP the
 * dated revision defines no such frame, and closing the response stream is the
 * cancellation signal instead.
 *
@@ -853,7 +1025,7 @@ function buildCancelledNotification(id, reason) {
 *
 * @param method - The method the pending request was issued for
 * @param resultType - The unknown `resultType` the peer answered with
-* @returns Whether that method may legally answer with that `resultType`
+* @returns True if that method may legally answer with that `resultType`; false otherwise
 *
 * @example
 * ```ts
@@ -1208,7 +1380,7 @@ function buildSubscriptionFilter(requested, supported, enabled = false) {
 *
 * @param notification - The server notification offered by the configured producer
 * @param filter - The filter acknowledged to the client
-* @returns `true` when the notification belongs on this subscription stream
+* @returns True if the notification belongs on this subscription stream; false otherwise
 */
 function matchesSubscriptionNotification(notification, filter) {
 	if (notification.method === "notifications/tools/list_changed") return filter.toolsListChanged === true;
@@ -1330,7 +1502,7 @@ function buildInitializeResult(name, version, requested) {
 *
 * @remarks
 * The bound is checked FIRST, against the raw string, so an oversized message is never
-* `JSON.parse`d at all: a decoder that parses before it measures has already spent the work
+* parsed at all: a decoder that parses before it measures has already spent the work
 * the bound exists to refuse. A message over the bound, malformed JSON, and a well-formed
 * value that is not a JSON-RPC message are one answer — `undefined` — because a binder does
 * exactly the same thing with each of them: nothing, and let
@@ -1350,8 +1522,444 @@ function buildInitializeResult(name, version, requested) {
 */
 function decodeBoundedMessage(message, limits) {
 	if (!isBoundedString(message, limits.bytes)) return void 0;
-	const parsed = attempt(() => JSON.parse(message));
-	return parsed.success ? parseJSONRPCMessage(parsed.value, limits) : void 0;
+	return parseJSONRPCMessage(parseJSON(message), limits);
+}
+/**
+* Decodes one inbound frame and delivers it onto a transport emitter as `message` or `error`.
+*
+* @remarks
+* The ONE inbound fold every message-carrying transport in this package runs: parse the frame,
+* narrow it with `parseJSONRPCMessage`, emit `message` for a well-formed
+* {@link JSONRPCMessage}, and emit `error` for anything else. Total — an adversarial frame
+* produces an `error` emission and never a throw.
+*
+* The two failures report differently on purpose. Unparsable text emits the CAUGHT parse
+* error, which names the offending position; well-formed JSON that is not a JSON-RPC message
+* has no caught value to report, so it emits `fault` — the carrier's own wording, passed in
+* rather than forked into a second copy of this body.
+*
+* @param emitter - The transport's emitter to deliver onto
+* @param text - One inbound frame's raw text
+* @param fault - The message for the error emitted when the frame parses but is not JSON-RPC
+*
+* @example
+* ```ts
+* deliverMessage(transport.emitter, frame, 'non-JSON-RPC WebSocket frame')
+* ```
+*/
+function deliverMessage(emitter, text, fault) {
+	let parsed;
+	try {
+		parsed = JSON.parse(text);
+	} catch (error) {
+		emitter.emit("error", error);
+		return;
+	}
+	const message = parseJSONRPCMessage(parsed);
+	if (message === void 0) {
+		emitter.emit("error", new Error(fault));
+		return;
+	}
+	emitter.emit("message", message);
+}
+/**
+* Decodes one SSE event's `data` string into a {@link JSONRPCMessage}, or `undefined`
+* when it is not one — the per-event step {@link readEventStream} folds over.
+*
+* @remarks
+* Parses the `data` (a peer serializes the JSON-RPC envelope as the event's `data`) with
+* `@orkestrel/contract`'s `parseJSON` — the declared JSON boundary, which answers `undefined`
+* instead of throwing — and narrows the parsed value with `parseJSONRPCMessage`. Total:
+* malformed JSON or a non-message value yields `undefined`, never throws.
+*
+* @param data - One SSE event's `data` payload
+* @returns The decoded {@link JSONRPCMessage}, or `undefined`
+*
+* @example
+* ```ts
+* decodeEvent('{"jsonrpc":"2.0","id":1,"result":{}}') // the decoded response
+* ```
+*/
+function decodeEvent(data) {
+	return parseJSONRPCMessage(parseJSON(data));
+}
+/**
+* Decodes a `fetch` Response's Server-Sent-Events body into the JSON-RPC messages it
+* carried — the CLIENT-side inverse of a server's Streamable-HTTP SSE response.
+*
+* @remarks
+* Reads the whole `response.body` stream chunk-by-chunk through a `TextDecoder({ stream: true
+* })` (handling a multi-byte character split across reads) and `@orkestrel/sse`'s
+* {@link SSEParserInterface} (handling a partial line or in-progress event split across
+* reads), then narrows each dispatched event's `data` to a {@link JSONRPCMessage} through
+* {@link decodeEvent} (so a non-message or non-JSON `data:` event is DROPPED, never thrown —
+* total). It reuses the SAME `SSEParser` a server's `createStream` seam serializes against, so
+* the wire round-trips. A `null` body (no stream) yields no messages;
+* {@link import('./transports/HTTPClientTransport.js').HTTPClientTransport} reads a
+* request/response SSE reply (the server sends one `data:` event then ends), so this drains to
+* completion.
+*
+* @param response - The SSE `fetch` Response to decode (its `body` is read to completion)
+* @returns Every {@link JSONRPCMessage} the stream carried, in order
+*
+* @example
+* ```ts
+* const messages = await readEventStream(await fetch(url, { method: 'POST', body }))
+* ```
+*/
+async function readEventStream(response) {
+	const body = response.body;
+	if (body === null) return [];
+	const reader = body.getReader();
+	const decoder = new TextDecoder();
+	const parser = createSSEParser();
+	const messages = [];
+	try {
+		for (;;) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			for (const event of parser.parse(decoder.decode(value, { stream: true }))) {
+				const message = decodeEvent(event.data);
+				if (message !== void 0) messages.push(message);
+			}
+		}
+	} finally {
+		reader.releaseLock();
+	}
+	return messages;
+}
+/**
+* Builds the error for a non-success HTTP response that carried no JSON-RPC message.
+*
+* @param response - The response whose status is reported
+* @param type - The response's content type, or an empty string when absent
+* @returns An error naming the HTTP status and unsupported response shape
+*
+* @example
+* ```ts
+* const error = buildResponseError(new Response('', { status: 500 }), '')
+* ```
+*/
+function buildResponseError(response, type) {
+	if (type.includes("application/json")) return /* @__PURE__ */ new Error(`HTTP ${response.status} response contained an application/json body that was not a JSON-RPC message`);
+	if (type.includes("text/event-stream")) return /* @__PURE__ */ new Error(`HTTP ${response.status} response contained a text/event-stream body without a JSON-RPC message`);
+	const shape = type === "" ? "a body without a content type" : `an unsupported '${type}' body`;
+	return /* @__PURE__ */ new Error(`HTTP ${response.status} response contained ${shape}`);
+}
+/**
+* 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 = decodeBase64(payload);
+	if (bytes === void 0) return void 0;
+	return 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}${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 (isArray(node)) {
+			if (seen.has(node)) continue;
+			seen.add(node);
+			for (const item of node) pending.push(item);
+			continue;
+		}
+		if (!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 (!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 (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 (!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 isString(value) ? value : void 0;
+	if (primitive === "boolean") return isBoolean(value) ? value ? "true" : "false" : void 0;
+	return 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 must carry. 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 = 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 = isRecord(response) ? response["result"] : void 0;
+	const tools = isRecord(result) ? result["tools"] : void 0;
+	if (!isArray(tools)) return void 0;
+	for (const tool of tools) {
+		if (!isRecord(tool) || tool["name"] !== name) continue;
+		const schema = tool["inputSchema"];
+		return isRecord(schema) ? schema : void 0;
+	}
 }
 /**
 * Reads the request id an inbound `notifications/cancelled` names — the inverse of
@@ -1527,7 +2135,7 @@ function bindServer(server, transport) {
 * @remarks
 * The client's outbound writes flow through `client.transport.send` — its existing,
 * unmodified request/response correlation — so `client` must have been constructed
-* with a {@link import('./types.js').MCPClientTransportInterface} that itself carries
+* with a {@link import('./types.js').MCPMessageTransportInterface} that itself carries
 * the SAME `transport` (see {@link import('./factories.js').createDuplexClientTransport},
 * the additive factory that adapts an {@link MCPTransportInterface} into that shape);
 * this binder then completes the inbound half by decoding each message and pushing it
@@ -1640,7 +2248,7 @@ function isMCPResultMetaObject(value) {
 * {@link JSONRPCId}, because a stamp naming nothing addressable is worse than no stamp.
 *
 * @param value - The unknown value to inspect
-* @returns `true` when the value is exact metadata whose subscription stamp, if present, is valid
+* @returns True if the value is exact metadata whose subscription stamp, if present, is valid; false otherwise
 *
 * @example
 * ```ts
@@ -1663,12 +2271,54 @@ function isMCPLoggingLevel(value) {
 * Determines whether a value is standard padded base64 as required by JSON Schema `byte` format.
 *
 * @param value - The unknown value to inspect
-* @returns Whether the value is an empty or completely padded standard base64 encoding
+* @returns True if the value is an empty or completely padded standard base64 encoding; false otherwise
 */
 function isStandardBase64(value) {
 	return 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 True if the value is a non-empty RFC 9110 token; false otherwise
+*
+* @example
+* ```ts
+* isFieldToken('Region') // true
+* isFieldToken('My Region') // false
+* ```
+*/
+function isFieldToken(value) {
+	return 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 True if the value is one of `'string'`, `'integer'`, or `'boolean'`; false otherwise
+*
+* @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
@@ -1676,7 +2326,7 @@ function isStandardBase64(value) {
 * scheme allowlist. Component scanning is bounded by the input length.
 *
 * @param value - The unknown value to inspect
-* @returns Whether the value is an RFC 3986 URI rather than a relative reference
+* @returns True if the value is an RFC 3986 URI rather than a relative reference; false otherwise
 */
 function isAbsoluteURI(value) {
 	if (!isString(value) || value.length === 0) return false;
@@ -1772,7 +2422,7 @@ function isAbsoluteURI(value) {
 * refuse. It is a SYNTAX guard: no time zone, locale, calendar era, or leap second applies.
 *
 * @param value - The unknown value to inspect
-* @returns Whether the value is an RFC 3339 `full-date` for a day that exists
+* @returns True if the value is an RFC 3339 `full-date` for a day that exists; false otherwise
 *
 * @example
 * ```ts
@@ -1805,7 +2455,7 @@ function isRFC3339Date(value) {
 * second.
 *
 * @param value - The unknown value to inspect
-* @returns Whether the value is an RFC 3339 `date-time` for a day that exists
+* @returns True if the value is an RFC 3339 `date-time` for a day that exists; false otherwise
 *
 * @example
 * ```ts
@@ -1823,7 +2473,7 @@ function isRFC3339DateTime(value) {
 * Determines whether a value is one exact finite MCP progress payload.
 *
 * @param value - The unknown value to inspect
-* @returns Whether required progress and optional total/message fields match the dated schema
+* @returns True if required progress and optional total/message fields match the dated schema; false otherwise
 */
 function isMCPProgress(value) {
 	const owned = attempt(() => cloneJSONRecord(value));
@@ -1842,7 +2492,7 @@ function isMCPProgress(value) {
 * Determines whether a value carries valid dated-schema MCP content annotations.
 *
 * @param value - The unknown value to inspect
-* @returns Whether the value is valid MCP annotations
+* @returns True if the value is valid MCP annotations; false otherwise
 */
 function isMCPAnnotations(value) {
 	const owned = attempt(() => cloneJSONRecord(value));
@@ -1863,7 +2513,7 @@ function isMCPAnnotations(value) {
 * Determines whether a value is one exact dated-schema MCP icon.
 *
 * @param value - The unknown value to inspect
-* @returns Whether the value is a valid MCP icon
+* @returns True if the value is a valid MCP icon; false otherwise
 */
 function isMCPIcon(value) {
 	const owned = attempt(() => cloneJSONRecord(value));
@@ -1954,7 +2604,7 @@ function isMCPServerCapabilities(value) {
 * Determines whether a value is embedded textual MCP resource contents.
 *
 * @param value - The unknown value to inspect
-* @returns Whether the value is embedded textual resource contents
+* @returns True if the value is embedded textual resource contents; false otherwise
 */
 function isMCPTextResource(value) {
 	const owned = attempt(() => cloneJSONRecord(value));
@@ -1973,7 +2623,7 @@ function isMCPTextResource(value) {
 * Determines whether a value is embedded blob MCP resource contents.
 *
 * @param value - The unknown value to inspect
-* @returns Whether the value is embedded blob resource contents
+* @returns True if the value is embedded blob resource contents; false otherwise
 */
 function isMCPBlobResource(value) {
 	const owned = attempt(() => cloneJSONRecord(value));
@@ -1992,7 +2642,7 @@ function isMCPBlobResource(value) {
 * Determines whether a value is one `resources/list` descriptor.
 *
 * @param value - The unknown value to inspect
-* @returns Whether the value is a valid resource descriptor
+* @returns True if the value is a valid resource descriptor; false otherwise
 */
 function isMCPResource(value) {
 	const owned = attempt(() => cloneJSONRecord(value));
@@ -2014,7 +2664,7 @@ function isMCPResource(value) {
 * level belong to the consumer-supplied resource manager; this package projects the string.
 *
 * @param value - The unknown value to inspect
-* @returns Whether the value is a valid resource-template descriptor
+* @returns True if the value is a valid resource-template descriptor; false otherwise
 */
 function isMCPResourceTemplate(value) {
 	const owned = attempt(() => cloneJSONRecord(value));
@@ -2031,7 +2681,7 @@ function isMCPResourceTemplate(value) {
 * Determines whether a value is structurally discriminated resource contents.
 *
 * @param value - The unknown value to inspect
-* @returns Whether exactly one of `text` and `blob` is present and valid
+* @returns True if exactly one of `text` and `blob` is present and valid; false otherwise
 */
 function isMCPResourceContents(value) {
 	const owned = attempt(() => cloneJSONRecord(value));
@@ -2045,7 +2695,7 @@ function isMCPResourceContents(value) {
 * Determines whether a value carries the shared optional pagination cursor.
 *
 * @param value - The unknown value to inspect
-* @returns Whether a present `cursor` is a string
+* @returns True if a present `cursor` is a string; false otherwise
 */
 function isMCPPaginationParams(value) {
 	const owned = attempt(() => cloneJSONRecord(value));
@@ -2055,7 +2705,7 @@ function isMCPPaginationParams(value) {
 * Determines whether a value is one consumer-owned resource page.
 *
 * @param value - The unknown value to inspect
-* @returns Whether the resources and optional following cursor are valid
+* @returns True if the resources and optional following cursor are valid; false otherwise
 */
 function isMCPResourcePage(value) {
 	const owned = attempt(() => cloneJSONRecord(value));
@@ -2068,7 +2718,7 @@ function isMCPResourcePage(value) {
 * Determines whether a value is one consumer-owned resource-template page.
 *
 * @param value - The unknown value to inspect
-* @returns Whether the templates and optional following cursor are valid
+* @returns True if the templates and optional following cursor are valid; false otherwise
 */
 function isMCPResourceTemplatePage(value) {
 	const owned = attempt(() => cloneJSONRecord(value));
@@ -2081,7 +2731,7 @@ function isMCPResourceTemplatePage(value) {
 * Determines whether a value is a string-valued MCP argument record.
 *
 * @param value - The unknown value to inspect
-* @returns Whether every own argument value is a string
+* @returns True if every own argument value is a string; false otherwise
 */
 function isMCPStringArguments(value) {
 	const owned = attempt(() => cloneJSONRecord(value));
@@ -2091,7 +2741,7 @@ function isMCPStringArguments(value) {
 * Determines whether a value is one prompt argument descriptor.
 *
 * @param value - The unknown value to inspect
-* @returns Whether the prompt argument descriptor is valid
+* @returns True if the prompt argument descriptor is valid; false otherwise
 */
 function isMCPPromptArgument(value) {
 	const owned = attempt(() => cloneJSONRecord(value));
@@ -2103,7 +2753,7 @@ function isMCPPromptArgument(value) {
 * Determines whether a value is one `prompts/list` descriptor.
 *
 * @param value - The unknown value to inspect
-* @returns Whether the prompt descriptor is valid
+* @returns True if the prompt descriptor is valid; false otherwise
 */
 function isMCPPrompt(value) {
 	const owned = attempt(() => cloneJSONRecord(value));
@@ -2117,7 +2767,7 @@ function isMCPPrompt(value) {
 * Determines whether a value is one prompt message with existing rich content.
 *
 * @param value - The unknown value to inspect
-* @returns Whether the role and content are valid
+* @returns True if the role and content are valid; false otherwise
 */
 function isMCPPromptMessage(value) {
 	const owned = attempt(() => cloneJSONRecord(value));
@@ -2127,7 +2777,7 @@ function isMCPPromptMessage(value) {
 * Determines whether a value is one consumer-owned prompt page.
 *
 * @param value - The unknown value to inspect
-* @returns Whether the prompts and optional following cursor are valid
+* @returns True if the prompts and optional following cursor are valid; false otherwise
 */
 function isMCPPromptPage(value) {
 	const owned = attempt(() => cloneJSONRecord(value));
@@ -2140,7 +2790,7 @@ function isMCPPromptPage(value) {
 * Determines whether a value is one complete `prompts/get` result.
 *
 * @param value - The unknown value to inspect
-* @returns Whether the prompt result and all messages are valid
+* @returns True if the prompt result and all messages are valid; false otherwise
 */
 function isMCPPromptGetResult(value) {
 	const owned = attempt(() => cloneJSONRecord(value));
@@ -2153,7 +2803,7 @@ function isMCPPromptGetResult(value) {
 * Determines whether a value is a prompt or resource-template completion reference.
 *
 * @param value - The unknown value to inspect
-* @returns Whether the discriminated reference is valid
+* @returns True if the discriminated reference is valid; false otherwise
 */
 function isMCPCompletionReference(value) {
 	const owned = attempt(() => cloneJSONRecord(value));
@@ -2165,7 +2815,7 @@ function isMCPCompletionReference(value) {
 * Determines whether a value is one `completion/complete` parameter object.
 *
 * @param value - The unknown value to inspect
-* @returns Whether its reference, fragment, and optional string context are valid
+* @returns True if its reference, fragment, and optional string context are valid; false otherwise
 */
 function isMCPCompletionParams(value) {
 	const owned = attempt(() => cloneJSONRecord(value));
@@ -2184,7 +2834,7 @@ function isMCPCompletionParams(value) {
 * Determines whether a value is one host-produced completion candidate set.
 *
 * @param value - The unknown value to inspect
-* @returns Whether its candidates and optional result facts are valid
+* @returns True if its candidates and optional result facts are valid; false otherwise
 */
 function isMCPCompletion(value) {
 	const owned = attempt(() => cloneJSONRecord(value));
@@ -2198,7 +2848,7 @@ function isMCPCompletion(value) {
 * Determines whether a value is one complete, capped `completion/complete` result.
 *
 * @param value - The unknown value to inspect
-* @returns Whether the result is complete and carries at most 100 candidates
+* @returns True if the result is complete and carries at most 100 candidates; false otherwise
 */
 function isMCPCompletionResult(value) {
 	const owned = attempt(() => cloneJSONRecord(value));
@@ -2210,7 +2860,7 @@ function isMCPCompletionResult(value) {
 * Determines whether a value is one exact dated-schema MCP tool content block.
 *
 * @param value - The unknown value to inspect
-* @returns Whether the value is valid MCP content
+* @returns True if the value is valid MCP content; false otherwise
 */
 function isMCPContent(value) {
 	const owned = attempt(() => cloneJSONRecord(value));
@@ -2251,7 +2901,7 @@ function isMCPContent(value) {
 * input.
 *
 * @param value - The unknown value to inspect
-* @returns Whether the value is a modern result
+* @returns True if the value is a modern result; false otherwise
 *
 * @example
 * ```ts
@@ -2277,7 +2927,7 @@ function isMCPResult(value) {
 * hostile input.
 *
 * @param value - The unknown value to inspect
-* @returns Whether the value is a legacy result
+* @returns True if the value is a legacy result; false otherwise
 *
 * @example
 * ```ts
@@ -2293,7 +2943,7 @@ function isMCPLegacyResult(value) {
 * Determines whether a value is a complete modern MCP tool result.
 *
 * @param value - The unknown value to inspect
-* @returns Whether the value is a complete MCP call result
+* @returns True if the value is a complete MCP call result; false otherwise
 */
 function isMCPCallResult(value) {
 	const owned = attempt(() => cloneJSONRecord(value));
@@ -2321,7 +2971,7 @@ function isMCPCallResult(value) {
 * INTEGER milliseconds because the schema formats them `int`.
 *
 * @param value - The unknown value to inspect
-* @returns Whether the value is a well-formed `resultType: 'task'` result
+* @returns True if the value is a well-formed `resultType: 'task'` result; false otherwise
 *
 * @example
 * ```ts
@@ -2348,7 +2998,7 @@ function isMCPTaskResult(value) {
 * Determines whether a value is one of the extension's task lifecycle states.
 *
 * @param value - The unknown value to inspect
-* @returns Whether the value is an {@link MCPTaskStatus}
+* @returns True if the value is an {@link MCPTaskStatus}; false otherwise
 *
 * @example
 * ```ts
@@ -2379,7 +3029,7 @@ function isMCPTaskStatus(value) {
 * What is checked is what this package publishes as the contract.
 *
 * @param value - The unknown value to inspect
-* @returns Whether the value is a well-formed {@link MCPTaskDetail}
+* @returns True if the value is a well-formed {@link MCPTaskDetail}; false otherwise
 *
 * @example
 * ```ts
@@ -2422,7 +3072,7 @@ function isMCPTaskDetail(value) {
 * peer stamps there is the peer's to write.
 *
 * @param value - The unknown value to inspect
-* @returns Whether the value is a well-formed {@link MCPTaskDetailResult}
+* @returns True if the value is a well-formed {@link MCPTaskDetailResult}; false otherwise
 *
 * @example
 * ```ts
@@ -2456,7 +3106,7 @@ function isMCPTaskDetailResult(value) {
 * to it, so a guard that demanded the stamp would refuse every frame a producer emits.
 *
 * @param value - The unknown value to inspect
-* @returns Whether the value is a well-formed `notifications/tasks` notification
+* @returns True if the value is a well-formed `notifications/tasks` notification; false otherwise
 *
 * @example
 * ```ts
@@ -2484,7 +3134,7 @@ function isMCPTaskNotification(value) {
 *
 * @param value - The unknown value to inspect
 * @param bytes - The maximum accepted encoded bytes
-* @returns `true` only for a string whose UTF-8 representation fits the bound
+* @returns True if `value` is a string whose UTF-8 representation fits the bound; false otherwise
 *
 * @example
 * ```ts
@@ -2520,7 +3170,7 @@ function isBoundedString(value, bytes) {
 *
 * @param value - The unknown value to inspect
 * @param limits - Serialized byte, optional key, and nesting-depth bounds
-* @returns `true` only for safe JSON satisfying every bound
+* @returns True if `value` is safe JSON satisfying every bound; false otherwise
 *
 * @example
 * ```ts
@@ -2542,7 +3192,7 @@ function isBoundedJSON(value, limits) {
 * no minimum length. Total: any other input returns `false`.
 *
 * @param value - The already-parsed value to test
-* @returns `true` when `value` is a string or a finite integer
+* @returns True if `value` is a string or a finite integer; false otherwise
 *
 * @example
 * ```ts
@@ -2560,7 +3210,7 @@ function isJSONRPCId(value) {
 * Determines whether a value is a supported {@link MCPVersion}.
 *
 * @param value - The unknown value to inspect
-* @returns `true` when the value is one of {@link SUPPORTED_MCP_VERSIONS}
+* @returns True if the value is one of {@link SUPPORTED_MCP_VERSIONS}; false otherwise
 */
 function isMCPVersion(value) {
 	return isString(value) && SUPPORTED_MCP_VERSIONS.some((version) => version === value);
@@ -2569,7 +3219,7 @@ function isMCPVersion(value) {
 * Determines whether a value is a modern protocol revision accepted by a bare server.
 *
 * @param value - The unknown value to inspect
-* @returns `true` when the value is one of {@link SUPPORTED_MODERN_PROTOCOL_VERSIONS}
+* @returns True if the value is one of {@link SUPPORTED_MODERN_PROTOCOL_VERSIONS}; false otherwise
 */
 function isMCPModernVersion(value) {
 	return isString(value) && SUPPORTED_MODERN_PROTOCOL_VERSIONS.some((version) => version === value);
@@ -2578,7 +3228,7 @@ function isMCPModernVersion(value) {
 * Determines whether a value is a revision accepted by the optional legacy decorator.
 *
 * @param value - The unknown value to inspect
-* @returns `true` when the value is one of {@link SUPPORTED_LEGACY_PROTOCOL_VERSIONS}
+* @returns True if the value is one of {@link SUPPORTED_LEGACY_PROTOCOL_VERSIONS}; false otherwise
 */
 function isMCPLegacyVersion(value) {
 	return isString(value) && SUPPORTED_LEGACY_PROTOCOL_VERSIONS.some((version) => version === value);
@@ -2597,7 +3247,7 @@ function isMCPLegacyVersion(value) {
 * the caller asked for.
 *
 * @param value - The unknown value to inspect
-* @returns `true` when every recognized filter field has its protocol shape
+* @returns True if every recognized filter field has its protocol shape; false otherwise
 */
 function isMCPSubscriptionFilter(value) {
 	const owned = attempt(() => cloneJSONRecord(value));
@@ -2618,7 +3268,7 @@ function isMCPSubscriptionFilter(value) {
 * Determines whether a value is a graceful `subscriptions/listen` result.
 *
 * @param value - The unknown value to inspect
-* @returns `true` when the result is complete and carries a valid subscription id
+* @returns True if the result is complete and carries a valid subscription id; false otherwise
 */
 function isMCPSubscriptionResult(value) {
 	const owned = attempt(() => cloneJSONRecord(value));
@@ -2630,7 +3280,7 @@ function isMCPSubscriptionResult(value) {
 * Determines whether a value is one restricted primitive form-elicitation schema.
 *
 * @param value - The unknown value to inspect
-* @returns `true` for a supported boolean, numeric, string, or string-array schema
+* @returns True if `value` is a supported boolean, numeric, string, or string-array schema; false otherwise
 *
 * @example
 * ```ts
@@ -2693,7 +3343,7 @@ function isMCPElicitFieldSchema(value) {
 * an unrecognized top-level annotation is data rather than a rejection.
 *
 * @param value - The unknown value to inspect
-* @returns `true` when `value` is a restricted object schema of supported field schemas
+* @returns True if `value` is a restricted object schema of supported field schemas; false otherwise
 *
 * @example
 * ```ts
@@ -2720,7 +3370,7 @@ function isMCPElicitSchema(value) {
 * Determines whether a value is a form-mode elicitation parameter object.
 *
 * @param value - The unknown value to inspect
-* @returns `true` when `value` has the restricted form elicitation shape
+* @returns True if `value` has the restricted form elicitation shape; false otherwise
 *
 * @example
 * ```ts
@@ -2746,7 +3396,7 @@ function isMCPElicitForm(value) {
 * Determines whether a value is a URL-mode elicitation parameter object.
 *
 * @param value - The unknown value to inspect
-* @returns `true` when `value` has the URL elicitation shape
+* @returns True if `value` has the URL elicitation shape; false otherwise
 *
 * @example
 * ```ts
@@ -2767,7 +3417,7 @@ function isMCPElicitURL(value) {
 * Determines whether a value is an embedded `elicitation/create` request.
 *
 * @param value - The unknown value to inspect
-* @returns `true` when `value` is a form- or URL-mode elicitation request
+* @returns True if `value` is a form- or URL-mode elicitation request; false otherwise
 *
 * @example
 * ```ts
@@ -2792,7 +3442,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 if `value` is an embedded elicitation, sampling, or roots request; false otherwise
 *
 * @example
 * ```ts
@@ -2813,10 +3463,10 @@ 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}
+* @returns True if every own value is a legal {@link MCPInputRequest}; false otherwise
 *
 * @example
 * ```ts
@@ -2836,7 +3486,7 @@ function isMCPInputRequestMap(value) {
 * Determines whether a value is one elicitation response.
 *
 * @param value - The unknown value to inspect
-* @returns `true` when action/content have the protocol shape
+* @returns True if action/content have the protocol shape; false otherwise
 *
 * @example
 * ```ts
@@ -2886,7 +3536,7 @@ function isMCPElicitResult(value) {
 *
 * @param value - The accepted response content to check
 * @param schema - The exact {@link MCPElicitSchema} that was issued with the elicitation
-* @returns `true` when every declared and undeclared value is legal under `schema`
+* @returns True if every declared and undeclared value is legal under `schema`; false otherwise
 *
 * @example
 * ```ts
@@ -2967,6 +3617,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 if `value` carries an absolute `uri` and an optional string `name`; false otherwise
+*
+* @example
+* ```ts
+* isMCPRoot({ uri: 'file:///workspace', name: 'workspace' }) // true
+* isMCPRoot({ uri: 'workspace' }) // false — the schema declares `format: uri`
+* ```
+*/
+function isMCPRoot(value) {
+	const owned = attempt(() => 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 (!isUndefined(name) && !isString(name)) return false;
+		return 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 if `value` carries an array of valid roots; false otherwise
+*
+* @example
+* ```ts
+* isMCPRootResult({ roots: [{ uri: 'file:///workspace' }] }) // true
+* isMCPRootResult({ roots: {} }) // false — the schema requires an array
+* ```
+*/
+function isMCPRootResult(value) {
+	const owned = attempt(() => 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 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 if `value` is one legal sampling content block; false otherwise
+*
+* @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 = attempt(() => cloneJSONRecord(value));
+	if (!owned.success) return false;
+	try {
+		const block = owned.value;
+		const metadata = block["_meta"];
+		if (!isUndefined(metadata) && !isMCPMetaObject(metadata)) return false;
+		if (block["type"] === "tool_use") return isString(block["id"]) && isString(block["name"]) && 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 (!isUndefined(failed) && !isBoolean(failed)) return false;
+			return 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 if `value` has the sampling-completion shape; false otherwise
+*
+* @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 = attempt(() => 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 (!isString(result["model"])) return false;
+		if (!(Array.isArray(content) ? content : [content]).every((block) => isMCPSampleContent(block))) return false;
+		if (!isUndefined(reason) && !isString(reason)) return false;
+		return 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 if the answer is legal for that request; false otherwise
+*
+* @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
@@ -2974,7 +3805,7 @@ function isElicitContent(value, schema) {
 * both must be present and valid. Total over hostile input.
 *
 * @param value - The unknown value to inspect
-* @returns `true` when `value` is a valid input-required result
+* @returns True if `value` is a valid input-required result; false otherwise
 *
 * @example
 * ```ts
@@ -3011,7 +3842,7 @@ function isMCPInputResult(value) {
 * be a record. Total: any other input returns `false`.
 *
 * @param value - The already-parsed value to test
-* @returns `true` when `value` is a valid JSON-RPC request
+* @returns True if `value` is a valid JSON-RPC request; false otherwise
 *
 * @example
 * ```ts
@@ -3038,7 +3869,7 @@ function isJSONRPCRequest(value) {
 * be a record. Total: any other input returns `false`.
 *
 * @param value - The already-parsed value to test
-* @returns `true` when `value` is a valid JSON-RPC notification
+* @returns True if `value` is a valid JSON-RPC notification; false otherwise
 *
 * @example
 * ```ts
@@ -3064,7 +3895,7 @@ function isJSONRPCNotification(value) {
 * mutually exclusive, so a positive answer names exactly one arm. Total.
 *
 * @param value - The already-parsed value to test
-* @returns `true` when `value` is a valid JSON-RPC request or notification
+* @returns True if `value` is a valid JSON-RPC request or notification; false otherwise
 */
 function isJSONRPCInvocation(value) {
 	return isJSONRPCRequest(value) || isJSONRPCNotification(value);
@@ -3082,7 +3913,7 @@ function isJSONRPCInvocation(value) {
 * Total.
 *
 * @param value - The already-parsed value to test
-* @returns `true` when `value` is a valid JSON-RPC result response
+* @returns True if `value` is a valid JSON-RPC result response; false otherwise
 *
 * @example
 * ```ts
@@ -3118,7 +3949,7 @@ function isJSONRPCResultResponse(value) {
 * itself the hostile step, and it is bounded here rather than allowed to escape. Total.
 *
 * @param value - The already-parsed value to test
-* @returns `true` when `value` carries an integer `code` and a string `message`
+* @returns True if `value` carries an integer `code` and a string `message`; false otherwise
 *
 * @example
 * ```ts
@@ -3142,7 +3973,7 @@ function isJSONRPCError(value) {
 * `result`. `error` carries an integer `code` and a string `message`. Total.
 *
 * @param value - The already-parsed value to test
-* @returns `true` when `value` is a valid JSON-RPC error response
+* @returns True if `value` is a valid JSON-RPC error response; false otherwise
 *
 * @example
 * ```ts
@@ -3166,7 +3997,7 @@ function isJSONRPCErrorResponse(value) {
 * The union of the mutually exclusive arms. Total.
 *
 * @param value - The already-parsed value to test
-* @returns `true` when `value` is a valid JSON-RPC response
+* @returns True if `value` is a valid JSON-RPC response; false otherwise
 */
 function isJSONRPCResponse(value) {
 	return isJSONRPCResultResponse(value) || isJSONRPCErrorResponse(value);
@@ -3179,7 +4010,7 @@ function isJSONRPCResponse(value) {
 * The union of {@link isJSONRPCInvocation} and {@link isJSONRPCResponse}. Total.
 *
 * @param value - The already-parsed value to test
-* @returns `true` when `value` is a valid JSON-RPC message
+* @returns True if `value` is a valid JSON-RPC message; false otherwise
 */
 function isJSONRPCMessage(value) {
 	return isJSONRPCInvocation(value) || isJSONRPCResponse(value);
@@ -3188,7 +4019,7 @@ function isJSONRPCMessage(value) {
 * Determines whether a parsed value is an MCP `initialize` invocation.
 *
 * @param value - The already-parsed value to test
-* @returns `true` when `value` is a valid `initialize` request or notification
+* @returns True if `value` is a valid `initialize` request or notification; false otherwise
 *
 * @example
 * ```ts
@@ -3211,7 +4042,7 @@ function isInitializeRequest(value) {
 * legacy dispatch. Total over hostile and malformed input.
 *
 * @param value - The already-parsed value to inspect
-* @returns `true` when the value is an invocation carrying the reserved version key
+* @returns True if the value is an invocation carrying the reserved version key; false otherwise
 */
 function isModernRequest(value) {
 	const owned = attempt(() => cloneJSONRecord(value));
@@ -3241,6 +4072,27 @@ function inferEra(version) {
 	if (isMCPLegacyVersion(version)) return "legacy";
 }
 /**
+* Infers the wire era one invocation's own structure selects.
+*
+* @remarks
+* The STRUCTURAL read, distinct from {@link inferEra}'s read of a revision string: era is fixed
+* by the reserved modern metadata a request carries, so this answers for a message whose
+* revision has not been read and cannot answer `undefined` — every invocation took one of the
+* two published wire shapes. It is what an observation surface reports and what an ingress
+* routes on, so both derive it here rather than each spelling the ternary out.
+*
+* @param invocation - The invocation whose structure selects the era
+* @returns `'modern'` when the invocation carries the modern request shape, `'legacy'` otherwise
+*
+* @example
+* ```ts
+* inferRequestEra({ jsonrpc: '2.0', id: 1, method: 'tools/list', params: { _meta: meta } })
+* ```
+*/
+function inferRequestEra(invocation) {
+	return isModernRequest(invocation) ? "modern" : "legacy";
+}
+/**
 * Infers the newest supported modern protocol revision present in a peer's offer.
 *
 * @param offered - The protocol revisions offered by the peer
@@ -3286,7 +4138,7 @@ function inferRequestVersion(message) {
 //#endregion
 //#region src/core/MCPMethodManager.ts
 /**
-* The modern method registry an {@link import('./types.js').MCPServerInterface}
+* Holds the modern methods an {@link import('./types.js').MCPServerInterface}
 * dispatches through — a name-keyed store of {@link MCPMethodHandler}s that owns its
 * map rather than exposing one.
 *
@@ -3320,7 +4172,7 @@ var MCPMethodManager = class {
 //#endregion
 //#region src/core/MCPProgressReporter.ts
 /**
-* A bounded, request-scoped progress handoff between one producer and one serial consumer.
+* Hands bounded, request-scoped progress from one producer to one serial consumer.
 *
 * The reporter holds at most one owned progress item. {@link report} applies backpressure until
 * {@link take} consumes that slot. It has no replay, queue, concurrent-consumer coordination,
@@ -3444,7 +4296,8 @@ var MCPProgressReporter = class {
 //#endregion
 //#region src/core/MCPStreamController.ts
 /**
-* The one cancellation engine every modern held-open result leaves `MCPServer` through.
+* Provides the one cancellation engine every modern held-open result leaves `MCPServer`
+* through.
 *
 * @remarks
 * A native async generator decides cancellation with a QUEUE: `return()` and `throw()` wait
@@ -3641,7 +4494,7 @@ var MCPStreamController = class {
 //#endregion
 //#region src/core/MCPTextStreamController.ts
 /**
-* The string-boundary mirror of a controlled held-open result — the same exchange, already
+* Mirrors a controlled held-open result at the string boundary — the same exchange, already
 * serialized.
 *
 * @remarks
@@ -3803,12 +4656,7 @@ var MCPLegacy = class {
 	}
 	async handle(message, options) {
 		if (!isBoundedString(message, this.limit.message)) return JSON.stringify(buildJSONRPCError(void 0, JSONRPC_INVALID_REQUEST, "Invalid Request"));
-		let parsed;
-		try {
-			parsed = JSON.parse(message);
-		} catch {
-			return this.#options.dispatcher.handle(message, options);
-		}
+		const parsed = parseJSON(message);
 		if (isModernRequest(parsed) || !isJSONRPCInvocation(parsed)) return this.#options.dispatcher.handle(message, options);
 		const answer = await this.#legacy(parsed, options);
 		return answer === void 0 ? void 0 : JSON.stringify(answer);
@@ -3895,7 +4743,7 @@ var MCPLegacyClientTransport = class {
 		if (requested !== void 0 && !isMCPLegacyVersion(requested)) throw new MCPError("Unsupported legacy protocol version", MCP_UNSUPPORTED_VERSION, { requested });
 		this.#transport = transport;
 		this.#client = options?.identity ?? {
-			name: "taverna",
+			name: "@orkestrel/mcp",
 			version: "1.0.0"
 		};
 		this.#capabilities = options?.capabilities ?? {};
@@ -4087,8 +4935,8 @@ var MCPLegacyClientTransport = class {
 //#endregion
 //#region src/core/MCPServer.ts
 /**
-* A transport-agnostic Model Context Protocol server — dispatches JSON-RPC 2.0
-* requests over a live {@link ToolManagerInterface}, with NO transport coupling.
+* Dispatches JSON-RPC 2.0 requests over a live {@link ToolManagerInterface}, with NO
+* transport coupling.
 *
 * @remarks
 * - **`dispatch` and `handle`.** `dispatch(invocation)` runs an already-parsed invocation and
@@ -4165,8 +5013,21 @@ var MCPServer = class {
 		if (decoded === void 0 || !("method" in decoded)) return buildJSONRPCError(void 0, JSONRPC_INVALID_REQUEST, "Invalid Request");
 		return this.#dispatch(decoded, options);
 	}
+	async handle(message, options) {
+		if (!isBoundedString(message, this.#limits.message)) return JSON.stringify(buildJSONRPCError(void 0, JSONRPC_PARSE_ERROR, "Parse error"));
+		const parsed = parseJSON(message);
+		if (parsed === void 0) return JSON.stringify(buildJSONRPCError(void 0, JSONRPC_PARSE_ERROR, "Parse error"));
+		const decoded = parseJSONRPCMessage(parsed, {
+			bytes: this.#limits.message,
+			depth: this.#limits.depth
+		});
+		if (decoded === void 0 || !("method" in decoded)) return JSON.stringify(buildJSONRPCError(void 0, JSONRPC_INVALID_REQUEST, "Invalid Request"));
+		const answer = await this.#dispatch(decoded, options ?? {});
+		if (answer === void 0) return void 0;
+		return Symbol.asyncIterator in answer ? new MCPTextStreamController(answer) : JSON.stringify(answer);
+	}
 	async #dispatch(invocation, options) {
-		this.#emitter.emit("request", invocation.method, invocation.id, "modern");
+		this.#emitter.emit("request", invocation.method, invocation.id, inferRequestEra(invocation));
 		if (invocation.id === void 0) return;
 		const id = invocation.id;
 		const metadata = invocation.params?.["_meta"];
@@ -4184,26 +5045,9 @@ var MCPServer = class {
 			return this.#contain(error, id);
 		}
 	}
-	async handle(message, options) {
-		if (!isBoundedString(message, this.#limits.message)) return JSON.stringify(buildJSONRPCError(void 0, JSONRPC_PARSE_ERROR, "Parse error"));
-		let parsed;
-		try {
-			parsed = JSON.parse(message);
-		} catch {
-			return JSON.stringify(buildJSONRPCError(void 0, JSONRPC_PARSE_ERROR, "Parse error"));
-		}
-		const decoded = parseJSONRPCMessage(parsed, {
-			bytes: this.#limits.message,
-			depth: this.#limits.depth
-		});
-		if (decoded === void 0 || !("method" in decoded)) return JSON.stringify(buildJSONRPCError(void 0, JSONRPC_INVALID_REQUEST, "Invalid Request"));
-		const answer = await this.#dispatch(decoded, options ?? {});
-		if (answer === void 0) return void 0;
-		return Symbol.asyncIterator in answer ? new MCPTextStreamController(answer) : JSON.stringify(answer);
-	}
 	#register() {
-		this.#methods.add("server/discover", async (request, _options) => this.#discover(request));
-		this.#methods.add("tools/list", async (request, _options) => this.#list(request));
+		this.#methods.add("server/discover", async (request) => this.#discover(request));
+		this.#methods.add("tools/list", async (request) => this.#list(request));
 		this.#methods.add("tools/call", async (request, options) => this.#call(request, options));
 		this.#methods.add("subscriptions/listen", async (request, options) => this.#subscribe(request, options));
 		const resources = this.#options.resources;
@@ -4292,13 +5136,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);
@@ -4360,13 +5198,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];
@@ -4429,20 +5261,20 @@ var MCPServer = class {
 	async #defer(request, call, options) {
 		const configured = this.#options.task;
 		if (configured === void 0) return void 0;
-		const deferral = {
+		const deferred = {
 			request,
 			call,
 			tools: this.#options.tools
 		};
-		const key = await configured.defer(deferral, options);
+		const key = await configured.deferral(deferred, options);
 		if (isUndefined(key)) return void 0;
 		if (!isString(key) || key.length === 0) return buildJSONRPCError(request.id, JSONRPC_INTERNAL_ERROR, "Server execution returned an invalid task key");
 		const context = parseRequestContext(request, {
 			bytes: this.#limits.message,
 			depth: this.#limits.depth
 		});
-		if (context === void 0 || !isTaskSupported(context.capabilities)) return buildJSONRPCError(request.id, MCP_MISSING_CAPABILITY, "Client does not support the required Tasks extension", { requiredCapabilities: { extensions: { [MCP_EXTENSION_TASKS]: {} } } });
-		const created = await configured.tasks.start(key, deferral, options);
+		if (context === void 0 || !supportsTask(context.capabilities)) return buildJSONRPCError(request.id, MCP_MISSING_CAPABILITY, "Client does not support the required Tasks extension", { requiredCapabilities: { extensions: { [MCP_EXTENSION_TASKS]: {} } } });
+		const created = await configured.tasks.start(key, deferred, options);
 		const captured = snapshotJSON({
 			resultType: "task",
 			taskId: created.taskId,
@@ -4520,21 +5352,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.#ownRound(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;
@@ -4547,55 +5404,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.#checkAnswers(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 (!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.#ownRound(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);
+	}
+	#checkAnswers(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, {
+	#ownRound(round) {
+		const owned = snapshotJSON(round, {
 			bytes: this.#limits.content,
 			keys: this.#limits.keys,
 			depth: this.#limits.depth
 		});
 		if (owned === void 0 || !isRecord(owned[0])) return void 0;
-		const form = owned[0]["request"];
+		const requests = owned[0]["requests"];
 		const state = owned[0]["state"];
-		if (!isMCPElicitForm(form) || !isUndefined(state) && !isJSONValue(state)) return void 0;
-		return isUndefined(state) ? { request: form } : {
-			request: form,
+		if (!isMCPInputRequestMap(requests) || Object.keys(requests).length === 0) return void 0;
+		if (!isUndefined(state) && !isJSONValue(state)) return void 0;
+		return 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 || !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 || !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,
@@ -4603,11 +5471,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,
@@ -4623,13 +5490,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 }
 		});
@@ -4666,7 +5527,7 @@ var MCPServer = class {
 			}
 			yield buildSubscriptionAcknowledgement(notifications, id);
 			if (configured !== void 0) {
-				const iterator = (await configured.listen(notifications, options))[Symbol.asyncIterator]();
+				const iterator = (await configured.producer(notifications, options))[Symbol.asyncIterator]();
 				options.signal.addEventListener("abort", () => void iterator.return?.(void 0)?.catch(() => void 0), { once: true });
 				for (let next = await iterator.next(); next.done !== true; next = await iterator.next()) {
 					const owned = parseJSONRPCMessage(next.value, {
@@ -4685,22 +5546,22 @@ var MCPServer = class {
 			slot.abort();
 		}
 	}
-	#named(request) {
+	#readTaskId(request) {
 		const id = request.id;
 		const context = parseRequestContext(request, {
 			bytes: this.#limits.message,
 			depth: this.#limits.depth
 		});
-		if (context === void 0 || !isTaskSupported(context.capabilities)) return buildJSONRPCError(id, MCP_MISSING_CAPABILITY, "Server requires the tasks extension capability for this request", { requiredCapabilities: { extensions: { [MCP_EXTENSION_TASKS]: {} } } });
+		if (context === void 0 || !supportsTask(context.capabilities)) return buildJSONRPCError(id, MCP_MISSING_CAPABILITY, "Server requires the tasks extension capability for this request", { requiredCapabilities: { extensions: { [MCP_EXTENSION_TASKS]: {} } } });
 		const taskId = request.params?.["taskId"];
 		if (!isBoundedString(taskId, this.#limits.state) || taskId.length === 0) return buildJSONRPCError(id, JSONRPC_INVALID_PARAMS, "Invalid params: a bounded string `taskId` is required");
 		return taskId;
 	}
 	async #task(request, tasks, options) {
 		const id = request.id;
-		const named = this.#named(request);
-		if (!isString(named)) return named;
-		const found = await tasks.task(named, options);
+		const taskId = this.#readTaskId(request);
+		if (!isString(taskId)) return taskId;
+		const found = await tasks.task(taskId, options);
 		if (found === void 0) return buildJSONRPCError(id, JSONRPC_INVALID_PARAMS, "Invalid params: no task is available for that `taskId`");
 		const owned = snapshotJSON(found, {
 			bytes: this.#limits.content,
@@ -4712,20 +5573,20 @@ var MCPServer = class {
 	}
 	async #update(request, tasks, options) {
 		const id = request.id;
-		const named = this.#named(request);
-		if (!isString(named)) return named;
+		const taskId = this.#readTaskId(request);
+		if (!isString(taskId)) return taskId;
 		const responses = request.params?.["inputResponses"];
 		if (!isRecord(responses)) return buildJSONRPCError(id, JSONRPC_INVALID_PARAMS, "Invalid params: an `inputResponses` object is required");
-		if (!isMCPTaskDetail(await tasks.task(named, options))) return buildJSONRPCError(id, JSONRPC_INVALID_PARAMS, "Invalid params: no task is available for that `taskId`");
-		await tasks.update(named, responses, options);
+		if (!isMCPTaskDetail(await tasks.task(taskId, options))) return buildJSONRPCError(id, JSONRPC_INVALID_PARAMS, "Invalid params: no task is available for that `taskId`");
+		await tasks.update(taskId, responses, options);
 		return buildJSONRPCResult(id, buildModernResult({}, this.#options.identity));
 	}
 	async #abort(request, tasks, options) {
 		const id = request.id;
-		const named = this.#named(request);
-		if (!isString(named)) return named;
-		if (!isMCPTaskDetail(await tasks.task(named, options))) return buildJSONRPCError(id, JSONRPC_INVALID_PARAMS, "Invalid params: no task is available for that `taskId`");
-		await tasks.abort(named, options);
+		const taskId = this.#readTaskId(request);
+		if (!isString(taskId)) return taskId;
+		if (!isMCPTaskDetail(await tasks.task(taskId, options))) return buildJSONRPCError(id, JSONRPC_INVALID_PARAMS, "Invalid params: no task is available for that `taskId`");
+		await tasks.abort(taskId, options);
 		return buildJSONRPCResult(id, buildModernResult({}, this.#options.identity));
 	}
 	#contain(error, id) {
@@ -4775,8 +5636,8 @@ var MCPServer = class {
 //#endregion
 //#region src/core/MCPTaskClient.ts
 /**
-* The CLIENT half of the stable Tasks extension — the `tasks/*` methods over one
-* correlated-request door, exposed as an {@link import('./types.js').MCPClientInterface}'s
+* Issues the `tasks/*` methods over one correlated-request door — the CLIENT half of the
+* stable Tasks extension, exposed as an {@link import('./types.js').MCPClientInterface}'s
 * `tasks`.
 *
 * @remarks
@@ -4835,9 +5696,9 @@ var MCPTaskClient = class {
 //#endregion
 //#region src/core/MCPClient.ts
 /**
-* A transport-agnostic Model Context Protocol CLIENT — connects to a REMOTE MCP server
-* over an injected {@link MCPClientTransportInterface}, negotiates the modern revision, and
-* exposes the server's tools as local {@link ToolInterface}s an agent can run.
+* Connects to a REMOTE MCP server over any injected {@link MCPMessageTransportInterface},
+* negotiates the modern revision, and exposes the server's tools as local
+* {@link ToolInterface}s an agent can run.
 *
 * @remarks
 * - **The mirror of `MCPServer`.** The server DISPATCHES requests over a tool registry;
@@ -4928,7 +5789,7 @@ var MCPClient = class {
 		});
 		this.#transport = options.transport;
 		this.#identity = options.identity ?? {
-			name: "taverna",
+			name: "@orkestrel/mcp",
 			version: "1.0.0"
 		};
 		this.#capabilities = options.capabilities ?? {};
@@ -5044,7 +5905,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));
@@ -5069,18 +5930,19 @@ var MCPClient = class {
 				} }
 			}
 		};
-		const subscription = {
-			queue: [],
-			capacity
-		};
 		const abort = this.#abortSubscription.bind(this, id, signal);
 		signal.addEventListener("abort", abort, { once: true });
 		this.#pending.set(id, {
 			method,
 			signal,
 			abort,
-			subscription
+			subscription: {
+				queue: [],
+				capacity
+			}
 		});
+		const subscription = this.#pending.get(id)?.subscription;
+		if (subscription === void 0) throw new Error("MCP subscription state is missing");
 		this.#transport.send(request).catch((error) => this.#settle(id, error, true));
 		try {
 			for (;;) {
@@ -5406,13 +6268,222 @@ var MCPClient = class {
 	}
 };
 //#endregion
+//#region src/core/transports/HTTPClientTransport.ts
+/**
+* Drives a REMOTE Streamable-HTTP MCP server over `fetch` — a CLIENT
+* {@link MCPMessageTransportInterface} for the Model Context Protocol, the egress mirror of
+* the server's `createMCPRoutes`.
+*
+* @remarks
+* - **One class, both faces.** It touches `fetch`, `Response`, `AbortController`,
+*   `AbortSignal`, and `WeakMap` alone, so it is host-independent and lives in core. Each
+*   environment face publishes its own `createHTTPClientTransport` over it —
+*   `@orkestrel/mcp/browser` and `@orkestrel/mcp/server` — and both factories return this
+*   class, so a reply reaches a page and a Node process through the same decode.
+* - **Request/response over `fetch`.** `send(message)` POSTs the JSON-serialized
+*   message to `options.url` with `content-type: application/json` and an
+*   `Accept` of BOTH `application/json` and `text/event-stream` (so the server may
+*   answer with either framing) — plus any `options.headers` (for example, an `Authorization`
+*   bearer). It then decodes the reply and emits each decoded {@link JSONRPCMessage} on
+*   the `message` event the {@link import('@orkestrel/mcp').MCPClientInterface} subscribes
+*   to.
+* - **Both reply framings.** A `200` with an `application/json` body is parsed with
+*   `parseJSONRPCMessage`; a `200` with a `text/event-stream` body is decoded with the
+*   `@orkestrel/sse` {@link import('@orkestrel/sse').SSEParserInterface} ({@link
+*   readEventStream}) — the inverse of the server's `createStream` seam, so the wire
+*   round-trips. A `202`
+*   Accepted (a notification) carries no body and emits nothing.
+* - **Session and protocol headers.** `start()` is a no-op (a
+*   request/response transport opens no long-lived connection). The
+*   `mcp-session-id` response header, when a STATEFUL server sends one (on
+*   `initialize`), is captured into `session` and then ECHOED as the
+*   `mcp-session-id` request header on every SUBSEQUENT request — so an
+*   `MCPClient` passes a stateful server's session validation. The
+*   initialize result's `protocolVersion` is likewise captured, but only
+*   when it is a SUPPORTED value, and echoed as `mcp-protocol-version` alone on
+*   subsequent legacy requests. Modern requests instead derive protocol and method
+*   headers from the message, plus the name header only for `tools/call` — carried in the
+*   protocol's Base64 sentinel form whenever the tool name cannot ride as plain ASCII.
+*   Before initialize returns, neither captured legacy header is sent.
+*   `close()` clears the captured protocol so a reconnect's `initialize`
+*   POST is headerless; the captured `session` persists across `close()`.
+* - **`close()` releases what is in flight.** Every `fetch` this transport still has open is
+*   ABORTED, which cancels the response body a `send` is reading — an SSE reply the server
+*   never ends would otherwise outlive the transport, with nothing left able to reach it. The
+*   aborted read surfaces on `error` and the `send` reporting it resolves. `close()` is
+*   idempotent (one `close` event per connected lifetime), and `start()` opens the next one.
+* - **Total at the boundary, and a non-success reply REJECTS.** Every reply is narrowed
+*   (`parseJSONRPCMessage`, the SSE decoder). A non-message success reply is dropped, never
+*   asserted. A non-success reply that carries no valid JSON-RPC message rejects `send` with
+*   an error naming its HTTP status and body shape — the peer answered, and answering the
+*   caller's request with silence would leave it waiting out its own deadline for a failure
+*   the transport already read. A valid JSON-RPC error body is emitted at any HTTP status,
+*   because the protocol carries that outcome in band. A `fetch` or decode failure on a
+*   success response surfaces on the `error` event rather than escaping `send`.
+* - **Observable.** Owns the `emitter` ({@link MCPMessageTransportEventMap}); fires
+*   `message` per decoded reply, `error` on a fault, and `close` on `close()`.
+*
+* @example
+* ```ts
+* const transport = new HTTPClientTransport({ url: 'http://localhost:3000/mcp' })
+* const client = new MCPClient({ transport })
+* await client.connect()
+* ```
+*/
+var HTTPClientTransport = class {
+	#emitter;
+	#url;
+	#headers;
+	#fetch;
+	#timeout;
+	#pending = /* @__PURE__ */ new Set();
+	#parameters = /* @__PURE__ */ new Map();
+	#stamps = /* @__PURE__ */ new WeakMap();
+	#session = void 0;
+	#protocol = void 0;
+	#generation = 0;
+	#closed = false;
+	constructor(options) {
+		this.#emitter = new Emitter();
+		this.#url = options.url;
+		this.#headers = options.headers ?? {};
+		this.#fetch = options.fetch ?? globalThis.fetch.bind(globalThis);
+		this.#timeout = options.timeout;
+	}
+	get emitter() {
+		return this.#emitter;
+	}
+	get session() {
+		return this.#session;
+	}
+	get duplex() {
+		return false;
+	}
+	async start() {
+		this.#closed = false;
+	}
+	async send(message) {
+		this.#stamp(message);
+		const request = new AbortController();
+		this.#pending.add(request);
+		try {
+			await this.#exchange(message, request.signal);
+		} finally {
+			this.#pending.delete(request);
+		}
+	}
+	async close() {
+		if (this.#closed) return;
+		this.#closed = true;
+		for (const request of this.#pending) request.abort();
+		this.#pending.clear();
+		this.#protocol = void 0;
+		this.#emitter.emit("close");
+	}
+	#stamp(message) {
+		if (!isModernRequest(message) || message.method !== "tools/list") return;
+		if (message.params?.["cursor"] === void 0) this.#generation += 1;
+		this.#stamps.set(message, this.#generation);
+	}
+	async #exchange(message, signal) {
+		let response;
+		try {
+			response = await this.#fetch(this.#url, {
+				method: "POST",
+				headers: {
+					"content-type": "application/json",
+					accept: "application/json, text/event-stream",
+					...this.#session === void 0 ? {} : { [MCP_SESSION_HEADER]: this.#session },
+					...this.#buildHeaders(message),
+					...this.#headers
+				},
+				body: JSON.stringify(message),
+				signal: this.#timeout === void 0 ? signal : AbortSignal.any([signal, AbortSignal.timeout(this.#timeout)])
+			});
+		} catch (error) {
+			this.#emitter.emit("error", error);
+			return;
+		}
+		const session = response.headers.get(MCP_SESSION_HEADER);
+		if (session !== null) this.#session = session;
+		await this.#deliver(response, message);
+	}
+	#buildHeaders(message) {
+		if (isModernRequest(message)) {
+			const version = inferRequestVersion(message);
+			const name = message.params?.["name"];
+			return {
+				...version === void 0 ? {} : { [MCP_PROTOCOL_VERSION_HEADER]: version },
+				[MCP_METHOD_HEADER]: message.method,
+				...message.method === "tools/call" && isString(name) ? {
+					[MCP_NAME_HEADER]: encodeSentinel(name),
+					...buildHeaderProjection(this.#parameters.get(name) ?? [], message.params?.["arguments"])
+				} : {}
+			};
+		}
+		return this.#protocol === void 0 ? {} : { [MCP_PROTOCOL_VERSION_HEADER]: this.#protocol };
+	}
+	async #deliver(response, sent) {
+		if (response.status === 202) return;
+		const type = response.headers.get("content-type") ?? "";
+		let messages = [];
+		let failure;
+		try {
+			if (type.includes("text/event-stream")) messages = await readEventStream(response);
+			else if (type.includes("application/json")) {
+				const message = parseJSONRPCMessage(await response.json());
+				if (message !== void 0) messages = [message];
+			}
+		} catch (error) {
+			failure = { error };
+		}
+		for (const message of messages) this.#capture(message, sent);
+		if (!response.ok && messages.length === 0) throw buildResponseError(response, type);
+		if (failure !== void 0) this.#emitter.emit("error", failure.error);
+	}
+	#capture(message, sent) {
+		if (isJSONRPCResponse(message) && isRecord(message.result) && isMCPVersion(message.result["protocolVersion"])) this.#protocol = message.result["protocolVersion"];
+		this.#emitter.emit("message", this.#select(message, sent));
+	}
+	#select(message, sent) {
+		if (!isModernRequest(sent) || sent.method !== "tools/list") return message;
+		if (!isJSONRPCResponse(message) || message.error !== void 0) return message;
+		const result = message.result;
+		const listed = isRecord(result) ? result["tools"] : void 0;
+		if (!isRecord(result) || !isArray(listed)) return message;
+		const current = this.#stamps.get(sent) === this.#generation;
+		if (current && sent.params?.["cursor"] === void 0) this.#parameters.clear();
+		const kept = [];
+		for (const tool of listed) {
+			if (!isRecord(tool) || !isString(tool["name"])) {
+				kept.push(tool);
+				continue;
+			}
+			const parameters = buildHeaderParameters(tool["inputSchema"]);
+			if (parameters === void 0) {
+				this.#emitter.emit("error", /* @__PURE__ */ new Error(`MCP tool '${tool["name"]}' is excluded from tools/list: its inputSchema carries an invalid x-mcp-header annotation`));
+				continue;
+			}
+			if (current) this.#parameters.set(tool["name"], parameters);
+			kept.push(tool);
+		}
+		return {
+			...message,
+			result: {
+				...result,
+				tools: kept
+			}
+		};
+	}
+};
+//#endregion
 //#region src/core/factories.ts
 /**
 * Creates a transport-agnostic Model Context Protocol server — exposes a live
 * {@link import('@orkestrel/tool').ToolManagerInterface} and an optional
 * {@link import('./types.js').MCPResourceManagerInterface},
 * {@link import('./types.js').MCPPromptManagerInterface}, and
-* {@link import('./types.js').MCPCompletionManagerInterface} over JSON-RPC 2.0.
+* {@link import('./types.js').MCPCompletionInterface} over JSON-RPC 2.0.
 *
 * @remarks
 * Pump raw message strings through `handle` (parse → dispatch → serialize) from a
@@ -5464,7 +6535,7 @@ function createMCPLegacy(server) {
 }
 /**
 * Creates a transport-agnostic Model Context Protocol CLIENT — connects to a REMOTE
-* MCP server over an injected {@link import('./types.js').MCPClientTransportInterface},
+* MCP server over an injected {@link import('./types.js').MCPMessageTransportInterface},
 * negotiates the modern revision through `server/discover`, and exposes the server's tools as local
 * {@link import('@orkestrel/tool').ToolInterface}s an agent can run.
 *
@@ -5495,7 +6566,7 @@ function createMCPLegacy(server) {
 * })
 * await client.connect()
 * agent.context.tools.add(await client.tools()) // give the agent the remote tools
-* const value = await client.call('search', { query: 'mcp' })
+* const outcome = await client.call('search', { query: 'mcp' })
 * ```
 */
 function createMCPClient(options) {
@@ -5521,7 +6592,7 @@ function createMCPLegacyClientTransport(transport, options) {
 }
 /**
 * Adapts an {@link MCPTransportInterface} (the environment-agnostic duplex message
-* channel) into a {@link MCPClientTransportInterface} — the additive bridge that lets
+* channel) into a {@link MCPMessageTransportInterface} — the additive bridge that lets
 * `createMCPClient` run over the new port without any change to `MCPClient`'s
 * existing shape.
 *
@@ -5544,7 +6615,7 @@ function createMCPLegacyClientTransport(transport, options) {
 * capable emitter for `bindClient` to push onto.
 *
 * @param transport - The duplex channel to adapt
-* @returns A {@link MCPClientTransportInterface} `createMCPClient` can drive
+* @returns A {@link MCPMessageTransportInterface} `createMCPClient` can drive
 *
 * @example
 * ```ts
@@ -5568,6 +6639,6 @@ function createDuplexClientTransport(transport) {
 	};
 }
 //#endregion
-export { DEFAULT_MCP_CACHE_TTL, DEFAULT_MCP_CLIENT_NAME, DEFAULT_MCP_CLIENT_VERSION, DEFAULT_MCP_LIMITS, DEFAULT_MCP_REQUEST_TIMEOUT, DEFAULT_MCP_SUBSCRIPTION_CAPACITY, EMPTY_MCP_ARGUMENTS, JSONRPC_INTERNAL_ERROR, JSONRPC_INVALID_PARAMS, JSONRPC_INVALID_REQUEST, JSONRPC_METHOD_NOT_FOUND, JSONRPC_PARSE_ERROR, JSONRPC_SERVER_ERROR, MCPClient, MCPError, MCPLegacy, MCPLegacyClientTransport, MCPMethodManager, MCPProgressReporter, MCPServer, MCPStreamController, MCPTaskClient, MCPTextStreamController, MCP_EXTENSION_TASKS, MCP_FALLBACK_VERSION, MCP_HANDSHAKE_VERSION, MCP_HEADER_MISMATCH, MCP_META_CAPABILITIES, MCP_META_CLIENT, MCP_META_SERVER, MCP_META_SUBSCRIPTION, MCP_META_VERSION, MCP_MISSING_CAPABILITY, MCP_MODERN_VERSION, MCP_UNSUPPORTED_VERSION, SUPPORTED_LEGACY_PROTOCOL_VERSIONS, SUPPORTED_MCP_VERSIONS, SUPPORTED_MODERN_PROTOCOL_VERSIONS, bindClient, bindServer, buildCallOutcome, buildCancelledNotification, buildDiscoverResult, buildInitializeResult, buildJSONRPCError, buildJSONRPCResult, buildMethodOptions, buildModernResult, buildProgressNotification, buildSubscriptionAcknowledgement, buildSubscriptionFilter, buildSubscriptionResult, buildToolCall, buildToolDescriptors, createDuplexClientTransport, createMCPClient, createMCPLegacy, createMCPLegacyClientTransport, createMCPServer, decodeBoundedMessage, digestJSON, extractContentText, inferEra, inferRequestVersion, inferVersion, isAbsoluteURI, isBoundedJSON, isBoundedString, isElicitContent, isFormElicitationSupported, isInitializeRequest, isJSONObject, isJSONRPCError, isJSONRPCErrorResponse, isJSONRPCId, isJSONRPCInvocation, isJSONRPCMessage, isJSONRPCNotification, isJSONRPCRequest, isJSONRPCResponse, isJSONRPCResultResponse, isMCPAnnotations, isMCPBlobResource, isMCPCallResult, isMCPClientCapabilities, isMCPCompletion, isMCPCompletionParams, isMCPCompletionReference, isMCPCompletionResult, isMCPContent, isMCPElicitFieldSchema, isMCPElicitForm, isMCPElicitRequest, isMCPElicitResult, isMCPElicitSchema, isMCPElicitURL, isMCPError, isMCPIcon, isMCPIdentity, isMCPInputRequest, isMCPInputRequestMap, isMCPInputResult, isMCPLegacyResult, isMCPLegacyVersion, isMCPLoggingLevel, isMCPMetaKey, isMCPMetaObject, isMCPModernVersion, isMCPNotificationMetaObject, isMCPPaginationParams, isMCPProgress, isMCPPrompt, isMCPPromptArgument, isMCPPromptGetResult, isMCPPromptMessage, isMCPPromptPage, isMCPResource, isMCPResourceContents, isMCPResourcePage, isMCPResourceTemplate, isMCPResourceTemplatePage, isMCPResult, isMCPResultMetaObject, isMCPServerCapabilities, isMCPStringArguments, isMCPSubscriptionFilter, isMCPSubscriptionResult, isMCPTaskDetail, isMCPTaskDetailResult, isMCPTaskNotification, isMCPTaskResult, isMCPTaskStatus, isMCPTextResource, isMCPVersion, isModernRequest, isRFC3339Date, isRFC3339DateTime, isStandardBase64, isTaskSupported, legacyInvocationToModern, legacyResultToModern, matchesResultType, matchesSubscriptionNotification, modernInvocationToLegacy, modernResultToLegacy, parseJSONRPCMessage, parseMCPInputState, parseRequestContext, readCancelledId, sendStream, serializeJSON, snapshotJSON, snapshotToolResult, stampSubscriptionNotification };
+export { DEFAULT_MCP_CACHE_TTL, DEFAULT_MCP_CLIENT_NAME, DEFAULT_MCP_CLIENT_VERSION, DEFAULT_MCP_LIMITS, DEFAULT_MCP_REQUEST_TIMEOUT, DEFAULT_MCP_SUBSCRIPTION_CAPACITY, EMPTY_MCP_ARGUMENTS, HTTPClientTransport, JSONRPC_INTERNAL_ERROR, JSONRPC_INVALID_PARAMS, JSONRPC_INVALID_REQUEST, JSONRPC_METHOD_NOT_FOUND, JSONRPC_PARSE_ERROR, JSONRPC_SERVER_ERROR, MCPClient, MCPError, MCPLegacy, MCPLegacyClientTransport, MCPMethodManager, MCPProgressReporter, MCPServer, MCPStreamController, MCPTaskClient, MCPTextStreamController, MCP_EXTENSION_TASKS, MCP_FALLBACK_VERSION, MCP_HANDSHAKE_VERSION, MCP_HEADER_ANNOTATION, MCP_HEADER_MISMATCH, MCP_LOOKUP_PAGES, MCP_META_CAPABILITIES, MCP_META_CLIENT, MCP_META_SERVER, MCP_META_SUBSCRIPTION, MCP_META_VERSION, MCP_METHOD_HEADER, MCP_MISSING_CAPABILITY, MCP_MODERN_VERSION, MCP_NAME_HEADER, MCP_PARAM_PREFIX, MCP_PROTOCOL_VERSION_HEADER, MCP_SENTINEL_PREFIX, MCP_SENTINEL_SUFFIX, MCP_SESSION_HEADER, MCP_UNSUPPORTED_VERSION, MCP_WEBSOCKET_SUBPROTOCOL, SUPPORTED_LEGACY_PROTOCOL_VERSIONS, SUPPORTED_MCP_VERSIONS, SUPPORTED_MODERN_PROTOCOL_VERSIONS, bindClient, bindServer, buildCallOutcome, buildCancelledNotification, buildDiscoverResult, buildHeaderParameters, buildHeaderProjection, buildInitializeResult, buildJSONRPCError, buildJSONRPCResult, buildMethodOptions, buildModernResult, buildProgressNotification, buildResponseError, buildSubscriptionAcknowledgement, buildSubscriptionFilter, buildSubscriptionResult, buildToolCall, buildToolDescriptors, computeMissingCapabilities, countHeaderAnnotations, createDuplexClientTransport, createMCPClient, createMCPLegacy, createMCPLegacyClientTransport, createMCPServer, decodeBoundedMessage, decodeEvent, decodeSentinel, deliverMessage, digestJSON, encodeSentinel, extractContentText, extractHeaderAnnotations, extractToolSchema, inferEra, inferRequestEra, inferRequestVersion, inferVersion, isAbsoluteURI, isBoundedJSON, isBoundedString, isElicitContent, isFieldToken, isInitializeRequest, isJSONObject, isJSONRPCError, isJSONRPCErrorResponse, isJSONRPCId, isJSONRPCInvocation, isJSONRPCMessage, isJSONRPCNotification, isJSONRPCRequest, isJSONRPCResponse, isJSONRPCResultResponse, isMCPAnnotations, isMCPBlobResource, isMCPCallResult, isMCPClientCapabilities, isMCPCompletion, isMCPCompletionParams, isMCPCompletionReference, isMCPCompletionResult, isMCPContent, isMCPElicitFieldSchema, isMCPElicitForm, isMCPElicitRequest, isMCPElicitResult, isMCPElicitSchema, isMCPElicitURL, isMCPError, isMCPHeaderPrimitive, isMCPIcon, isMCPIdentity, isMCPInputRequest, isMCPInputRequestMap, isMCPInputResponse, isMCPInputResult, isMCPLegacyResult, isMCPLegacyVersion, isMCPLoggingLevel, isMCPMetaKey, isMCPMetaObject, isMCPModernVersion, isMCPNotificationMetaObject, isMCPPaginationParams, isMCPProgress, isMCPPrompt, isMCPPromptArgument, isMCPPromptGetResult, isMCPPromptMessage, isMCPPromptPage, isMCPResource, isMCPResourceContents, isMCPResourcePage, isMCPResourceTemplate, isMCPResourceTemplatePage, isMCPResult, isMCPResultMetaObject, isMCPRoot, isMCPRootResult, isMCPSampleContent, isMCPSampleResult, isMCPServerCapabilities, isMCPStringArguments, isMCPSubscriptionFilter, isMCPSubscriptionResult, isMCPTaskDetail, isMCPTaskDetailResult, isMCPTaskNotification, isMCPTaskResult, isMCPTaskStatus, isMCPTextResource, isMCPVersion, isModernRequest, isRFC3339Date, isRFC3339DateTime, isStandardBase64, legacyInvocationToModern, legacyResultToModern, matchesResultType, matchesSubscriptionNotification, modernInvocationToLegacy, modernResultToLegacy, parseJSONRPCMessage, parseMCPInputState, parseRequestContext, readCancelledId, readEventStream, renderHeaderValue, sendStream, serializeJSON, snapshotJSON, snapshotToolResult, stampSubscriptionNotification, supportsFormElicitation, supportsTask };
 
 //# sourceMappingURL=index.js.map