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

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

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

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

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

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

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

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

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

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;