@code-yeongyu/senpi 2026.10.25-1 → 2026.10.25-3

package/dist/core/extensions/builtin/mcp/modern/request.js

@@ -0,0 +1,292 @@
+import { beginLegacyMcpOperation, physicalMcpClient, takeMcpRequestOrigin, } from "../request-origin.js";
+import { AuthError } from "../errors.js";
+import { loadMcpSdkTypes, loadMcpSdkZodCompat } from "../sdk.lazy.js";
+import { mcpElapsedClock } from "../wrap.js";
+import { collectMrtrForm } from "./elicitation.js";
+import { isRecord, validateMrtrForm } from "./form-schema.js";
+import { McpMrtrError } from "./errors.js";
+import { queuedForm } from "./consent-queue.js";
+import { parseInputs } from "./inputs.js";
+export const MAX_MCP_MRTR_ROUNDS = 8;
+const capableMethods = new Set(["tools/call", "resources/read", "prompts/get"]);
+const capabilitiesKey = "io.modelcontextprotocol/clientCapabilities";
+/** Local dispatch guard survives SDK object spreads but is never JSON serialized. */
+export const modernDispatchGuard = Symbol("mcp-modern-dispatch");
+const states = new WeakMap();
+export const isModernMcpClient = (client) => states.get(physicalMcpClient(client))?.version !== undefined;
+export const legacyMcpFormsAdvertised = (client) => states.get(physicalMcpClient(client))?.legacyFormEligible;
+const own = (value, key) => Object.hasOwn(value, key);
+const byteSize = (value) => Buffer.byteLength(JSON.stringify(value), "utf8");
+export function getModernDispatchGuard(params) {
+    return isRecord(params)
+        ? params[modernDispatchGuard]
+        : undefined;
+}
+/** One instance-local adapter. Captured SDK requests retain ID allocation and final output-schema validation. */
+export function installModernRequestAdapter(client, protocol, clock = mcpElapsedClock, readCredential = () => undefined) {
+    const sdkRequest = client.request.bind(client);
+    states.set(client, protocol);
+    const requestWithMrtr = async (request, schema, options) => {
+        if (request.method === "initialize")
+            return sdkRequest(request, schema, options);
+        const { origin, sdkOptions } = takeMcpRequestOrigin(options, client);
+        if (protocol.version === undefined) {
+            const end = request.method === "tools/call" && origin
+                ? beginLegacyMcpOperation(client, origin, sdkOptions.signal)
+                : undefined;
+            try {
+                return await sdkRequest(request, schema, sdkOptions);
+            }
+            finally {
+                end?.();
+            }
+        }
+        if (own(request.params ?? {}, "requestState") || own(request.params ?? {}, "inputResponses") || options?.task)
+            throw new McpMrtrError("MCP_MRTR_INVALID_INPUT");
+        const params = structuredClone(request.params ?? {});
+        const start = clock.now();
+        const timeout = sdkOptions.timeout ?? 60_000;
+        const duration = Math.min(sdkOptions.maxTotalTimeout ?? Infinity, 9 * timeout + 300_000);
+        const deadline = start + duration;
+        const operation = new AbortController();
+        const credential = readCredential();
+        let authority;
+        let authorityCaptured = false;
+        const controller = origin?.connection;
+        const generation = controller?.generation;
+        let presentationLost = origin?.presentation === undefined || origin.presentation.signal.aborted;
+        let consentSpent = 0;
+        let continuation = {};
+        let failure;
+        const stop = (code) => {
+            failure ??= new McpMrtrError(code);
+            operation.abort(failure);
+        };
+        const onCallerAbort = () => stop("MCP_MRTR_CANCELLED");
+        const onOwnerAbort = () => stop("MCP_MRTR_CONTEXT_CHANGED");
+        const onPresentationLost = () => {
+            presentationLost = true;
+        };
+        const check = () => {
+            if (clock.now() >= deadline)
+                stop("MCP_MRTR_TIMEOUT");
+            if (origin &&
+                (!origin.isCurrent() ||
+                    origin.signal.aborted ||
+                    controller?.generation !== generation ||
+                    controller?.state !== "connected"))
+                stop("MCP_MRTR_CONTEXT_CHANGED");
+            if (failure)
+                throw failure;
+        };
+        const resolveAuthority = async () => {
+            check();
+            if (origin) {
+                await origin.privateForm?.synchronize?.();
+                const snapshot = JSON.stringify(await interrupted(origin.resolveAuthority(operation.signal), operation.signal));
+                if (!authorityCaptured) {
+                    authority = snapshot;
+                    authorityCaptured = true;
+                }
+                else if (authority !== snapshot)
+                    stop("MCP_MRTR_CONTEXT_CHANGED");
+            }
+            check();
+        };
+        const off = controller?.onStateChange(() => {
+            try {
+                check();
+            }
+            catch {
+                /* Abort reaches the active attempt and consent. */
+            }
+        });
+        sdkOptions.signal?.addEventListener("abort", onCallerAbort, { once: true });
+        origin?.signal.addEventListener("abort", onOwnerAbort, { once: true });
+        origin?.presentation?.signal.addEventListener("abort", onPresentationLost, { once: true });
+        const timer = clock.schedule(() => stop("MCP_MRTR_TIMEOUT"), Math.max(0, duration));
+        if (sdkOptions.signal?.aborted)
+            onCallerAbort();
+        if (origin?.signal.aborted)
+            onOwnerAbort();
+        try {
+            const { safeParse } = await interrupted(loadMcpSdkZodCompat(), operation.signal);
+            // Use the SDK's own Zod identity, including when npm installs another copy for this package.
+            const { ResultSchema } = await interrupted(loadMcpSdkTypes(), operation.signal);
+            for (let round = 0;; round++) {
+                await resolveAuthority();
+                const remaining = deadline - clock.now();
+                const attempt = new AbortController();
+                const forward = () => attempt.abort("MCP request canceled");
+                operation.signal.addEventListener("abort", forward, { once: true });
+                const metadata = isRecord(params._meta) ? params._meta : {};
+                const capabilities = origin?.privateFormsEnforced
+                    ? origin.privateForm?.ready()
+                        ? { elicitation: {} }
+                        : {}
+                    : !presentationLost && origin?.presentation
+                        ? { elicitation: {} }
+                        : {};
+                const outgoing = {
+                    ...params,
+                    ...continuation,
+                    _meta: { ...metadata, [capabilitiesKey]: capabilities },
+                    [modernDispatchGuard]: (snapshot) => {
+                        check();
+                        if ((snapshot ?? readCredential()) !== credential)
+                            throw new McpMrtrError("MCP_MRTR_CONTEXT_CHANGED");
+                    },
+                };
+                let result;
+                try {
+                    check();
+                    result = await sdkRequest({ method: request.method, params: outgoing }, ResultSchema, {
+                        ...sdkOptions,
+                        signal: attempt.signal,
+                        timeout: Math.min(timeout, remaining),
+                        maxTotalTimeout: remaining,
+                        onprogress: sdkOptions.onprogress
+                            ? (progress) => {
+                                check();
+                                if (!Number.isFinite(progress.progress) ||
+                                    (progress.total !== undefined && !Number.isFinite(progress.total)))
+                                    return;
+                                sdkOptions.onprogress?.({
+                                    progress: progress.progress,
+                                    ...(progress.total === undefined ? {} : { total: progress.total }),
+                                });
+                            }
+                            : undefined,
+                    });
+                }
+                finally {
+                    operation.signal.removeEventListener("abort", forward);
+                }
+                check();
+                const type = own(result, "resultType") ? result.resultType : "complete";
+                if (type === "complete") {
+                    if (["requestState", "inputRequests", "inputResponses"].some((key) => own(result, key)))
+                        throw new McpMrtrError("MCP_MRTR_INVALID_RESULT");
+                    const parsed = safeParse(schema, result);
+                    if (!parsed.success)
+                        throw new McpMrtrError("MCP_MRTR_INVALID_RESULT");
+                    return parsed.data;
+                }
+                if (type !== "input_required" || !capableMethods.has(request.method))
+                    throw new McpMrtrError("MCP_MRTR_INVALID_RESULT");
+                if (round >= MAX_MCP_MRTR_ROUNDS)
+                    throw new McpMrtrError("MCP_MRTR_ROUND_LIMIT");
+                const inputs = parseInputs(result);
+                continuation = own(result, "requestState") ? { requestState: result.requestState } : {};
+                if (inputs) {
+                    const responses = Object.create(null);
+                    let cancelled = false;
+                    for (const [key, input] of inputs) {
+                        await resolveAuthority();
+                        if (input.params.mode === "url") {
+                            throw new McpMrtrError("MCP_MRTR_UNSUPPORTED_INPUT");
+                        }
+                        else if (cancelled) {
+                            // A human stopped this batch, not necessarily the caller's AbortSignal.
+                            // Keep the cancellation code; never fabricate results for unshown inputs.
+                            throw new McpMrtrError("MCP_MRTR_CANCELLED");
+                        }
+                        else if (consentSpent >= 300_000) {
+                            throw new McpMrtrError("MCP_MRTR_PROCESSING_UNAVAILABLE");
+                        }
+                        else if (origin?.privateFormsEnforced) {
+                            const presenter = origin.privateForm;
+                            const schema = input.params.requestedSchema;
+                            if (!presenter?.ready() || !validateMrtrForm(schema))
+                                throw new McpMrtrError("MCP_MRTR_PROCESSING_UNAVAILABLE");
+                            const began = clock.now();
+                            const outcome = await presenter.present({
+                                operationId: String(start),
+                                inputId: key,
+                                round,
+                                server: { label: origin.serverLabel, source: origin.serverSource ?? "user" },
+                                message: input.params.message,
+                                schema,
+                                operationSignal: operation.signal,
+                                presentationSignal: presenter.signal,
+                                deadlineMs: Math.max(0, 300_000 - consentSpent),
+                            });
+                            consentSpent += clock.now() - began;
+                            check();
+                            if (outcome.kind !== "result")
+                                throw new McpMrtrError(outcome.kind === "operation_aborted"
+                                    ? "MCP_MRTR_CANCELLED"
+                                    : "MCP_MRTR_PROCESSING_UNAVAILABLE");
+                            responses[key] = outcome.result;
+                            cancelled = outcome.result.action !== "accept";
+                        }
+                        else if (presentationLost || !origin?.presentation) {
+                            throw new McpMrtrError("MCP_MRTR_PROCESSING_UNAVAILABLE");
+                        }
+                        else {
+                            const consent = new AbortController();
+                            const began = clock.now();
+                            const consentTimer = clock.schedule(() => consent.abort(), Math.max(0, 300_000 - consentSpent));
+                            const signal = AbortSignal.any([operation.signal, origin.presentation.signal, consent.signal]);
+                            let presented = false;
+                            try {
+                                const answer = await interrupted(queuedForm(origin.binding, signal, () => {
+                                    presented = true;
+                                    return collectMrtrForm(origin.presentation, origin.serverLabel, { message: input.params.message, requestedSchema: input.params.requestedSchema }, signal);
+                                }), operation.signal);
+                                check();
+                                if (!presented)
+                                    throw new McpMrtrError("MCP_MRTR_PROCESSING_UNAVAILABLE");
+                                responses[key] = answer;
+                                cancelled = answer.action !== "accept";
+                            }
+                            finally {
+                                consentSpent += clock.now() - began;
+                                clock.cancel(consentTimer);
+                                consent.abort();
+                            }
+                        }
+                    }
+                    if (byteSize(responses) > 512 * 1024)
+                        throw new McpMrtrError("MCP_MRTR_INPUT_LIMIT");
+                    continuation.inputResponses = responses;
+                }
+            }
+        }
+        catch (error) {
+            check();
+            if (error instanceof McpMrtrError)
+                throw error;
+            if (error instanceof AuthError)
+                throw error;
+            const remoteCode = isRecord(error) && typeof error.code === "number" ? error.code : undefined;
+            throw new McpMrtrError("MCP_MRTR_TRANSPORT_FAILED", remoteCode);
+        }
+        finally {
+            continuation = {};
+            clock.cancel(timer);
+            off?.();
+            sdkOptions.signal?.removeEventListener("abort", onCallerAbort);
+            origin?.signal.removeEventListener("abort", onOwnerAbort);
+            origin?.presentation?.signal.removeEventListener("abort", onPresentationLost);
+        }
+    };
+    // Preserve the SDK method itself until negotiation positively selects modern.
+    protocol.activateRequests = () => {
+        client.request = requestWithMrtr;
+    };
+    // Default legacy clients retain the SDK method and its original admission behavior.
+    // Enforced legacy calls need private operation ownership before the first tools/call.
+    if (protocol.privateForms || protocol.version !== undefined)
+        protocol.activateRequests();
+}
+function interrupted(work, signal) {
+    return new Promise((resolve, reject) => {
+        const onabort = () => reject(signal.reason);
+        signal.addEventListener("abort", onabort, { once: true });
+        if (signal.aborted)
+            onabort();
+        void work.then(resolve, reject).finally(() => signal.removeEventListener("abort", onabort));
+    });
+}
+//# sourceMappingURL=request.js.map

