@orkestrel/mcp 0.0.23 → 0.0.25

package/dist/src/core/index.cjs

@@ -11,25 +11,24 @@ let _orkestrel_tool = require("@orkestrel/tool");
 * and defines no `initialize`, so it can never be the handshake's version — a client that offers
 * it is asking to negotiate a revision with no negotiation.
 */
-var MCP_PROTOCOL_VERSION = "2025-11-25";
-/** The legacy fallback anchor used when an initialize request cannot be accepted as modern. */
-var MCP_LEGACY_VERSION = "2025-06-18";
+var MCP_HANDSHAKE_VERSION = "2025-11-25";
+/** 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. */
 var MCP_MODERN_VERSION = "2026-07-28";
 /**
-* The MCP protocol revisions this server can negotiate.
+* The modern MCP protocol revisions a bare server accepts and advertises.
 *
 * @remarks
-* `initialize` echoes the client's requested `protocolVersion` when it appears in
-* this list. Frozen in client-preference and discovery-advertisement order. The
-* package does not advertise `2025-03-26` because that revision mandates JSON-RPC
-* batching, while this package accepts only individual JSON-RPC messages.
+* Frozen in discovery-advertisement order. Legacy revisions are absent because
+* only {@link SUPPORTED_LEGACY_PROTOCOL_VERSIONS} and the optional legacy
+* decorator own them.
 */
-var SUPPORTED_PROTOCOL_VERSIONS = Object.freeze([
-	"2026-07-28",
-	"2025-11-25",
-	"2025-06-18"
-]);
+var SUPPORTED_MODERN_PROTOCOL_VERSIONS = Object.freeze([MCP_MODERN_VERSION]);
+/** 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. */
+var SUPPORTED_MCP_VERSIONS = Object.freeze([...SUPPORTED_MODERN_PROTOCOL_VERSIONS, ...SUPPORTED_LEGACY_PROTOCOL_VERSIONS]);
 /** 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. */
@@ -41,10 +40,11 @@ var MCP_META_SERVER = "io.modelcontextprotocol/serverInfo";
 /** Reserved modern `_meta` key carrying a `subscriptions/listen` request id. */
 var MCP_META_SUBSCRIPTION = "io.modelcontextprotocol/subscriptionId";
 /**
-* The reserved extension key identifying the draft Tasks extension.
+* The reserved extension key identifying the stable Tasks extension.
 *
 * @remarks
-* The ONE spelling of it in this package. A client declares it per REQUEST, under
+* The ONE spelling of it in this package, and the identity of the immutable snapshot dated
+* 2026-07-28 this package implements. A client declares it per REQUEST, under
 * `_meta['io.modelcontextprotocol/clientCapabilities'].extensions`; a server advertises it
 * under `server/discover`'s `capabilities.extensions`. Both sides carry an empty object —
 * the extension defines no options, so presence is the entire declaration.
@@ -62,8 +62,8 @@ var MCP_HEADER_MISMATCH = -32020;
 * `error.data.requiredCapabilities` alone (`{ elicitation: {} }` against
 * `{ extensions: { 'io.modelcontextprotocol/tasks': {} } }`). They are instances of the same
 * condition, so a separate numeral would describe the same fact twice. The Tasks extension's
-* own draft prose still shows `-32003` in examples; the dated core schema fixes this code,
-* and the dated schema is what a peer implements against.
+* own prose examples show `-32003`; the dated core schema fixes this code, and the dated
+* schema is what a peer implements against.
 */
 var MCP_MISSING_CAPABILITY = -32021;
 /** MCP reserved error: a request names an unsupported protocol revision. */
@@ -148,6 +148,8 @@ var DEFAULT_MCP_CLIENT_VERSION = "1.0.0";
 * 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. */
