@code-yeongyu/senpi 2026.10.10-5 → 2026.10.10-6

package/dist/core/extensions/builtin/mcp/auth/catalog-identity.js

@@ -0,0 +1,41 @@
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { resolveAuthMode } from "./context.js";
+import { McpTokenStore } from "./token-store.js";
+/** Local snapshot only: never migrates credentials, acquires a lock, or refreshes authentication. */
+export function mcpCredentialIdentity(config, serverName, agentDir, env) {
+    const mode = resolveAuthMode(config);
+    if (mode === "none")
+        return "none";
+    if (mode === "bearer") {
+        const name = config.bearerTokenEnv;
+        if (name === undefined)
+            return undefined;
+        const token = env?.[name] ?? process.env[name];
+        if (token === undefined || token.length === 0)
+            return undefined;
+        return createHash("sha256")
+            .update(JSON.stringify(["mcp-catalog-bearer", token]))
+            .digest("hex");
+    }
+    try {
+        const store = new McpTokenStore({ serverName, serverUrl: config.url ?? "", agentDir });
+        const value = JSON.parse(readFileSync(store.tokensPath, "utf8"));
+        if (typeof value !== "object" || value === null || !("accessToken" in value))
+            return undefined;
+        if (typeof value.accessToken !== "string" || value.accessToken.length === 0)
+            return undefined;
+        const refreshToken = "refreshToken" in value ? value.refreshToken : undefined;
+        if (refreshToken !== undefined && typeof refreshToken !== "string")
+            return undefined;
+        return createHash("sha256")
+            .update(JSON.stringify(["mcp-catalog-oauth", value.accessToken, refreshToken]))
+            .digest("hex");
+    }
+    catch (error) {
+        if (error instanceof Error)
+            return undefined;
+        throw error;
+    }
+}
+//# sourceMappingURL=catalog-identity.js.map

package/dist/core/extensions/builtin/mcp/auth/legacy-lock.d.ts

@@ -0,0 +1,3 @@
+/** Shares the existing O_EXCL file with synchronous migrators without blocking the event loop. */
+export declare function acquireLegacyLock(path: string, stale: number): Promise<() => Promise<void>>;
+//# sourceMappingURL=legacy-lock.d.ts.map

package/dist/core/extensions/builtin/mcp/auth/legacy-lock.js

@@ -0,0 +1,39 @@
+import { open, rm, stat } from "node:fs/promises";
+import { safeDelay } from "../wrap.js";
+/** Shares the existing O_EXCL file with synchronous migrators without blocking the event loop. */
+export async function acquireLegacyLock(path, stale) {
+    const deadline = Date.now() + stale;
+    for (;;) {
+        try {
+            const file = await open(path, "wx", 0o600);
+            return async () => {
+                try {
+                    await file.close();
+                }
+                finally {
+                    await rm(path, { force: true });
+                }
+            };
+        }
+        catch (error) {
+            if (!(error instanceof Error) || !("code" in error) || error.code !== "EEXIST")
+                throw error;
+            try {
+                const age = Date.now() - (await stat(path)).mtimeMs;
+                if (age >= stale) {
+                    await rm(path, { force: true });
+                    continue;
+                }
+            }
+            catch (error) {
+                if (error instanceof Error && "code" in error && error.code === "ENOENT")
+                    continue;
+                throw error;
+            }
+            if (Date.now() >= deadline)
+                throw new Error("Legacy OAuth migration lock acquisition timed out");
+            await safeDelay(20);
+        }
+    }
+}
+//# sourceMappingURL=legacy-lock.js.map

package/dist/core/extensions/builtin/mcp/auth/legacy-migration.d.ts

@@ -0,0 +1,14 @@
+export interface LegacyMigration<TRecord> {
+    readonly rootDir: string;
+    readonly lockPath: string;
+    readonly legacyTokens: string;
+    readonly tokensPath: string;
+    readonly stale: number;
+    readonly disableLock: boolean;
+    readonly read: (path: string) => TRecord | undefined;
+    readonly write: (record: TRecord) => void;
+    readonly lockError: (cause: unknown) => Error;
+}
+export declare function adoptLegacyRecord<TRecord>(options: LegacyMigration<TRecord>): TRecord | undefined;
+export declare function readRecordAsync<TRecord>(options: LegacyMigration<TRecord>): Promise<TRecord | undefined>;
+//# sourceMappingURL=legacy-migration.d.ts.map