package/dist/core/extensions/builtin/mcp/modern/stdio-probe.d.ts

@@ -10,5 +10,5 @@ export declare const STDIO_PROBE_MS = 2000;
  * keeps the same process for the legacy handshake; a discovery reply that arrives late still upgrades it to modern.
  * Only a child that exited or wrote non-JSON to stdout is replaced by a fresh process for the legacy handshake.
  */
-export declare function probeStdioTransport(transport: Transport, options: ProbeOptions, logger: McpLogger, timeoutMs: number, serverName: string, onModern?: (version: string) => void, probeMs?: number): void;
+export declare function probeStdioTransport(transport: Transport, options: ProbeOptions, logger: McpLogger, timeoutMs: number, serverName: string, onModern?: (version: string) => void, probeMs?: number, onLegacy?: () => void): void;
 //# sourceMappingURL=stdio-probe.d.ts.map

package/dist/core/extensions/builtin/mcp/modern/stdio-probe.js

@@ -3,6 +3,9 @@ import { reapProcessTree } from "../process-tree.js";
 import { discoveryReply, probeStdioEra, STDIO_PROBE_ID, StdioProbeSilence, } from "./era.js";
 import { modernInitializeResult, normalizeModernResult } from "./sdk-bridge.js";
 import { ModernTransportError } from "./transport.js";
