@orkestrel/mcp 0.0.24 → 0.0.26

package/dist/src/core/index.d.cts

@@ -318,9 +318,11 @@ export declare function buildSubscriptionAcknowledgement(notifications: MCPSubsc
  *
  * @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
  */
-export declare function buildSubscriptionFilter(requested: MCPSubscriptionFilter, supported: MCPSubscriptionFilter): MCPSubscriptionFilter;
+export declare function buildSubscriptionFilter(requested: MCPSubscriptionFilter, supported: MCPSubscriptionFilter, enabled?: boolean): MCPSubscriptionFilter;
 
 /**
  * Builds the terminating response for a subscription source that closes gracefully.
@@ -395,13 +397,14 @@ export declare function createDuplexClientTransport(transport: MCPTransportInter
 /**
  * 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}
@@ -437,6 +440,23 @@ export declare function createMCPClient(options: MCPClientOptions): MCPClientInt
  */
 export declare function createMCPLegacy(server: MCPServerInterface): MCPDispatcherInterface;
 
+/**
+ * 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'
+ * ```
+ */
+export declare function createMCPLegacyClientTransport(transport: MCPClientTransportInterface, options?: MCPLegacyClientTransportOptions): MCPClientTransportInterface;
+
 /**
  * Creates a transport-agnostic Model Context Protocol server — exposes a live
  * {@link import('@orkestrel/tool').ToolManagerInterface} and an optional
@@ -548,6 +568,9 @@ export declare const DEFAULT_MCP_LIMITS: Readonly<{
  */
 export declare const DEFAULT_MCP_REQUEST_TIMEOUT = 30000;
 
+/** The default number of subscription frames retained while no client read is parked. */
+export declare const DEFAULT_MCP_SUBSCRIPTION_CAPACITY = 64;
+
 /**
  * Computes a lowercase host-neutral SHA-256 digest of one bounded canonical JSON value.
  *
@@ -596,9 +619,14 @@ export declare function extractContentText(result: unknown): string;
 /**
  * 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 `2026-07-28`, `'legacy'` for either supported legacy
- * revision, or `undefined` when the revision is unsupported
+ * @returns `'modern'` for a revision a bare server accepts, `'legacy'` for a revision the
+ * optional decorator accepts, or `undefined` when the revision is unsupported
  */
 export declare function inferEra(version: string): MCPEra | undefined;
 
@@ -634,12 +662,12 @@ export declare function inferEra(version: string): MCPEra | undefined;
 export declare function inferRequestVersion(message: JSONRPCMessage): string | undefined;
 
 /**
- * Infers the newest supported protocol revision present in a peer's offer.
+ * 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 offered revision, or `undefined`
+ * @returns The newest locally supported modern revision, or `undefined`
  */
-export declare function inferVersion(offered: readonly string[]): MCPVersion | undefined;
+export declare function inferVersion(offered: readonly string[]): MCPModernVersion | undefined;
 
 /**
  * Determines whether a value is one absolute URI under RFC 3986 syntax.
@@ -1190,6 +1218,14 @@ export declare function isMCPInputResult(value: unknown): value is MCPInputResul
  */
 export declare function isMCPLegacyResult(value: unknown): value is MCPLegacyResult;
 
+/**
+ * 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}
+ */
+export declare function isMCPLegacyVersion(value: unknown): value is MCPLegacyVersion;
+
 /** Determines whether a value is one dated MCP logging level. */
 export declare function isMCPLoggingLevel(value: unknown): value is MCPLoggingLevel;
 
@@ -1199,6 +1235,35 @@ export declare function isMCPMetaKey(value: unknown): value is string;
 /** Determines whether a value is exact finite MCP metadata with valid keys. */
 export declare function isMCPMetaObject(value: unknown): value is MCPMetaObject;
 
+/**
+ * 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}
+ */
+export declare function isMCPModernVersion(value: unknown): value is MCPModernVersion;
+
+/**
+ * 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
+ * ```
+ */
+export declare function isMCPNotificationMetaObject(value: unknown): value is MCPNotificationMetaObject;
+
 /**
  * Determines whether a value carries the shared optional pagination cursor.
  *
@@ -1341,16 +1406,28 @@ export declare function isMCPStringArguments(value: unknown): value is Readonly<
  * 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
  */
 export declare function isMCPSubscriptionFilter(value: unknown): value is MCPSubscriptionFilter;
 
+/**
+ * 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
+ */
+export declare function isMCPSubscriptionResult(value: unknown): value is MCPSubscriptionResult;
+
 /**
  * Determines whether a value is one durable task's full snapshot.
  *
@@ -1361,9 +1438,14 @@ export declare function isMCPSubscriptionFilter(value: unknown): value is MCPSub
  * 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}
@@ -1378,6 +1460,64 @@ export declare function isMCPSubscriptionFilter(value: unknown): value is MCPSub
  */
 export declare function isMCPTaskDetail(value: unknown): value is MCPTaskDetail;
 
+/**
+ * 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`
+ * ```
+ */
+export declare function isMCPTaskDetailResult(value: unknown): value is MCPTaskDetailResult;
+
+/**
+ * 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
+ * ```
+ */
+export declare function isMCPTaskNotification(value: unknown): value is JSONRPCNotification & {
+    readonly method: 'notifications/tasks';
+    readonly params: MCPTaskNotificationParams;
+};
+
 /**
  * Determines whether a value is a modern MCP task-creation result.
  *
@@ -1386,7 +1526,8 @@ export declare function isMCPTaskDetail(value: unknown): value is MCPTaskDetail;
  * 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
@@ -1425,7 +1566,7 @@ export declare function isMCPTextResource(value: unknown): value is MCPTextResou
  * 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}
  */
 export declare function isMCPVersion(value: unknown): value is MCPVersion;
 
@@ -1503,26 +1644,29 @@ export declare function isRFC3339DateTime(value: unknown): value is string;
 export declare function isStandardBase64(value: unknown): value is string;
 
 /**
- * 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
  * ```
  */
 export declare function isTaskSupported(value: unknown): boolean;
@@ -1677,6 +1821,28 @@ export declare interface JSONRPCResultResponse {
     readonly error?: never;
 }
 
+/**
+ * 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
+ */
+export declare function legacyInvocationToModern(request: JSONRPCRequest): JSONRPCRequest;
+
+/**
+ * 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
+ */
+export declare function legacyResultToModern(result: MCPLegacyResult, method: string, identity: MCPIdentity): MCPResult;
+
 /**
  * Determines whether one method may answer with a given modern `resultType`.
  *
@@ -1713,22 +1879,33 @@ export declare function matchesResultType(method: string, resultType: unknown):
 export declare function matchesSubscriptionNotification(notification: JSONRPCNotification, filter: MCPSubscriptionFilter): boolean;
 
 /**
- * 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.
  */
 export declare const MCP_EXTENSION_TASKS = "io.modelcontextprotocol/tasks";
 
+/** The older legacy revision the optional legacy decorator accepts and an adapter can pin. */
+export declare const MCP_FALLBACK_VERSION: MCPLegacyVersion;
+
+/**
+ * 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
+ * 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.
+ */
+export declare const MCP_HANDSHAKE_VERSION: MCPLegacyVersion;
+
 /** MCP reserved error: required HTTP metadata does not match the request body. */
 export declare const MCP_HEADER_MISMATCH = -32020;
 
-/** The legacy fallback anchor used when an initialize request cannot be accepted as modern. */
-export declare const MCP_LEGACY_VERSION: MCPVersion;
-
 /** Reserved modern `_meta` key carrying the client's open capability record. */
 export declare const MCP_META_CAPABILITIES = "io.modelcontextprotocol/clientCapabilities";
 
@@ -1754,23 +1931,13 @@ export declare const MCP_META_VERSION = "io.modelcontextprotocol/protocolVersion
  * `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.
  */
 export declare const MCP_MISSING_CAPABILITY = -32021;
 
 /** The modern revision offered by an unpinned client during discovery. */
-export declare const MCP_MODERN_VERSION: MCPVersion;
-
-/**
- * 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
- * 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.
- */
-export declare const MCP_PROTOCOL_VERSION: MCPVersion;
+export declare const MCP_MODERN_VERSION: MCPModernVersion;
 
 /** MCP reserved error: a request names an unsupported protocol revision. */
 export declare const MCP_UNSUPPORTED_VERSION = -32022;
@@ -1800,11 +1967,10 @@ export declare interface MCPBlobResource {
 }
 
 /**
- * Per-call policy for one remote `tools/call` — the caller's cancellation and its
- * progress consumer.
+ * Configures per-call policy and continuation data for one remote `tools/call`.
  *
  * @remarks
- * Both leaves are the CALLER's, and both live for exactly one request:
+ * Each option lives for exactly one request:
  *
  * - `signal` cancels THAT request and nothing else. It never closes the connection, never
  *   reaches a durable task the call may have become, and never asks the peer to undo work
@@ -1814,16 +1980,25 @@ export declare interface MCPBlobResource {
  * - `progress` receives each `notifications/progress` frame the peer publishes for this
  *   request. Supplying it is what stamps the request's progress token, so a peer only
  *   reports where a caller is listening.
+ * - `input` carries one input-required retry. Its `state` and `responses` leaves are
+ *   required together. The retry must repeat the original `name` and byte-identical
+ *   `arguments`; the client maps the leaves to the top-level `requestState` and
+ *   `inputResponses` parameters.
  *
- * Neither leaf survives the call: when the request settles — answered, refused, timed out,
- * aborted, or drained by a `disconnect` — the signal listener is removed and the progress
- * handler is dropped in the same step.
+ * No option survives the call: the continuation data is placed only on that request, and when
+ * the request settles — answered, refused, timed out, aborted, or drained by a `disconnect` —
+ * the signal listener is removed and the progress handler is dropped in the same step.
  */
 export declare interface MCPCallOptions {
     /** Cancels this one in-flight request; an already-aborted signal refuses it unsent. */
     readonly signal?: AbortSignal;
     /** Receives this request's progress frames; supplying it stamps the progress token. */
     readonly progress?: MCPProgressHandler;
+    /** Carries the protected state and responses for one input-required retry. */
+    readonly input?: {
+        readonly state: string;
+        readonly responses: Readonly<Record<string, unknown>>;
+    };
 }
 
 /**
@@ -1857,14 +2032,14 @@ export declare type MCPCallResult = MCPUnstampedCallResult & {
 
 /**
  * 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
@@ -1921,13 +2096,14 @@ export declare class MCPClient implements MCPClientInterface {
     constructor(options: MCPClientOptions);
     get emitter(): EmitterInterface<MCPClientEventMap>;
     get connected(): boolean;
-    get version(): MCPVersion | undefined;
+    get version(): MCPModernVersion | undefined;
     get transport(): MCPClientTransportInterface;
     get tasks(): MCPTaskClientInterface;
     connect(): Promise<void>;
     discover(): Promise<MCPDiscoverResult>;
     disconnect(): Promise<void>;
     tools(): Promise<readonly ToolInterface[]>;
+    listen(notifications: MCPSubscriptionFilter | undefined, options: MCPListenOptions): MCPSubscriptionStream;
     call(name: string, args: Readonly<Record<string, unknown>>, options?: MCPCallOptions): Promise<MCPCallOutcome>;
 }
 
@@ -1951,8 +2127,9 @@ export declare type MCPClientCapabilities = Readonly<Record<string, MCPMetaObjec
  * fire-and-forget observer (logging, tracing) subscribes to through `client.emitter.on`.
  *
  * @remarks
- * - `connect` — era negotiation completed and the client is connected: modern after
- *   `server/discover`, legacy after `initialize` and its notification.
+ * - `connect` — modern revision negotiation completed through `server/discover`, and the client
+ *   is connected. A legacy transport adapter presents this same modern boundary after completing
+ *   its own handshake.
  * - `disconnect` — the connection this client had announced ended (every pending request
  *   rejected, and the connection it owned on the transport closed — or that close faulted or
  *   timed out, which rejects the `disconnect` caller rather than withholding this event).
@@ -1980,14 +2157,15 @@ export declare type MCPClientEventMap = {
 /**
  * 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
+ * modern wire revision, and exposes the server's tools as local
  * {@link ToolInterface}s an agent can run.
  *
  * @remarks
  * - **The mirror of {@link MCPServerInterface}.** Where the server DISPATCHES requests
- *   over a tool registry, the client ISSUES them over a transport: `connect` probes
- *   `server/discover` first unless pinned to a legacy revision, falling back to the
- *   legacy `initialize` handshake only when the peer does not speak the modern era.
+ *   over a tool registry, the client ISSUES them over a transport: `connect` negotiates through
+ *   `server/discover`. A legacy peer requires an explicit
+ *   {@link MCPLegacyClientTransportOptions legacy transport adapter}; the bare client refuses a
+ *   peer that does not speak the modern era and names that adapter.
  *   The negotiated revision is exposed through `version`; `tools()` lists
  *   the remote tools and wraps each as a local {@link ToolInterface} whose `execute`
  *   calls back through `call`; `call(name, args)` runs a remote `tools/call` and reports
@@ -2031,14 +2209,14 @@ export declare type MCPClientEventMap = {
  */
 export declare interface MCPClientInterface {
     readonly emitter: EmitterInterface<MCPClientEventMap>;
-    /** Whether era negotiation has completed and the client is connected. */
+    /** Whether modern revision negotiation has completed and the client is connected. */
     readonly connected: boolean;
     /** The negotiated protocol revision, or `undefined` while disconnected. */
-    readonly version: MCPVersion | undefined;
+    readonly version: MCPModernVersion | undefined;
     /** The injected transport the client drives the remote server over. */
     readonly transport: MCPClientTransportInterface;
     /**
-     * The draft Tasks extension's client half — reading, answering, and stopping a durable task.
+     * The stable Tasks extension's client half — reading, answering, and stopping a durable task.
      *
      * @remarks
      * Always present, because the `tasks/*` methods are ordinary requests a client may
@@ -2049,7 +2227,7 @@ export declare interface MCPClientInterface {
     readonly tasks: MCPTaskClientInterface;
     /**
      * Connects to the remote server — opens a connection on the transport and negotiates the
-     * modern or legacy wire era without exposing that choice to the caller.
+     * modern wire revision.
      *
      * @remarks
      * Idempotent — a second `connect` while already connected is a no-op, and one issued
@@ -2062,8 +2240,8 @@ export declare interface MCPClientInterface {
      * or having outrun its deadline without ever confirming that the connection ended — closes that
      * connection FIRST, joining a close still running rather than issuing a second one, and rejects
      * with the fault if that close fails or goes unanswered again; so the transport is never opened
-     * beside a connection no path has closed. An unpinned client probes `server/discover`; a pinned legacy
-     * client and a legacy fallback run `initialize` and send `notifications/initialized`.
+     * beside a connection no path has closed. The client probes `server/discover`; an explicit legacy
+     * transport adapter owns any `initialize` handshake and presents a modern discovery result.
      * On success {@link version} contains a supported revision and the `connect` event
      * fires. Whichever side owns the open connection closes it when the attempt rejects — the
      * attempt itself, or the {@link disconnect} that superseded it — and a `close` that fails, or
@@ -2135,6 +2313,14 @@ export declare interface MCPClientInterface {
      * @returns The remote tools as local {@link ToolInterface}s, in server order
      */
     tools(): Promise<readonly ToolInterface[]>;
+    /**
+     * Listens for the remote server's matching subscription notifications.
+     *
+     * @param notifications - The requested filter, or `undefined` for an empty filter
+     * @param options - Required cancellation and optional queue-capacity policy
+     * @returns The acknowledgement and matching notifications, with the graceful result on closure
+     */
+    listen(notifications: MCPSubscriptionFilter | undefined, options: MCPListenOptions): MCPSubscriptionStream;
     /**
      * Calls a remote tool by name — runs `tools/call` and reports which permitted arm
      * the peer answered with.
@@ -2171,15 +2357,17 @@ export declare interface MCPClientInterface {
  *
  * @remarks
  * - `transport` — the carrier the client drives a remote MCP server over (REQUIRED;
- *   a concrete one from `src/server/mcp`, or an in-process loopback).
- * - `identity` — identifies the client in the `initialize` handshake (`clientInfo`);
- *   defaults to {@link import('./constants.js').DEFAULT_MCP_CLIENT_NAME} /
+ *   a concrete one from `src/server/mcp`, or an in-process loopback). The bare client negotiates
+ *   the modern revision through `server/discover`; wrap the carrier with
+ *   {@link import('./factories.js').createMCPLegacyClientTransport} for a legacy peer.
+ * - `identity` — identifies the client in modern request metadata; defaults to
+ *   {@link import('./constants.js').DEFAULT_MCP_CLIENT_NAME} /
  *   {@link import('./constants.js').DEFAULT_MCP_CLIENT_VERSION}.
  * - `capabilities` — the open client-capability record carried by every modern
- *   request; defaults to an empty record when the modern client implementation lands.
- * - `version` — an optional protocol pin; absence lets the modern client negotiate.
- * - `timeout` — the per-request deadline in milliseconds: a `tools/list` / `tools/call`
- *   / `initialize` that the server does not answer within it REJECTS (the pending
+ *   request; defaults to an empty record.
+ * - `version` — an optional modern protocol pin; absence lets `server/discover` negotiate.
+ * - `timeout` — the per-request deadline in milliseconds: a `server/discover` / `tools/list` /
+ *   `tools/call` that the server does not answer within it REJECTS (the pending
  *   request is settled by an `AbortSignal.timeout(timeout)` deadline — never a raw
  *   `setTimeout`). The same deadline bounds the client's WAIT on the transport's `close`, so a
  *   shutdown the transport accepts and never answers rejects its caller instead of wedging the
@@ -2197,11 +2385,11 @@ export declare interface MCPClientOptions {
     /** The open client-capability record carried by modern requests. */
     readonly capabilities?: MCPClientCapabilities;
     /**
-     * An optional exact protocol revision pin; absence permits negotiation. A defined pin must
-     * match the peer's negotiated revision. An unsupported runtime value throws an
+     * An optional exact modern protocol revision pin; absence permits modern negotiation. A defined
+     * pin must match the peer's discovery advertisement. An unsupported runtime value throws an
      * {@link MCPError} synchronously during construction.
      */
-    readonly version?: MCPVersion;
+    readonly version?: MCPModernVersion;
     /** The per-request deadline in milliseconds (default {@link import('./constants.js').DEFAULT_MCP_REQUEST_TIMEOUT}). */
     readonly timeout?: number;
 }