package/dist/core/extensions/builtin/mcp/auth/legacy-migration.js

@@ -0,0 +1,91 @@
+import { closeSync, mkdirSync, openSync, rmSync, statSync } from "node:fs";
+import { acquireLegacyLock } from "./legacy-lock.js";
+export function adoptLegacyRecord(options) {
+    const release = acquireSync(options);
+    try {
+        return claim(options);
+    }
+    finally {
+        release();
+    }
+}
+export async function readRecordAsync(options) {
+    const record = options.read(options.tokensPath);
+    if (record !== undefined)
+        return record;
+    mkdirSync(options.rootDir, { mode: 0o700, recursive: true });
+    let release;
+    try {
+        release = options.disableLock ? async () => undefined : await acquireLegacyLock(options.lockPath, options.stale);
+    }
+    catch (cause) {
+        throw options.lockError(cause);
+    }
+    try {
+        return claim(options);
+    }
+    finally {
+        await release();
+    }
+}
+function claim(options) {
+    const legacy = options.read(options.legacyTokens);
+    if (legacy === undefined)
+        return undefined;
+    const existing = options.read(options.tokensPath);
+    if (existing !== undefined) {
+        rmSync(options.legacyTokens, { force: true });
+        return existing;
+    }
+    options.write(legacy);
+    rmSync(options.legacyTokens, { force: true });
+    return legacy;
+}
+function acquireSync(options) {
+    if (options.disableLock)
+        return () => undefined;
+    mkdirSync(options.rootDir, { mode: 0o700, recursive: true });
+    const deadline = Date.now() + options.stale;
+    for (;;) {
+        let fd;
+        try {
+            fd = openSync(options.lockPath, "wx", 0o600);
+            const file = fd;
+            return () => {
+                try {
+                    closeSync(file);
+                }
+                catch {
+                    // A caller may already have closed its descriptor.
+                }
+                rmSync(options.lockPath, { force: true });
+            };
+        }
+        catch (cause) {
+            if (fd !== undefined)
+                closeSync(fd);
+            if (!(cause instanceof Error) || !("code" in cause) || cause.code !== "EEXIST")
+                throw cause;
+            let age;
+            try {
+                age = Date.now() - statSync(options.lockPath).mtimeMs;
+            }
+            catch (error) {
+                if (error instanceof Error && "code" in error && error.code === "ENOENT")
+                    continue;
+                throw error;
+            }
+            if (age >= options.stale) {
+                rmSync(options.lockPath, { force: true });
+                continue;
+            }
+            if (Date.now() >= deadline)
+                throw options.lockError(new Error(`legacy migration lock held for ${age}ms`));
+            const until = Date.now() + 20;
+            while (Date.now() < until) {
+                // Preserve the synchronous API; background preparation uses readRecordAsync.
+            }
+        }
+    }
+}
+//# sourceMappingURL=legacy-migration.js.map

package/dist/core/extensions/builtin/mcp/auth/oauth-refresh.js