+import { sanitizeModernMessage } from "./diagnostics.js";
+import { McpMrtrError } from "./errors.js";
+import { getModernDispatchGuard } from "./request.js";
 import { MODERN_PROTOCOL_VERSION, modernizeRequest } from "./wire.js";
 /** How long a stdio child gets to answer discovery (at most a quarter of the connect timeout) before it is treated as legacy. */
 export const STDIO_PROBE_MS = 2_000;
@@ -13,7 +16,7 @@ export const STDIO_PROBE_MS = 2_000;
  * keeps the same process for the legacy handshake; a discovery reply that arrives late still upgrades it to modern.
  * Only a child that exited or wrote non-JSON to stdout is replaced by a fresh process for the legacy handshake.
  */
-export function probeStdioTransport(transport, options, logger, timeoutMs, serverName, onModern, probeMs = STDIO_PROBE_MS) {
+export function probeStdioTransport(transport, options, logger, timeoutMs, serverName, onModern, probeMs = STDIO_PROBE_MS, onLegacy) {
     const start = transport.start.bind(transport);
     const close = transport.close.bind(transport);
     const send = transport.send.bind(transport);
@@ -31,6 +34,8 @@ export function probeStdioTransport(transport, options, logger, timeoutMs, serve
                 await restart();
             else if (outcome.silent)
                 awaitLateDiscovery();
+            if (!outcome.silent)
+                onLegacy?.();
             return;
         }
         if (outcome.kind === "indeterminate" || !outcome.discovery) {
@@ -161,8 +166,10 @@ export function probeStdioTransport(transport, options, logger, timeoutMs, serve
                 }, extra);
                 return;
             }
-            if (isInitializeReply)
+            if (isInitializeReply) {
                 settle();
+                onLegacy?.();
+            }
             deliver?.(message, extra);
         };
         transport.send = async (message, sendOptions) => {
@@ -178,8 +185,34 @@ export function probeStdioTransport(transport, options, logger, timeoutMs, serve
     function speakModern(discovery, version) {
         const initializeResult = modernInitializeResult(discovery, version);
         const deliver = transport.onmessage;
+        const live = new Set();
         let initialized = false;
-        transport.onmessage = (message, extra) => deliver?.(normalizeModernResult(message), extra);
+        transport.onerror = () => {
+            // A parser error may quote a wire body; never forward it.
+            const failure = new McpMrtrError("MCP_MRTR_TRANSPORT_FAILED");
+            logger.warn(failure.message);
+            void transport.close();
+        };
+        transport.onmessage = (message, extra) => {
+            if ("id" in message && "method" in message) {
+                void send({
+                    jsonrpc: "2.0",
+                    id: message.id,
+                    error: { code: -32601, message: "Unsupported MCP method." },
+                }).catch(() => { });
+                return;
+            }
+            if ("id" in message && message.id !== undefined && !live.delete(message.id))
+                return;
+            if ("method" in message && message.method === "notifications/progress") {
+                const token = message.params?.progressToken;
+                if ((typeof token !== "string" && typeof token !== "number") || !live.has(token))
+                    return;
+            }
+            const safe = sanitizeModernMessage(message);
+            if (safe)
+                deliver?.(normalizeModernResult(safe), extra);
+        };
         transport.send = async (message, sendOptions) => {
             if (!("method" in message))
                 return send(message, sendOptions);
@@ -188,14 +221,29 @@ export function probeStdioTransport(transport, options, logger, timeoutMs, serve
                     throw new ModernTransportError("Modern MCP stdio has already initialized");
                 }
                 initialized = true;
-                transport.onmessage?.({ jsonrpc: "2.0", id: message.id, result: initializeResult });
+                deliver?.({ jsonrpc: "2.0", id: message.id, result: initializeResult });
                 return;
             }
             if (message.method === "notifications/initialized" && !("id" in message))
                 return;
+            if (message.method === "notifications/cancelled" && !("id" in message)) {
+                const id = message.params?.requestId;
+                if ((typeof id !== "string" && typeof id !== "number") || !live.delete(id))
+                    return;
+                return send({ jsonrpc: "2.0", method: message.method, params: { requestId: id, reason: "MCP request canceled" } }, sendOptions);
+            }
+            getModernDispatchGuard(message.params)?.();
             const request = modernizeRequest("id" in message ? message.id : 0, message.method, options.clientInfo, options.clientCapabilities, version, message.params);
-            if ("id" in message)
-                return send(request, sendOptions);
+            if ("id" in message) {
+                live.add(message.id);
+                try {
+                    return await send(request, sendOptions);
+                }
+                catch {
+                    live.delete(message.id);
+                    throw new McpMrtrError("MCP_MRTR_TRANSPORT_FAILED");
+                }
+            }
             const { id: _id, ...notification } = request;
             return send(notification, sendOptions);
         };

package/dist/core/extensions/builtin/mcp/modern/transport.js

@@ -1,5 +1,10 @@
 import { JSONRPCMessageSchema } from "@modelcontextprotocol/sdk/types.js";
 import { deriveModernHeaders, MODERN_PROTOCOL_VERSION, modernizeRequest } from "./wire.js";
+import { AuthError } from "../errors.js";
+import { sanitizeModernMessage } from "./diagnostics.js";
+import { McpMrtrError } from "./errors.js";
+import { getModernDispatchGuard, modernDispatchGuard } from "./request.js";
+import { clearMcpParameterHeaders, ModernParameterHeaders } from "./parameter-headers.js";
 export class ModernTransportError extends Error {
     constructor(message) {
         super(message);
@@ -10,6 +15,9 @@ export class ModernTransportError extends Error {
 export class ModernHttpTransport {
     #options;
     #abort = new AbortController();
+    #attempts = new Map();
+    #toolLists = new Map();
+    #parameterHeaders = new ModernParameterHeaders();
     #started = false;
     #closed = false;
     constructor(options) {
@@ -30,9 +38,24 @@ export class ModernHttpTransport {
     async send(message) {
         if (!this.#started || this.#closed)
             throw new ModernTransportError("Modern MCP transport is not open");
+        if ("method" in message && message.method === "notifications/cancelled") {
+            const id = message.params?.requestId;
+            if (typeof id === "string" || typeof id === "number")
+                this.#attempts.get(id)?.abort();
+            return;
+        }
+        const id = "method" in message && "id" in message ? message.id : undefined;
+        if (id !== undefined && "method" in message && message.method === "tools/list") {
+            this.#toolLists.set(id, message.params?.cursor === undefined);
+        }
+        const controller = new AbortController();
+        if (id !== undefined)
+            this.#attempts.set(id, controller);
+        const signal = AbortSignal.any([this.#abort.signal, controller.signal]);
         try {
             const version = this.#options.protocolVersion ?? MODERN_PROTOCOL_VERSION;
             const headers = new Headers(this.#options.headers);
+            clearMcpParameterHeaders(headers);
             // Auth headers pass through, but protocol routing is exclusively derived from the body.
             for (const name of ["Mcp-Session-Id", "Mcp-Name", "Mcp-Method", "MCP-Protocol-Version"])
                 headers.delete(name);
@@ -43,6 +66,9 @@ export class ModernHttpTransport {
                 const request = modernizeRequest("id" in message ? message.id : 0, message.method, this.#options.clientInfo, this.#options.clientCapabilities, version, message.params);
                 for (const [name, value] of Object.entries(deriveModernHeaders(request)))
                     headers.set(name, value);
+                if (request.method === "tools/call") {
+                    this.#parameterHeaders.append(headers, request.params.name, request.params.arguments);
+                }
                 if ("id" in message) {
                     body = request;
                 }
@@ -55,13 +81,24 @@ export class ModernHttpTransport {
                 // JSON-RPC replies have no method or params; do not turn them into requests.
                 headers.set("MCP-Protocol-Version", version);
             }
-            const response = await this.#options.fetch(this.#options.url, {
+            const guard = "method" in message ? getModernDispatchGuard(message.params) : undefined;
+            guard?.();
+            const init = {
                 method: "POST",
                 headers,
                 body: JSON.stringify(body),
-                signal: this.#abort.signal,
-            });
-            this.#abort.signal.throwIfAborted();
+                signal,
+                [modernDispatchGuard]: guard,
+            };
+            const response = await this.#options.fetch(this.#options.url, init);
+            signal.throwIfAborted();
+            if (response.status === 401 || response.status === 403) {
+                await response.body?.cancel();
+                throw new AuthError("MCP server needs authentication; use /mcp auth-start.", {
+                    phase: "auth",
+                    retriable: false,
+                });
+            }
             if (response.status === 202 || response.status === 204)
                 return;
             const mediaType = response.headers.get("Content-Type")?.split(";")[0].trim().toLowerCase();
@@ -71,35 +108,64 @@ export class ModernHttpTransport {
                 if (!response.ok && !("error" in incoming)) {
                     throw new ModernTransportError(`Modern MCP POST failed with HTTP ${response.status}`);
                 }
-                this.#abort.signal.throwIfAborted();
-                this.onmessage?.(incoming);
+                signal.throwIfAborted();
+                this.#deliver(incoming, id);
             }
             else if (response.ok && mediaType === "text/event-stream" && response.body) {
-                await this.#consumeSse(response.body, "method" in message && "id" in message ? message.id : undefined);
+                await this.#consumeSse(response.body, id, signal);
             }
             else {
                 throw new ModernTransportError(`Modern MCP POST failed with HTTP ${response.status} (${mediaType ?? "no content type"})`);
             }
         }
         catch (error) {
-            const failure = error instanceof Error ? error : new ModernTransportError(String(error));
+            const failure = error instanceof McpMrtrError || error instanceof AuthError
+                ? error
+                : new McpMrtrError("MCP_MRTR_TRANSPORT_FAILED");
             this.onerror?.(failure);
             throw failure;
         }
+        finally {
+            if (id !== undefined)
+                this.#attempts.delete(id);
+            if (id !== undefined)
+                this.#toolLists.delete(id);
+        }
+    }
+    #deliver(incoming, expected) {
+        if ("id" in incoming && (expected === undefined || incoming.id !== expected))
+            throw new McpMrtrError("MCP_MRTR_INVALID_RESULT");
+        if ("id" in incoming && "result" in incoming && this.#toolLists.has(incoming.id)) {
+            const result = incoming.result;
+            if (Array.isArray(result.tools)) {
+                incoming = {
+                    ...incoming,
+                    result: {
+                        ...result,
+                        tools: this.#parameterHeaders.filterTools(result.tools, this.#toolLists.get(incoming.id) === true),
+                    },
+                };
+            }
+        }
+        const safe = sanitizeModernMessage(incoming);
+        if (safe)
+            this.onmessage?.(safe);
     }
-    async #consumeSse(stream, requestId) {
+    async #consumeSse(stream, requestId, signal) {
         const reader = stream.getReader();
         const decoder = new TextDecoder();
         const aborted = Promise.withResolvers();
-        const onabort = () => aborted.reject(this.#abort.signal.reason);
-        this.#abort.signal.addEventListener("abort", onabort, { once: true });
+        const onabort = () => aborted.reject(signal.reason);
+        signal.addEventListener("abort", onabort, { once: true });
+        if (signal.aborted)
+            onabort();
         let buffer = "";
         let data = [];
         let event = "";
         try {
             while (true) {
                 const { value, done } = await Promise.race([reader.read(), aborted.promise]);
-                this.#abort.signal.throwIfAborted();
+                signal.throwIfAborted();
                 buffer += done ? decoder.decode() : decoder.decode(value, { stream: true });
                 while (true) {
                     const match = /[\r\n]/.exec(buffer);
@@ -114,7 +180,7 @@ export class ModernHttpTransport {
                     if (line === "") {
                         if (data.length > 0 && (event === "" || event === "message")) {
                             const incoming = JSONRPCMessageSchema.parse(JSON.parse(data.join("\n")));
-                            this.onmessage?.(incoming);
+                            this.#deliver(incoming, requestId);
                             if ("id" in incoming && !("method" in incoming) && incoming.id === requestId)
                                 return;
                         }
@@ -139,7 +205,7 @@ export class ModernHttpTransport {
             }
         }
         finally {
-            this.#abort.signal.removeEventListener("abort", onabort);
+            signal.removeEventListener("abort", onabort);
             await reader.cancel();
             reader.releaseLock();
         }

package/dist/core/extensions/builtin/mcp/modern/wire.js

@@ -1,4 +1,4 @@
-import { Buffer } from "node:buffer";
+import { encodeMcpHeaderValue } from "./parameter-headers.js";
 export const MODERN_PROTOCOL_VERSION = "2026-07-28";
 export const MODERN_ERROR_CODES = {
     HeaderMismatch: -32020,
@@ -24,9 +24,17 @@ export function buildModernRequest(id, method, clientInfo, clientCapabilities, p
 /** Rewrite an outgoing SDK request or notification into the modern wire shape at the negotiated version. */
 export function modernizeRequest(id, method, clientInfo, clientCapabilities, version, params) {
     const built = buildModernRequest(id, method, clientInfo, clientCapabilities, params);
+    const capabilities = params?._meta?.["io.modelcontextprotocol/clientCapabilities"];
     return {
         ...built,
-        params: { ...built.params, _meta: { ...built.params._meta, "io.modelcontextprotocol/protocolVersion": version } },
+        params: {
+            ...built.params,
+            _meta: {
+                ...built.params._meta,
+                "io.modelcontextprotocol/clientCapabilities": isRecord(capabilities) ? capabilities : clientCapabilities,
+                "io.modelcontextprotocol/protocolVersion": version,
+            },
+        },
     };
 }
 /** Derive protocol headers from the same request that will be serialized. */
@@ -41,11 +49,7 @@ export function deriveModernHeaders(request) {
             ? request.params.name
             : undefined;
     if (typeof name === "string") {
-        // Encode the sentinel itself too, so a literal name cannot be mistaken for encoded text.
-        headers["Mcp-Name"] =
-            /^[\x20-\x7E]*$/.test(name) && !name.startsWith("base64:")
-                ? name
-                : `base64:${Buffer.from(name, "utf8").toString("base64url")}`;
+        headers["Mcp-Name"] = encodeMcpHeaderValue(name);
     }
     return headers;
 }

package/dist/core/extensions/builtin/mcp/prompts.d.ts

@@ -1,8 +1,12 @@
-import type { ExtensionAPI } from "../../types.ts";
+import type { ExtensionAPI, ExtensionUIContext } from "../../types.ts";
 import type { McpCachedServerCatalog } from "./catalog-cache.ts";
 import type { ServerConnection } from "./connection.ts";
 import type { McpService } from "./service.ts";
+import { type McpRequestOrigin } from "./request-origin.ts";
 export interface McpPromptServer {
+    readonly ensureFresh?: () => Promise<void>;
+    readonly requestOrigin?: () => McpRequestOrigin | undefined;
+    readonly bindPresentation?: (ui: ExtensionUIContext) => void;
     readonly server: string;
     readonly connection: ServerConnection;
     readonly requestTimeoutMs?: number;

package/dist/core/extensions/builtin/mcp/prompts.js

@@ -10,6 +10,8 @@
 // last-wins, and prompts removed server-side keep a stale command until the
 // next session — invoking one surfaces the server error as a notice.
 import { createMcpLogger } from "./log.js";
+import { mcpRequestOptions } from "./request-origin.js";
+import { ensureMcpToolCallConnection } from "./health.js";
 const registeredCommandNames = new Set();
 /** Test seam: forget which commands were registered (module-level last-wins). */
 export function resetMcpPromptCommandsForTests() {
@@ -34,10 +36,13 @@ export function registerMcpPromptCommands(serviceOrPi, piOrServers, serversArg)
                 description: prompt.description ?? `MCP prompt ${prompt.name} from ${server.server}`,
                 handler: async (_args, ctx) => {
                     try {
+                        server.bindPresentation?.(ctx.ui);
                         const collected = await collectPromptArguments(prompt.arguments ?? [], ctx);
                         if (collected === undefined)
                             return;
-                        const result = await server.connection.client.getPrompt({ arguments: collected, name: prompt.name }, { timeout: server.requestTimeoutMs });
+                        if (server.requestOrigin)
+                            await ensureMcpToolCallConnection(server.connection, server.ensureFresh);
+                        const result = await server.connection.client.getPrompt({ arguments: collected, name: prompt.name }, mcpRequestOptions(server.requestOrigin?.(), { timeout: server.requestTimeoutMs }));
                         ctx.ui.setEditorText(flattenPromptMessages(result.messages));
                     }
                     catch (error) {