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

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

@@ -0,0 +1,65 @@
+import { isRecord, validateMrtrForm } from "./form-schema.js";
+import { McpMrtrError } from "./errors.js";
+const own = (value, key) => Object.hasOwn(value, key);
+const byteSize = (value) => Buffer.byteLength(JSON.stringify(value), "utf8");
+export function parseInputs(result) {
+    if (!own(result, "requestState") && !own(result, "inputRequests"))
+        throw new McpMrtrError("MCP_MRTR_INVALID_INPUT");
+    if (own(result, "requestState") && typeof result.requestState !== "string")
+        throw new McpMrtrError("MCP_MRTR_INVALID_INPUT");
+    if (byteSize(result) > 512 * 1024 ||
+        (typeof result.requestState === "string" && Buffer.byteLength(result.requestState) > 64 * 1024))
+        throw new McpMrtrError("MCP_MRTR_INPUT_LIMIT");
+    if (!own(result, "inputRequests"))
+        return undefined;
+    if (!isRecord(result.inputRequests))
+        throw new McpMrtrError("MCP_MRTR_INVALID_INPUT");
+    const entries = Object.entries(result.inputRequests);
+    if (entries.length > 32)
+        throw new McpMrtrError("MCP_MRTR_INPUT_LIMIT");
+    // Scan the complete batch before collecting anything, including unsupported capability requests.
+    for (const [, input] of entries)
+        if (isRecord(input) && ["roots/list", "sampling/createMessage"].includes(String(input.method)))
+            throw new McpMrtrError("MCP_MRTR_UNSUPPORTED_INPUT");
+    const inputs = new Map();
+    const checkStrings = (value) => {
+        if (typeof value === "string" && Buffer.byteLength(value) > 16 * 1024)
+            throw new McpMrtrError("MCP_MRTR_INPUT_LIMIT");
+        if (Array.isArray(value))
+            for (const entry of value)
+                checkStrings(entry);
+        else if (isRecord(value))
+            for (const [key, entry] of Object.entries(value)) {
+                checkStrings(key);
+                checkStrings(entry);
+            }
+    };
+    for (const [key, input] of entries) {
+        checkStrings(key);
+        if (!isRecord(input) ||
+            input.method !== "elicitation/create" ||
+            !isRecord(input.params) ||
+            typeof input.params.message !== "string")
+            throw new McpMrtrError("MCP_MRTR_INVALID_INPUT");
+        const params = input.params;
+        checkStrings(params);
+        if (params.mode === "url") {
+            if (typeof params.url !== "string" || typeof params.elicitationId !== "string")
+                throw new McpMrtrError("MCP_MRTR_INVALID_INPUT");
+            throw new McpMrtrError("MCP_MRTR_UNSUPPORTED_INPUT");
+        }
+        else {
+            if (params.mode !== undefined && params.mode !== "form")
+                throw new McpMrtrError("MCP_MRTR_INVALID_INPUT");
+            if (isRecord(params.requestedSchema) &&
+                isRecord(params.requestedSchema.properties) &&
+                Object.keys(params.requestedSchema.properties).length > 64)
+                throw new McpMrtrError("MCP_MRTR_INPUT_LIMIT");
+            if (!validateMrtrForm(params.requestedSchema))
+                throw new McpMrtrError("MCP_MRTR_INVALID_INPUT");
+        }
+        inputs.set(key, input);
+    }
+    return inputs;
+}
+//# sourceMappingURL=inputs.js.map

package/dist/core/extensions/builtin/mcp/modern/parameter-headers.d.ts

@@ -0,0 +1,11 @@
+/** RFC 9110 field values, preserving whitespace and literal sentinel strings. */
+export declare function encodeMcpHeaderValue(value: string): string;
+/** Configured headers must never supply parameter metadata absent from the request body. */
+export declare function clearMcpParameterHeaders(headers: Headers): void;
+/** Connection-local catalog: never shared with another server or transport generation. */
+export declare class ModernParameterHeaders {
+    #private;
+    filterTools(tools: readonly unknown[], firstPage: boolean): unknown[];
+    append(headers: Headers, name: unknown, args: unknown): void;
+}
+//# sourceMappingURL=parameter-headers.d.ts.map

package/dist/core/extensions/builtin/mcp/modern/parameter-headers.js