@@ -28,7 +28,7 @@ export class McpRefreshManager {
         this.#options = options;
     }
     async ensureFresh() {
-        const record = this.#provider.store.read();
+        const record = await this.#provider.store.readAsync();
         if (record?.accessToken === undefined)
             return undefined;
         if (!isTokenStale(record, Date.now()))

package/dist/core/extensions/builtin/mcp/auth/token-store.d.ts

@@ -37,6 +37,7 @@ export declare class McpTokenStore<TRecord extends McpStoredAuth = McpStoredAuth
     get lockPath(): string;
     get legacyDir(): string;
     read(): TRecord | undefined;
+    readAsync(): Promise<TRecord | undefined>;
     update(mutate: (current: TRecord | undefined) => TRecord | undefined): Promise<TRecord | undefined>;
     write(record: TRecord): Promise<void>;
     withLock<T>(fn: () => Promise<T> | T): Promise<T>;

package/dist/core/extensions/builtin/mcp/auth/token-store.js

@@ -1,8 +1,9 @@
 import { createHash, randomBytes } from "node:crypto";
-import { chmodSync, closeSync, existsSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, statSync, writeFileSync, } from "node:fs";
+import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import lockfile from "proper-lockfile";
 import { getAgentDir } from "../../../../../config.js";
+import { adoptLegacyRecord, readRecordAsync } from "./legacy-migration.js";
 const AUTH_ROOT = "mcp-auth";
 const TOKENS_FILE = "tokens.json";
 const INDEX_FILE = "index.json";
@@ -57,95 +58,23 @@ export class McpTokenStore {
         const record = readJsonFile(this.tokensPath);
         if (record !== undefined)
             return record;
-        return this.#adoptLegacyRecord();
-    }
-    // The first server that reads a URL-keyed record takes it over; other servers with the same URL sign in again.
-    // Claiming is serialized on a lock shared by every consumer of the legacy URL (keyed on the
-    // legacy hash, not the per-server destination hash), so two processes cannot both read the
-    // URL-keyed record before either removes it and duplicate a rotating grant across identities.
-    #adoptLegacyRecord() {
-        const release = this.#acquireLegacyLockSync();
-        try {
-            // Recheck under the lock: another process may have already claimed the record.
-            const legacyTokens = join(this.legacyDir, TOKENS_FILE);
-            const legacy = readJsonFile(legacyTokens);
-            if (legacy === undefined)
-                return undefined;
-            // Recheck the destination before writing so a delayed migrator cannot
-            // overwrite a newer same-server record another process already refreshed.
-            const existing = readJsonFile(this.tokensPath);
-            if (existing !== undefined) {
-                rmSync(legacyTokens, { force: true });
-                return existing;
-            }
-            this.#writeAtomic(legacy);
-            this.#writeIndex();
-            rmSync(legacyTokens, { force: true });
-            return legacy;
-        }
-        finally {
-            release();
-        }
-    }
-    // The lock is a file created with O_EXCL (atomic create-or-fail), keyed on the
-    // legacy hash so every server of the URL contends on the same path. It is only
-    // ever taken by this migration (never nested under the per-server update lock),
-    // and release removes a plain file, so it cannot linger the way a directory can.
-    #acquireLegacyLockSync() {
-        if (this.#disableLock)
-            return () => undefined;
-        mkdirSync(this.rootDir, { mode: 0o700, recursive: true });
-        const lockFile = this.#legacyLockFile;
-        const stale = this.#lock.stale;
-        const deadline = Date.now() + stale;
-        for (;;) {
-            let fd;
-            try {
-                fd = openSync(lockFile, "wx", 0o600);
-                const file = fd;
-                return () => {
-                    try {
-                        closeSync(file);
-                    }
-                    catch {
-                        // already closed
-                    }
-                    rmSync(lockFile, { force: true });
-                };
-            }
-            catch (cause) {
-                if (fd !== undefined) {
-                    try {
-                        closeSync(fd);
-                    }
-                    catch {
-                        // ignore
-                    }
-                }
-                const code = cause.code;
-                if (code !== "EEXIST")
-                    throw cause;
-                let age = 0;
-                try {
-                    age = Date.now() - statSync(lockFile).mtimeMs;
-                }
-                catch {
-                    continue; // lock vanished between attempts; retry
-                }
-                if (age >= stale) {
-                    rmSync(lockFile, { force: true });
-                    continue;
-                }
-                if (Date.now() >= deadline) {
-                    throw new LockAcquireError(lockFile, new Error(`legacy migration lock held for ${age}ms`));
-                }
-                // bounded spin; the claim window is tiny (a read + one write + one delete)
-                const until = Date.now() + 20;
-                while (Date.now() < until) {
-                    // spin
-                }
-            }
-        }
+        return adoptLegacyRecord(this.#migration());
+    }
+    async readAsync() {
+        return readRecordAsync(this.#migration());
+    }
+    #migration() {
+        return {
+            rootDir: this.rootDir,
+            lockPath: this.#legacyLockFile,
+            legacyTokens: join(this.legacyDir, TOKENS_FILE),
+            tokensPath: this.tokensPath,
+            stale: this.#lock.stale,
+            disableLock: this.#disableLock,
+            read: readJsonFile,
+            write: (record) => this.writeUnlocked(record),
+            lockError: (cause) => new LockAcquireError(this.#legacyLockFile, cause),
+        };
     }
     async update(mutate) {
         const release = await this.#acquire();

package/dist/core/extensions/builtin/mcp/catalog-cache.d.ts

@@ -3,6 +3,7 @@ import type { McpServerConfig } from "./config-schema.ts";
 import type { ServerConnection } from "./connection.ts";
 type ListedTool = Awaited<ReturnType<Client["listTools"]>>["tools"][number];
 type ListedResource = Awaited<ReturnType<Client["listResources"]>>["resources"][number];
+type ListedResourceTemplate = Awaited<ReturnType<Client["listResourceTemplates"]>>["resourceTemplates"][number];
 type ListedPrompt = Awaited<ReturnType<Client["listPrompts"]>>["prompts"][number];
 export interface McpCatalogCacheFile {
     readonly version: 1;
@@ -10,16 +11,19 @@ export interface McpCatalogCacheFile {
 }
 export interface McpCachedServerCatalog {
     readonly configHash: string;
+    readonly credentialIdentity?: string;
     readonly fetchedAt: number;
     readonly tools: ListedTool[];
     readonly resources: ListedResource[];
+    readonly resourceTemplates?: ListedResourceTemplate[];
     readonly prompts: ListedPrompt[];
     readonly instructions?: string;
 }
 export declare function getMcpCatalogCachePath(agentDir?: string): string;
 export declare function readMcpCatalogCache(agentDir?: string): Promise<McpCatalogCacheFile>;
-export declare function getValidCachedServer(cache: McpCatalogCacheFile, serverName: string, configHash: string, now?: number): McpCachedServerCatalog | undefined;
-export declare function collectServerCatalogForCache(connection: ServerConnection, config: McpServerConfig, configHash: string): Promise<McpCachedServerCatalog>;
-export declare function writeMcpCachedServer(agentDir: string | undefined, serverName: string, server: McpCachedServerCatalog): Promise<void>;
+export declare function getValidCachedServer(cache: McpCatalogCacheFile, serverName: string, configHash: string, credentialIdentity?: string): McpCachedServerCatalog | undefined;
+export declare function cachedCatalogNeedsRefresh(cached: McpCachedServerCatalog, now?: number): boolean;
+export declare function collectServerCatalogForCache(connection: ServerConnection, config: McpServerConfig, configHash: string, credentialIdentity?: string): Promise<McpCachedServerCatalog>;
+export declare function writeMcpCachedServer(agentDir: string | undefined, serverName: string, server: McpCachedServerCatalog, isCurrent?: () => boolean): Promise<void>;
 export {};
 //# sourceMappingURL=catalog-cache.d.ts.map

package/dist/core/extensions/builtin/mcp/catalog-cache.js

@@ -1,6 +1,7 @@
 import { randomUUID } from "node:crypto";
-import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
+import lockfile from "proper-lockfile";
 import { getAgentDir } from "../../../../config.js";
 import { collectAllPages } from "./expose/pagination.js";
 const CACHE_TTL_MS = 7 * 24 * 60 * 60 * 1000;
@@ -17,33 +18,62 @@ export async function readMcpCatalogCache(agentDir) {
         return EMPTY_CACHE;
     }
 }
-export function getValidCachedServer(cache, serverName, configHash, now = Date.now()) {
+export function getValidCachedServer(cache, serverName, configHash, credentialIdentity = "none") {
     const cached = cache.servers[serverName];
     if (cached === undefined)
         return undefined;
     if (cached.configHash !== configHash)
         return undefined;
-    if (now - cached.fetchedAt > CACHE_TTL_MS)
+    if (cached.credentialIdentity !== credentialIdentity &&
+        !(credentialIdentity === "none" && cached.credentialIdentity === undefined)) {
         return undefined;
+    }
     return cached;
 }
-export async function collectServerCatalogForCache(connection, config, configHash) {
+export function cachedCatalogNeedsRefresh(cached, now = Date.now()) {
+    return now - cached.fetchedAt > CACHE_TTL_MS;
+}
+export async function collectServerCatalogForCache(connection, config, configHash, credentialIdentity) {
     const tools = await collectAllPages((cursor) => connection.client.listTools(cursor === undefined ? {} : { cursor }, { timeout: config.requestTimeoutMs }));
     const resources = await collectOptionalPages((cursor) => connection.client.listResources(cursor === undefined ? {} : { cursor }, { timeout: config.requestTimeoutMs }));
     const prompts = await collectOptionalPages((cursor) => connection.client.listPrompts(cursor === undefined ? {} : { cursor }, { timeout: config.requestTimeoutMs }));
+    const resourceTemplates = await collectOptionalPages((cursor) => connection.client.listResourceTemplates(cursor === undefined ? {} : { cursor }, {
+        timeout: config.requestTimeoutMs,
+    }));
     return {
         configHash,
+        credentialIdentity,
         fetchedAt: Date.now(),
         instructions: connection.client.getInstructions(),
         prompts,
         resources,
+        resourceTemplates,
         tools: tools.items,
     };
 }
-export async function writeMcpCachedServer(agentDir, serverName, server) {
-    const cache = await readMcpCatalogCache(agentDir);
-    const next = { version: 1, servers: { ...cache.servers, [serverName]: server } };
-    await atomicWriteJson(getMcpCatalogCachePath(agentDir), next);
+export async function writeMcpCachedServer(agentDir, serverName, server, isCurrent) {
+    if (isCurrent?.() === false)
+        return;
+    const path = getMcpCatalogCachePath(agentDir);
+    await mkdir(dirname(path), { recursive: true });
+    const release = await lockfile.lock(dirname(path), {
+        lockfilePath: `${path}.lock`,
+        realpath: false,
+        retries: { retries: 50, factor: 1.2, minTimeout: 20, maxTimeout: 200 },
+        stale: 30_000,
+    });
+    try {
+        if (isCurrent?.() === false)
+            return;
+        const cache = await readMcpCatalogCache(agentDir);
+        if (isCurrent?.() === false)
+            return;
+        const next = { version: 1, servers: { ...cache.servers, [serverName]: server } };
+        await atomicWriteJson(path, next, isCurrent);
+    }
+    finally {
+        await release();
+    }
 }
 async function collectOptionalPages(listFn) {
     try {
@@ -54,11 +84,18 @@ async function collectOptionalPages(listFn) {
         return [];
     }
 }
-async function atomicWriteJson(path, value) {
+async function atomicWriteJson(path, value, isCurrent) {
     await mkdir(dirname(path), { recursive: true });
     const tmp = `${path}.${process.pid}.${randomUUID()}.tmp`;
-    await writeFile(tmp, `${JSON.stringify(value, null, 2)}\n`, "utf8");
-    await rename(tmp, path);
+    try {
+        await writeFile(tmp, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+        if (isCurrent?.() === false)
+            return;
+        await rename(tmp, path);
+    }
+    finally {
+        await rm(tmp, { force: true });
+    }
 }
 function normalizeCacheFile(value) {
     if (!isRecord(value) || value.version !== 1 || !isRecord(value.servers))
@@ -80,8 +117,20 @@ function normalizeCachedServer(value) {
         return undefined;
     const resources = Array.isArray(value.resources) ? value.resources : [];
     const prompts = Array.isArray(value.prompts) ? value.prompts : [];
+    const resourceTemplates = Array.isArray(value.resourceTemplates)
+        ? value.resourceTemplates
+        : [];
     const instructions = typeof value.instructions === "string" ? value.instructions : undefined;
-    return { configHash: value.configHash, fetchedAt: value.fetchedAt, instructions, prompts, resources, tools };
+    return {
+        configHash: value.configHash,
+        credentialIdentity: typeof value.credentialIdentity === "string" ? value.credentialIdentity : undefined,
+        fetchedAt: value.fetchedAt,
+        instructions,
+        prompts,
+        resources,
+        resourceTemplates,
+        tools,
+    };
 }
 function normalizeTools(value) {
     if (!Array.isArray(value))

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

@@ -4,6 +4,7 @@ import type { McpServerConfig, McpSettings } from "./config-schema.ts";
 import type { ServerConnection } from "./connection.ts";
 import type { McpOutputArtifacts } from "./guard/output-guard.ts";
 import type { McpEnsureFreshAuth } from "./health.ts";
+import type { McpInvocationResolver } from "./invocation.ts";
 type ListedTool = Awaited<ReturnType<Client["listTools"]>>["tools"][number];
 export interface McpToolCatalogEntry {
     server: string;
@@ -18,8 +19,9 @@ export interface McpToolCatalogEntry {
     agentDir?: string;
     artifacts?: McpOutputArtifacts;
     outputGuard?: McpSettings["outputGuard"];
+    invocation?: McpInvocationResolver;
 }
-type McpToolCatalogOptions = Pick<McpToolCatalogEntry, "agentDir" | "artifacts" | "ensureFresh" | "outputGuard">;
+type McpToolCatalogOptions = Pick<McpToolCatalogEntry, "agentDir" | "artifacts" | "ensureFresh" | "outputGuard" | "invocation">;
 export declare function collectToolCatalog(server: string, connection: ServerConnection, config: McpServerConfig, options?: McpToolCatalogOptions): Promise<McpToolCatalogEntry[]>;
 /** What registering these tools with this catalog's resources and prompts exposes;
  * equal identities register identical definitions. */

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

@@ -8,6 +8,7 @@ export async function collectToolCatalog(server, connection, config, options = {
         connection,
         description: tool.description,
         ensureFresh: options.ensureFresh,
+        invocation: options.invocation,
         outputGuard: options.outputGuard,
         requestTimeoutMs: config.requestTimeoutMs,
         schema: tool.inputSchema,
@@ -33,6 +34,7 @@ export function cachedToolsToCatalogEntries(server, catalog, connection, request
         description: tool.description,
         ensureConnected,
         ensureFresh: options.ensureFresh,
+        invocation: options.invocation,
         outputGuard: options.outputGuard,
         requestTimeoutMs,
         schema: tool.inputSchema,

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

@@ -19,6 +19,8 @@ export type ServerConnectionToolsChangedEvent = {
     readonly cause: "connect" | "notification";
 };
 export interface ServerConnectionOptions {
+    readonly credentialIdentity?: string;
+    readonly credentialsCurrent?: () => boolean;
     readonly serverName: string;
     readonly config: McpServerConfig;
     readonly logger: McpLogger;

package/dist/core/extensions/builtin/mcp/expose/call.d.ts

@@ -0,0 +1,12 @@
+import type { McpToolCatalogEntry } from "../catalog.ts";
+import type { McpInvocation, McpInvocationError } from "../invocation.ts";
+import type { McpToolDefinition } from "./register.ts";
+export declare function callMcpTool(entry: McpToolCatalogEntry, args: Record<string, unknown>, signal: AbortSignal | undefined, onUpdate: Parameters<McpToolDefinition["execute"]>[3], label: string, invocation: McpInvocation | undefined): Promise<{
+    kind: "called";
+    entry: McpToolCatalogEntry;
+    result: Awaited<ReturnType<McpToolCatalogEntry["connection"]["client"]["callTool"]>>;
+} | {
+    kind: "refused";
+    error: McpInvocationError;
+}>;
+//# sourceMappingURL=call.d.ts.map

package/dist/core/extensions/builtin/mcp/expose/call.js

@@ -0,0 +1,60 @@
+import { ToolExecError } from "../errors.js";
+import { ensureMcpToolCallConnection, withMcpRetriableFailedSendRetry, withMcpSessionExpiryRetry } from "../health.js";
+import { runMcpConnectionLifecycleCall } from "../idle.js";
+export async function callMcpTool(entry, args, signal, onUpdate, label, invocation) {
+    try {
+        return await runMcpConnectionLifecycleCall(entry.connection, () => withMcpSessionExpiryRetry(entry.connection, async () => {
+            if (entry.invocation === undefined) {
+                await ensureMcpToolCallConnection(entry.connection, entry.ensureFresh);
+                await entry.ensureConnected?.();
+            }
+            const prepare = async () => {
+                for (;;) {
+                    const prepared = await entry.invocation?.resolve(entry, args, invocation, signal);
+                    if (prepared === undefined || prepared.kind === "refused" || prepared.isCurrent()) {
+                        return prepared;
+                    }
+                }
+            };
+            // Readiness and its bounded renewal are not failed remote sends.
+            // Only a call attempt below enters the existing failed-send retry.
+            let next = await prepare();
+            return await withMcpRetriableFailedSendRetry(entry.connection, async () => {
+                for (;;) {
+                    const prepared = next ?? (await prepare());
+                    next = undefined;
+                    if (prepared?.kind === "refused")
+                        return prepared;
+                    if (prepared !== undefined && !prepared.isCurrent())
+                        continue;
+                    const current = prepared?.entry ?? entry;
+                    const result = await current.connection.client.callTool({ name: current.tool, arguments: args }, undefined, {
+                        onprogress: (progress) => {
+                            onUpdate?.({
+                                content: [{ type: "text", text: formatProgress(label, progress) }],
+                                details: { progress, server: entry.server, tool: entry.tool },
+                            });
+                        },
+                        signal,
+                        timeout: current.requestTimeoutMs,
+                    });
+                    return { kind: "called", entry: current, result };
+                }
+            });
+        }));
+    }
+    catch (error) {
+        const label = error instanceof Error ? `${error.name}: ${error.message}` : String(error);
+        throw new ToolExecError(`ToolExecError: ${label}`, {
+            cause: error,
+            phase: "call",
+            serverName: entry.server,
+        });
+    }
+}
+function formatProgress(label, progress) {
+    const total = progress.total === undefined ? "" : `/${progress.total}`;
+    const message = progress.message === undefined ? "" : ` ${progress.message}`;
+    return `${label} progress ${progress.progress}${total}${message}`.trim();
+}
+//# sourceMappingURL=call.js.map

package/dist/core/extensions/builtin/mcp/expose/proxy.js

@@ -10,6 +10,7 @@
 // self-correct; unknown tool names get nearest-match suggestions.
 import { Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
+import { registerDispatchIdentity } from "../../permission-system/dispatch-metadata.js";
 import { buildBm25Index } from "../../tool-search/engine/bm25.js";
 import { deriveMcpRegistrationId } from "../../tool-search/engine/marker.js";
 import { executeMcpCatalogEntry, mapMcpCatalogNames } from "./register.js";
@@ -38,14 +39,21 @@ export function createMcpProxyTool(server, entries) {
         registrationId: deriveMcpRegistrationId(server, entry.tool),
     })));
     const name = named[0]?.name.split("_").slice(0, 2).join("_") ?? `mcp_${server}`;
+    const parameters = Type.Object(ParamsSchema.properties);
+    registerDispatchIdentity(parameters, (input) => {
+        if (input.op !== "call" || typeof input.tool !== "string")
+            return undefined;
+        const entry = byTool.get(input.tool);
+        return entry?.invocation?.identity(entry);
+    });
     return {
         name,
         label: `MCP proxy for ${server}`,
         description: `Gateway to the '${server}' MCP server (${entries.length} tools). Use op:"search" with a query to find tools, op:"describe" with a tool name for its schema, then op:"call" with tool + args (args is a JSON object STRING — no strict validation, so match the described schema exactly).`,
         promptSnippet: `Proxy for the ${server} MCP server: search -> describe -> call (args as a JSON string).`,
-        parameters: ParamsSchema,
+        parameters,
         executionMode: "parallel",
-        async execute(_toolCallId, params, signal, onUpdate) {
+        async execute(toolCallId, params, signal, onUpdate, context) {
             if (params.op === "search") {
                 const matches = index.search(params.query ?? "", 10, {});
                 const body = matches.length === 0
@@ -73,7 +81,12 @@ export function createMcpProxyTool(server, entries) {
             catch (error) {
                 return textResult(server, `Invalid args for '${entry.tool}': ${error instanceof Error ? error.message : String(error)}. Pass args as a JSON object STRING matching the schema from op:"describe", e.g. {"op":"call","tool":"${entry.tool}","args":"{\\"key\\": \\"value\\"}"}.`);
             }
-            return await executeMcpCatalogEntry(entry, args, signal, onUpdate);
+            return await executeMcpCatalogEntry(entry, args, signal, onUpdate, {
+                toolCallId,
+                toolName: name,
+                input: params,
+                context,
+            });
         },
         renderCall(args, theme) {
             const detail = args.op === "search" ? (args.query ?? "") : (args.tool ?? "");