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

package/dist/core/extensions/builtin/mcp/request-origin.d.ts

@@ -0,0 +1,47 @@
+import type { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import type { RequestOptions } from "@modelcontextprotocol/sdk/shared/protocol.js";
+import type { McpMrtrPresentation } from "../../../mcp-mrtr-presentations.ts";
+import type { McpFormPresentation } from "../../../mcp-form-types.ts";
+import type { ServerConnection } from "./connection.ts";
+declare const originOption: unique symbol;
+export declare const physicalMcpClient: (client: Client) => Client;
+export declare function registerMcpClientAlias(alias: Client, physical: Client): void;
+export interface McpRequestOrigin {
+    readonly binding: object;
+    readonly connection: ServerConnection;
+    readonly signal: AbortSignal;
+    readonly presentation?: McpMrtrPresentation;
+    readonly privateForm?: McpFormPresentation;
+    readonly privateFormsEnforced?: boolean;
+    readonly serverLabel: string;
+    readonly serverSource?: "user" | "project" | "plugin";
+    readonly isCurrent: () => boolean;
+    readonly resolveAuthority: (signal: AbortSignal) => Promise<unknown>;
+}
+export declare function beginLegacyMcpOperation(client: Client, origin: McpRequestOrigin, caller?: AbortSignal): () => void;
+export declare function legacyMcpOperation(client: Client): "ambiguous" | {
+    readonly origin: McpRequestOrigin;
+    readonly signal: AbortSignal;
+} | undefined;
+/** Issued by the binding-specific registration boundary, never from JSON/model arguments. */
+export declare function createMcpRequestOrigin(origin: McpRequestOrigin): McpRequestOrigin;
+export declare function mcpRequestOptions(origin: McpRequestOrigin | undefined, options?: RequestOptions): RequestOptions & {
+    [originOption]?: McpRequestOrigin;
+};
+export declare function takeMcpRequestOrigin(options: RequestOptions | undefined, client: Client): {
+    origin: McpRequestOrigin | undefined;
+    sdkOptions: {
+        relatedRequestId?: import("@modelcontextprotocol/sdk/types").RequestId;
+        resumptionToken?: string;
+        onresumptiontoken?: (token: string) => void;
+        onprogress?: import("@modelcontextprotocol/sdk/shared/protocol.js").ProgressCallback;
+        signal?: AbortSignal;
+        timeout?: number;
+        resetTimeoutOnProgress?: boolean;
+        maxTotalTimeout?: number;
+        task?: import("@modelcontextprotocol/sdk/types").TaskCreationParams;
+        relatedTask?: import("@modelcontextprotocol/sdk/types").RelatedTaskMetadata;
+    };
+};
+export {};
+//# sourceMappingURL=request-origin.d.ts.map

package/dist/core/extensions/builtin/mcp/request-origin.js

@@ -0,0 +1,59 @@
+import { McpMrtrError } from "./modern/errors.js";
+const originOption = Symbol("mcp-request-origin");
+const origins = new WeakSet();
+const aliases = new WeakMap();
+export const physicalMcpClient = (client) => aliases.get(client) ?? client;
+export function registerMcpClientAlias(alias, physical) {
+    aliases.set(alias, physical);
+}
+const legacyOperations = new WeakMap();
+export function beginLegacyMcpOperation(client, origin, caller) {
+    const lifetime = new AbortController();
+    const operation = {
+        origin,
+        signal: AbortSignal.any([origin.signal, lifetime.signal, ...(caller ? [caller] : [])]),
+    };
+    let operations = legacyOperations.get(client);
+    if (!operations) {
+        operations = new Set();
+        legacyOperations.set(client, operations);
+    }
+    operations.add(operation);
+    return () => {
+        operations.delete(operation);
+        lifetime.abort();
+        if (operations.size === 0)
+            legacyOperations.delete(client);
+    };
+}
+export function legacyMcpOperation(client) {
+    const operations = legacyOperations.get(client);
+    if (operations && operations.size > 1)
+        return "ambiguous";
+    if (operations?.size !== 1)
+        return undefined;
+    const operation = operations.values().next().value;
+    return operation && !operation.signal.aborted && operation.origin.isCurrent() ? operation : undefined;
+}
+/** Issued by the binding-specific registration boundary, never from JSON/model arguments. */
+export function createMcpRequestOrigin(origin) {
+    origins.add(origin);
+    return origin;
+}
+export function mcpRequestOptions(origin, options = {}) {
+    return origin === undefined ? options : { ...options, [originOption]: origin };
+}
+export function takeMcpRequestOrigin(options, client) {
+    const supplied = options;
+    const origin = supplied?.[originOption];
+    const { [originOption]: _origin, ...sdkOptions } = supplied ?? {};
+    if (origin !== undefined) {
+        if (!origins.has(origin) || !origin.isCurrent())
+            throw new McpMrtrError("MCP_MRTR_CONTEXT_CHANGED");
+        const candidate = origin.connection.client;
+        if (physicalMcpClient(candidate) !== client)
+            throw new McpMrtrError("MCP_MRTR_CONTEXT_CHANGED");
+    }
+    return { origin, sdkOptions };
+}
+//# sourceMappingURL=request-origin.js.map

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

@@ -6,7 +6,10 @@ import type { ServerConnection } from "./connection.ts";
 import type { McpToolDetails } from "./expose/register.ts";
 import type { McpOutputArtifacts } from "./guard/output-guard.ts";
 import { applyMcpOutputGuard } from "./guard/output-guard.ts";
+import { type McpRequestOrigin } from "./request-origin.ts";
 export interface McpResourceServer {
+    readonly ensureFresh?: () => Promise<void>;
+    readonly requestOrigin?: () => McpRequestOrigin | undefined;
     readonly server: string;
     readonly connection: ServerConnection;
     readonly agentDir?: string;
@@ -22,7 +25,7 @@ export declare function ensureMcpResourceSubscriptions(client: Client, resources
     uri: string;
 }>): Promise<void>;
 /** Read one resource and flatten its contents to guarded text. */
-export declare function readMcpResourceAsText(server: McpResourceServer, uri: string): Promise<string>;
+export declare function readMcpResourceAsText(server: McpResourceServer, uri: string, signal?: AbortSignal): Promise<string>;
 declare const ListParams: Type.TObject<{
     server: Type.TOptional<Type.TString>;
 }>;

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

@@ -16,6 +16,9 @@ import { redactResolvedReferenceData, redactResolvedReferenceValues } from "../.
 import { ToolExecError } from "./errors.js";
 import { applyMcpOutputGuard } from "./guard/output-guard.js";
 import { ResourceUpdatedNotificationSchema, registerMcpNotificationHandler } from "./notification-schemas.js";
+import { mcpRequestOptions } from "./request-origin.js";
+import { McpMrtrError } from "./modern/errors.js";
+import { ensureMcpToolCallConnection } from "./health.js";
 /** Route resource updated notifications into the shared refresh path. */
 export function subscribeMcpResourceUpdated(client, onChange) {
     registerMcpNotificationHandler(client, ResourceUpdatedNotificationSchema, () => {
@@ -29,13 +32,20 @@ export async function ensureMcpResourceSubscriptions(client, resources) {
     await Promise.all(resources.map((resource) => client.subscribeResource({ uri: resource.uri }).catch(() => undefined)));
 }
 /** Read one resource and flatten its contents to guarded text. */
-export async function readMcpResourceAsText(server, uri) {
+export async function readMcpResourceAsText(server, uri, signal) {
     let contents;
     try {
-        const result = await server.connection.client.readResource({ uri }, { timeout: server.requestTimeoutMs });
+        if (server.requestOrigin)
+            await ensureMcpToolCallConnection(server.connection, server.ensureFresh);
+        const result = await server.connection.client.readResource({ uri }, mcpRequestOptions(server.requestOrigin?.(), {
+            timeout: server.requestTimeoutMs,
+            ...(signal === undefined ? {} : { signal }),
+        }));
         contents = result.contents;
     }
     catch (error) {
+        if (error instanceof McpMrtrError)
+            throw error;
         throw new ToolExecError(redactResolvedReferenceValues(`Failed to read MCP resource ${uri}: ${error instanceof Error ? error.message : String(error)}`), {
             phase: "call",
             serverName: server.server,
@@ -93,7 +103,7 @@ export function createMcpResourceTools(servers) {
         description: "Read one MCP resource by server name and URI; returns its (guarded) content.",
         parameters: ReadParams,
         executionMode: "parallel",
-        async execute(_id, params) {
+        async execute(_id, params, signal) {
             const entry = servers().find((candidate) => candidate.server === params.server);
             if (entry === undefined) {
                 throw new ToolExecError(redactResolvedReferenceValues(`Unknown MCP server '${params.server}' for resource ${params.uri}.`), {
@@ -101,7 +111,7 @@ export function createMcpResourceTools(servers) {
                     serverName: params.server,
                 });
             }
-            const text = await readMcpResourceAsText(entry, params.uri);
+            const text = await readMcpResourceAsText(entry, params.uri, signal);
             return {
                 content: [{ type: "text", text }],
                 details: redactResolvedReferenceData({
@@ -137,6 +147,11 @@ export async function expandMcpResourceMentions(text, servers) {
             expanded = expanded.replace(mention, `<mcp-resource server="${serverName}" uri="${uri}">\n${body}\n</mcp-resource>`);
         }
         catch (error) {
+            if (error instanceof McpMrtrError &&
+                ["MCP_MRTR_CANCELLED", "MCP_MRTR_CONTEXT_CHANGED", "MCP_MRTR_TIMEOUT"].includes(error.code)) {
+                notices.push("MCP resource request canceled; mention left unchanged.");
+                continue;
+            }
             notices.push(`@mcp mention left as-is: ${error instanceof Error ? error.message : String(error)}`);
         }
     }

package/dist/core/extensions/builtin/mcp/sdk.lazy.d.ts

@@ -15,9 +15,11 @@
  */
 /** `Client` — the MCP client class, built once per transport connection. */
 export declare const loadMcpSdkClient: () => Promise<typeof import("@modelcontextprotocol/sdk/client/index.js")>;
+/** Compatibility parser for final caller schemas at the modern request boundary. */
+export declare const loadMcpSdkZodCompat: () => Promise<typeof import("@modelcontextprotocol/sdk/server/zod-compat.js")>;
 /** `StdioClientTransport` + `getDefaultEnvironment` — stdio servers and the stdio diagnostic rerun. */
 export declare const loadMcpSdkStdioTransport: () => Promise<typeof import("@modelcontextprotocol/sdk/client/stdio.js")>;
-/** Protocol schemas (currently only the elicitation request schema). */
+/** SDK-owned protocol schemas for elicitation and modern request results. */
 export declare const loadMcpSdkTypes: () => Promise<typeof import("@modelcontextprotocol/sdk/types.js")>;
 /** OAuth 2.1 discovery, authorization, token exchange and refresh. */
 export declare const loadMcpSdkAuth: () => Promise<typeof import("@modelcontextprotocol/sdk/client/auth.js")>;

package/dist/core/extensions/builtin/mcp/sdk.lazy.js

@@ -36,9 +36,11 @@ function memoizeLoader(load) {
 }
 /** `Client` — the MCP client class, built once per transport connection. */
 export const loadMcpSdkClient = memoizeLoader(() => import("@modelcontextprotocol/sdk/client/index.js"));
+/** Compatibility parser for final caller schemas at the modern request boundary. */
+export const loadMcpSdkZodCompat = memoizeLoader(() => import("@modelcontextprotocol/sdk/server/zod-compat.js"));
 /** `StdioClientTransport` + `getDefaultEnvironment` — stdio servers and the stdio diagnostic rerun. */
 export const loadMcpSdkStdioTransport = memoizeLoader(() => import("@modelcontextprotocol/sdk/client/stdio.js"));
-/** Protocol schemas (currently only the elicitation request schema). */
+/** SDK-owned protocol schemas for elicitation and modern request results. */
 export const loadMcpSdkTypes = memoizeLoader(() => import("@modelcontextprotocol/sdk/types.js"));
 let authModule;
 /** OAuth 2.1 discovery, authorization, token exchange and refresh. */

package/dist/core/extensions/builtin/mcp/service-register.d.ts

@@ -1,10 +1,13 @@
-import type { ExtensionAPI } from "../../types.ts";
+import type { ExtensionAPI, ExtensionUIContext } from "../../types.ts";
 import type { ToolSearchService } from "../tool-search/service.ts";
 import type { ResolvedMcpConfig } from "./config-schema.ts";
 import type { McpSessionRegistration } from "./expose/session.ts";
 import type { McpConnectionEntry } from "./service-types.ts";
+import type { McpRequestOrigin } from "./request-origin.ts";
 type McpToolRegistrar = Pick<ExtensionAPI, "getActiveTools" | "setActiveTools" | "registerTool">;
 export interface McpServiceDirectToolRegistrationOptions {
+    readonly requestOrigin?: (entry: McpConnectionEntry) => McpRequestOrigin;
+    readonly bindPresentation?: (ui: ExtensionUIContext) => void;
     readonly refreshActiveSetWhenEmpty?: boolean;
     readonly onRegistered?: (entry: McpConnectionEntry, identity: string) => void;
     readonly isCurrent?: (entry: McpConnectionEntry) => boolean;

package/dist/core/extensions/builtin/mcp/service-register.js

@@ -39,6 +39,7 @@ export async function registerMcpServiceDirectTools(pi, config, entries, toolSea
                     ensureFresh: () => entry.authPlan?.refresh?.ensureFresh().then(() => undefined) ?? Promise.resolve(),
                     outputGuard: config.settings.outputGuard,
                     invocation,
+                    requestOrigin: () => options.requestOrigin?.(entry),
                 });
                 return computeMcpExposurePolicy(current, serverConfig, config.settings).filteredEntries.find((candidate) => candidate.tool === tool);
             },
@@ -54,6 +55,8 @@ export async function registerMcpServiceDirectTools(pi, config, entries, toolSea
             startupCatalogPending,
             localCatalogOnly: true,
             invocation,
+            requestOrigin: () => options.requestOrigin?.(entry),
+            bindPresentation: options.bindPresentation,
             onRegistered: (identity) => options.onRegistered?.(entry, identity),
             connection: entry.connection,
             ensureFresh: () => entry.authPlan?.refresh?.ensureFresh().then(() => undefined) ?? Promise.resolve(),

package/dist/core/extensions/builtin/mcp/service-types.d.ts

@@ -1,4 +1,4 @@
-import type { ExtensionContext, SessionShutdownEvent, SessionStartEvent } from "../../types.ts";
+import type { ExtensionContext, ExtensionUIContext, SessionShutdownEvent, SessionStartEvent } from "../../types.ts";
 import type { ServerAuthPlan } from "./auth/context.ts";
 import type { McpCachedServerCatalog } from "./catalog-cache.ts";
 import type { ResolvedMcpServer } from "./config-schema.ts";
@@ -65,6 +65,7 @@ export type McpWireStatusSnapshot = {
     readonly servers: readonly McpWireStatusServer[];
 };
 export type McpSessionContext = Pick<ExtensionContext, "cwd" | "isProjectTrusted"> & {
+    ui?: ExtensionUIContext;
     mode?: ExtensionContext["mode"];
     /**
      * Session history access, present on the real ExtensionContext. Only

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

@@ -89,6 +89,7 @@ export declare class McpService {
     setMcpInstructions(instructions: string): void;
     getMcpInstructions(): string;
     setMcpElicitationUiProvider(provider: (() => McpElicitationUi | undefined) | undefined): void;
+    bindMcpMrtrPresentation(pi: object, ui: ExtensionUIContext): void;
     getMcpElicitationUi(): McpElicitationUi | undefined;
     isMcpPromptCommandRegistered(name: string): boolean;
     markMcpPromptCommandRegistered(name: string): void;

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

@@ -1,6 +1,7 @@
 import { ConfigReferenceError } from "@earendil-works/pi-ai/utils/config-reference";
 import { getAgentDir } from "../../../../config.js";
 import { redactResolvedReferenceData } from "../../../config-reference-redaction.js";
+import { getMcpMrtrPresentation } from "../../../mcp-mrtr-presentations.js";
 import { getToolSearchService, getToolSearchServiceForExtension, resetToolSearchServiceForTests, ToolSearchService, } from "../tool-search/service.js";
 import { mcpCredentialIdentity } from "./auth/catalog-identity.js";
 import { resolveAuthMode } from "./auth/context.js";
@@ -13,6 +14,8 @@ import { HostMcpRegistry } from "./host-registry.js";
 import { refreshMcpInstructionsForSession } from "./instructions.js";
 import { createMcpLogger } from "./log.js";
 import { prepareProjectSkillServer } from "./project-skill-policy.js";
+import { createMcpRequestOrigin } from "./request-origin.js";
+import { McpMrtrError } from "./modern/errors.js";
 import { reconnectMcpNow } from "./reconnect.js";
 import { createMcpSessionConnection, disposeEntryConnection } from "./service-connection.js";
 import { getMcpServiceExposureStatus } from "./service-exposure.js";
@@ -181,8 +184,12 @@ export class McpService {
         };
         const previous = this.#bindings.get(pi);
         // A session-owned service serves exactly one session: a new attach takes over its binding.
-        if (!this.#servesManySessions)
+        previous?.lifetime.abort();
+        if (!this.#servesManySessions) {
+            for (const binding of this.#bindings.values())
+                binding.lifetime.abort();
             this.#bindings.clear();
+        }
         let fallbackToolSearch;
         let holdsProcessFallback = false;
         const sessionToolSearch = getToolSearchServiceForExtension(pi);
@@ -205,6 +212,8 @@ export class McpService {
             }
         }
         const binding = {
+            lifetime: new AbortController(),
+            presentation: owner.context.ui === undefined ? undefined : getMcpMrtrPresentation(owner.context.ui),
             pi,
             fallbackToolSearch,
             holdsProcessFallback,
@@ -224,8 +233,10 @@ export class McpService {
     #liveBindings() {
         for (const [pi, binding] of this.#bindings) {
             // A disposed session retires its own tool-search service; its binding goes with it.
-            if (getToolSearchServiceForExtension(binding.pi)?.isDisposed === true)
+            if (getToolSearchServiceForExtension(binding.pi)?.isDisposed === true) {
+                binding.lifetime.abort();
                 this.#bindings.delete(pi);
+            }
         }
         return [...this.#bindings.values()];
     }
@@ -240,6 +251,7 @@ export class McpService {
      */
     async releaseSession(pi, disposeReason) {
         const released = this.#bindings.get(pi);
+        released?.lifetime.abort();
         this.#bindings.delete(pi);
         if (disposeReason !== undefined)
             this.#releasedSessions.add(pi);
@@ -386,7 +398,7 @@ export class McpService {
                 ? await prepareProjectSkillServer(name, decl, {
                     context: binding.context,
                     options: binding.options,
-                    ui: () => this.getMcpElicitationUi(),
+                    ui: this.#elicitationProviderFor(binding),
                     notice: (identity, names) => {
                         // An untrusted project keeps the skill's references literal (senpi#2345); keep that fix in
                         // the one notice instead of a generic withheld line (senpi#3796).
@@ -527,6 +539,8 @@ export class McpService {
         this.#disposed = true;
         this.#disposeCount += 1;
         this.#lastDisposeReason = reason;
+        for (const binding of this.#bindings.values())
+            binding.lifetime.abort();
         this.#bindings.clear();
         this.#sessionContext = null;
         this.#config = null;
@@ -711,7 +725,7 @@ export class McpService {
                 session: options,
                 elicitationEnabled: declarer.context.mode !== "print" && declarer.context.mode !== "json",
                 cwd: declarer.context.cwd,
-                ui: () => this.getMcpElicitationUi(),
+                ui: this.#elicitationProviderFor(declarer),
                 artifacts: this.#outputArtifacts,
                 shouldReconnect: (current) => !this.#disposed &&
                     this.#entryForName(name) === current &&
@@ -813,6 +827,8 @@ export class McpService {
             onRegistered: (entry, identity) => binding.registeredIdentities.set(entry.key, identity),
             contextRequired: binding.context.mode !== undefined,
             sessionManager: binding.context.sessionManager,
+            requestOrigin: (entry) => this.#requestOrigin(binding, entry),
+            bindPresentation: (ui) => this.bindMcpMrtrPresentation(binding.pi, ui),
             // A new attach of this session replaces its binding (and with it its config); a peer's attach does not.
             isCurrent: (entry) => !this.#disposed &&
                 this.#bindings.get(binding.pi) === binding &&
@@ -955,9 +971,68 @@ export class McpService {
     setMcpElicitationUiProvider(provider) {
         this.#elicitationUiProvider = provider;
     }
+    bindMcpMrtrPresentation(pi, ui) {
+        const binding = this.#bindings.get(pi);
+        const presentation = getMcpMrtrPresentation(ui);
+        if (binding && presentation)
+            binding.presentation = presentation;
+    }
+    #requestOrigin(binding, entry) {
+        const source = binding.config.servers[entry.name]?.source;
+        return createMcpRequestOrigin({
+            binding,
+            connection: entry.connection,
+            signal: AbortSignal.any([binding.lifetime.signal, entry.connection.requestLifetimeSignal]),
+            presentation: binding.presentation,
+            privateFormsEnforced: binding.presentation?.privateForms !== undefined,
+            privateForm: binding.presentation?.privateForms?.capture(),
+            serverLabel: entry.name,
+            serverSource: source === "project" || source === "claude"
+                ? "project"
+                : source === "skill" || source === "extension"
+                    ? "plugin"
+                    : "user",
+            isCurrent: () => !this.#disposed &&
+                !binding.lifetime.signal.aborted &&
+                this.#bindings.get(binding.pi) === binding &&
+                [...this.#connections.values()].includes(entry) &&
+                declares(binding.config, entry.name, entry.configHash) &&
+                entry.isCurrent?.() !== false &&
+                entry.credentialsCurrent?.() !== false,
+            resolveAuthority: async (signal) => {
+                if (await entry.generationChanged?.())
+                    throw new McpMrtrError("MCP_MRTR_CONTEXT_CHANGED");
+                // Same observed-revocation boundary as ordinary MCP requests. Never prompts for a new grant.
+                return await entry.connection.projectPolicy?.resolve(signal, false);
+            },
+        });
+    }
     getMcpElicitationUi() {
         return this.#elicitationUiProvider?.();
     }
+    #elicitationProviderFor(owner) {
+        // Connections outlive their first declarer's extension context. Capture its host-owned
+        // references while it is live; readiness must never read a released session's ctx.ui.
+        const binding = [...this.#bindings.values()].find((candidate) => candidate === owner);
+        const ui = owner.context.ui;
+        const privateBinding = () => {
+            // Keep observing presentation replacements on the binding, not just its initial grant.
+            const presentation = binding
+                ? binding.presentation
+                : ui === undefined
+                    ? undefined
+                    : getMcpMrtrPresentation(ui);
+            return presentation?.privateForms;
+        };
+        return Object.assign(() => this.getMcpElicitationUi(), {
+            enforced: () => privateBinding() !== undefined,
+            subscribe: (listener) => privateBinding()?.subscribe?.(listener) ?? (() => { }),
+            eligible: () => {
+                const binding = privateBinding();
+                return binding === undefined || binding.capture()?.ready() === true;
+            },
+        });
+    }
     isMcpPromptCommandRegistered(name) {
         return this.#promptCommandNames.has(name);
     }

package/dist/core/extensions/builtin/mcp/shared-connection.js

@@ -9,6 +9,8 @@ import { safeInterval, safeTimer } from "./wrap.js";
 /** Owns one SDK handler set, reconnect loop, cache writer and aggregate lifetime. */
 export class SharedMcpConnection {
     #calls;
+    #readinessListeners;
+    #readinessSubscriptions;
     #options;
     #onDispose;
     #idleTimeoutMin;
@@ -22,6 +24,8 @@ export class SharedMcpConnection {
     constructor(options, onDispose) {
         this.leases = new Set();
         this.#calls = new Map();
+        this.#readinessListeners = new Set();
+        this.#readinessSubscriptions = new Map();
         this.#cacheGeneration = -1;
         this.#disposed = false;
         this.#inFlight = 0;
@@ -64,13 +68,30 @@ export class SharedMcpConnection {
                     },
                 },
             logger,
-            elicitationUiProvider: () => {
+            elicitationUiProvider: Object.assign(() => {
                 // SDK server requests carry no originating tool-call id.
                 const owners = [...this.#calls.keys()];
                 return owners.length === 1 && this.leases.has(owners[0])
                     ? owners[0].options.elicitationUiProvider?.()
                     : undefined;
-            },
+            }, {
+                enforced: () => [...this.leases].some((lease) => lease.options.elicitationUiProvider?.enforced?.()),
+                subscribe: (listener) => {
+                    this.#readinessListeners.add(listener);
+                    return () => {
+                        this.#readinessListeners.delete(listener);
+                    };
+                },
+                eligible: () => {
+                    const leases = [...this.leases];
+                    const eligible = (lease) => lease.options.elicitationEnabled !== false &&
+                        lease.options.elicitationUiProvider?.eligible?.() !== false;
+                    // Any ready owner permits negotiation; per-operation authority still selects the holder.
+                    if (leases.some((lease) => lease.options.elicitationUiProvider?.enforced?.()))
+                        return leases.some(eligible);
+                    return leases.length > 0 && leases.every(eligible);
+                },
+            }),
         });
         this.connection.onToolsChanged(() => {
             this.#catalog = undefined;
@@ -112,6 +133,14 @@ export class SharedMcpConnection {
         this.#clearIdle();
         const lease = new SharedMcpLease(this, options, owner, key);
         this.leases.add(lease);
+        const unsubscribe = options.elicitationUiProvider?.subscribe?.(() => {
+            for (const listener of this.#readinessListeners)
+                listener();
+        });
+        if (unsubscribe)
+            this.#readinessSubscriptions.set(lease, unsubscribe);
+        for (const listener of this.#readinessListeners)
+            listener();
         this.#idleTimeoutMin = Math.max(...[...this.leases].map((item) => item.options.config.idleTimeoutMin));
         this.#refreshKeepAlive();
         return lease;
@@ -154,6 +183,11 @@ export class SharedMcpConnection {
         // Capture the last attached policy before removing the final owner.
         this.#idleTimeoutMin = Math.max(...[...this.leases].map((item) => item.options.config.idleTimeoutMin));
         this.leases.delete(lease);
+        this.#readinessSubscriptions.get(lease)?.();
+        this.#readinessSubscriptions.delete(lease);
+        if (this.leases.size > 0)
+            for (const listener of this.#readinessListeners)
+                listener();
         this.#refreshKeepAlive();
         this.#armIdle();
     }

package/dist/core/extensions/builtin/mcp/shared-lease.d.ts

@@ -9,6 +9,7 @@ export declare class SharedMcpLease extends ServerConnection {
     readonly key: string;
     readonly options: ServerConnectionOptions;
     readonly shared: SharedMcpConnection;
+    get requestLifetimeSignal(): AbortSignal;
     constructor(shared: SharedMcpConnection, options: ServerConnectionOptions, owner: object, key: string);
     get state(): import("./connection-types.ts").ServerConnectionState;
     get generation(): number;

package/dist/core/extensions/builtin/mcp/shared-lease.js

@@ -1,5 +1,6 @@
 import { ServerConnection } from "./connection.js";
 import { ConnectError } from "./errors.js";
+import { registerMcpClientAlias } from "./request-origin.js";
 const requestMethods = new Set([
     "request",
     "listTools",
@@ -19,6 +20,10 @@ export class SharedMcpLease extends ServerConnection {
     #unsubscribeTools;
     #stateSubscriptions = new Set();
     #released = false;
+    #requestLifetime = new AbortController();
+    get requestLifetimeSignal() {
+        return this.#requestLifetime.signal;
+    }
     #localGeneration = 0;
     #client;
     #physicalClient;
@@ -63,6 +68,7 @@ export class SharedMcpLease extends ServerConnection {
                     return typeof value === "function" ? value.bind(target) : value;
                 },
             });
+            registerMcpClientAlias(this.#client, physical);
         }
         if (this.#client === undefined)
             throw new ConnectError("MCP client unavailable", { phase: "client" });
@@ -79,6 +85,8 @@ export class SharedMcpLease extends ServerConnection {
     }
     async bumpGeneration() {
         this.#assertAttached();
+        this.#requestLifetime.abort();
+        this.#requestLifetime = new AbortController();
         this.#localGeneration++;
         this.#refreshCatalog = true;
         // Re-list only this owner's catalog; never interrupt another owner's call.
@@ -128,6 +136,7 @@ export class SharedMcpLease extends ServerConnection {
         if (this.#released)
             return;
         this.#released = true;
+        this.#requestLifetime.abort();
         this.#unsubscribeTools();
         for (const off of this.#stateSubscriptions)
             off();

package/dist/core/extensions/builtin/mcp/transport-sdk.d.ts

@@ -11,8 +11,9 @@
 import type { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
 import type { McpOAuthProvider } from "./auth/oauth-provider.ts";
-import { type McpElicitationUiProvider } from "./elicitation.ts";
+import type { McpElicitationUiProvider } from "./elicitation.ts";
 import type { McpLogger } from "./log.ts";
+import type { ModernProtocolState } from "./modern/request.ts";
 import { type McpAsyncErrorSink } from "./wrap.ts";
 export type McpStdioTransportSpec = {
     readonly projectPolicy?: boolean;
@@ -48,5 +49,5 @@ export interface MaterializeMcpTransportOptions {
     /** Invoked once the stdio child has started, so the caller can capture its pid. */
     readonly onStart: () => void;
 }
-export declare function materializeMcpTransport(options: MaterializeMcpTransportOptions): Promise<McpMaterializedTransport>;
+export declare function materializeMcpTransport(options: MaterializeMcpTransportOptions, protocol?: ModernProtocolState): Promise<McpMaterializedTransport>;
 //# sourceMappingURL=transport-sdk.d.ts.map