@@ -0,0 +1,109 @@
+import { Buffer } from "node:buffer";
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/** RFC 9110 field values, preserving whitespace and literal sentinel strings. */
+export function encodeMcpHeaderValue(value) {
+    return /^[\x09\x20-\x7e]*$/.test(value) &&
+        value.trim() === value &&
+        !(value.startsWith("=?base64?") && value.endsWith("?="))
+        ? value
+        : `=?base64?${Buffer.from(value, "utf8").toString("base64")}?=`;
+}
+/** Configured headers must never supply parameter metadata absent from the request body. */
+export function clearMcpParameterHeaders(headers) {
+    for (const name of [...headers.keys()]) {
+        if (name.toLowerCase().startsWith("mcp-param-"))
+            headers.delete(name);
+    }
+}
+function parseParameterHeaders(schema) {
+    const headers = [];
+    const names = new Set();
+    const visit = (node, path) => {
+        if (!isRecord(node))
+            return true;
+        if (Object.hasOwn(node, "x-mcp-header")) {
+            const name = node["x-mcp-header"];
+            const type = node.type;
+            if (!path?.length ||
+                typeof name !== "string" ||
+                !/^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/.test(name) ||
+                names.has(name.toLowerCase()) ||
+                (type !== "string" && type !== "integer" && type !== "boolean"))
+                return false;
+            names.add(name.toLowerCase());
+            headers.push({ name, path, type });
+        }
+        // Only schema-valued keywords are traversed: examples/default/const are instance data.
+        for (const [keyword, value] of Object.entries(node)) {
+            if (["properties", "patternProperties", "$defs", "definitions", "dependentSchemas", "dependencies"].includes(keyword)) {
+                if (!isRecord(value))
+                    continue;
+                for (const [key, child] of Object.entries(value)) {
+                    const childPath = keyword === "properties" && path !== undefined ? [...path, key] : undefined;
+                    if (!visit(child, childPath))
+                        return false;
+                }
+            }
+            else if ([
+                "items",
+                "prefixItems",
+                "allOf",
+                "anyOf",
+                "oneOf",
+                "additionalItems",
+                "additionalProperties",
+                "unevaluatedItems",
+                "unevaluatedProperties",
+                "contains",
+                "propertyNames",
+                "not",
+                "if",
+                "then",
+                "else",
+                "contentSchema",
+            ].includes(keyword)) {
+                for (const child of Array.isArray(value) ? value : [value]) {
+                    if (!visit(child, undefined))
+                        return false;
+                }
+            }
+        }
+        return true;
+    };
+    return visit(schema, []) ? headers : undefined;
+}
+/** Connection-local catalog: never shared with another server or transport generation. */
+export class ModernParameterHeaders {
+    #tools = new Map();
+    filterTools(tools, firstPage) {
+        if (firstPage)
+            this.#tools.clear();
+        return tools.filter((tool) => {
+            if (!isRecord(tool) || typeof tool.name !== "string")
+                return true;
+            const headers = parseParameterHeaders(tool.inputSchema);
+            if (headers === undefined) {
+                this.#tools.delete(tool.name);
+                return false;
+            }
+            this.#tools.set(tool.name, headers);
+            return true;
+        });
+    }
+    append(headers, name, args) {
+        if (typeof name !== "string")
+            return;
+        for (const parameter of this.#tools.get(name) ?? []) {
+            let value = args;
+            for (const key of parameter.path) {
+                value = isRecord(value) && Object.hasOwn(value, key) ? value[key] : undefined;
+            }
+            const valid = (parameter.type === "string" && typeof value === "string") ||
+                (parameter.type === "boolean" && typeof value === "boolean") ||
+                (parameter.type === "integer" && typeof value === "number" && Number.isSafeInteger(value));
+            if (valid)
+                headers.set(`Mcp-Param-${parameter.name}`, encodeMcpHeaderValue(String(value)));
+        }
+    }
+}
+//# sourceMappingURL=parameter-headers.js.map

package/dist/core/extensions/builtin/mcp/modern/request.d.ts

@@ -0,0 +1,20 @@
+import type { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { type McpClock } from "../wrap.ts";
+export declare const MAX_MCP_MRTR_ROUNDS = 8;
+/** Local dispatch guard survives SDK object spreads but is never JSON serialized. */
+export declare const modernDispatchGuard: unique symbol;
+export interface ModernProtocolState {
+    privateForms?: boolean;
+    legacyFormEligible?: boolean;
+    version?: string;
+    legacy?: boolean;
+    resolveStdioDiagnostics?: (modern: boolean) => void;
+    activateRequests?: () => void;
+}
+export type MrtrClock = McpClock;
+export declare const isModernMcpClient: (client: Client) => boolean;
+export declare const legacyMcpFormsAdvertised: (client: Client) => boolean | undefined;
+export declare function getModernDispatchGuard(params: unknown): ((credential?: string) => void) | undefined;
+/** One instance-local adapter. Captured SDK requests retain ID allocation and final output-schema validation. */
+export declare function installModernRequestAdapter(client: Client, protocol: ModernProtocolState, clock?: MrtrClock, readCredential?: () => string | undefined): void;
+//# sourceMappingURL=request.d.ts.map

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);
         };