@vibesdotdev/mcp 0.0.0-stage → 1.0.0-rc.1

package/dist/adapters/mcp/stdio-relay.js

@@ -0,0 +1,1169 @@
+import { loadPurposePresetOverrides } from '@vibesdotdev/tools/config/load';
+import { runtimePurposePresets, purposePresetPolicyKey } from '@vibesdotdev/tools/schemas/presets/registry';
+/**
+ * Relay a stdio MCP connection to the workspace's shared host.
+ *
+ * WHAT THIS SAVES, measured on this machine 2026-08-21:
+ *
+ *   10 `vibes dev mcp serve` processes, ALL serving one workspace, 51.3 GB
+ *   resident. Eight had byte-identical arguments. Every one had booted its own
+ *   full runtime to answer the same questions about the same files.
+ *
+ * Each client spawns its own stdio server, and each stdio server booted its
+ * own full MCP runtime, ~6 GB. Nothing was wrong with any individual decision;
+ * the cost only exists in the sum, which no single process is in a position to
+ * see.
+ *
+ * THE RELAY MUST SHORT-CIRCUIT BEFORE THE SERVE BODY. A relay that boots a
+ * runtime and then forwards has moved the work without removing it — it would
+ * look like a fix in every log line and change nothing on the memory graph.
+ *
+ * OPEN (RC02): `dev mcp serve` is a serve command, so the CLI boots its serve
+ * host through the one entry — compose and discover — BEFORE the
+ * action that calls this relay runs (rc02-rc03 §2.3). The relay still skips
+ * the adapter, session, hot-reload and indexing work, but no longer the host
+ * boot itself. Recovering that saving is a design decision (the relay is not a
+ * serve host). Relay activation is deferred by its descriptor so autonomous
+ * work belongs to the remote serving body, not to each forwarding process.
+ *
+ * TRANSPARENT PASSTHROUGH, deliberately. This bridges raw JSON-RPC messages
+ * rather than instantiating a Client/Server pair and re-implementing methods.
+ * A proxy that enumerates the methods it understands silently breaks every
+ * method added after it was written, and the failure looks like the feature
+ * simply not existing. Forwarding whole messages means new MCP methods, and
+ * capabilities this file has never heard of, work with no change here.
+ */
+import { CallToolRequestSchema, ErrorCode, InitializeRequestSchema, JSONRPCErrorSchema, ListToolsRequestSchema, ListToolsResultSchema } from '@modelcontextprotocol/sdk/types.js';
+import z from 'zod/v4';
+import { CapabilityError, CaughtFailureSchema, getRuntimeStdinEvents, isCapabilityError, revealLocalAttestation, valueFreeFailure } from '@vibesdotdev/kernel';
+import { isLifecycleDeadline, RpcConnector } from '@vibesdotdev/kernel-rpc';
+import { LOCAL_ATTESTATION_CLAIM_MISSING, readLocalAttestation } from '@vibesdotdev/secrets/attestation';
+import { mcpRelayAttestationPath, readHostClaim } from "./host-registry.js";
+import { mcpCatalogAttachKey, resolveMcpPreset } from "./tool-selection.js";
+import { connectionIdentityMeta } from "./connection-identity.js";
+import { createMcpWireNameMap, harnessNeedsSafeMcpNames, mcpWireToolName } from "./mcp-wire-name.js";
+function messageRequestId(message) {
+    return 'method' in message && 'id' in message ? message.id : undefined;
+}
+function messageResponseId(message) {
+    return 'method' in message ? undefined : message.id;
+}
+function cancellationRequestId(message) {
+    if (!('method' in message) || message.method !== 'notifications/cancelled')
+        return undefined;
+    const parsed = JSONRPCErrorSchema.shape.id.safeParse(message.params?.requestId);
+    return parsed.success ? parsed.data : undefined;
+}
+function cloneMessage(message) {
+    return structuredClone(message);
+}
+function withCancellationRequestId(message, requestId) {
+    const translated = cloneMessage(message);
+    if (!('method' in translated))
+        throw new CapabilityError('Cancellation must be a JSON-RPC notification or request', 'INVALID_INPUT');
+    translated.params = { ...translated.params, requestId };
+    return translated;
+}
+/**
+ * HTTP statuses on which the host has REFUSED one request while keeping the
+ * transport session intact. 400/401/403/404 stay "reconnect": they mean the
+ * session itself is unusable (bad session id, auth, evicted).
+ */
+const HOST_REFUSAL_STATUSES = new Set([405, 406, 409, 413, 415, 422, 429]);
+const TransportHostErrorSchema = z.object({
+    error: JSONRPCErrorSchema.shape.error,
+    id: JSONRPCErrorSchema.shape.id.optional()
+});
+/** Parse the transport's JSON refusal while retaining failed decoding. */
+function decodeHostRefusalBody(text) {
+    try {
+        const parsed = z.union([
+            TransportHostErrorSchema,
+            z.tuple([TransportHostErrorSchema]).rest(z.unknown()).transform((batch) => batch[0])
+        ]).safeParse(JSON.parse(text));
+        return { response: parsed.success ? parsed.data : null };
+    }
+    catch (cause) {
+        return { failure: CaughtFailureSchema.parse(cause) };
+    }
+}
+/** Decode the host's own error envelope, including the request it refused. */
+function readHostProtocolError(error, log) {
+    const transportFailure = z.object({ code: z.number(), message: z.string() }).safeParse(error);
+    if (!transportFailure.success)
+        return null;
+    const { code: status, message } = transportFailure.data;
+    if (!HOST_REFUSAL_STATUSES.has(status) && status !== 400)
+        return null;
+    const start = message.indexOf('{');
+    if (start < 0)
+        return null;
+    const decoded = decodeHostRefusalBody(message.slice(start));
+    if ('failure' in decoded) {
+        log.debug('host refusal body is not JSON; not classified', { failure: valueFreeFailure(decoded.failure) });
+        return null;
+    }
+    return decoded.response ? { status, ...decoded.response } : null;
+}
+/**
+ * The host is up but no longer holds this relay's HTTP session: it answered
+ * 404, the protocol's "start a new session" (a session it reclaimed), or 400
+ * "No valid session ID provided" (an id it never knew). That is not a lost
+ * host: the relay opens a fresh session, replays its state and resends the
+ * calls in flight.
+ */
+export function isHostSessionExpired(error) {
+    // The 400 envelope carries `id: null`, which the refusal decoder (request ids only) does not accept.
+    const parsed = HostSessionExpiredSchema.safeParse(error);
+    return parsed.success && (parsed.data.code === 404 || /no valid session id/i.test(parsed.data.message));
+}
+const HostSessionExpiredSchema = z.object({ code: z.union([z.literal(400), z.literal(404)]), message: z.string() });
+function requestRefusal(response, beforeInitialize) {
+    if (!response)
+        return null;
+    // A request sent before initialization has no HTTP session to invalidate.
+    // Its correlated 400 is a protocol answer; established-session 400s,
+    // authentication failures, and evicted sessions keep their loss behavior.
+    return HOST_REFUSAL_STATUSES.has(response.status) || (response.status === 400 && beforeInitialize)
+        ? response.error
+        : null;
+}
+/** The host's protocol refusal, or null when the transport session was lost. */
+export function hostRefusalFromTransportError(error, log, beforeInitialize = false) {
+    return requestRefusal(readHostProtocolError(CaughtFailureSchema.parse(error), log), beforeInitialize);
+}
+const HOST_LOSS_TEXT = {
+    restarted: {
+        error: 'The shared Vibes MCP host restarted before this request completed. Retry it.',
+        notice: 'The shared Vibes MCP host restarted; this relay is reconnecting.',
+        reason: 'host-restarted'
+    },
+    unresponsive: {
+        error: 'The shared Vibes MCP host stopped answering before this request completed; it did not restart. Retry it.',
+        notice: 'The shared Vibes MCP host stopped answering (same process, no restart); this relay is reconnecting.',
+        reason: 'host-unresponsive'
+    }
+};
+function hostLossError(id, loss) {
+    return {
+        jsonrpc: '2.0',
+        id,
+        error: {
+            code: -32000,
+            message: HOST_LOSS_TEXT[loss].error,
+            data: { retryable: true, reason: HOST_LOSS_TEXT[loss].reason }
+        }
+    };
+}
+/** {@link observeHostLoss} for a handler that must finish its loss handling: a claim read failure is returned, never thrown. */
+async function observeHostLossOrFailure(options, attached) {
+    try {
+        return { loss: await observeHostLoss(options, attached) };
+    }
+    catch (error) {
+        return { loss: 'unresponsive', error: CaughtFailureSchema.parse(error) };
+    }
+}
+/**
+ * Whether the host the relay attached to (`attached`, its claim at attach) was
+ * replaced: the advertised claim is gone or names another pid or start. With
+ * no claim at attach (an explicit host URL) a replacement cannot be observed.
+ */
+export async function observeHostLoss(options, attached) {
+    if (!attached)
+        return 'unresponsive';
+    const observed = await resolveHostUrl(options);
+    return !observed.url || observed.claim?.pid !== attached.pid || observed.claim?.startedAt !== attached.startedAt
+        ? 'restarted'
+        : 'unresponsive';
+}
+function isInitializedNotification(message) {
+    return ('method' in message ? message.method : undefined) === 'notifications/initialized';
+}
+function advertisesToolListChanges(message) {
+    if (!('result' in message))
+        return false;
+    const parsed = z.object({ capabilities: z.object({ tools: z.object({ listChanged: z.boolean().optional() }).optional() }).optional() }).safeParse(message.result);
+    return parsed.success && parsed.data.capabilities?.tools?.listChanged === true;
+}
+function isSessionBindingRequest(message) {
+    if (!('method' in message) || message.method !== 'tools/call' || message.params?.name !== 'session')
+        return false;
+    return z.union([
+        z.object({ action: z.literal('init') }),
+        z.object({ action: z.literal('status'), sessionId: z.string(), participantId: z.string() })
+    ]).safeParse(message.params.arguments).success;
+}
+function readDurableSessionBindReceipt(message) {
+    if (!('result' in message))
+        return undefined;
+    const parsed = z.object({
+        sessionId: z.string().optional(),
+        session: z.object({ id: z.string().optional() }).optional(),
+        participant: z.object({ id: z.string().optional() }).optional()
+    }).safeParse(message.result.structuredContent);
+    if (!parsed.success)
+        return undefined;
+    const structured = parsed.data;
+    const sessionId = structured?.sessionId ?? structured?.session?.id;
+    const participantId = structured?.participant?.id;
+    return sessionId !== undefined && participantId !== undefined
+        ? { sessionId, participantId }
+        : undefined;
+}
+function durableSessionRestoreRequest(receipt) {
+    return {
+        jsonrpc: '2.0',
+        id: 'replaced-by-relay',
+        method: 'tools/call',
+        params: {
+            name: 'session',
+            arguments: {
+                action: 'status',
+                sessionId: receipt.sessionId,
+                participantId: receipt.participantId,
+                receiptOnly: true
+            }
+        }
+    };
+}
+function isErrorResponse(message) {
+    return 'error' in message;
+}
+function isToolErrorResponse(message) {
+    return 'result' in message && message.result.isError === true;
+}
+function relayStateNotification(level, message) {
+    return {
+        jsonrpc: '2.0',
+        method: 'notifications/message',
+        params: { level, logger: 'vibes.shared-relay', data: message }
+    };
+}
+function toolsListChangedNotification() {
+    return { jsonrpc: '2.0', method: 'notifications/tools/list_changed' };
+}
+/**
+ * Whether the host at `mcpUrl` answers `/health` within `timeoutMs`. An
+ * unanswered or failing probe is `false`: this is a liveness sample for a
+ * pending call, never a verdict on its own (a slow event loop is not a dead
+ * host), and every non-answer is logged with its cause.
+ */
+async function probeMcpHost(lifecycle, mcpUrl, timeoutMs) {
+    const healthUrl = new URL(mcpUrl);
+    healthUrl.pathname = '/health';
+    healthUrl.search = '';
+    return await lifecycle.wait(async (signal) => {
+        const response = await fetch(healthUrl, { method: 'GET', headers: { accept: 'application/json' }, signal });
+        if (!response.ok)
+            return false;
+        const body = z.object({ ok: z.boolean() }).safeParse(await response.json());
+        return body.success && body.data.ok;
+    }, { timeoutMs, reason: 'mcp-shared-host-health-probe' });
+}
+/** A failed observation remains a sample, never proof that the host died. */
+async function healthProbeOutcome(probe) {
+    try {
+        return { healthy: await probe() };
+    }
+    catch (cause) {
+        return { healthy: false, failure: CaughtFailureSchema.parse(cause) };
+    }
+}
+/**
+ * Decide whether a host is available, WITHOUT connecting.
+ *
+ * Split out from the connect path so the decision is testable on its own — the
+ * interesting cases here (dead pid, wrong workspace, no claim) are precisely the
+ * ones that are awkward to stage against a live socket.
+ */
+/**
+ * The catalog id a client's identity resolves to, through the same resolver
+ * the host used when it wrote its claim. `undefined` when the client named no
+ * preset — it takes whatever the host serves.
+ */
+export function canonicalWantedPreset(identity, customPresets) {
+    if (identity.preset === undefined)
+        return undefined;
+    return resolveMcpPreset(identity.client, identity.preset, customPresets).presetId;
+}
+/** A host claim's catalog id in canonical form (`mcp:`-prefixed), or undefined. */
+export function canonicalServedPreset(presetId) {
+    const raw = presetId?.trim();
+    if (!raw)
+        return undefined;
+    return raw.startsWith('mcp:') || raw === 'mcp' ? raw : `mcp:${raw}`;
+}
+export async function resolveHostUrl(options) {
+    if (options.hostUrl)
+        return { relayed: false, url: options.hostUrl };
+    const lookup = await (options.lookup ?? ((root) => readHostClaim(options.runtime, root, options.roots, options.processProbe, options.logger)))(options.workspaceRoot);
+    if (lookup.status === 'none')
+        return { relayed: false, reason: 'no-host' };
+    if (lookup.status === 'stale') {
+        return { relayed: false, reason: 'stale-host', staleReason: lookup.reason, claim: lookup.claim };
+    }
+    // The host bakes ONE catalog at boot. Attaching a client that asked for a
+    // different one does not fail loudly — it hands that agent the host's tools
+    // and looks like success. Refuse, and let the caller run isolated with a
+    // reason it can state. Remove this only when the host scopes catalogs per
+    // connection; until then a match is the only case we can serve honestly.
+    //
+    // Compare CANONICAL catalog ids. The host writes the id tool-selection
+    // resolved for it (`mcp:full`); a client carries the raw flag value
+    // (`--client full` → preset `full`). Comparing those strings directly never
+    // matched, so every client booted its own ~6GB runtime while the claim said
+    // the host was serving exactly what they asked for.
+    const customPresets = runtimePurposePresets(options.runtime, await loadPurposePresetOverrides(options.runtime));
+    const wanted = canonicalWantedPreset(options.identity, customPresets);
+    const served = canonicalServedPreset(lookup.claim.presetId);
+    const wantedKey = mcpCatalogAttachKey(wanted, customPresets);
+    // New hosts advertise their selected identity. A relay cannot establish it
+    // by resolving the host's id through its own, possibly different composition.
+    let servedKey = lookup.claim.catalogAttachKey;
+    if (servedKey === undefined) {
+        if (lookup.claim.presetPolicyKey === purposePresetPolicyKey(customPresets)) {
+            servedKey = mcpCatalogAttachKey(served, customPresets);
+        }
+        else if (lookup.claim.presetPolicyKey === undefined && wantedKey === mcpCatalogAttachKey(wanted)) {
+            servedKey = mcpCatalogAttachKey(served);
+        }
+    }
+    if (wanted !== undefined && wantedKey !== servedKey) {
+        return {
+            relayed: false,
+            reason: 'identity-mismatch',
+            // `hostPreset` stays undefined when the claim carries no presetId: that
+            // host predates catalog advertising, and the message layer says so
+            // rather than inventing a catalog it disagrees with.
+            mismatch: { hostPreset: served ?? lookup.claim.presetId, wantedPreset: wanted },
+            claim: lookup.claim
+        };
+    }
+    return { relayed: false, url: lookup.url, claim: lookup.claim };
+}
+/**
+ * The `Authorization` this relay presents to the shared host it found through
+ * its claim (RC08 U7): the host start's local attestation, read fresh on every
+ * attach so a restarted host's rotated secret is picked up. No claim is no
+ * attestation (the host then verifies no identity for this connection); an
+ * insecure or invalid claim fails the attach. An explicit `hostUrl` is never
+ * sent the secret: it is not the host the claim names.
+ */
+async function relayAuthorization(options) {
+    if (options.hostUrl)
+        return undefined;
+    if (options.readAttestation)
+        return options.readAttestation();
+    const observed = await readLocalAttestation(mcpRelayAttestationPath(options.workspaceRoot, options.roots), options.runtime)
+        .then((token) => ({ token }), (cause) => ({ failure: CaughtFailureSchema.parse(cause) }));
+    if ('failure' in observed) {
+        if (isCapabilityError(observed.failure) && observed.failure.reason === LOCAL_ATTESTATION_CLAIM_MISSING)
+            return undefined;
+        throw observed.failure;
+    }
+    return `Bearer ${revealLocalAttestation(observed.token)}`;
+}
+/**
+ * The identity a relayed client asked for, as `initialize` params.
+ *
+ * The host serves many clients, and they do NOT all want the same tools — on
+ * this machine eight clients asked for `full` and one asked for `cursor`. If the
+ * relay does not carry identity, every client silently inherits whichever
+ * catalog the host happened to boot with. That is not a crash; it is an agent
+ * quietly holding the wrong tools, which is worse.
+ */
+export function relayInitializeMeta(identity) {
+    const meta = connectionIdentityMeta({
+        agentId: identity.agent, harness: identity.harness,
+        harnessSessionId: identity.harnessSessionId, agentSystemId: identity.agentSystemId,
+        projectIds: identity.projectIds, home: identity.home
+    });
+    if (identity.preset)
+        meta['vibes/preset'] = identity.preset;
+    if (identity.client)
+        meta['vibes/client'] = identity.client;
+    if (identity.toolPatterns?.length)
+        meta['vibes/tools'] = identity.toolPatterns;
+    return meta;
+}
+/** Stamp relay identity onto an outbound `initialize` request, in place. */
+export function applyRelayIdentity(message, identity) {
+    if (!('method' in message) || message.method !== 'initialize')
+        return message;
+    const candidate = message;
+    const meta = relayInitializeMeta(identity);
+    if (Object.keys(meta).length === 0)
+        return message;
+    candidate.params = candidate.params ?? {};
+    const existing = candidate.params._meta ?? {};
+    // Capability/catalog hints remain client-overridable, but the stable body
+    // identity comes from the process environment that launched this relay. A
+    // stale authored value cannot retarget durable Session custody.
+    candidate.params._meta = { ...meta, ...existing };
+    if (identity.harnessSessionId)
+        candidate.params._meta['vibes/harnessSessionId'] = identity.harnessSessionId;
+    return message;
+}
+/**
+ * Attach this process's stdio to the shared host and pipe until it closes.
+ *
+ * Returns `{relayed:false}` when there is no usable host. It NEVER throws for a
+ * missing host: it reports WHAT it found (`reason`, `staleReason`, `mismatch`,
+ * `claim`, `url`) and leaves the decision to the caller. Today that caller is
+ * `startStdioMcp`, which turns the receipt into a specific error — never a
+ * silent private runtime — so every field here is a sentence someone reads.
+ */
+export async function relayStdioToHost(options) {
+    const log = options.logger;
+    const resolved = await resolveHostUrl(options);
+    if (!resolved.url)
+        return resolved;
+    const customPresets = runtimePurposePresets(options.runtime, await loadPurposePresetOverrides(options.runtime));
+    // GUARDED. These are dynamic imports of SDK transports, and the client-side
+    // transport is used NOWHERE else in shipped code — only in tests, which are
+    // not bundled. On a compiled consumer binary there is therefore no proof the
+    // module resolves at all. An unguarded throw here would propagate out of the
+    // serve command and take down an MCP server that was perfectly capable of
+    // running isolated.
+    // Admit the EOF owner before any SDK transport can acquire a session.
+    const clientInput = options.clientInput;
+    const stdinEvents = clientInput || options.transports ? undefined : await getRuntimeStdinEvents(options.runtime);
+    let transports = options.transports;
+    if (!transports) {
+        try {
+            const [server, client] = await Promise.all([
+                import('@modelcontextprotocol/sdk/server/stdio.js'),
+                import('@modelcontextprotocol/sdk/client/streamableHttp.js')
+            ]);
+            transports = {
+                createUpstream: (url, authorization) => new client.StreamableHTTPClientTransport(url, authorization ? { requestInit: { headers: { authorization } } } : undefined),
+                createDownstream: () => new server.StdioServerTransport()
+            };
+        }
+        catch (error) {
+            const failure = CaughtFailureSchema.parse(error);
+            log.debug('relay transports unavailable', { failure: valueFreeFailure(failure) });
+            return {
+                relayed: false,
+                reason: 'transport-unavailable',
+                failure,
+                url: resolved.url,
+                claim: resolved.claim
+            };
+        }
+    }
+    const initialUpstream = transports.createUpstream(new URL(resolved.url), await relayAuthorization(options));
+    try {
+        await initialUpstream.start();
+    }
+    catch (error) {
+        const failure = CaughtFailureSchema.parse(error);
+        log.debug('relay host claim verified but the socket did not answer', { url: resolved.url, failure: valueFreeFailure(failure) });
+        const cleanup = await closeUpstream(initialUpstream).catch((cause) => CaughtFailureSchema.parse(cause));
+        const attachmentFailure = cleanup ? new AggregateError([failure, cleanup], 'The initial MCP attachment and cleanup failed.', { cause: failure }) : failure;
+        // The claim verified but the socket did not answer — the host is shutting
+        // down, or wedged. Report which process, rather than strand the client.
+        return { relayed: false, reason: 'unreachable', failure: attachmentFailure, url: resolved.url, claim: resolved.claim };
+    }
+    const downstream = transports.createDownstream();
+    let upstream = initialUpstream;
+    let upstreamUrl = new URL(resolved.url);
+    let upstreamClaim = resolved.claim;
+    /** How the host was last lost: what a request arriving mid-reconnect is told. */
+    let lastHostLoss = 'restarted';
+    /** Set while the relay re-opens a session the host evicted; calls arriving meanwhile wait on it. */
+    let reinitializing;
+    let upstreamReady = true;
+    let upstreamGeneration = 0;
+    let internalSequence = 0;
+    let hostRequestSequence = 0;
+    let initializeRequest;
+    let initializedNotification;
+    let sessionBindReceipt;
+    let bindingReceiptMissing = false;
+    let supportsToolListChanges = false;
+    let protocolInitialized = false;
+    let nameClient = options.identity.harness ?? options.identity.client;
+    let toolNames = new Map();
+    const hostRequestIdPrefix = `vibes-relay-host-${crypto.randomUUID()}-`;
+    const healthProbeIntervalMs = options.reconnect?.healthProbeIntervalMs ?? 10_000;
+    const healthProbeTimeoutMs = options.reconnect?.healthProbeTimeoutMs ?? 2_000;
+    const bindRestoreJitterWindowMs = options.reconnect?.bindRestoreJitterWindowMs ?? 60_000;
+    const recoveryRandom = options.reconnect?.random ?? Math.random;
+    const pendingClientRequests = new Map();
+    /** A failing health probe is reported once per relay, not on every interval. */
+    let probeFailureReported = false;
+    const pendingHostRequests = new Map();
+    const internalRequests = new Map();
+    const rejectInternal = (reason) => {
+        for (const waiter of internalRequests.values()) {
+            waiter.timer();
+            waiter.reject(reason);
+        }
+        internalRequests.clear();
+    };
+    const retireHostRequests = (candidate) => {
+        for (const [id, pending] of pendingHostRequests) {
+            if (pending.upstream === candidate)
+                pendingHostRequests.delete(id);
+        }
+    };
+    const isRelayHostRequestId = (id) => {
+        const parsed = z.string().safeParse(id);
+        return parsed.success && parsed.data.startsWith(hostRequestIdPrefix);
+    };
+    // Assigned at the bottom of this function, once the client pipe is watched.
+    let detachClientInputWatch = () => { };
+    /** Owns terminal settlement and failure routing for each upstream generation. */
+    class RelayFailureOwner {
+        closing = false;
+        shutdownFailure;
+        clientCancellation = new CapabilityError('The downstream MCP client disconnected.', 'CANCELLED', { reason: 'mcp-client-disconnected' });
+        signalDone = () => { };
+        signalFailed = () => { };
+        done = new Promise((resolve, reject) => {
+            this.signalDone = resolve;
+            this.signalFailed = reject;
+        });
+        generations = new WeakMap();
+        close() {
+            if (this.closing)
+                return;
+            this.closing = true;
+            detachClientInputWatch();
+            rejectInternal(this.clientCancellation);
+            for (const pending of pendingClientRequests.values())
+                pending.timer();
+            pendingClientRequests.clear();
+            pendingHostRequests.clear();
+            const current = upstream;
+            upstream = undefined;
+            upstreamUrl = undefined;
+            upstreamReady = false;
+            const connectorOwned = connector.connection;
+            const disposed = connector.dispose();
+            const upstreamClosed = current && current !== connectorOwned ? closeUpstream(current) : Promise.resolve();
+            const downstreamClosed = downstream.close();
+            void Promise.allSettled([disposed, upstreamClosed, downstreamClosed]).then((outcomes) => {
+                const failures = outcomes.flatMap((outcome) => outcome.status === 'rejected' ? [CaughtFailureSchema.parse(outcome.reason)] : [])
+                    .filter((failure) => failure !== this.clientCancellation);
+                if (this.shutdownFailure)
+                    failures.push(this.shutdownFailure);
+                if (failures.length)
+                    this.signalFailed(new AggregateError(failures, 'Closing the MCP relay failed.'));
+                else
+                    this.signalDone();
+            });
+        }
+        fail(cause) {
+            if (this.closing)
+                return;
+            this.shutdownFailure ??= cause;
+            log.warn('Closing the client relay after a transport failure', { failure: valueFreeFailure(cause) });
+            this.close();
+        }
+        bindDownstream() {
+            downstream.onerror = (cause) => this.fail(cause);
+        }
+        bindUpstream(candidate, generation, lost, expired) {
+            this.generations.set(candidate, { generation, lost, expired });
+            candidate.onerror = (cause) => this.transportFailed(candidate, cause);
+        }
+        transportFailed(candidate, cause) {
+            const registered = this.generations.get(candidate);
+            if (!registered || this.closing || upstream !== candidate || upstreamGeneration !== registered.generation)
+                return;
+            const response = readHostProtocolError(cause, log);
+            const pending = response?.id !== undefined ? pendingClientRequests.get(response.id) : undefined;
+            // The SDK reports each failed send here before rejecting the send.
+            // A correlated refusal remains with that send's client-response owner.
+            if (requestRefusal(response, pending?.beforeInitialize === true))
+                return;
+            if (isHostSessionExpired(cause))
+                registered.expired();
+            else
+                registered.lost(cause);
+        }
+    }
+    const failureOwner = new RelayFailureOwner();
+    const done = failureOwner.done;
+    const closeRelay = () => failureOwner.close();
+    const closeAfterFailure = (cause) => failureOwner.fail(cause);
+    const failInterruptedClientRequests = (loss) => {
+        for (const [id, pending] of pendingClientRequests) {
+            pending.timer();
+            void downstream.send(hostLossError(id, loss)).catch((cause) => CaughtFailureSchema.parse(cause)).then((failure) => { if (failure)
+                closeAfterFailure(failure); });
+        }
+        pendingClientRequests.clear();
+    };
+    const sendInternal = async (message) => {
+        const target = upstream;
+        if (!target)
+            throw new Error('The shared MCP host is reconnecting.');
+        const id = `vibes-relay-${++internalSequence}`;
+        const request = cloneMessage(message);
+        if (!('id' in request))
+            throw new CapabilityError('Relay initialization must carry a request id', 'INVALID_INPUT');
+        request.id = id;
+        return await new Promise((resolve, reject) => {
+            const timer = options.lifecycle.timeout(() => {
+                internalRequests.delete(id);
+                reject(new Error('The shared MCP host did not answer relay reinitialization.'));
+            }, 15_000);
+            internalRequests.set(id, { resolve, reject, timer });
+            void target.send(request).catch((cause) => CaughtFailureSchema.parse(cause)).then((error) => {
+                if (!error)
+                    return;
+                const waiter = internalRequests.get(id);
+                if (!waiter) {
+                    log.debug('Retired relay reinitialization send failed', { failure: valueFreeFailure(error) });
+                    return;
+                }
+                waiter.timer();
+                internalRequests.delete(id);
+                waiter.reject(error instanceof Error ? error : new CapabilityError('Relay reinitialization send failed.', 'UNAVAILABLE', { cause: error }));
+            });
+        });
+    };
+    const forwardHostMessage = (message, candidate, generation) => {
+        const responseId = messageResponseId(message);
+        if (responseId !== undefined) {
+            const internal = internalRequests.get(responseId);
+            if (internal) {
+                internal.timer();
+                internalRequests.delete(responseId);
+                if (isErrorResponse(message)) {
+                    internal.reject(new Error('The shared MCP host rejected relay reinitialization.'));
+                }
+                else {
+                    internal.resolve(message);
+                }
+                return;
+            }
+            const pending = pendingClientRequests.get(responseId);
+            if (pending) {
+                pending.timer();
+                pendingClientRequests.delete(responseId);
+                const request = pending.request;
+                if ('method' in request && request.method === 'tools/list' && 'result' in message && harnessNeedsSafeMcpNames(nameClient, customPresets)) {
+                    const hostResult = message.result;
+                    const project = () => {
+                        try {
+                            const list = ListToolsResultSchema.parse(hostResult);
+                            const page = ListToolsRequestSchema.parse(request);
+                            const previousNames = page.params?.cursor ? [...toolNames.values()] : [];
+                            const names = createMcpWireNameMap(new Set([...previousNames, ...list.tools.map(tool => tool.name)]), nameClient, customPresets);
+                            return { names, result: { ...hostResult, tools: list.tools.map(tool => ({ ...tool, name: mcpWireToolName(tool.name, nameClient, customPresets) })) } };
+                        }
+                        catch (cause) {
+                            return { failure: CaughtFailureSchema.parse(cause) };
+                        }
+                    };
+                    const projection = project();
+                    if ('failure' in projection) {
+                        log.error('Shared MCP host tool-name projection failed', { failure: valueFreeFailure(projection.failure) });
+                        void downstream.send({ jsonrpc: '2.0', id: responseId, error: { code: ErrorCode.InternalError, message: 'The shared MCP host advertised invalid or ambiguous tool metadata.' } })
+                            .catch((cause) => CaughtFailureSchema.parse(cause)).then((failure) => { if (failure)
+                            closeAfterFailure(failure); });
+                        return;
+                    }
+                    message = { ...message, result: projection.result };
+                    toolNames = projection.names;
+                }
+                if (('method' in request ? request.method : undefined) === 'initialize') {
+                    supportsToolListChanges = advertisesToolListChanges(message);
+                    protocolInitialized = !isErrorResponse(message);
+                }
+                if (isSessionBindingRequest(request) &&
+                    !isErrorResponse(message) &&
+                    !isToolErrorResponse(message)) {
+                    const receipt = readDurableSessionBindReceipt(message);
+                    sessionBindReceipt = receipt;
+                    bindingReceiptMissing = !receipt;
+                }
+            }
+        }
+        const requestId = messageRequestId(message);
+        if (requestId !== undefined) {
+            // JSON-RPC ids are unique only within one endpoint generation. A host
+            // restart can reuse an id while the downstream client is still answering
+            // the old request, so never expose host ids directly across the relay.
+            const relayRequestId = `${hostRequestIdPrefix}${generation}-${++hostRequestSequence}`;
+            pendingHostRequests.set(relayRequestId, {
+                generation,
+                upstream: candidate,
+                originalId: requestId
+            });
+            const relayedRequest = cloneMessage(message);
+            if (!('id' in relayedRequest))
+                throw new CapabilityError('Host request must carry a request id', 'INVALID_INPUT');
+            relayedRequest.id = relayRequestId;
+            void downstream.send(relayedRequest).catch((cause) => CaughtFailureSchema.parse(cause)).then((failure) => { if (failure)
+                closeAfterFailure(failure); });
+            return;
+        }
+        const cancelledId = cancellationRequestId(message);
+        if (cancelledId !== undefined) {
+            for (const [relayRequestId, pending] of pendingHostRequests) {
+                if (pending.upstream === candidate &&
+                    pending.generation === generation &&
+                    pending.originalId === cancelledId) {
+                    void downstream
+                        .send(withCancellationRequestId(message, relayRequestId))
+                        .catch((cause) => CaughtFailureSchema.parse(cause)).then((failure) => { if (failure)
+                        closeAfterFailure(failure); });
+                    return;
+                }
+            }
+            // The request already completed or belongs to a retired generation.
+            // Forwarding the host-local id could cancel an unrelated client request.
+            return;
+        }
+        void downstream.send(message).catch((cause) => CaughtFailureSchema.parse(cause)).then((failure) => { if (failure)
+            closeAfterFailure(failure); });
+    };
+    const installUpstreamHandlers = (candidate, generation) => {
+        candidate.onmessage = (message) => {
+            // A response can already be queued when close/error fires. Once that
+            // generation is retired, forwarding it would double-answer a request:
+            // first host-restarted, then a late success from the dead host.
+            if (failureOwner.closing || upstream !== candidate || upstreamGeneration !== generation)
+                return;
+            forwardHostMessage(message, candidate, generation);
+        };
+        const lost = (failure) => {
+            if (failureOwner.closing || upstream !== candidate || upstreamGeneration !== generation)
+                return;
+            if (failure)
+                log.warn('Shared MCP host transport failed; retiring its connection', { failure: valueFreeFailure(failure) });
+            // Retire the lost generation at once, so nothing more is forwarded to it.
+            retireHostRequests(candidate);
+            toolNames.clear();
+            upstream = undefined;
+            upstreamUrl = undefined;
+            upstreamReady = false;
+            upstreamLost.get(candidate)?.();
+            // The connector closes a connection it opened when it re-attaches.
+            if (connector.connection !== candidate)
+                void closeUpstream(candidate).catch((cause) => CaughtFailureSchema.parse(cause)).then((failure) => { if (failure)
+                    closeAfterFailure(failure); });
+            // Which loss it was is read from the claim (an async read), then reported.
+            void (async () => {
+                const observed = await observeHostLossOrFailure(options, upstreamClaim);
+                // An unreadable claim proves no restart; the loss is still handled below.
+                if (observed.error !== undefined)
+                    log.warn('Could not read the shared MCP host claim after losing its connection', { failure: valueFreeFailure(observed.error) });
+                const loss = observed.loss;
+                lastHostLoss = loss;
+                rejectInternal(new Error(HOST_LOSS_TEXT[loss].notice));
+                failInterruptedClientRequests(loss);
+                void downstream
+                    .send(relayStateNotification('warning', HOST_LOSS_TEXT[loss].notice))
+                    .catch((cause) => CaughtFailureSchema.parse(cause)).then((failure) => { if (failure)
+                    closeAfterFailure(failure); });
+                if (failureOwner.closing)
+                    return;
+                // One reconnect: concurrent losses join the connector's in-flight attempt.
+                await connector.connect();
+            })().catch((cause) => CaughtFailureSchema.parse(cause)).then((error) => {
+                if (!error)
+                    return;
+                if (failureOwner.closing)
+                    return;
+                log.warn('Shared MCP host relay stopped reconnecting', { failure: valueFreeFailure(CaughtFailureSchema.parse(error)) });
+            });
+        };
+        /**
+         * The host dropped this relay's session but is serving: open a fresh
+         * session (re-initialize and replay), then resend every call that was in
+         * flight. Calls that arrive meanwhile wait for it. Only a failed
+         * re-initialization fails them.
+         */
+        /** The fresh session's attach: null once it serves, else the failure, returned for the caller to handle. */
+        const connectOutcome = async () => {
+            try {
+                await connector.connect();
+                return null;
+            }
+            catch (error) {
+                return CaughtFailureSchema.parse(error);
+            }
+        };
+        const sessionExpired = () => {
+            if (failureOwner.closing || upstream !== candidate || upstreamGeneration !== generation)
+                return;
+            // The calls in flight stay pending (their health probes disarmed) until the fresh session answers or fails.
+            for (const pending of pendingClientRequests.values())
+                pending.timer();
+            const held = [...pendingClientRequests.keys()];
+            retireHostRequests(candidate);
+            toolNames.clear();
+            upstream = undefined;
+            upstreamUrl = undefined;
+            upstreamReady = false;
+            rejectInternal(new Error('The shared MCP host no longer holds this relay session.'));
+            upstreamLost.get(candidate)?.();
+            if (connector.connection !== candidate)
+                void closeUpstream(candidate).catch((cause) => CaughtFailureSchema.parse(cause)).then((failure) => { if (failure)
+                    closeAfterFailure(failure); });
+            log.info('Shared MCP host no longer holds this relay session; re-initializing', { inFlight: held.length });
+            const reattach = async () => {
+                const failure = await connectOutcome();
+                reinitializing = undefined;
+                if (failure) {
+                    if (failureOwner.closing)
+                        return;
+                    // Re-initialization failed: the held calls fail now, typed, and the failure is logged.
+                    log.warn('Shared MCP host relay could not re-initialize its session', { error: failure });
+                    lastHostLoss = 'unresponsive';
+                    failInterruptedClientRequests('unresponsive');
+                    return;
+                }
+                for (const id of held) {
+                    const pending = pendingClientRequests.get(id);
+                    if (!pending)
+                        continue;
+                    pendingClientRequests.delete(id);
+                    downstream.onmessage?.(pending.request);
+                }
+            };
+            reinitializing = reattach();
+        };
+        candidate.onclose = lost;
+        failureOwner.bindUpstream(candidate, generation, lost, sessionExpired);
+    };
+    const replayClientState = async (signal) => {
+        if (!initializeRequest)
+            return;
+        const initializeResponse = await sendInternal(applyRelayIdentity(cloneMessage(initializeRequest), options.identity));
+        supportsToolListChanges = advertisesToolListChanges(initializeResponse);
+        if (initializedNotification) {
+            await upstream?.send(cloneMessage(initializedNotification));
+        }
+        if (bindingReceiptMissing) {
+            throw new Error('The prior session bind did not return a durable replay receipt.');
+        }
+        let bindingRestored = false;
+        if (sessionBindReceipt) {
+            // A host restart wakes every long-lived relay at once. Initialize is
+            // intentionally cheap, but restoring a durable Session binding crosses
+            // participant/session/presence storage. Without admission jitter, 100+
+            // bodies hit SQLite in the same tick, starve /health, and make PM recycle
+            // the otherwise-correct host forever. Spread only the restore — the
+            // original authored `session init` is never replayed.
+            const restoreDelayMs = Math.floor(Math.max(0, Math.min(1, recoveryRandom())) * bindRestoreJitterWindowMs);
+            await options.lifecycle.delay(restoreDelayMs, signal);
+            if (failureOwner.closing || !upstream)
+                return;
+            const bindResponse = await sendInternal(durableSessionRestoreRequest(sessionBindReceipt));
+            if (isToolErrorResponse(bindResponse)) {
+                // The host is UP — it just answered a tool call — and it refuses
+                // this receipt: the durable (participant, session) pair no longer
+                // validates there (session deleted, participant unmapped, session
+                // archived). Retrying the same receipt forever wedges the relay
+                // behind host-restarted errors — including for `session init`,
+                // the one call that could mint a clean pair. Drop the stale
+                // receipt, tell the body, and serve unbound; the next init
+                // rebinds durably.
+                sessionBindReceipt = undefined;
+                bindingReceiptMissing = false;
+                await downstream
+                    .send(relayStateNotification('warning', 'The shared Vibes MCP host no longer recognizes this session binding; run session { action: "init" } to mint a fresh one.'))
+                    .catch((cause) => CaughtFailureSchema.parse(cause)).then((failure) => { if (failure)
+                    closeAfterFailure(failure); });
+            }
+            const restored = sessionBindReceipt
+                ? readDurableSessionBindReceipt(bindResponse)
+                : undefined;
+            if (sessionBindReceipt) {
+                if (!restored ||
+                    restored.sessionId !== sessionBindReceipt.sessionId ||
+                    restored.participantId !== sessionBindReceipt.participantId) {
+                    throw new Error('The shared MCP host restored a different session binding.');
+                }
+                bindingRestored = true;
+            }
+        }
+        if (supportsToolListChanges) {
+            await downstream.send(toolsListChangedNotification());
+        }
+        await downstream.send(relayStateNotification('info', bindingRestored
+            ? 'The shared Vibes MCP host reconnected; tools and session binding were restored.'
+            : 'The shared Vibes MCP host is available again; the prior session binding was dropped — run session { action: "init" } to rebind.'));
+    };
+    /** The transport owner joins closure and preserves its failure. */
+    async function closeUpstream(candidate) {
+        await candidate.close();
+    }
+    // A retired upstream's end, for the connector's `closed`: resolved in `lost()`.
+    const upstreamLost = new WeakMap();
+    const upstreamEnded = new WeakMap();
+    /**
+     * Re-attach after the host is lost (RC07: runtime-rpc's one reconnect state
+     * machine). One attempt at a time; a failed attempt holds off on the
+     * runtime's lifecycle, doubling to `maxDelayMs`; the relay's disposal cancels
+     * both. An attempt re-reads the host claim (a restarted host rotates its
+     * relay secret), attaches, and replays this client's state before the
+     * upstream serves calls again.
+     */
+    const connector = new RpcConnector({
+        lifecycle: options.lifecycle,
+        reason: 'mcp-shared-host-relay',
+        reconnect: {
+            initialDelayMs: options.reconnect?.initialDelayMs ?? 100,
+            maxDelayMs: options.reconnect?.maxDelayMs ?? 2_000
+        },
+        live: (candidate) => upstream === candidate,
+        closed: (candidate) => upstreamEnded.get(candidate) ?? Promise.resolve(),
+        close: closeUpstream,
+        open: async (signal) => {
+            const next = await resolveHostUrl(options);
+            if (!next.url)
+                throw new Error('No shared MCP host is advertised for this workspace yet.');
+            const candidate = transports.createUpstream(new URL(next.url), await relayAuthorization(options));
+            try {
+                await candidate.start();
+                signal.throwIfAborted();
+                upstream = candidate;
+                upstreamUrl = new URL(next.url);
+                upstreamClaim = next.claim;
+                upstreamReady = false;
+                upstreamGeneration += 1;
+                upstreamEnded.set(candidate, new Promise((resolve) => upstreamLost.set(candidate, resolve)));
+                installUpstreamHandlers(candidate, upstreamGeneration);
+                await replayClientState(signal);
+                // A loss during the replay (the restore jitter outlasts a cut stream)
+                // retired this candidate: fail the attempt so the connector dials again,
+                // rather than serve on a connection that is gone.
+                if (upstream !== candidate)
+                    throw new Error('The shared MCP host connection closed while this relay restored its state.');
+                upstreamReady = true;
+                return candidate;
+            }
+            catch (error) {
+                const failure = CaughtFailureSchema.parse(error);
+                retireHostRequests(candidate);
+                if (upstream === candidate) {
+                    upstream = undefined;
+                    upstreamUrl = undefined;
+                    upstreamReady = false;
+                }
+                upstreamLost.get(candidate)?.();
+                rejectInternal(new Error('The candidate shared MCP host could not restore relay state.'));
+                const cleanup = await closeUpstream(candidate).catch((cause) => CaughtFailureSchema.parse(cause));
+                if (cleanup)
+                    throw new AggregateError([failure, cleanup], 'The MCP relay candidate and its cleanup failed.', { cause: failure });
+                throw failure;
+            }
+        }
+    });
+    // client -> host
+    downstream.onmessage = (message) => {
+        if (('method' in message ? message.method : undefined) === 'initialize') {
+            initializeRequest = cloneMessage(message);
+            if (!nameClient) {
+                const initialize = InitializeRequestSchema.safeParse(message);
+                if (initialize.success)
+                    nameClient = initialize.data.params.clientInfo.name;
+            }
+        }
+        if (isInitializedNotification(message)) {
+            initializedNotification = cloneMessage(message);
+        }
+        const cancelledId = cancellationRequestId(message);
+        const hostCancellationId = z.string().safeParse(cancelledId);
+        if (hostCancellationId.success && isRelayHostRequestId(hostCancellationId.data)) {
+            const pending = pendingHostRequests.get(hostCancellationId.data);
+            if (!pending ||
+                upstream !== pending.upstream ||
+                upstreamGeneration !== pending.generation) {
+                return;
+            }
+            void pending.upstream
+                .send(withCancellationRequestId(message, pending.originalId))
+                .catch((cause) => CaughtFailureSchema.parse(cause)).then((error) => {
+                if (!error)
+                    return;
+                log.debug('relay upstream cancellation send failed', {
+                    error: error instanceof Error ? error.message : String(error)
+                });
+                if (upstream === pending.upstream &&
+                    upstreamGeneration === pending.generation) {
+                    pending.upstream.onclose?.();
+                }
+            });
+            return;
+        }
+        const responseId = messageResponseId(message);
+        if (responseId !== undefined) {
+            const hostResponseId = z.string().safeParse(responseId);
+            if (hostResponseId.success) {
+                const pending = pendingHostRequests.get(hostResponseId.data);
+                if (pending) {
+                    pendingHostRequests.delete(hostResponseId.data);
+                    if (upstream !== pending.upstream || upstreamGeneration !== pending.generation)
+                        return;
+                    const restoredResponse = cloneMessage(message);
+                    if (!('id' in restoredResponse))
+                        throw new CapabilityError('Client response must carry a request id', 'INVALID_INPUT');
+                    restoredResponse.id = pending.originalId;
+                    void pending.upstream.send(restoredResponse).catch((cause) => CaughtFailureSchema.parse(cause)).then((error) => {
+                        if (!error)
+                            return;
+                        log.debug('relay upstream response send failed', {
+                            error: error instanceof Error ? error.message : String(error)
+                        });
+                        if (upstream === pending.upstream &&
+                            upstreamGeneration === pending.generation) {
+                            pending.upstream.onclose?.();
+                        }
+                    });
+                    return;
+                }
+            }
+            // A reply to a retired host generation must die with that generation.
+            // Forwarding it to the replacement can satisfy an unrelated request that
+            // reused the same original id.
+            if (isRelayHostRequestId(responseId))
+                return;
+        }
+        const requestId = messageRequestId(message);
+        const beforeInitialize = !protocolInitialized && 'method' in message && message.method !== 'initialize';
+        const target = upstreamReady ? upstream : undefined;
+        const targetUrl = upstreamReady ? upstreamUrl : undefined;
+        if (!target || !targetUrl) {
+            // A session re-initialization is in flight: this call waits for it.
+            if (reinitializing) {
+                const queued = cloneMessage(message);
+                void reinitializing.then(() => downstream.onmessage?.(queued));
+                return;
+            }
+            if (requestId !== undefined) {
+                void downstream.send(hostLossError(requestId, lastHostLoss)).catch((cause) => CaughtFailureSchema.parse(cause)).then((failure) => { if (failure)
+                    closeAfterFailure(failure); });
+            }
+            return;
+        }
+        if (requestId !== undefined) {
+            const request = cloneMessage(message);
+            const armHealthProbe = () => options.lifecycle.timeout(() => {
+                void (async () => {
+                    const pending = pendingClientRequests.get(requestId);
+                    if (!pending || pending.request !== request || upstream !== target)
+                        return;
+                    const sample = await healthProbeOutcome(() => options.probeHost
+                        ? options.probeHost(new URL(targetUrl))
+                        : probeMcpHost(options.lifecycle, new URL(targetUrl), healthProbeTimeoutMs));
+                    if (sample.failure !== undefined && !probeFailureReported) {
+                        probeFailureReported = true;
+                        if (!isLifecycleDeadline(sample.failure))
+                            log.warn('Shared MCP host health probe failed; treating the host as unhealthy', { failure: valueFreeFailure(sample.failure) });
+                    }
+                    const current = pendingClientRequests.get(requestId);
+                    if (!current || current.request !== request || upstream !== target)
+                        return;
+                    if (!sample.healthy) {
+                        const observed = await observeHostLossOrFailure(options, upstreamClaim);
+                        if ('error' in observed && observed.error !== undefined)
+                            log.warn('Could not read the shared MCP host claim after a failed health probe', { failure: valueFreeFailure(observed.error) });
+                        if (observed.loss === 'restarted') {
+                            target.onclose?.();
+                            return;
+                        }
+                        // A slow event loop is not proof of a restarted process.
+                        // Preserve pending calls and the host's sampling requests.
+                        if (!current.healthWarned) {
+                            current.healthWarned = true;
+                            void downstream.send(relayStateNotification('warning', 'The shared MCP host is slow to answer health probes; existing calls remain attached.')).catch((cause) => CaughtFailureSchema.parse(cause)).then((failure) => { if (failure)
+                                closeAfterFailure(failure); });
+                        }
+                    }
+                    current.timer = armHealthProbe();
+                })();
+            }, healthProbeIntervalMs);
+            pendingClientRequests.set(requestId, { request, beforeInitialize, timer: armHealthProbe() });
+        }
+        let outbound = cloneMessage(message);
+        if (harnessNeedsSafeMcpNames(nameClient, customPresets)) {
+            const call = CallToolRequestSchema.safeParse(message);
+            if (call.success) {
+                const canonicalName = toolNames.get(call.data.params.name);
+                if (canonicalName && 'method' in outbound)
+                    outbound = { ...outbound, params: { ...call.data.params, name: canonicalName } };
+            }
+            // Malformed requests still reach the host's SDK validation unchanged.
+        }
+        void target
+            .send(applyRelayIdentity(outbound, options.identity))
+            .catch((cause) => CaughtFailureSchema.parse(cause)).then((error) => {
+            if (!error)
+                return;
+            // A host that ANSWERS is not a host that died. The streamable-HTTP
+            // transport throws on a non-2xx POST even when the body is a
+            // JSON-RPC error the host wrote on purpose (2026-09-06: `session
+            // init` from an identity-less body → 409 -32004 "Legacy session
+            // restore requires a stable participant or harness session
+            // identity"). Treating that as loss failed the call with
+            // "host restarted", reconnected, and dropped the binding — every
+            // time, while /health answered 200. Hand the host's own error to the
+            // client under the client's id instead.
+            const refusal = requestId !== undefined ? hostRefusalFromTransportError(error, log, beforeInitialize) : null;
+            if (refusal && upstream === target) {
+                const pending = pendingClientRequests.get(requestId);
+                if (pending) {
+                    pending.timer();
+                    pendingClientRequests.delete(requestId);
+                }
+                void downstream
+                    .send({ jsonrpc: '2.0', id: requestId, error: refusal })
+                    .catch((cause) => CaughtFailureSchema.parse(cause)).then((failure) => { if (failure)
+                    closeAfterFailure(failure); });
+                return;
+            }
+            if (upstream === target)
+                target.onclose?.();
+        });
+    };
+    // host -> client
+    installUpstreamHandlers(initialUpstream, upstreamGeneration);
+    downstream.onclose = closeRelay;
+    failureOwner.bindDownstream();
+    await downstream.start();
+    // END OF CLIENT INPUT IS THE END OF THIS PROCESS'S JOB.
+    //
+    // `StdioServerTransport` subscribes to `data` and `error` on stdin and to
+    // nothing else, so a client that closes the pipe never fires `onclose`,
+    // `done` never resolves, and `startStdioMcp` never returns. Measured
+    // 2026-08-30 against the shipping binary: `initialize` answered, `tools/list`
+    // returned 96 tools, then the body was still alive 123 s after stdin EOF
+    // (exit code null) while SIGTERM killed it in 144 ms. Every MCP client that
+    // disconnects by closing stdio — the normal way — left an orphan holding a
+    // live upstream HTTP session against the shared host.
+    //
+    // This relay, not the transport, owns the process's stdio, so it owns the
+    // EOF. Watch it only when nobody injected transports (i.e. this really is
+    // process stdio) or when a falsifier supplied its own pipe.
+    const onClientEof = () => closeRelay();
+    if (clientInput) {
+        clientInput.once('end', onClientEof);
+        clientInput.once('close', onClientEof);
+        detachClientInputWatch = () => {
+            clientInput.off('end', onClientEof);
+            clientInput.off('close', onClientEof);
+        };
+    }
+    else if (stdinEvents) {
+        const detachEnd = stdinEvents.subscribeStdin('end', onClientEof);
+        const detachClose = stdinEvents.subscribeStdin('close', onClientEof);
+        detachClientInputWatch = () => {
+            detachEnd();
+            detachClose();
+        };
+    }
+    if (failureOwner.closing)
+        detachClientInputWatch();
+    return { relayed: true, url: resolved.url, done };
+}
+//# sourceMappingURL=stdio-relay.js.map