@@ -2400,7 +2588,7 @@ export declare interface MCPContinuationInterface {
 
 /** The mandatory modern `server/discover` result. */
 export declare type MCPDiscoverResult = {
-    readonly supportedVersions: readonly MCPVersion[];
+    readonly supportedVersions: readonly MCPModernVersion[];
     readonly capabilities: MCPServerCapabilities;
     readonly resultType: 'complete';
     readonly ttlMs: number;
@@ -2784,9 +2972,12 @@ export declare interface MCPJSONLimitOptions {
  * 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.
  */
 export declare class MCPLegacy implements MCPDispatcherInterface {
@@ -2805,6 +2996,70 @@ export declare class MCPLegacy implements MCPDispatcherInterface {
     handle(message: string, options?: MCPDispatchOptions): Promise<string | MCPTextStreamControllerInterface | undefined>;
 }
 
+/**
+ * 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.
+ */
+export declare class MCPLegacyClientTransport implements MCPClientTransportInterface {
+    #private;
+    /**
+     * Creates a legacy client transport adapter.
+     *
+     * @param transport - The legacy peer transport
+     * @param options - The legacy handshake identity, capabilities, revision, and deadline
+     */
+    constructor(transport: MCPClientTransportInterface, options?: MCPLegacyClientTransportOptions);
+    get emitter(): EmitterInterface<MCPClientTransportEventMap>;
+    get session(): string | undefined;
+    get duplex(): boolean;
+    start(): Promise<void>;
+    send(message: JSONRPCMessage): Promise<void>;
+    /**
+     * 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
+     */
+    close(): Promise<void>;
+}
+
+/**
+ * Options for the explicit legacy client transport adapter.
+ *
+ * @remarks
+ * - `identity` — the client identity sent through the legacy `clientInfo` field. Defaults to the
+ *   package client identity.
+ * - `capabilities` — the legacy handshake capability record. Defaults to an empty record.
+ * - `version` — an optional exact legacy handshake revision. Absence offers the newest supported
+ *   legacy revision and accepts the supported revision the peer selects.
+ * - `timeout` — the legacy handshake, handshake-write, and forwarded-request deadline in
+ *   milliseconds. Default:
+ *   {@link import('./constants.js').DEFAULT_MCP_REQUEST_TIMEOUT}.
+ *
+ * The adapter reserves JSON-RPC wire id `0` for its handshake while `start()` is waiting for
+ * the peer. Do not send unrelated id-`0` traffic through the wrapped transport in that window.
+ */
+export declare interface MCPLegacyClientTransportOptions {
+    /** The client identity sent during the legacy handshake. */
+    readonly identity?: MCPIdentity;
+    /** The client capabilities sent during the legacy handshake. */
+    readonly capabilities?: MCPClientCapabilities;
+    /** The exact legacy revision to request and require. */
+    readonly version?: MCPLegacyVersion;
+    /** The legacy handshake and forwarded-request deadline in milliseconds. */
+    readonly timeout?: number;
+}
+
 /** Construction options for the removable legacy protocol decorator. */
 export declare interface MCPLegacyOptions {
     /** The sole dispatcher and execution engine. */
@@ -2825,8 +3080,7 @@ export declare interface MCPLegacyOptions {
  * `result.resultType === undefined` narrows a {@link JSONRPCResultResponse}'s
  * `result` to the legacy arm.
  *
- * This arm exists only while `MCPServer` still carries the legacy branch, and is
- * removed with it.
+ * This arm exists only for the optional legacy server decorator and client transport adapter.
  */
 export declare interface MCPLegacyResult {
     /** Forbidden — the legacy revision has no result discriminator. */
@@ -2834,6 +3088,9 @@ export declare interface MCPLegacyResult {
     readonly [key: string]: unknown;
 }
 
+/** A legacy protocol revision supported by the optional legacy decorators. */
+export declare type MCPLegacyVersion = '2025-11-25' | '2025-06-18';
+
 /** Configurable hostile-input and live-resource bounds for an MCP server. */
 export declare interface MCPLimitOptions {
     /** Maximum UTF-8 bytes accepted by the raw string boundary. */
@@ -2852,6 +3109,14 @@ export declare interface MCPLimitOptions {
     readonly depth?: number;
 }
 
+/** Per-subscription cancellation and bounded buffering policy. */
+export declare interface MCPListenOptions {
+    /** Aborts the subscription and rejects its pending read with the signal reason. */
+    readonly signal: AbortSignal;
+    /** The maximum number of delivered frames retained while no read is parked. */
+    readonly capacity?: number;
+}
+
 /**
  * The MCP `tools/list` result — tool descriptors plus optional modern result
  * stamps.
@@ -3006,6 +3271,27 @@ export declare interface MCPMethodOptions {
     readonly caller?: unknown;
 }
 
+/** A modern protocol revision supported by the bare MCP server. */
+export declare type MCPModernVersion = '2026-07-28';
+
+/**
+ * Open notification metadata with the dated reserved subscription field.
+ *
+ * @remarks
+ * The subscription id is OPTIONAL here, and that is the schema's own split rather than
+ * this package hedging. A frame delivered down a `subscriptions/listen` stream carries the
+ * stamp naming the listen request that agreed to it; the same notification delivered any
+ * other way carries no stamp, because there is no subscription to name. A required key
+ * would refuse a frame the protocol permits.
+ *
+ * Compare {@link MCPSubscriptionResultMetaObject}, where the same key is REQUIRED: that one
+ * sits on the terminating result of a stream, so a subscription always exists to name.
+ */
+export declare type MCPNotificationMetaObject = MCPMetaObject & {
+    /** The JSON-RPC id of the `subscriptions/listen` request whose stream delivered the frame. */
+    readonly 'io.modelcontextprotocol/subscriptionId'?: JSONRPCId;
+};
+
 /** Shared cursor parameters for every paginated modern list method. */
 export declare interface MCPPaginationParams {
     /** Opaque cursor returned by the preceding page. */
@@ -3430,7 +3716,7 @@ export declare type MCPRole = 'user' | 'assistant';
  * - **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`.
@@ -3445,8 +3731,8 @@ export declare type MCPRole = 'user' | 'assistant';
  * 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.
  * ```
  */
 export declare class MCPServer implements MCPServerInterface {
@@ -3530,7 +3816,7 @@ export declare type MCPServerEventMap = {
 
 /**
  * A transport-agnostic Model Context Protocol server — dispatches JSON-RPC 2.0
- * requests (the fixed legacy methods plus the modern subscription method) over a live
+ * modern requests over a live
  * {@link ToolManagerInterface}, with NO transport coupling (a transport layer
  * pumps strings through `handle`).
  *
@@ -3657,7 +3943,7 @@ export declare interface MCPServerInterface extends MCPDispatcherInterface {
  * {@link MCPServerEventMap}, wired at construction. `input` enables modern
  * `tools/call` multi-round trips: the consumer decides when input is needed and
  * supplies principal/continuation/TTL policy, while MCP assigns the request key and
- * owns the protected wire round trip. `task` enables the draft Tasks extension: the
+ * owns the protected wire round trip. `task` enables the stable Tasks extension: the
  * consumer supplies the durable store and the deferral decision, while MCP owns the
  * capability gate and the `resultType: 'task'` answer. `limit` configures the server's
  * hostile-input and live-subscription bounds; every omitted leaf uses
@@ -3700,12 +3986,12 @@ export declare interface MCPServerOptions {
     /** Optional event-driven producer for the modern `subscriptions/listen` method. */
     readonly subscription?: MCPSubscriptionOptions;
     /**
-     * Optional draft Tasks extension; the durable store and the deferral decision are consumer-supplied.
+     * Optional Tasks extension; the durable store and the deferral decision are consumer-supplied.
      *
      * @remarks
      * Omitting it leaves every existing path untouched — nothing is advertised, no call is
-     * deferred, and `tasks/*` stays unregistered. The extension is DRAFT and carries no
-     * stability guarantee.
+     * deferred, and `tasks/*` stays unregistered. The extension is the STABLE, immutable
+     * snapshot dated 2026-07-28, so the shape this option admits is fixed.
      */
     readonly task?: MCPTaskOptions;
     /** Hostile-input and live-resource bounds; omitted leaves use secure defaults. */
@@ -3946,6 +4232,25 @@ export declare interface MCPSubscriptionFilter {
     readonly resourcesListChanged?: boolean;
     /** Receives `notifications/resources/updated` for these resource URIs. */
     readonly resourceSubscriptions?: readonly string[];
+    /**
+     * Receives `notifications/tasks` for these task identifiers.
+     *
+     * @remarks
+     * The wire placement is `params.notifications.taskIds`, beside `resourceSubscriptions`,
+     * and that placement is THIS PACKAGE'S READING rather than a settled fact: the Tasks
+     * extension declares the fragment carrying this member without composing it into the
+     * `subscriptions/listen` request, so no source states where the fragment lands. The
+     * spelling itself is the schema's and is carried verbatim under the same wire-key
+     * exemption as its siblings.
+     *
+     * The server honours the member only when a consumer configured BOTH a task manager and
+     * a subscription producer: the manager resolves each requested identifier before the
+     * acknowledgement agrees to it, and the producer is what a transition frame arrives
+     * through. Either one missing leaves nothing to deliver, so the acknowledgement omits
+     * the member. That fact is DERIVED from the two configured options at the moment the
+     * listen request is answered; no third flag records it, so it cannot drift from them.
+     */
+    readonly taskIds?: readonly string[];
 }
 
 /**
@@ -3982,6 +4287,9 @@ export declare type MCPSubscriptionResultMetaObject = MCPResultMetaObject & {
     readonly 'io.modelcontextprotocol/subscriptionId': JSONRPCId;
 };
 
+/** A client subscription's owned notifications and graceful terminal result. */
+export declare type MCPSubscriptionStream = AsyncGenerator<JSONRPCNotification, MCPSubscriptionResult, unknown>;
+
 /**
  * One durable task's wire snapshot — the payload a deferred `tools/call` answers with.
  *
@@ -4010,7 +4318,7 @@ export declare type MCPTask = {
 };
 
 /**
- * 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`.
  *
@@ -4054,7 +4362,7 @@ export declare class MCPTaskClient implements MCPTaskClientInterface {
 }
 
 /**
- * The CLIENT half of the draft Tasks extension — reading, answering, and stopping a durable
+ * The CLIENT half of the stable Tasks extension — reading, answering, and stopping a durable
  * task the peer created.
  *
  * @remarks
@@ -4073,8 +4381,11 @@ export declare class MCPTaskClient implements MCPTaskClientInterface {
  * beside it. It supplies no timer, no scheduler, no terminal-await helper, and no cache,
  * because it has no durable place to keep a task, no way to know when the application still
  * cares, and no lifetime to hang a timer on that outlives the request. Schedule the reads
- * yourself, or wait for the peer to push: an inbound task notification arrives on the client's
- * existing `notification` event at zero new mechanism.
+ * yourself, or wait for the peer to push. A task notification the server stamped for a
+ * subscription is claimed by the `listen` stream that asked for it and does not re-emit
+ * through the `MCPClientEventMap` `notification` event, so a subscribed consumer reads its
+ * transitions from the stream it opened; an unstamped notification arrives on that event at
+ * no added mechanism.
  *
  * Every method authorizes on the peer's side, so a task belonging to another principal is
  * indistinguishable from one that never existed and one whose TTL purged it — each is
@@ -4093,7 +4404,7 @@ export declare interface MCPTaskClientInterface {
      *
      * The peer's payload is carried VERBATIM once it proves well-formed. A modern result's own
      * `resultType: 'complete'` and `_meta` stamps therefore ride along on the snapshot, because
-     * rebuilding the object to drop them would also drop the unrecognized draft members this
+     * rebuilding the object to drop them would also drop the unrecognized members this
      * package deliberately preserves.
      *
      * @param id - The `taskId` to read
@@ -4202,9 +4513,12 @@ export declare interface MCPTaskContext {
  * `completed` carries the deferred call's result, `failed` carries the JSON-RPC error
  * that ended it, and `working` / `cancelled` carry nothing extra. Narrow on `status`.
  *
- * `result` is an open {@link MCPResult} rather than an {@link MCPCallResult}: only
- * `tools/call` can be deferred, but the payload is the deferred method's
- * own result and the extension says nothing that fixes it to one method forever.
+ * `result` is an OPEN RECORD rather than an {@link MCPResult} or an
+ * {@link MCPCallResult}, because the schema declares it one: a completed task's payload
+ * is whatever the deferred method answered, and the extension constrains nothing inside
+ * it — not even a `resultType`. Only `tools/call` can be deferred today, and the
+ * extension says nothing that fixes the payload to one method forever, so a reader that
+ * knows which call it deferred narrows this record with that method's own guard.
  */
 export declare type MCPTaskDetail = (MCPTask & {
     readonly status: 'working';
@@ -4213,7 +4527,7 @@ export declare type MCPTaskDetail = (MCPTask & {
     readonly inputRequests: MCPInputRequestMap;
 }) | (MCPTask & {
     readonly status: 'completed';
-    readonly result: MCPResult;
+    readonly result: Readonly<Record<string, unknown>>;
 }) | (MCPTask & {
     readonly status: 'failed';
     readonly error: JSONRPCError;
@@ -4221,6 +4535,27 @@ export declare type MCPTaskDetail = (MCPTask & {
     readonly status: 'cancelled';
 });
 
+/**
+ * The wire answer to `tasks/get` — one snapshot under the completed-result stamp.
+ *
+ * @remarks
+ * DISTINCT from {@link MCPTaskDetail}, and the distinction is the whole point. A detail is
+ * what the consumer's {@link MCPTaskManagerInterface} answers, unstamped, because a durable
+ * store knows nothing about the request that read it. This is what a `tasks/get` REPLY
+ * carries: the schema types that reply as the detail intersected with the standard result,
+ * so `resultType: 'complete'` is required rather than incidental and a peer that omits it
+ * has answered something other than the method's declared result.
+ *
+ * `complete`, not `task`. Only the creation answer ({@link MCPTaskResult}) carries
+ * `resultType: 'task'`; reading a task is an ordinary completed call whose payload happens
+ * to be a task.
+ */
+export declare type MCPTaskDetailResult = MCPTaskDetail & {
+    readonly resultType: 'complete';
+    /** Open modern protocol metadata, including reserved namespaced keys. */
+    readonly _meta?: MCPResultMetaObject;
+};
+
 /**
  * Decides whether the `tools/call` in hand becomes a durable task.
  *
@@ -4347,7 +4682,28 @@ export declare interface MCPTaskManagerInterface {
 }
 
 /**
- * Consumer policy for the server's draft Tasks extension.
+ * The parameters of a `notifications/tasks` frame — one snapshot, flat, optionally stamped
+ * with the subscription that delivered it.
+ *
+ * @remarks
+ * FLAT, and that is the schema's shape rather than a choice: the extension types these
+ * parameters as the notification envelope intersected with the detail, so every task field
+ * sits directly under `params` and no `task` wrapper member exists. Narrow on `status`
+ * exactly as with {@link MCPTaskDetail}.
+ *
+ * The index signature is the envelope's own openness, carried through. `_meta` is optional
+ * because the reserved subscription stamp is present only on a frame delivered down a
+ * `subscriptions/listen` stream and absent on one delivered any other way — see
+ * {@link MCPNotificationMetaObject}.
+ */
+export declare type MCPTaskNotificationParams = MCPTaskDetail & {
+    /** Open notification metadata, including the reserved subscription stamp. */
+    readonly _meta?: MCPNotificationMetaObject;
+    readonly [key: string]: unknown;
+};
+
+/**
+ * Consumer policy for the server's stable Tasks extension.
  *
  * @remarks
  * Supplying this is what turns the extension on: an unconfigured server advertises
@@ -4645,8 +5001,8 @@ export declare interface MCPTransportInterface {
  * `resultType`, which is the only shape the legacy revision has for one.
  * {@link MCPCallResult} is this payload plus the modern `'complete'` stamp, so
  * stamping is the one difference between the modern and legacy answers to `tools/call`.
- * Its sole producer is `MCPServer`'s legacy branch, and it is removed with that
- * branch.
+ * `MCPServer` produces it before modern stamping, and `MCPLegacy` projects the
+ * stamped answer back to this shape.
  *
  * A success carries the tool's value unchanged as `structuredContent` alongside
  * its serialized form in one `text` content block. A value-less success omits
@@ -4665,8 +5021,32 @@ export declare type MCPUnstampedCallResult = {
     readonly _meta?: MCPResultMetaObject;
 };
 
-/** A protocol revision supported by this MCP package. */
-export declare type MCPVersion = '2026-07-28' | '2025-11-25' | '2025-06-18';
+/** A protocol revision supported by an MCP package surface. */
+export declare type MCPVersion = MCPModernVersion | MCPLegacyVersion;
+
+/**
+ * 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
+ */
+export declare function modernInvocationToLegacy(invocation: JSONRPCInvocation): JSONRPCInvocation;
+
+/**
+ * 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
+ */
+export declare function modernResultToLegacy(result: MCPResult | MCPLegacyResult): MCPLegacyResult | undefined;
 
 /**
  * Narrows an already-parsed value to a {@link JSONRPCMessage}, or `undefined` when
@@ -4884,15 +5264,20 @@ export declare function snapshotToolResult(value: unknown, limits: MCPJSONLimitO
  */
 export declare function stampSubscriptionNotification(notification: JSONRPCNotification, id: JSONRPCId): JSONRPCNotification;
 
+/** The protocol revisions accepted by the optional legacy decorator. */
+export declare const SUPPORTED_LEGACY_PROTOCOL_VERSIONS: readonly MCPLegacyVersion[];
+
+/** The protocol revisions the `isMCPVersion` guard admits, spanning the modern and legacy eras. */
+export declare const SUPPORTED_MCP_VERSIONS: readonly MCPVersion[];
+
 /**
- * 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.
  */
-export declare const SUPPORTED_PROTOCOL_VERSIONS: readonly MCPVersion[];
+export declare const SUPPORTED_MODERN_PROTOCOL_VERSIONS: readonly MCPModernVersion[];
 
 export { }