+var DEFAULT_MCP_SUBSCRIPTION_CAPACITY = 64;
 //#endregion
 //#region src/core/errors.ts
 /**
@@ -210,66 +212,6 @@ function isMCPError(value) {
 	}
 }
 //#endregion
-//#region src/core/inferers.ts
-/**
-* Infers the wire era for an MCP protocol revision.
-*
-* @param version - The protocol revision to classify
-* @returns `'modern'` for `2026-07-28`, `'legacy'` for either supported legacy
-* revision, or `undefined` when the revision is unsupported
-*/
-function inferEra(version) {
-	switch (version) {
-		case "2026-07-28": return "modern";
-		case "2025-11-25":
-		case "2025-06-18": return "legacy";
-		default: return;
-	}
-}
-/**
-* Infers the newest supported protocol revision present in a peer's offer.
-*
-* @param offered - The protocol revisions offered by the peer
-* @returns The newest locally supported offered revision, or `undefined`
-*/
-function inferVersion(offered) {
-	for (const version of SUPPORTED_PROTOCOL_VERSIONS) if (offered.includes(version)) return version;
-}
-/**
-* Infers the protocol version an outbound message announces itself with — the ONE
-* projection every HTTP client transport stamps `mcp-protocol-version` from.
-*
-* @remarks
-* This is deliberately the SAME read the server's own expectation performs
-* ({@link import('@orkestrel/mcp/server').inferHeaderIssue}): a modern request's reserved
-* `_meta` version, accepted whenever it is a string. It is NOT
-* {@link import('./parsers.js').parseRequestContext}, and the difference is the whole
-* point. That parser answers a different question — is the modern metadata WELL FORMED —
-* and refuses a request whose capability declaration or logging level is malformed. Such a
-* request is still modern (era is fixed by key presence) and the server still demands the
-* header for it, so projecting through the parser withholds a header the peer requires and
-* earns `-32602` instead of the `-32602` the malformed metadata itself deserves.
-*
-* A non-modern message projects nothing: a legacy request's version comes from the
-* `initialize` handshake the transport captured, not from the message.
-*
-* Header NAMES stay with the transports that own the wire (see `constants.ts`); core owns
-* the value this projection derives, which is the part the browser and Node faces disagreed about.
-*
-* @param message - The outbound message about to be written
-* @returns The version to announce, or `undefined` when the message announces none
-*
-* @example
-* ```ts
-* inferRequestVersion({ jsonrpc: '2.0', id: 1, method: 'tools/list', params: { _meta: meta } })
-* ```
-*/
-function inferRequestVersion(message) {
-	if (!isModernRequest(message)) return void 0;
-	const version = ((0, _orkestrel_contract.isRecord)(message.params?.["_meta"]) ? message.params["_meta"] : void 0)?.[MCP_META_VERSION];
-	return (0, _orkestrel_contract.isString)(version) ? version : void 0;
-}
-//#endregion
 //#region src/core/cloners.ts
 /**
 * Snapshots one bounded exact JSON value together with its canonical wire serialization.
@@ -571,26 +513,29 @@ function isFormElicitationSupported(value) {
 	}
 }
 /**
-* Determines whether a client capability record declares the draft Tasks extension.
+* Determines whether a client capability record declares the stable Tasks extension.
 *
 * @remarks
-* The declaration lives at `extensions['io.modelcontextprotocol/tasks']` and its value is
-* an empty object, so this is a PRESENCE check: the extension defines no options, and a
-* server that read one would be reading a field no client can meaningfully set. The value
-* must still be a record, because that is the shape the capability record declares — a
-* `true` or a string there is a client speaking a different protocol, not a shorthand.
+* The declaration lives at `extensions['io.modelcontextprotocol/tasks']` and the schema
+* types its value EXACTLY EMPTY — `Record<string, never>`, an object with no additional
+* properties. So the key's presence is the whole declaration, and the value carries the
+* whole of the check: a `true` or a string there is a client speaking a different protocol
+* rather than a shorthand, and a member inside the object is a client declaring an option
+* this extension does not define. Both are refused, because a server that accepted either
+* would be reading a shape no peer can produce from the snapshot's own schema.
 *
 * A client declares this PER REQUEST. Nothing here consults a session, because the modern
 * revision is stateless and a capability declared once at connect time says nothing about
 * the request in hand. Total over hostile input.
 *
 * @param value - The client capability record to inspect
-* @returns `true` when the tasks extension is declared
+* @returns `true` when the tasks extension is declared as the schema's empty object
 *
 * @example
 * ```ts
 * isTaskSupported({ extensions: { 'io.modelcontextprotocol/tasks': {} } }) // true
 * isTaskSupported({ extensions: {} }) // false — the key is the declaration
+* isTaskSupported({ extensions: { 'io.modelcontextprotocol/tasks': { on: true } } }) // false
 * ```
 */
 function isTaskSupported(value) {
@@ -598,7 +543,9 @@ function isTaskSupported(value) {
 	if (!owned.success) return false;
 	try {
 		const extensions = owned.value["extensions"];
-		return (0, _orkestrel_contract.isRecord)(extensions) && (0, _orkestrel_contract.isRecord)(extensions["io.modelcontextprotocol/tasks"]);
+		if (!(0, _orkestrel_contract.isRecord)(extensions)) return false;
+		const declaration = extensions[MCP_EXTENSION_TASKS];
+		return (0, _orkestrel_contract.isRecord)(declaration) && Object.keys(declaration).length === 0;
 	} catch {
 		return false;
 	}
@@ -1143,23 +1090,118 @@ function buildModernResult(result, identity, ttl, scope) {
 	};
 }
 /**
+* Projects one complete modern result onto the legacy wire shape.
+*
+* @remarks
+* The projection removes the modern discriminator, cache fields, and reserved server identity.
+* A non-complete result has no legacy representation and returns `undefined`.
+*
+* @param result - The modern result to project
+* @returns The legacy result, or `undefined` when the modern arm cannot be represented
+*/
+function modernResultToLegacy(result) {
+	if (result.resultType !== "complete") return void 0;
+	const projected = {};
+	for (const [key, value] of Object.entries(result)) {
+		if (key === "resultType" || key === "ttlMs" || key === "cacheScope") continue;
+		if (key === "content" && Array.isArray(value)) {
+			projected[key] = value.map((entry) => (0, _orkestrel_contract.isRecord)(entry) && entry["type"] === "text" && (0, _orkestrel_contract.isString)(entry["text"]) ? {
+				type: "text",
+				text: entry["text"]
+			} : entry);
+			continue;
+		}
+		if (key !== "_meta" || !(0, _orkestrel_contract.isRecord)(value)) {
+			projected[key] = value;
+			continue;
+		}
+		const metadata = {};
+		for (const [name, entry] of Object.entries(value)) if (name !== "io.modelcontextprotocol/serverInfo") metadata[name] = entry;
+		if (Object.keys(metadata).length > 0) projected["_meta"] = metadata;
+	}
+	return projected;
+}
+/**
+* Restores one legacy result to the modern complete-result shape.
+*
+* @remarks
+* Legacy `tools/list` results receive the required modern cache fields. Other legacy results are
+* non-cacheable. Every restored result receives the server identity learned during `initialize`.
+*
+* @param result - The unstamped legacy result
+* @param method - The request method whose result is being restored
+* @param identity - The server identity learned during the legacy handshake
+* @returns The modern complete result
+*/
+function legacyResultToModern(result, method, identity) {
+	return method === "tools/list" ? buildModernResult(result, identity, DEFAULT_MCP_CACHE_TTL) : buildModernResult(result, identity);
+}
+/**
+* Stamps one legacy request for the modern dispatcher.
+*
+* @param request - The legacy request to translate
+* @returns A modern request carrying the package revision and an empty capability set
+*/
+function legacyInvocationToModern(request) {
+	const params = request.params ?? {};
+	const metadata = (0, _orkestrel_contract.isRecord)(params["_meta"]) ? params["_meta"] : {};
+	return {
+		...request,
+		params: {
+			...params,
+			_meta: {
+				...metadata,
+				[MCP_META_VERSION]: MCP_MODERN_VERSION,
+				[MCP_META_CAPABILITIES]: {}
+			}
+		}
+	};
+}
+/**
+* Removes modern request metadata before an invocation reaches a legacy peer.
+*
+* @remarks
+* Non-reserved metadata such as `progressToken` remains on the legacy wire. When no metadata
+* remains, the translated parameters omit `_meta`.
+*
+* @param invocation - The modern invocation to translate
+* @returns The legacy invocation with reserved modern metadata removed
+*/
+function modernInvocationToLegacy(invocation) {
+	const params = invocation.params;
+	if (params === void 0 || !(0, _orkestrel_contract.isRecord)(params["_meta"])) return invocation;
+	const translated = {};
+	for (const [key, value] of Object.entries(params)) if (key !== "_meta") translated[key] = value;
+	const metadata = {};
+	for (const [key, value] of Object.entries(params["_meta"])) if (key !== "io.modelcontextprotocol/protocolVersion" && key !== "io.modelcontextprotocol/clientCapabilities" && key !== "io.modelcontextprotocol/clientInfo") metadata[key] = value;
+	if (Object.keys(metadata).length > 0) translated["_meta"] = metadata;
+	return {
+		...invocation,
+		params: translated
+	};
+}
+/**
 * Intersects a requested subscription filter with the notification families a server supports.
 *
 * @param requested - The notification families requested by the client
 * @param supported - The notification families the server can actually produce
+* @param enabled - If `true`, carries the requested task identifiers into the filter; if `false`,
+*   omits them. Default: `false`
 * @returns The exact subset the server will honour
 */
-function buildSubscriptionFilter(requested, supported) {
+function buildSubscriptionFilter(requested, supported, enabled = false) {
 	const toolsListChanged = requested.toolsListChanged === true && supported.toolsListChanged === true;
 	const promptsListChanged = requested.promptsListChanged === true && supported.promptsListChanged === true;
 	const resourcesListChanged = requested.resourcesListChanged === true && supported.resourcesListChanged === true;
 	const supportedResources = new Set(supported.resourceSubscriptions ?? []);
 	const resourceSubscriptions = requested.resourceSubscriptions?.filter((uri) => supportedResources.has(uri));
+	const taskIds = enabled ? requested.taskIds : void 0;
 	return {
 		...toolsListChanged ? { toolsListChanged: true } : {},
 		...promptsListChanged ? { promptsListChanged: true } : {},
 		...resourcesListChanged ? { resourcesListChanged: true } : {},
-		...resourceSubscriptions !== void 0 && resourceSubscriptions.length > 0 ? { resourceSubscriptions } : {}
+		...resourceSubscriptions !== void 0 && resourceSubscriptions.length > 0 ? { resourceSubscriptions } : {},
+		...taskIds !== void 0 && taskIds.length > 0 ? { taskIds } : {}
 	};
 }
 /**
@@ -1173,9 +1215,12 @@ function matchesSubscriptionNotification(notification, filter) {
 	if (notification.method === "notifications/tools/list_changed") return filter.toolsListChanged === true;
 	if (notification.method === "notifications/prompts/list_changed") return filter.promptsListChanged === true;
 	if (notification.method === "notifications/resources/list_changed") return filter.resourcesListChanged === true;
-	if (notification.method !== "notifications/resources/updated") return false;
-	const uri = notification.params?.["uri"];
-	return typeof uri === "string" && filter.resourceSubscriptions?.includes(uri) === true;
+	if (notification.method === "notifications/resources/updated") {
+		const uri = notification.params?.["uri"];
+		return typeof uri === "string" && filter.resourceSubscriptions?.includes(uri) === true;
+	}
+	if (notification.method === "notifications/tasks") return isMCPTaskNotification(notification) && filter.taskIds?.includes(notification.params.taskId) === true;
+	return false;
 }
 /**
 * Stamps a subscription notification with the request id reserved for its held-open stream.
@@ -1240,7 +1285,7 @@ function buildSubscriptionResult(id, identity) {
 */
 function buildDiscoverResult(options) {
 	return buildModernResult({
-		supportedVersions: SUPPORTED_PROTOCOL_VERSIONS.filter(isMCPVersion),
+		supportedVersions: SUPPORTED_MODERN_PROTOCOL_VERSIONS,
 		capabilities: {
 			tools: {},
 			...options.resources === void 0 ? {} : { resources: {
@@ -1271,9 +1316,8 @@ function buildDiscoverResult(options) {
 * @returns The `initialize` result payload
 */
 function buildInitializeResult(name, version, requested) {
-	const newestLegacy = SUPPORTED_PROTOCOL_VERSIONS.find((candidate) => inferEra(candidate) === "legacy") ?? "2025-06-18";
 	return {
-		protocolVersion: isMCPVersion(requested) && inferEra(requested) === "legacy" ? requested : newestLegacy,
+		protocolVersion: isMCPLegacyVersion(requested) ? requested : MCP_HANDSHAKE_VERSION,
 		capabilities: { tools: {} },
 		serverInfo: {
 			name,
@@ -1587,6 +1631,31 @@ function isMCPResultMetaObject(value) {
 	const identity = owned.value[MCP_META_SERVER];
 	return (0, _orkestrel_contract.isUndefined)(identity) || isMCPIdentity(identity);
 }
+/**
+* Determines whether a value is exact notification metadata with a valid reserved
+* subscription id.
+*
+* @remarks
+* The reserved key is OPTIONAL, so a frame delivered outside a `subscriptions/listen`
+* stream passes with no stamp at all. When the key IS present its value must be a valid
+* {@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
+*
+* @example
+* ```ts
+* isMCPNotificationMetaObject({}) // true — an unstamped frame carries no subscription
+* isMCPNotificationMetaObject({ 'io.modelcontextprotocol/subscriptionId': 7 }) // true
+* isMCPNotificationMetaObject({ 'io.modelcontextprotocol/subscriptionId': null }) // false
+* ```
+*/
+function isMCPNotificationMetaObject(value) {
+	const owned = (0, _orkestrel_contract.attempt)(() => (0, _orkestrel_contract.cloneJSONRecord)(value));
+	if (!owned.success || !Object.keys(owned.value).every((key) => isMCPMetaKey(key))) return false;
+	const subscription = owned.value[MCP_META_SUBSCRIPTION];
+	return (0, _orkestrel_contract.isUndefined)(subscription) || isJSONRPCId(subscription);
+}
 /** Determines whether a value is one dated MCP logging level. */
 function isMCPLoggingLevel(value) {
 	return value === "debug" || value === "info" || value === "notice" || value === "warning" || value === "error" || value === "critical" || value === "alert" || value === "emergency";
@@ -2249,7 +2318,8 @@ function isMCPCallResult(value) {
 * shape. The manager is consumer-supplied, so its types are a promise rather than a
 * proof: this is what stands between a manager that answers a numeric `taskId` and a
 * client that would receive one. `ttlMs` accepts `null` because the schema uses it to
-* mean "no expiry", which is distinct from an absent field.
+* mean "no expiry", which is distinct from an absent field, and both durations must be
+* 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
@@ -2270,7 +2340,7 @@ function isMCPTaskResult(value) {
 		const interval = result["pollIntervalMs"];
 		const lifetime = result["ttlMs"];
 		const metadata = result["_meta"];
-		return (0, _orkestrel_contract.isString)(result["taskId"]) && isMCPTaskStatus(result["status"]) && (0, _orkestrel_contract.isString)(result["createdAt"]) && (0, _orkestrel_contract.isString)(result["lastUpdatedAt"]) && (lifetime === null || (0, _orkestrel_contract.isFiniteNumber)(lifetime)) && ((0, _orkestrel_contract.isUndefined)(message) || (0, _orkestrel_contract.isString)(message)) && ((0, _orkestrel_contract.isUndefined)(interval) || (0, _orkestrel_contract.isFiniteNumber)(interval)) && ((0, _orkestrel_contract.isUndefined)(metadata) || isMCPResultMetaObject(metadata));
+		return (0, _orkestrel_contract.isString)(result["taskId"]) && isMCPTaskStatus(result["status"]) && (0, _orkestrel_contract.isString)(result["createdAt"]) && (0, _orkestrel_contract.isString)(result["lastUpdatedAt"]) && (lifetime === null || (0, _orkestrel_contract.isInteger)(lifetime)) && ((0, _orkestrel_contract.isUndefined)(message) || (0, _orkestrel_contract.isString)(message)) && ((0, _orkestrel_contract.isUndefined)(interval) || (0, _orkestrel_contract.isInteger)(interval)) && ((0, _orkestrel_contract.isUndefined)(metadata) || isMCPResultMetaObject(metadata));
 	} catch {
 		return false;
 	}
@@ -2300,9 +2370,14 @@ function isMCPTaskStatus(value) {
 * the requests to answer, `completed` owns the deferred call's result, `failed` owns the
 * JSON-RPC error that ended it, and `working` / `cancelled` own nothing further.
 *
-* Unrecognized members stay valid, because the extension is DRAFT and a manager tracking a
-* later revision must not be refused by this one. What is checked is what this package
-* publishes as the contract.
+* A `completed` task's `result` is checked as an OBJECT and no further. The schema declares
+* it an open record, so its contents belong to whichever method was deferred; a guard that
+* demanded a protocol result here would refuse payloads the extension permits.
+* `ttlMs` and `pollIntervalMs` are integer milliseconds, per the schema's `int` formats.
+*
+* Unrecognized members stay valid, because this guard reads a value a consumer's manager
+* produced, and a guard over a foreign contract enforces the published contract and no more.
+* 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}
@@ -2324,9 +2399,9 @@ function isMCPTaskDetail(value) {
 		const message = detail["statusMessage"];
 		const interval = detail["pollIntervalMs"];
 		const lifetime = detail["ttlMs"];
-		if (!(0, _orkestrel_contract.isString)(detail["taskId"]) || !isMCPTaskStatus(status) || !(0, _orkestrel_contract.isString)(detail["createdAt"]) || !(0, _orkestrel_contract.isString)(detail["lastUpdatedAt"]) || lifetime !== null && !(0, _orkestrel_contract.isFiniteNumber)(lifetime) || !(0, _orkestrel_contract.isUndefined)(message) && !(0, _orkestrel_contract.isString)(message) || !(0, _orkestrel_contract.isUndefined)(interval) && !(0, _orkestrel_contract.isFiniteNumber)(interval)) return false;
+		if (!(0, _orkestrel_contract.isString)(detail["taskId"]) || !isMCPTaskStatus(status) || !(0, _orkestrel_contract.isString)(detail["createdAt"]) || !(0, _orkestrel_contract.isString)(detail["lastUpdatedAt"]) || lifetime !== null && !(0, _orkestrel_contract.isInteger)(lifetime) || !(0, _orkestrel_contract.isUndefined)(message) && !(0, _orkestrel_contract.isString)(message) || !(0, _orkestrel_contract.isUndefined)(interval) && !(0, _orkestrel_contract.isInteger)(interval)) return false;
 		if (status === "input_required") return isMCPInputRequestMap(detail["inputRequests"]);
-		if (status === "completed") return isMCPResult(detail["result"]);
+		if (status === "completed") return (0, _orkestrel_contract.isRecord)(detail["result"]);
 		if (status === "failed") return isJSONRPCError(detail["error"]);
 		return true;
 	} catch {
@@ -2334,6 +2409,78 @@ function isMCPTaskDetail(value) {
 	}
 }
 /**
+* Determines whether a value is the wire answer to `tasks/get`.
+*
+* @remarks
+* {@link isMCPTaskDetail} plus the stamp the METHOD owes. The schema types a `tasks/get`
+* reply as the detail intersected with the standard result, so `resultType: 'complete'` is
+* part of the answer rather than decoration on it — and an unstamped payload, or one
+* carrying the creation answer's `resultType: 'task'`, is a peer answering some other
+* shape. Use this guard wherever a `tasks/get` REPLY is read; use
+* {@link isMCPTaskDetail} wherever a consumer's manager answers directly.
+*
+* `_meta` is checked only when present, and only as result metadata: the server identity a
+* 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}
+*
+* @example
+* ```ts
+* isMCPTaskDetailResult({ resultType: 'complete', taskId: 'a', status: 'working',
+*   createdAt: '', lastUpdatedAt: '', ttlMs: null }) // true
+* isMCPTaskDetailResult({ taskId: 'a', status: 'working', createdAt: '',
+*   lastUpdatedAt: '', ttlMs: null }) // false — the reply owes its `resultType`
+* ```
+*/
+function isMCPTaskDetailResult(value) {
+	const owned = (0, _orkestrel_contract.attempt)(() => (0, _orkestrel_contract.cloneJSONRecord)(value));
+	if (!owned.success) return false;
+	const result = owned.value;
+	if (result["resultType"] !== "complete") return false;
+	const metadata = result["_meta"];
+	if (!(0, _orkestrel_contract.isUndefined)(metadata) && !isMCPResultMetaObject(metadata)) return false;
+	return isMCPTaskDetail(result);
+}
+/**
+* Determines whether a value is a `notifications/tasks` frame carrying a task snapshot.
+*
+* @remarks
+* The ADMISSION guard for a task transition: a subscription producer is consumer-written,
+* so the frame it hands over is foreign input, and this is what stands between a mutated
+* or half-built snapshot and a subscribed client. Both halves are checked — the method
+* literal the extension fixes, and params that hold together as an
+* {@link MCPTaskDetail} — because either alone admits a frame the other rejects.
+*
+* `_meta` is checked for SHAPE WHEN PRESENT and nothing more. The reserved subscription
+* stamp is the SERVER'S to write, after this guard admits the frame and the matcher agrees
+* 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
+*
+* @example
+* ```ts
+* isMCPTaskNotification({ jsonrpc: '2.0', method: 'notifications/tasks',
+*   params: { taskId: 'a', status: 'working', createdAt: '', lastUpdatedAt: '',
+*     ttlMs: null } }) // true
+* isMCPTaskNotification({ jsonrpc: '2.0', method: 'notifications/tasks',
+*   params: { taskId: 'a' } }) // false — the params owe a whole snapshot
+* ```
+*/
+function isMCPTaskNotification(value) {
+	const owned = (0, _orkestrel_contract.attempt)(() => (0, _orkestrel_contract.cloneJSONRecord)(value));
+	if (!owned.success) return false;
+	const notification = owned.value;
+	if (!isJSONRPCNotification(notification)) return false;
+	if (notification["method"] !== "notifications/tasks") return false;
+	const params = notification["params"];
+	if (!(0, _orkestrel_contract.isRecord)(params)) return false;
+	const metadata = params["_meta"];
+	if (!(0, _orkestrel_contract.isUndefined)(metadata) && !isMCPNotificationMetaObject(metadata)) return false;
+	return isMCPTaskDetail(params);
+}
+/**
 * Determines whether a value is a string within a UTF-8 byte bound.
 *
 * @param value - The unknown value to inspect
@@ -2414,19 +2561,41 @@ 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_PROTOCOL_VERSIONS}
+* @returns `true` when the value is one of {@link SUPPORTED_MCP_VERSIONS}
 */
 function isMCPVersion(value) {
-	return (0, _orkestrel_contract.isString)(value) && SUPPORTED_PROTOCOL_VERSIONS.some((version) => version === value);
+	return (0, _orkestrel_contract.isString)(value) && SUPPORTED_MCP_VERSIONS.some((version) => version === 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}
+*/
+function isMCPModernVersion(value) {
+	return (0, _orkestrel_contract.isString)(value) && SUPPORTED_MODERN_PROTOCOL_VERSIONS.some((version) => version === 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}
+*/
+function isMCPLegacyVersion(value) {
+	return (0, _orkestrel_contract.isString)(value) && SUPPORTED_LEGACY_PROTOCOL_VERSIONS.some((version) => version === value);
 }
 /**
 * Determines whether a value is an MCP {@link MCPSubscriptionFilter}.
 *
 * @remarks
-* Every filter field is optional. Boolean notification families accept only booleans, and
-* `resourceSubscriptions` accepts only an array of string URIs. Unknown fields remain open
-* for protocol extensions and are ignored by the built-in subscription matcher. Total over
-* hostile input.
+* Every filter field is optional. Boolean notification families accept only booleans,
+* `resourceSubscriptions` accepts only an array of string URIs, and `taskIds` accepts only
+* an array of string task identifiers. Unknown fields remain open for protocol extensions
+* and are ignored by the built-in subscription matcher. Total over hostile input.
+*
+* A malformed `taskIds` is refused here rather than dropped, so the listen request that
+* carried it fails outright instead of quietly agreeing to a narrower subscription than
+* the caller asked for.
 *
 * @param value - The unknown value to inspect
 * @returns `true` when every recognized filter field has its protocol shape
@@ -2442,7 +2611,21 @@ function isMCPSubscriptionFilter(value) {
 	const resources = filter["resourcesListChanged"];
 	if (!(0, _orkestrel_contract.isUndefined)(resources) && !(0, _orkestrel_contract.isBoolean)(resources)) return false;
 	const subscriptions = filter["resourceSubscriptions"];
-	return (0, _orkestrel_contract.isUndefined)(subscriptions) || (0, _orkestrel_contract.arrayOf)(_orkestrel_contract.isString)(subscriptions);
+	if (!(0, _orkestrel_contract.isUndefined)(subscriptions) && !(0, _orkestrel_contract.arrayOf)(_orkestrel_contract.isString)(subscriptions)) return false;
+	const tasks = filter["taskIds"];
+	return (0, _orkestrel_contract.isUndefined)(tasks) || (0, _orkestrel_contract.arrayOf)(_orkestrel_contract.isString)(tasks);
+}
+/**
+* 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
+*/
+function isMCPSubscriptionResult(value) {
+	const owned = (0, _orkestrel_contract.attempt)(() => (0, _orkestrel_contract.cloneJSONRecord)(value));
+	if (!owned.success || owned.value["resultType"] !== "complete") return false;
+	const metadata = owned.value["_meta"];
+	return isMCPResultMetaObject(metadata) && (0, _orkestrel_contract.isRecord)(metadata) && isJSONRPCId(metadata["io.modelcontextprotocol/subscriptionId"]);
 }
 /**
 * Determines whether a value is one restricted primitive form-elicitation schema.
@@ -3041,6 +3224,67 @@ function isModernRequest(value) {
 	return (0, _orkestrel_contract.isRecord)(metadata) && Object.hasOwn(metadata, "io.modelcontextprotocol/protocolVersion");
 }
 //#endregion
+//#region src/core/inferers.ts
+/**
+* Infers the wire era for an MCP protocol revision.
+*
+* @remarks
+* The era is READ from the two era guards rather than restated here, so a revision added
+* to {@link SUPPORTED_MODERN_PROTOCOL_VERSIONS} or {@link SUPPORTED_LEGACY_PROTOCOL_VERSIONS}
+* carries its era with it and no third list can disagree with those two.
+*
+* @param version - The protocol revision to classify
+* @returns `'modern'` for a revision a bare server accepts, `'legacy'` for a revision the
+* optional decorator accepts, or `undefined` when the revision is unsupported
+*/
+function inferEra(version) {
+	if (isMCPModernVersion(version)) return "modern";
+	if (isMCPLegacyVersion(version)) return "legacy";
+}
+/**
+* Infers the newest supported modern protocol revision present in a peer's offer.
+*
+* @param offered - The protocol revisions offered by the peer
+* @returns The newest locally supported modern revision, or `undefined`
+*/
+function inferVersion(offered) {
+	for (const version of SUPPORTED_MODERN_PROTOCOL_VERSIONS) if (offered.includes(version)) return version;
+}
+/**
+* Infers the protocol version an outbound message announces itself with — the ONE
+* projection every HTTP client transport stamps `mcp-protocol-version` from.
+*
+* @remarks
+* This is deliberately the SAME read the server's own expectation performs
+* ({@link import('@orkestrel/mcp/server').inferHeaderIssue}): a modern request's reserved
+* `_meta` version, accepted whenever it is a string. It is NOT
+* {@link import('./parsers.js').parseRequestContext}, and the difference is the whole
+* point. That parser answers a different question — is the modern metadata WELL FORMED —
+* and refuses a request whose capability declaration or logging level is malformed. Such a
+* request is still modern (era is fixed by key presence) and the server still demands the
+* header for it, so projecting through the parser withholds a header the peer requires and
+* earns `-32602` instead of the `-32602` the malformed metadata itself deserves.
+*
+* A non-modern message projects nothing: a legacy request's version comes from the
+* `initialize` handshake the transport captured, not from the message.
+*
+* Header NAMES stay with the transports that own the wire (see `constants.ts`); core owns
+* the value this projection derives, which is the part the browser and Node faces disagreed about.
+*
+* @param message - The outbound message about to be written
+* @returns The version to announce, or `undefined` when the message announces none
+*
+* @example
+* ```ts
+* inferRequestVersion({ jsonrpc: '2.0', id: 1, method: 'tools/list', params: { _meta: meta } })
+* ```
+*/
+function inferRequestVersion(message) {
+	if (!isModernRequest(message)) return void 0;
+	const version = ((0, _orkestrel_contract.isRecord)(message.params?.["_meta"]) ? message.params["_meta"] : void 0)?.[MCP_META_VERSION];
+	return (0, _orkestrel_contract.isString)(version) ? version : void 0;
+}
+//#endregion
 //#region src/core/MCPMethodManager.ts
 /**
 * The modern method registry an {@link import('./types.js').MCPServerInterface}
@@ -3529,9 +3773,12 @@ var MCPTextStreamController = class {
 * Translates the fixed legacy method set onto one modern dispatcher.
 *
 * @remarks
-* This decorator owns no execution engine or result normalizer. Modern invocations
-* pass through untouched. Legacy tool methods acquire modern request metadata, run
-* through the configured dispatcher, and lose only fields their dated result shape
+* This decorator answers `initialize` and `ping` itself, under the limits the configured
+* dispatcher advertises through {@link MCPLegacy.limit}: an invocation outside the message
+* bound earns the same id-less `-32600` refusal the dispatcher produces, whether this
+* decorator would have answered it or forwarded it. It owns no result normalizer. Modern
+* invocations pass through untouched. Legacy tool methods acquire modern request metadata,
+* run through the configured dispatcher, and lose only fields their dated result shape
 * cannot represent.
 */
 var MCPLegacy = class {
@@ -3556,6 +3803,7 @@ var MCPLegacy = class {
 		return this.#legacy(invocation, options);
 	}
 	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);
@@ -3569,12 +3817,16 @@ var MCPLegacy = class {
 	async #legacy(invocation, options) {
 		if (invocation.id === void 0) return void 0;
 		const id = invocation.id;
+		if (parseJSONRPCMessage(invocation, {
+			bytes: this.limit.message,
+			depth: this.limit.depth
+		}) === void 0) return buildJSONRPCError(void 0, JSONRPC_INVALID_REQUEST, "Invalid Request");
 		switch (invocation.method) {
 			case "initialize": {
 				const requested = invocation.params?.["protocolVersion"];
 				return buildJSONRPCResult(id, buildInitializeResult(this.#options.identity.name, this.#options.identity.version, (0, _orkestrel_contract.isString)(requested) ? requested : void 0));
 			}
-			case "ping":
+			case "ping": return buildJSONRPCResult(id, {});
 			case "tools/list": return this.#forward(invocation, options);
 			case "tools/call":
 				if (invocation.params !== void 0 && (Object.hasOwn(invocation.params, "requestState") || Object.hasOwn(invocation.params, "inputResponses"))) return buildJSONRPCError(id, JSONRPC_INVALID_PARAMS, "Invalid params: legacy requests cannot continue an input-required result");
@@ -3583,19 +3835,7 @@ var MCPLegacy = class {
 		}
 	}
 	async #forward(request, options) {
-		const params = request.params ?? {};
-		const metadata = (0, _orkestrel_contract.isRecord)(params["_meta"]) ? params["_meta"] : {};
-		const translated = {
-			...request,
-			params: {
-				...params,
-				_meta: {
-					...metadata,
-					[MCP_META_VERSION]: MCP_MODERN_VERSION,
-					[MCP_META_CAPABILITIES]: {}
-				}
-			}
-		};
+		const translated = legacyInvocationToModern(request);
 		const answer = await this.#options.dispatcher.dispatch(translated, options);
 		if (Symbol.asyncIterator in answer) {
 			answer.stop();
@@ -3606,25 +3846,8 @@ var MCPLegacy = class {
 	}
 	#project(answer, id) {
 		if (answer.error !== void 0) return answer.error.code === -32021 ? this.#unsupported(id, this.#capability(answer)) : answer;
-		if (answer.result.resultType !== "complete") return this.#unsupported(id, answer.result.resultType ?? "unstamped");
-		const projected = {};
-		for (const [key, value] of Object.entries(answer.result)) {
-			if (key === "resultType" || key === "ttlMs" || key === "cacheScope") continue;
-			if (key === "content" && Array.isArray(value)) {
-				projected[key] = value.map((entry) => (0, _orkestrel_contract.isRecord)(entry) && entry["type"] === "text" && (0, _orkestrel_contract.isString)(entry["text"]) ? {
-					type: "text",
-					text: entry["text"]
-				} : entry);
-				continue;
-			}
-			if (key !== "_meta" || !(0, _orkestrel_contract.isRecord)(value)) {
-				projected[key] = value;
-				continue;
-			}
-			const metadata = {};
-			for (const [name, entry] of Object.entries(value)) if (name !== "io.modelcontextprotocol/serverInfo") metadata[name] = entry;
-			if (Object.keys(metadata).length > 0) projected["_meta"] = metadata;
-		}
+		const projected = modernResultToLegacy(answer.result);
+		if (projected === void 0) return this.#unsupported(id, answer.result.resultType ?? "unstamped");
 		return buildJSONRPCResult(id, projected);
 	}
 	#capability(answer) {
@@ -3636,7 +3859,230 @@ var MCPLegacy = class {
 		return (0, _orkestrel_contract.isRecord)(extensions) && Object.hasOwn(extensions, "io.modelcontextprotocol/tasks") ? "task" : "input-required";
 	}
 	#unsupported(id, result) {
-		return buildJSONRPCError(id, JSONRPC_SERVER_ERROR, `Legacy protocol ${MCP_PROTOCOL_VERSION} cannot represent ${result === "input-required" ? "an" : "a"} ${result} result`);
+		return buildJSONRPCError(id, JSONRPC_SERVER_ERROR, `Legacy protocol ${MCP_HANDSHAKE_VERSION} cannot represent ${result === "input-required" ? "an" : "a"} ${result} result`);
+	}
+};
+//#endregion
+//#region src/core/MCPLegacyClientTransport.ts
+/**
+* Adapts a legacy MCP peer to the modern client transport boundary.
+*
+* @remarks
+* `start` performs the legacy `initialize` handshake. The adapter answers
+* `server/discover` locally from that handshake, removes modern request metadata before writes,
+* restores legacy results to modern complete-result shapes before delivery, and bounds retained
+* request correlations with the configured deadline.
+*/
+var MCPLegacyClientTransport = class {
+	#emitter = new _orkestrel_emitter.Emitter();
+	#transport;
+	#client;
+	#capabilities;
+	#pin;
+	#timeout;
+	#correlations = /* @__PURE__ */ new Map();
+	#handshake = void 0;
+	#instructions = void 0;
+	#server = void 0;
+	#supported = void 0;
+	/**
+	* Creates a legacy client transport adapter.
+	*
+	* @param transport - The legacy peer transport
+	* @param options - The legacy handshake identity, capabilities, revision, and deadline
+	*/
+	constructor(transport, options) {
+		const requested = options?.version;
+		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",
+			version: "1.0.0"
+		};
+		this.#capabilities = options?.capabilities ?? {};
+		this.#pin = requested;
+		this.#timeout = options?.timeout ?? 3e4;
+		transport.emitter.on("message", (message) => this.#receive(message));
+		transport.emitter.on("close", () => this.#emitter.emit("close"));
+		transport.emitter.on("error", (error) => this.#emitter.emit("error", error));
+	}
+	get emitter() {
+		return this.#emitter;
+	}
+	get session() {
+		return this.#transport.session;
+	}
+	get duplex() {
+		return this.#transport.duplex;
+	}
+	async start() {
+		await this.#transport.start();
+		try {
+			await this.#initialize();
+		} catch (error) {
+			try {
+				await this.#transport.close();
+			} catch (fault) {
+				this.#emitter.emit("error", fault);
+			}
+			throw error;
+		}
+	}
+	async send(message) {
+		if (!("method" in message)) {
+			await this.#transport.send(message);
+			return;
+		}
+		if (message.method === "server/discover" && message.id !== void 0) {
+			this.#discover(message.id);
+			return;
+		}
+		const id = message.id;
+		let correlation;
+		if (id !== void 0) {
+			correlation = { method: message.method };
+			this.#correlations.set(id, correlation);
+			AbortSignal.timeout(this.#timeout).addEventListener("abort", () => {
+				if (this.#correlations.get(id) !== correlation) return;
+				this.#reject(id, new MCPError(`Legacy MCP request timed out after ${this.#timeout}ms`, JSONRPC_INTERNAL_ERROR));
+			}, { once: true });
+		}
+		try {
+			await this.#transport.send(modernInvocationToLegacy(message));
+		} catch (error) {
+			if (id !== void 0 && this.#correlations.get(id) === correlation) this.#correlations.delete(id);
+			throw error;
+		}
+	}
+	/**
+	* Closes the wrapped transport and clears retained adapter state.
+	*
+	* @remarks
+	* The cleared handshake state — the server identity, the supported reading, and the retained
+	* `instructions` value — is unobservable between `close()` and the next accepted handshake.
+	* Discovery answers the pre-handshake refusal in that window, and the accepted handshake
+	* reassigns the state unconditionally.
+	*
+	* @returns Resolves after the wrapped transport closes
+	*/
+	async close() {
+		this.#instructions = void 0;
+		this.#server = void 0;
+		this.#supported = void 0;
+		this.#correlations.clear();
+		await this.#transport.close();
+	}
+	async #initialize() {
+		const handshake = Promise.withResolvers();
+		this.#handshake = handshake;
+		try {
+			await this.#write({
+				jsonrpc: "2.0",
+				id: 0,
+				method: "initialize",
+				params: {
+					protocolVersion: this.#pin ?? "2025-11-25",
+					capabilities: this.#capabilities,
+					clientInfo: this.#client
+				}
+			});
+			AbortSignal.timeout(this.#timeout).addEventListener("abort", () => handshake.reject(new MCPError(`Legacy MCP handshake timed out after ${this.#timeout}ms`, MCP_UNSUPPORTED_VERSION)), { once: true });
+			const response = await handshake.promise;
+			this.#accept(response);
+			await this.#write({
+				jsonrpc: "2.0",
+				method: "notifications/initialized"
+			});
+		} finally {
+			if (this.#handshake === handshake) this.#handshake = void 0;
+		}
+	}
+	#accept(response) {
+		if (response.error !== void 0) throw new MCPError(response.error.message, response.error.code, response.error.data);
+		const owned = (0, _orkestrel_contract.attempt)(() => (0, _orkestrel_contract.cloneJSONRecord)(response.result));
+		if (!owned.success || !isMCPLegacyResult(owned.value)) throw new MCPError("Legacy MCP handshake returned a malformed result", JSONRPC_INVALID_PARAMS);
+		const result = owned.value;
+		const protocol = result["protocolVersion"];
+		const capabilities = result["capabilities"];
+		const identity = result["serverInfo"];
+		const instructions = result["instructions"];
+		if (protocol === void 0) throw new MCPError("Legacy MCP handshake returned no protocol version", JSONRPC_INVALID_PARAMS, result);
+		if (!(0, _orkestrel_contract.isString)(protocol)) throw new MCPError("Legacy MCP handshake returned a malformed protocol version", JSONRPC_INVALID_PARAMS, result);
+		if (!isMCPLegacyVersion(protocol)) throw new MCPError(`Legacy MCP peer negotiated unsupported protocol version '${protocol}'`, MCP_UNSUPPORTED_VERSION, {
+			supported: SUPPORTED_LEGACY_PROTOCOL_VERSIONS,
+			negotiated: protocol
+		});
+		if (!isMCPServerCapabilities(capabilities) || !isMCPIdentity(identity) || instructions !== void 0 && !(0, _orkestrel_contract.isString)(instructions)) throw new MCPError("Legacy MCP handshake returned a malformed result", JSONRPC_INVALID_PARAMS, result);
+		if (this.#pin !== void 0 && protocol !== this.#pin) throw new MCPError("Legacy MCP peer negotiated a different protocol version than the adapter requested", MCP_UNSUPPORTED_VERSION, {
+			requested: this.#pin,
+			negotiated: protocol
+		});
+		this.#instructions = instructions;
+		this.#server = identity;
+		this.#supported = capabilities;
+	}
+	async #write(message) {
+		const deadline = AbortSignal.timeout(this.#timeout);
+		await Promise.race([this.#transport.send(message), new Promise((_resolve, reject) => deadline.addEventListener("abort", () => reject(new MCPError(`Legacy MCP handshake write timed out after ${this.#timeout}ms`, MCP_UNSUPPORTED_VERSION)), { once: true }))]);
+	}
+	#discover(id) {
+		const identity = this.#server;
+		const capabilities = this.#supported;
+		if (identity === void 0 || capabilities === void 0) {
+			this.#reject(id, new MCPError("Legacy MCP transport has not completed its handshake", JSONRPC_INTERNAL_ERROR));
+			return;
+		}
+		this.#emitter.emit("message", {
+			jsonrpc: "2.0",
+			id,
+			result: buildModernResult({
+				supportedVersions: [MCP_MODERN_VERSION],
+				capabilities,
+				...this.#instructions === void 0 ? {} : { instructions: this.#instructions }
+			}, identity, 0)
+		});
+	}
+	#receive(message) {
+		const owned = parseJSONRPCMessage(message);
+		if (owned === void 0) {
+			this.#emitter.emit("error", new MCPError("Legacy MCP peer returned a malformed message", JSONRPC_INVALID_PARAMS));
+			return;
+		}
+		const handshake = this.#handshake;
+		if (handshake !== void 0 && isJSONRPCResponse(owned) && owned.id === 0) {
+			handshake.resolve(owned);
+			return;
+		}
+		if (!isJSONRPCResponse(owned) || owned.id === void 0) {
+			this.#emitter.emit("message", owned);
+			return;
+		}
+		const correlation = this.#correlations.get(owned.id);
+		if (correlation === void 0) {
+			this.#emitter.emit("message", owned);
+			return;
+		}
+		this.#correlations.delete(owned.id);
+		const method = correlation.method;
+		if (owned.error !== void 0) {
+			this.#emitter.emit("message", owned);
+			return;
+		}
+		const identity = this.#server;
+		if (identity === void 0 || !isMCPLegacyResult(owned.result)) {
+			this.#reject(owned.id, new MCPError("Legacy MCP peer returned a malformed result", JSONRPC_INTERNAL_ERROR));
+			return;
+		}
+		this.#emitter.emit("message", {
+			jsonrpc: "2.0",
+			id: owned.id,
+			result: legacyResultToModern(owned.result, method, identity)
+		});
+	}
+	#reject(id, error) {
+		this.#correlations.delete(id);
+		this.#emitter.emit("error", error);
+		this.#emitter.emit("message", buildJSONRPCError(id, error.code, error.message));
 	}
 };
 //#endregion
@@ -3657,7 +4103,7 @@ var MCPLegacy = class {
 * - **One modern seam.** `server/discover`, `tools/list`, `tools/call`, and
 *   `subscriptions/listen` are always registered; `resources/*`, `prompts/*`, and
 *   `completion/complete` register independently when their respective host ports are
-*   configured — plus `tasks/get`, `tasks/update`, and `tasks/cancel` when the draft Tasks
+*   configured — plus `tasks/get`, `tasks/update`, and `tasks/cancel` when the stable Tasks
 *   extension is configured — and every method is resolved from the registry on
 *   every dispatch: the same path a later method or a consumer's own takes, with an
 *   unregistered method still answering `-32601`.
@@ -3672,8 +4118,8 @@ var MCPLegacy = class {
 * const tools = createToolManager()
 * tools.add(createTool({ name: 'add', execute: (a) => Number(a.x) + Number(a.y) }))
 * const server = new MCPServer({ identity: { name: 'demo', version: '1.0.0' }, tools })
-* await server.handle('{"jsonrpc":"2.0","method":"ping","id":1,"params":{"_meta":{"io.modelcontextprotocol/protocolVersion":"2026-07-28","io.modelcontextprotocol/clientCapabilities":{}}}}')
-* // '{"jsonrpc":"2.0","id":1,"result":{"resultType":"complete","_meta":{"io.modelcontextprotocol/serverInfo":{"name":"demo","version":"1.0.0"}}}}'
+* await server.handle('{"jsonrpc":"2.0","method":"server/discover","id":1,"params":{"_meta":{"io.modelcontextprotocol/protocolVersion":"2026-07-28","io.modelcontextprotocol/clientCapabilities":{}}}}')
+* // The result advertises only `2026-07-28`; wrap with `createMCPLegacy` to serve initialize or ping.
 * ```
 */
 var MCPServer = class {
@@ -3757,7 +4203,6 @@ var MCPServer = class {
 		return Symbol.asyncIterator in answer ? new MCPTextStreamController(answer) : JSON.stringify(answer);
 	}
 	#register() {
-		this.#methods.add("ping", async (request, _options) => buildJSONRPCResult(request.id, buildModernResult({}, this.#options.identity)));
 		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("tools/call", async (request, options) => this.#call(request, options));
@@ -3794,8 +4239,8 @@ var MCPServer = class {
 			depth: this.#limits.depth
 		});
 		if (context === void 0) return buildJSONRPCError(id, JSONRPC_INVALID_PARAMS, "Invalid params: malformed modern request metadata");
-		if (inferEra(context.version) === void 0) return buildJSONRPCError(id, MCP_UNSUPPORTED_VERSION, `Unsupported protocol version: ${context.version}`, {
-			supported: SUPPORTED_PROTOCOL_VERSIONS,
+		if (!isMCPModernVersion(context.version)) return buildJSONRPCError(id, MCP_UNSUPPORTED_VERSION, `Unsupported protocol version: ${context.version}`, {
+			supported: SUPPORTED_MODERN_PROTOCOL_VERSIONS,
 			requested: context.version
 		});
 		const handler = this.#methods.method(request.method);
@@ -4204,8 +4649,22 @@ var MCPServer = class {
 		if (options.signal.aborted) slot.abort();
 		else options.signal.addEventListener("abort", () => slot.abort(), { once: true });
 		try {
+			const task = this.#options.task;
 			const configured = this.#options.subscription;
-			const notifications = buildSubscriptionFilter(requested, configured?.notifications ?? {});
+			const tasks = task !== void 0 && configured !== void 0;
+			let notifications = buildSubscriptionFilter(requested, configured?.notifications ?? {}, tasks);
+			const requestedTaskIds = notifications.taskIds;
+			if (requestedTaskIds !== void 0) {
+				const resolved = [];
+				if (task !== void 0) {
+					for (const taskId of requestedTaskIds) if (await task.tasks.task(taskId, options) !== void 0) resolved.push(taskId);
+				}
+				const { taskIds: _dropped, ...rest } = notifications;
+				notifications = resolved.length > 0 ? {
+					...rest,
+					taskIds: resolved
+				} : rest;
+			}
 			yield buildSubscriptionAcknowledgement(notifications, id);
 			if (configured !== void 0) {
 				const iterator = (await configured.listen(notifications, options))[Symbol.asyncIterator]();
@@ -4317,7 +4776,7 @@ var MCPServer = class {
 //#endregion
 //#region src/core/MCPTaskClient.ts
 /**
-* The CLIENT half of the draft Tasks extension — the `tasks/*` methods over one
+* 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
 * `tasks`.
 *
@@ -4361,7 +4820,7 @@ var MCPTaskClient = class {
 	}
 	async task(id) {
 		const result = await this.#request("tasks/get", { taskId: id }, this.#timeout);
-		if (!isMCPTaskDetail(result)) throw new MCPError("MCP server returned an invalid task", JSONRPC_INVALID_PARAMS);
+		if (!isMCPTaskDetailResult(result)) throw new MCPError("MCP server returned an invalid task", JSONRPC_INVALID_PARAMS);
 		return result;
 	}
 	async update(id, responses) {
@@ -4378,14 +4837,14 @@ var MCPTaskClient = class {
 //#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 or legacy
-* wire era, and exposes the server's tools as local {@link ToolInterface}s an agent can run.
+* over an injected {@link MCPClientTransportInterface}, 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;
-*   this client ISSUES them over a transport. `connect` probes `server/discover` unless
-*   pinned legacy, falls back to `initialize` only for a legacy peer, and exposes the
-*   negotiated `version`; `tools()` lists the remote tools and wraps each as a
+*   this client ISSUES them over a transport. `connect` probes `server/discover` and exposes
+*   the negotiated `version`; a legacy peer requires an explicit transport adapter.
+*   `tools()` lists the remote tools and wraps each as a
 *   local {@link ToolInterface} whose `execute` calls back through `call`; `call` runs a
 *   remote `tools/call` and reports the arm the peer answered with — a value, a durable
 *   task, or a request for more input (a remote `isError: true` throws locally, so an
@@ -4455,17 +4914,18 @@ var MCPClient = class {
 	#generation = 0;
 	#supersession = Promise.withResolvers();
 	#version = void 0;
-	#era = void 0;
 	#offer;
 	constructor(options) {
 		const requested = options.version;
-		if (requested !== void 0 && !isMCPVersion(requested)) throw new MCPError("Unsupported protocol version", MCP_UNSUPPORTED_VERSION, {
-			supported: SUPPORTED_PROTOCOL_VERSIONS,
+		const on = options.on;
+		const error = options.error;
+		if (requested !== void 0 && !isMCPModernVersion(requested)) throw new MCPError("Unsupported protocol version", MCP_UNSUPPORTED_VERSION, {
+			supported: SUPPORTED_MODERN_PROTOCOL_VERSIONS,
 			requested
 		});
 		this.#emitter = new _orkestrel_emitter.Emitter({
-			...options.on !== void 0 ? { on: options.on } : {},
-			...options.error !== void 0 ? { error: options.error } : {}
+			...on === void 0 ? {} : { on },
+			...error === void 0 ? {} : { error }
 		});
 		this.#transport = options.transport;
 		this.#identity = options.identity ?? {
@@ -4481,6 +4941,7 @@ var MCPClient = class {
 			timeout: this.#timeout
 		});
 		this.#transport.emitter.on("message", (message) => this.#receive(message));
+		this.#transport.emitter.on("close", () => this.#loseTransport());
 	}
 	get emitter() {
 		return this.#emitter;
@@ -4529,7 +4990,9 @@ var MCPClient = class {
 		}
 	}
 	async discover() {
-		const received = await this.#request("server/discover", void 0, this.#timeout, this.#version ?? this.#offer);
+		const negotiated = this.#version;
+		const version = isMCPModernVersion(negotiated) ? negotiated : this.#offer;
+		const received = await this.#request("server/discover", void 0, this.#timeout, version);
 		const owned = (0, _orkestrel_contract.attempt)(() => (0, _orkestrel_contract.cloneJSONRecord)(received));
 		if (!owned.success) throw new MCPError("MCP server returned a malformed discovery result", JSONRPC_INVALID_PARAMS);
 		const result = owned.value;
@@ -4542,7 +5005,7 @@ var MCPClient = class {
 		const resultType = result["resultType"];
 		if (!(0, _orkestrel_contract.isArray)(advertised) || !advertised.every(_orkestrel_contract.isString) || !isMCPServerCapabilities(capabilities) || !(0, _orkestrel_contract.isInteger)(ttl) || ttl < 0 || scope !== "public" && scope !== "private" || resultType !== "complete" || instructions !== void 0 && !(0, _orkestrel_contract.isString)(instructions) || metadata !== void 0 && !isMCPResultMetaObject(metadata)) throw new MCPError("MCP server returned a malformed discovery result", JSONRPC_INVALID_PARAMS, result);
 		const supportedVersions = [];
-		for (const version of advertised) if (isMCPVersion(version)) supportedVersions.push(version);
+		for (const candidate of advertised) if (isMCPModernVersion(candidate)) supportedVersions.push(candidate);
 		const retained = Object.freeze(supportedVersions);
 		return Object.freeze({
 			supportedVersions: retained,
@@ -4571,19 +5034,81 @@ var MCPClient = class {
 		}
 		return tools;
 	}
+	listen(notifications, options) {
+		const signal = options.signal;
+		const capacity = options.capacity ?? 64;
+		return this.#openSubscription(notifications, signal, capacity);
+	}
 	async call(name, args, options) {
+		const input = options?.input;
 		return buildCallOutcome(name, await this.#request("tools/call", {
 			name,
-			arguments: args
+			arguments: args,
+			...input === void 0 ? {} : {
+				requestState: input.state,
+				inputResponses: input.responses
+			}
 		}, this.#timeout, void 0, options));
 	}
+	async *#openSubscription(notifications, signal, capacity) {
+		signal.throwIfAborted();
+		if (!(0, _orkestrel_contract.isInteger)(capacity) || capacity < 1) throw new MCPError("MCP subscription capacity must be a positive integer", JSONRPC_INVALID_PARAMS);
+		this.#nextId += 1;
+		const id = this.#nextId;
+		const method = "subscriptions/listen";
+		const modern = this.#version;
+		const request = {
+			jsonrpc: "2.0",
+			id,
+			method,
+			params: {
+				notifications: notifications ?? {},
+				...modern === void 0 ? {} : { _meta: {
+					[MCP_META_VERSION]: modern,
+					[MCP_META_CAPABILITIES]: this.#capabilities,
+					[MCP_META_CLIENT]: this.#identity
+				} }
+			}
+		};
+		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
+		});
+		this.#transport.send(request).catch((error) => this.#settle(id, error, true));
+		try {
+			for (;;) {
+				if (subscription.failure !== void 0) throw subscription.failure.reason;
+				const queued = subscription.queue.shift();
+				if (queued !== void 0) {
+					yield queued;
+					continue;
+				}
+				if (subscription.terminal !== void 0) return subscription.terminal;
+				const waiter = Promise.withResolvers();
+				subscription.waiter = waiter;
+				const frame = await waiter.promise;
+				if ("method" in frame) yield frame;
+				else return frame;
+			}
+		} finally {
+			this.#cancelSubscription(id, /* @__PURE__ */ new Error("MCP subscription closed by its consumer"));
+		}
+	}
 	#request(method, params, deadline, version, options) {
 		this.#nextId += 1;
 		const id = this.#nextId;
 		const timeout = deadline;
 		const caller = options?.signal;
 		const report = options?.progress;
-		const modern = version ?? (this.#era === "modern" ? this.#version : void 0);
+		const modern = version ?? this.#version;
 		const metadata = {
 			...modern === void 0 ? {} : {
 				[MCP_META_VERSION]: modern,
@@ -4647,7 +5172,6 @@ var MCPClient = class {
 			});
 			if (correlated.success && correlated.value !== void 0) {
 				if (this.#pending.get(correlated.value)?.method === "server/discover") {
-					this.#era = "modern";
 					this.#settle(correlated.value, new MCPError("MCP server returned a malformed discovery result", JSONRPC_INVALID_PARAMS), true);
 					return;
 				}
@@ -4663,9 +5187,11 @@ var MCPClient = class {
 			const correlation = owned.id;
 			const pending = this.#pending.get(correlation);
 			if (pending !== void 0) {
-				if (pending.method === "server/discover" && (owned.error === void 0 || owned.error.code !== -32601 && owned.error.code !== -32600)) this.#era = "modern";
 				if (owned.error !== void 0) this.#settle(correlation, new MCPError(owned.error.message, owned.error.code, owned.error.data), true);
-				else {
+				else if (pending.subscription !== void 0) {
+					if (!isMCPSubscriptionResult(owned.result) || owned.result["_meta"]["io.modelcontextprotocol/subscriptionId"] !== correlation) this.#settle(correlation, new MCPError("MCP server returned a malformed subscription result", JSONRPC_INVALID_PARAMS, owned.result), true);
+					else this.#settle(correlation, owned.result, false);
+				} else {
 					const resultType = (0, _orkestrel_contract.isRecord)(owned.result) ? owned.result["resultType"] : void 0;
 					const metadata = (0, _orkestrel_contract.isRecord)(owned.result) ? owned.result["_meta"] : void 0;
 					if (metadata !== void 0 && !isMCPResultMetaObject(metadata)) {
@@ -4680,8 +5206,30 @@ var MCPClient = class {
 			return;
 		}
 		if ("method" in owned && this.#reportProgress(owned)) return;
+		if ("method" in owned && this.#routeSubscription(owned)) return;
 		this.#emitter.emit("notification", owned);
 	}
+	#routeSubscription(message) {
+		if (!isJSONRPCNotification(message)) return false;
+		const metadata = message.params?.["_meta"];
+		if (!(0, _orkestrel_contract.isRecord)(metadata)) return false;
+		const id = metadata[MCP_META_SUBSCRIPTION];
+		if (!isJSONRPCId(id)) return false;
+		const subscription = this.#pending.get(id)?.subscription;
+		if (subscription === void 0) return true;
+		const waiter = subscription.waiter;
+		if (waiter !== void 0) {
+			delete subscription.waiter;
+			waiter.resolve(message);
+			return true;
+		}
+		if (subscription.queue.length >= subscription.capacity) {
+			this.#cancelSubscription(id, new MCPError("MCP subscription frame queue overflow", JSONRPC_INTERNAL_ERROR));
+			return true;
+		}
+		subscription.queue.push(message);
+		return true;
+	}
 	#reportProgress(message) {
 		if (message.method !== "notifications/progress") return false;
 		const params = message.params;
@@ -4715,10 +5263,6 @@ var MCPClient = class {
 		this.#owner = generation;
 		try {
 			if (generation !== this.#generation) throw new Error("MCP client disconnected");
-			if (this.#era === "legacy" || this.#pin !== void 0 && inferEra(this.#pin) === "legacy") {
-				await this.#initialize(generation, this.#pin ?? "2025-11-25");
-				return;
-			}
 			let discovery;
 			try {
 				try {
@@ -4735,13 +5279,12 @@ var MCPClient = class {
 				}
 			} catch (error) {
 				if (generation !== this.#generation) throw error;
-				if (!(this.#pin !== "2026-07-28" && this.#era === void 0 && (!isMCPError(error) || error.code !== -32022))) throw error;
-				await this.#initialize(generation, MCP_PROTOCOL_VERSION);
-				return;
+				if (!isMCPError(error) || error.code !== -32601) throw error;
+				throw new MCPError("MCP server does not support modern negotiation; wrap the transport with createMCPLegacyClientTransport to connect to a legacy peer", error.code, error.context);
 			}
 			let version;
 			if (this.#pin === void 0) version = inferVersion(discovery.supportedVersions);
-			else if (discovery.supportedVersions.includes(this.#pin)) version = this.#pin;
+			else if (isMCPModernVersion(this.#pin) && discovery.supportedVersions.includes(this.#pin)) version = this.#pin;
 			else throw new MCPError("MCP server does not support the pinned protocol version", MCP_UNSUPPORTED_VERSION, {
 				supported: discovery.supportedVersions,
 				requested: this.#pin
@@ -4749,7 +5292,6 @@ var MCPClient = class {
 			if (version === void 0) throw new MCPError("MCP server supports no compatible protocol version", MCP_UNSUPPORTED_VERSION, { supported: discovery.supportedVersions });
 			if (generation !== this.#generation) throw new Error("MCP client disconnected");
 			this.#version = version;
-			this.#era = "modern";
 			this.#connected = true;
 			this.#emitter.emit("connect");
 		} catch (error) {
@@ -4811,31 +5353,6 @@ var MCPClient = class {
 		this.#closing = void 0;
 		if (closed) this.#owner = void 0;
 	}
-	async #initialize(generation, version) {
-		const result = await this.#request("initialize", {
-			protocolVersion: version,
-			capabilities: {},
-			clientInfo: this.#identity
-		}, this.#timeout);
-		const protocol = (0, _orkestrel_contract.isRecord)(result) ? result["protocolVersion"] : void 0;
-		if (protocol === void 0) throw new Error("MCP server returned no protocol version");
-		if (!(0, _orkestrel_contract.isString)(protocol)) throw new Error("MCP server returned a malformed protocol version");
-		if (!isMCPVersion(protocol) || inferEra(protocol) !== "legacy") throw new Error(`MCP server negotiated unsupported protocol version '${protocol}'`);
-		if (this.#pin !== void 0 && protocol !== this.#pin) throw new MCPError("MCP server negotiated a different protocol version than the client pinned", MCP_UNSUPPORTED_VERSION, {
-			requested: this.#pin,
-			negotiated: protocol
-		});
-		if (generation !== this.#generation) throw new Error("MCP client disconnected");
-		await Promise.race([this.#transport.send({
-			jsonrpc: "2.0",
-			method: "notifications/initialized"
-		}), this.#supersession.promise]);
-		if (generation !== this.#generation) throw new Error("MCP client disconnected");
-		this.#version = protocol;
-		this.#era = "legacy";
-		this.#connected = true;
-		this.#emitter.emit("connect");
-	}
 	#timeoutRequest(id, method, timeout) {
 		this.#settle(id, /* @__PURE__ */ new Error(`MCP request '${method}' timed out after ${timeout}ms`), true);
 	}
@@ -4845,14 +5362,48 @@ var MCPClient = class {
 		if (this.#transport.duplex) this.#transport.send(buildCancelledNotification(id, (0, _orkestrel_contract.isString)(reason) ? reason : void 0)).catch((error) => this.#emitter.emit("error", error));
 		this.#settle(id, new Error(`MCP request '${method}' was aborted`, { cause: reason }), true);
 	}
+	#abortSubscription(id, signal) {
+		this.#cancelSubscription(id, signal.reason);
+	}
+	#cancelSubscription(id, reason) {
+		if (this.#pending.get(id)?.subscription === void 0) return;
+		if (this.#transport.duplex) this.#transport.send(buildCancelledNotification(id, (0, _orkestrel_contract.isString)(reason) ? reason : void 0)).catch((error) => this.#emitter.emit("error", error));
+		this.#settle(id, reason, true);
+	}
+	#loseTransport() {
+		const announced = this.#connected;
+		this.#generation += 1;
+		this.#connected = false;
+		this.#version = void 0;
+		this.#owner = void 0;
+		const supersession = this.#supersession;
+		this.#supersession = Promise.withResolvers();
+		supersession.resolve();
+		for (const id of this.#pending.keys()) this.#settle(id, /* @__PURE__ */ new Error("MCP transport closed"), true);
+		if (announced) this.#emitter.emit("disconnect");
+	}
 	#settle(id, value, failed) {
 		const pending = this.#pending.get(id);
 		if (pending === void 0) return;
 		this.#pending.delete(id);
 		if (pending.deadline !== void 0 && pending.timeout !== void 0) pending.deadline.removeEventListener("abort", pending.timeout);
 		if (pending.signal !== void 0 && pending.abort !== void 0) pending.signal.removeEventListener("abort", pending.abort);
-		if (failed) pending.reject(value);
-		else pending.resolve(value);
+		const subscription = pending.subscription;
+		if (subscription !== void 0) {
+			const waiter = subscription.waiter;
+			delete subscription.waiter;
+			if (failed) {
+				subscription.queue.length = 0;
+				if (waiter === void 0) subscription.failure = { reason: value };
+				else waiter.reject(value);
+			} else if (isMCPSubscriptionResult(value)) {
+				if (waiter === void 0) subscription.terminal = value;
+				else waiter.resolve(value);
+			}
+			return;
+		}
+		if (failed) pending.reject?.(value);
+		else pending.resolve?.(value);
 	}
 };
 //#endregion
@@ -4915,13 +5466,14 @@ 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},
-* runs the `initialize` handshake, and exposes the server's tools as local
+* 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.
 *
 * @remarks
 * The egress mirror of {@link createMCPServer}: where the server exposes a local tool
-* registry over MCP, the client USES a remote server's tools. `connect()` handshakes,
-* validates and exposes the negotiated protocol, `tools()` lists + wraps the remote
+* registry over MCP, the client USES a remote server's tools. `connect()` discovers,
+* validates, and exposes the negotiated modern protocol; a legacy peer requires
+* {@link createMCPLegacyClientTransport}. `tools()` lists + wraps the remote
 * tools (each `execute` calls back over the wire),
 * and `call(name, args)` runs a remote `tools/call` (a remote tool failure throws
 * locally, so an agent's {@link import('@orkestrel/tool').ToolManagerInterface}
@@ -4951,6 +5503,24 @@ function createMCPClient(options) {
 	return new MCPClient(options);
 }
 /**
+* Decorates one client transport with explicit legacy handshake and era translation.
+*
+* @param transport - The transport connected to a legacy MCP peer
+* @param options - Optional legacy handshake identity, capabilities, revision, and deadline
+* @returns A modern-facing client transport over the legacy peer
+*
+* @example
+* ```ts
+* const transport = createMCPLegacyClientTransport(legacyTransport)
+* const client = createMCPClient({ transport })
+* await client.connect()
+* client.version // '2026-07-28'
+* ```
+*/
+function createMCPLegacyClientTransport(transport, options) {
+	return new MCPLegacyClientTransport(transport, options);
+}
+/**
 * Adapts an {@link MCPTransportInterface} (the environment-agnostic duplex message
 * channel) into a {@link MCPClientTransportInterface} — the additive bridge that lets
 * `createMCPClient` run over the new port without any change to `MCPClient`'s
@@ -5004,6 +5574,7 @@ exports.DEFAULT_MCP_CLIENT_NAME = DEFAULT_MCP_CLIENT_NAME;
 exports.DEFAULT_MCP_CLIENT_VERSION = DEFAULT_MCP_CLIENT_VERSION;
 exports.DEFAULT_MCP_LIMITS = DEFAULT_MCP_LIMITS;
 exports.DEFAULT_MCP_REQUEST_TIMEOUT = DEFAULT_MCP_REQUEST_TIMEOUT;
+exports.DEFAULT_MCP_SUBSCRIPTION_CAPACITY = DEFAULT_MCP_SUBSCRIPTION_CAPACITY;
 exports.EMPTY_MCP_ARGUMENTS = EMPTY_MCP_ARGUMENTS;
 exports.JSONRPC_INTERNAL_ERROR = JSONRPC_INTERNAL_ERROR;
 exports.JSONRPC_INVALID_PARAMS = JSONRPC_INVALID_PARAMS;
@@ -5014,6 +5585,7 @@ exports.JSONRPC_SERVER_ERROR = JSONRPC_SERVER_ERROR;
 exports.MCPClient = MCPClient;
 exports.MCPError = MCPError;
 exports.MCPLegacy = MCPLegacy;
+exports.MCPLegacyClientTransport = MCPLegacyClientTransport;
 exports.MCPMethodManager = MCPMethodManager;
 exports.MCPProgressReporter = MCPProgressReporter;
 exports.MCPServer = MCPServer;
@@ -5021,8 +5593,9 @@ exports.MCPStreamController = MCPStreamController;
 exports.MCPTaskClient = MCPTaskClient;
 exports.MCPTextStreamController = MCPTextStreamController;
 exports.MCP_EXTENSION_TASKS = MCP_EXTENSION_TASKS;
+exports.MCP_FALLBACK_VERSION = MCP_FALLBACK_VERSION;
+exports.MCP_HANDSHAKE_VERSION = MCP_HANDSHAKE_VERSION;
 exports.MCP_HEADER_MISMATCH = MCP_HEADER_MISMATCH;
-exports.MCP_LEGACY_VERSION = MCP_LEGACY_VERSION;
 exports.MCP_META_CAPABILITIES = MCP_META_CAPABILITIES;
 exports.MCP_META_CLIENT = MCP_META_CLIENT;
 exports.MCP_META_SERVER = MCP_META_SERVER;
@@ -5030,9 +5603,10 @@ exports.MCP_META_SUBSCRIPTION = MCP_META_SUBSCRIPTION;
 exports.MCP_META_VERSION = MCP_META_VERSION;
 exports.MCP_MISSING_CAPABILITY = MCP_MISSING_CAPABILITY;
 exports.MCP_MODERN_VERSION = MCP_MODERN_VERSION;
-exports.MCP_PROTOCOL_VERSION = MCP_PROTOCOL_VERSION;
 exports.MCP_UNSUPPORTED_VERSION = MCP_UNSUPPORTED_VERSION;
-exports.SUPPORTED_PROTOCOL_VERSIONS = SUPPORTED_PROTOCOL_VERSIONS;
+exports.SUPPORTED_LEGACY_PROTOCOL_VERSIONS = SUPPORTED_LEGACY_PROTOCOL_VERSIONS;
+exports.SUPPORTED_MCP_VERSIONS = SUPPORTED_MCP_VERSIONS;
+exports.SUPPORTED_MODERN_PROTOCOL_VERSIONS = SUPPORTED_MODERN_PROTOCOL_VERSIONS;
 exports.bindClient = bindClient;
 exports.bindServer = bindServer;
 exports.buildCallOutcome = buildCallOutcome;
@@ -5052,6 +5626,7 @@ exports.buildToolDescriptors = buildToolDescriptors;
 exports.createDuplexClientTransport = createDuplexClientTransport;
 exports.createMCPClient = createMCPClient;
 exports.createMCPLegacy = createMCPLegacy;
+exports.createMCPLegacyClientTransport = createMCPLegacyClientTransport;
 exports.createMCPServer = createMCPServer;
 exports.decodeBoundedMessage = decodeBoundedMessage;
 exports.digestJSON = digestJSON;
@@ -5097,9 +5672,12 @@ exports.isMCPInputRequest = isMCPInputRequest;
 exports.isMCPInputRequestMap = isMCPInputRequestMap;
 exports.isMCPInputResult = isMCPInputResult;
 exports.isMCPLegacyResult = isMCPLegacyResult;
+exports.isMCPLegacyVersion = isMCPLegacyVersion;
 exports.isMCPLoggingLevel = isMCPLoggingLevel;
 exports.isMCPMetaKey = isMCPMetaKey;
 exports.isMCPMetaObject = isMCPMetaObject;
+exports.isMCPModernVersion = isMCPModernVersion;
+exports.isMCPNotificationMetaObject = isMCPNotificationMetaObject;
 exports.isMCPPaginationParams = isMCPPaginationParams;
 exports.isMCPProgress = isMCPProgress;
 exports.isMCPPrompt = isMCPPrompt;
@@ -5117,7 +5695,10 @@ exports.isMCPResultMetaObject = isMCPResultMetaObject;
 exports.isMCPServerCapabilities = isMCPServerCapabilities;
 exports.isMCPStringArguments = isMCPStringArguments;
 exports.isMCPSubscriptionFilter = isMCPSubscriptionFilter;
+exports.isMCPSubscriptionResult = isMCPSubscriptionResult;
 exports.isMCPTaskDetail = isMCPTaskDetail;
+exports.isMCPTaskDetailResult = isMCPTaskDetailResult;
+exports.isMCPTaskNotification = isMCPTaskNotification;
 exports.isMCPTaskResult = isMCPTaskResult;
 exports.isMCPTaskStatus = isMCPTaskStatus;
 exports.isMCPTextResource = isMCPTextResource;
@@ -5127,8 +5708,12 @@ exports.isRFC3339Date = isRFC3339Date;
 exports.isRFC3339DateTime = isRFC3339DateTime;
 exports.isStandardBase64 = isStandardBase64;
 exports.isTaskSupported = isTaskSupported;
+exports.legacyInvocationToModern = legacyInvocationToModern;
+exports.legacyResultToModern = legacyResultToModern;
 exports.matchesResultType = matchesResultType;
 exports.matchesSubscriptionNotification = matchesSubscriptionNotification;
+exports.modernInvocationToLegacy = modernInvocationToLegacy;
+exports.modernResultToLegacy = modernResultToLegacy;
 exports.parseJSONRPCMessage = parseJSONRPCMessage;
 exports.parseMCPInputState = parseMCPInputState;
 exports.parseRequestContext = parseRequestContext;