@fitchmultz/pi-mcp-adapter 8.0.5 → 8.0.7

package/dist/index.js

@@ -1,18 +1,18 @@
 import { Type } from "typebox";
-import { cloneMcpConfig, isPathInsideProject, loadMcpConfig, writeProjectServerDisabledOverride } from "./config.js";
-import { buildProxyDescription, directToolSelection, getMissingConfiguredDirectToolServers } from "./direct-tools.js";
-import { getMetadataCachePath, isServerCacheValid, loadMetadataCache, reconstructToolMetadata } from "./metadata-cache.js";
+import { cloneMcpConfig, isPathInsideProject, loadMcpConfig, writeProjectServerDisabledOverride, } from "./config.js";
+import { buildProxyDescription, directToolSelection, getMissingConfiguredDirectToolServers, } from "./direct-tools.js";
+import { getMetadataCachePath, isServerCacheValid, loadMetadataCache, reconstructToolMetadata, } from "./metadata-cache.js";
 import { createPromptCommand, resolveCachedPrompts } from "./prompts.js";
 import { logger } from "./logger.js";
-import { DEFAULT_MCP_SCRIPT_TIMEOUT_MS, formatTerminalError } from "./utils.js";
+import { DEFAULT_MCP_SCRIPT_TIMEOUT_MS, formatTerminalError, MAX_CONCURRENT_SERVER_CONNECTS, parallelLimit, } from "./utils.js";
 import { createOAuthRuntime, shutdownOAuth } from "./mcp-oauth-runtime.js";
 import { renderMcpProxyToolCall, renderMcpToolResult } from "./tool-result-renderer.js";
-import { createMcpRuntimeOwner, createOwnedUi, isAbortError } from "./runtime-owner.js";
+import { createMcpRuntimeOwner, createOwnedUi, isAbortError, } from "./runtime-owner.js";
 import { publishMcpStatusShutdown } from "./mcp-status.js";
 import { MAX_PAGE_SIZE, paginate, rankToolMatches } from "./search-ranking.js";
 import { createToolLoader } from "./tool-loader.js";
-import { gatewayParameters, prepareGatewayArguments } from "./gateway-arguments.js";
-import { guardMcpOutput, guardedMcpDetails, readMcpResult, resolveMcpOutputGuardOptions } from "./mcp-output-guard.js";
+import { gatewayParameters, prepareGatewayArguments, } from "./gateway-arguments.js";
+import { guardMcpOutput, guardedMcpDetails, readMcpResult, resolveMcpOutputGuardOptions, } from "./mcp-output-guard.js";
 import { abortable, throwIfAborted } from "./abort.js";
 export { MCP_STATUS_EVENT, MCP_STATUS_SNAPSHOT_VERSION, } from "./types.js";
 const INIT_WAIT_TIMEOUT_MS = 30_000;
@@ -71,43 +71,49 @@ function installMcpAdapter(pi, options) {
             failures.push(error);
         }
         try {
-            if (currentState.owner)
+            if (currentState.owner) {
                 await currentState.owner.stop(reason);
-            else
+            }
+            else {
                 await currentState.lifecycle.gracefulShutdown();
+            }
         }
         catch (error) {
             failures.push(error);
         }
-        if (failures.length)
+        if (failures.length) {
             throw new AggregateError(failures, "MCP state persistence/cleanup failed");
+        }
     }
-    const earlyConfig = programmaticConfig
-        ? cloneMcpConfig(sessionConfig)
-        : { mcpServers: {} };
+    const earlyConfig = programmaticConfig ? cloneMcpConfig(sessionConfig) : { mcpServers: {} };
     const earlyCache = null;
     let currentConfig = earlyConfig;
     const envRaw = process.env.MCP_DIRECT_TOOLS;
-    const envDirectToolOverride = envRaw?.split(",").map(s => s.trim()).filter(Boolean);
+    const envDirectToolOverride = envRaw
+        ?.split(",")
+        .map((s) => s.trim())
+        .filter(Boolean);
     const toolLoader = createToolLoader(pi, () => state, () => initPromise, beforeExecute);
     let runtimeCwd;
     let proxyToolRegistered = false;
     let proxyToolDescription = null;
     let directToolsFrozen = false;
     function applyDirectToolConfigChanges(changes) {
-        if (!state)
+        if (!state) {
             return;
+        }
         for (const [serverName, value] of changes) {
             const definition = state.config.mcpServers[serverName];
-            if (!definition)
+            if (!definition) {
                 continue;
+            }
             state.config.mcpServers[serverName] = { ...definition, directTools: value };
         }
     }
     function syncToolSurface(ctx) {
         const config = state?.config ?? currentConfig;
         const cache = loadMetadataCache(state?.metadataCacheEnabled ?? false);
-        toolLoader.sync(config, cache, envRaw === "__none__" ? null : envDirectToolOverride, specs => syncGateways(config, cache, specs));
+        toolLoader.sync(config, cache, envRaw === "__none__" ? null : envDirectToolOverride, (specs) => syncGateways(config, cache, specs));
     }
     const registeredPromptCommands = new Set();
     function registerPromptCommands(specs) {
@@ -123,8 +129,9 @@ function installMcpAdapter(pi, options) {
     function syncPromptCommands() {
         registerPromptCommands([...(state?.promptMetadata?.values() ?? [])].flat());
     }
-    if (!options.transformConfig)
+    if (!options.transformConfig) {
         registerPromptCommands(resolveCachedPrompts(earlyConfig, false));
+    }
     const getPiTools = () => pi.getAllTools();
     pi.registerFlag("mcp-config", {
         description: "Path to MCP config file",
@@ -133,13 +140,16 @@ function installMcpAdapter(pi, options) {
     function startInitialization(init, ctx, owner, oauthRuntime, runtimeConfig, generation) {
         const promise = init.initializeMcp(pi, ctx, owner, {
             ...(programmaticConfig ? { config: runtimeConfig } : { resolvedConfig: runtimeConfig }),
-            ...(options.outputDirectory !== undefined ? { outputDirectory: options.outputDirectory } : {}),
+            ...(options.outputDirectory !== undefined
+                ? { outputDirectory: options.outputDirectory }
+                : {}),
             oauthRuntime,
             statusEvents: pi.events,
             ...(options.onToolCall ? { onToolCall: options.onToolCall } : {}),
         });
         initPromise = promise;
-        return promise.then(async (nextState) => {
+        return promise
+            .then(async (nextState) => {
             if (!owner.isActive() || generation !== lifecycleGeneration || initPromise !== promise) {
                 try {
                     await shutdownState(nextState, "stale_session_start");
@@ -151,8 +161,9 @@ function installMcpAdapter(pi, options) {
             }
             state = nextState;
             nextState.onToolMetadataUpdated = (_serverName, _reason) => {
-                if (state !== nextState || !owner.isActive())
+                if (state !== nextState || !owner.isActive()) {
                     return;
+                }
                 syncPromptCommands();
                 if (directToolsFrozen) {
                     logger.debug(`MCP: metadata update for ${_serverName} (${_reason}) skipped — directTools frozen`);
@@ -160,9 +171,11 @@ function installMcpAdapter(pi, options) {
                 }
                 syncToolSurface(ctx);
             };
-            for (const server of toolLoader.selectedServers()) {
-                if (!nextState.toolMetadata.has(server) && nextState.config.mcpServers[server])
-                    await init.lazyConnect(nextState, server, owner.signal);
+            const uncachedSelectedServers = toolLoader
+                .selectedServers()
+                .filter((server) => !nextState.toolMetadata.has(server) && nextState.config.mcpServers[server]);
+            if (uncachedSelectedServers.length > 0) {
+                await parallelLimit(uncachedSelectedServers, MAX_CONCURRENT_SERVER_CONNECTS, (server) => init.lazyConnect(nextState, server, owner.signal));
             }
             owner.throwIfInactive();
             syncPromptCommands();
@@ -171,9 +184,10 @@ function installMcpAdapter(pi, options) {
             initPromise = null;
             if (nextState.config.settings?.freezeDirectTools === true) {
                 directToolsFrozen = true;
-                logger.info("MCP: direct tools frozen after initial sync — reconnects won't rebuild the system prompt; use mcp({ action: \"connect\", server: \"server\" }) to rediscover");
+                logger.info('MCP: direct tools frozen after initial sync — reconnects won\'t rebuild the system prompt; use mcp({ action: "connect", server: "server" }) to rediscover');
             }
-        }).catch(async (err) => {
+        })
+            .catch(async (err) => {
             if (!owner.isActive() || generation !== lifecycleGeneration) {
                 return;
             }
@@ -182,13 +196,11 @@ function installMcpAdapter(pi, options) {
             }
             console.error(`MCP initialization failed: ${formatTerminalError(err)}`);
             initPromise = null;
-            if (state)
+            if (state) {
                 return;
+            }
             try {
-                await Promise.all([
-                    owner.stop("MCP initialization failed"),
-                    shutdownOAuth(oauthRuntime),
-                ]);
+                await Promise.all([owner.stop("MCP initialization failed"), shutdownOAuth(oauthRuntime)]);
             }
             catch (error) {
                 console.error(`MCP: failed to clean rejected initialization: ${formatTerminalError(error)}`);
@@ -221,8 +233,9 @@ function installMcpAdapter(pi, options) {
         catch (error) {
             console.error(`MCP: failed to shut down previous session state: ${formatTerminalError(error)}`);
         }
-        if (generation !== lifecycleGeneration || !owner.isActive())
+        if (generation !== lifecycleGeneration || !owner.isActive()) {
             return;
+        }
         let runtimeConfig;
         if (programmaticConfig) {
             currentConfigPath = undefined;
@@ -230,24 +243,27 @@ function installMcpAdapter(pi, options) {
         }
         else {
             const registeredConfigPath = pi.getFlag("mcp-config");
-            currentConfigPath = options.configPath
-                ?? (typeof registeredConfigPath === "string" ? registeredConfigPath : undefined);
-            runtimeConfig = loadMcpConfig(currentConfigPath, ctx.cwd, { includeProject: ctx.isProjectTrusted() });
+            currentConfigPath =
+                options.configPath ??
+                    (typeof registeredConfigPath === "string" ? registeredConfigPath : undefined);
+            runtimeConfig = loadMcpConfig(currentConfigPath, ctx.cwd, {
+                includeProject: ctx.isProjectTrusted(),
+            });
         }
         if (options.transformConfig) {
             runtimeConfig = cloneMcpConfig(options.transformConfig(cloneMcpConfig(runtimeConfig), ctx));
         }
         currentConfig = runtimeConfig;
-        const metadataCacheEnabled = ctx.isProjectTrusted()
-            || !isPathInsideProject(getMetadataCachePath(), ctx.cwd);
+        const metadataCacheEnabled = ctx.isProjectTrusted() || !isPathInsideProject(getMetadataCachePath(), ctx.cwd);
         toolLoader.restore(ctx);
         registerPromptCommands(resolveCachedPrompts(runtimeConfig, metadataCacheEnabled));
         const runtimeCache = loadMetadataCache(metadataCacheEnabled);
-        toolLoader.sync(runtimeConfig, runtimeCache, envRaw === "__none__" ? null : envDirectToolOverride, specs => syncGateways(runtimeConfig, runtimeCache, specs));
+        toolLoader.sync(runtimeConfig, runtimeCache, envRaw === "__none__" ? null : envDirectToolOverride, (specs) => syncGateways(runtimeConfig, runtimeCache, specs));
         const init = await import("./init.js");
         initModule = init;
-        if (generation !== lifecycleGeneration || !owner.isActive())
+        if (generation !== lifecycleGeneration || !owner.isActive()) {
             return;
+        }
         const initialization = startInitialization(init, ctx, owner, oauthRuntime, runtimeConfig, generation);
         if (envRaw !== undefined && envRaw !== "__none__") {
             const missingEnvDirectTools = getMissingConfiguredDirectToolServers(runtimeConfig, runtimeCache, envDirectToolOverride);
@@ -262,12 +278,14 @@ function installMcpAdapter(pi, options) {
         syncToolSurface(ctx);
     });
     pi.on("model_select", (_event, ctx) => {
-        if (state)
+        if (state) {
             syncToolSurface(ctx);
+        }
     });
     pi.on("before_agent_start", async (_event, ctx) => {
-        if (ctx.cwd !== runtimeCwd)
+        if (ctx.cwd !== runtimeCwd) {
             await startSession(ctx);
+        }
     });
     pi.on("session_shutdown", async () => {
         // Cached tool selections exist before background server initialization finishes.
@@ -288,10 +306,11 @@ function installMcpAdapter(pi, options) {
             shutdownState(currentState, "session_shutdown"),
             oauthRuntime ? shutdownOAuth(oauthRuntime) : Promise.resolve(),
         ]);
-        const failures = results.flatMap(result => result.status === "rejected" ? [result.reason] : []);
+        const failures = results.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
         // Ordinary extension error handling owns reporting. Strict clean-exit hosts must see failure.
-        if (failures.length)
+        if (failures.length) {
             throw new AggregateError(failures, "MCP session shutdown persistence/cleanup failed");
+        }
     });
     function createCommandContext(ctx) {
         const owner = currentOwner;
@@ -322,8 +341,9 @@ function installMcpAdapter(pi, options) {
                 return null;
             }
         }
-        if (!state)
+        if (!state) {
             ctx.ui?.notify("MCP not initialized", "error");
+        }
         return state;
     }
     pi.registerCommand("mcp", {
@@ -345,10 +365,14 @@ function installMcpAdapter(pi, options) {
                 return subcommands.length > 0 ? subcommands : null;
             }
             const [, subcommand, argumentPrefix] = argumentMatch;
-            if ((subcommand !== "reconnect" && subcommand !== "logout" && subcommand !== "disable" && subcommand !== "enable")
-                || argumentPrefix === undefined
-                || !state)
+            if ((subcommand !== "reconnect" &&
+                subcommand !== "logout" &&
+                subcommand !== "disable" &&
+                subcommand !== "enable") ||
+                argumentPrefix === undefined ||
+                !state) {
                 return null;
+            }
             const servers = Object.keys(state.config.mcpServers)
                 .filter((serverName) => serverName.startsWith(argumentPrefix.trimStart()))
                 .map((serverName) => ({ value: `${subcommand} ${serverName}`, label: serverName }));
@@ -358,9 +382,10 @@ function installMcpAdapter(pi, options) {
             const { owner: commandOwner, context: commandCtx } = createCommandContext(ctx);
             const commandProjectTrusted = commandCtx.isProjectTrusted();
             const commandState = await ensureCommandState(commandOwner, commandCtx);
-            if (!commandState)
+            if (!commandState) {
                 return;
-            const { showStatus, showTools, showPrompts, reconnectServers, logoutServer, openMcpPanel, openMcpSetup } = await import("./commands.js");
+            }
+            const { showStatus, showTools, showPrompts, reconnectServers, logoutServer, openMcpPanel, openMcpSetup, } = await import("./commands.js");
             const parts = args?.trim()?.split(/\s+/) ?? [];
             const subcommand = parts[0] ?? "";
             const targetServer = parts[1];
@@ -369,8 +394,9 @@ function installMcpAdapter(pi, options) {
                 case "reconnect":
                     commandOwner?.throwIfInactive();
                     await reconnectServers(commandState, commandCtx, targetServer);
-                    if (directToolsFrozen)
+                    if (directToolsFrozen) {
                         syncToolSurface(commandCtx);
+                    }
                     break;
                 case "tools":
                     await showTools(commandState, commandCtx);
@@ -395,8 +421,9 @@ function installMcpAdapter(pi, options) {
                 case "logout": {
                     const serverName = rest;
                     if (!serverName) {
-                        if (commandCtx.hasUI)
+                        if (commandCtx.hasUI) {
                             commandCtx.ui?.notify("Usage: /mcp logout <server>", "error");
+                        }
                         return;
                     }
                     commandOwner?.throwIfInactive();
@@ -468,8 +495,9 @@ function installMcpAdapter(pi, options) {
                 return;
             }
             const commandState = await ensureCommandState(commandOwner, commandCtx);
-            if (!commandState)
+            if (!commandState) {
                 return;
+            }
             const { authenticateServer, openMcpAuthPanel, reconnectServer } = await import("./commands.js");
             if (!serverName) {
                 if (programmaticConfig) {
@@ -491,76 +519,143 @@ function installMcpAdapter(pi, options) {
         if (!state && initPromise) {
             try {
                 const initialized = await awaitWithTimeout(abortable(initPromise, signal), INIT_WAIT_TIMEOUT_MS);
-                if (initialized === INIT_WAIT_TIMED_OUT)
+                if (initialized === INIT_WAIT_TIMED_OUT) {
                     return {
-                        content: [{ type: "text", text: "MCP initialization is still in progress. Try again shortly." }],
+                        content: [
+                            {
+                                type: "text",
+                                text: "MCP initialization is still in progress. Try again shortly.",
+                            },
+                        ],
                         details: { error: "init_timeout", timeoutMs: INIT_WAIT_TIMEOUT_MS },
                     };
+                }
                 owner?.throwIfInactive();
                 state = initialized;
             }
             catch (error) {
-                if (signal?.aborted || (owner && isAbortError(error, owner.signal)))
+                if (signal?.aborted || (owner && isAbortError(error, owner.signal))) {
                     throw error;
+                }
                 const message = error instanceof Error ? error.message : String(error);
-                return { content: [{ type: "text", text: `MCP initialization failed: ${message}` }], details: { error: "init_failed", message } };
+                return {
+                    content: [{ type: "text", text: `MCP initialization failed: ${message}` }],
+                    details: { error: "init_failed", message },
+                };
             }
         }
         owner?.throwIfInactive();
-        return state ?? { content: [{ type: "text", text: "MCP not initialized" }], details: { error: "not_initialized" } };
+        return (state ?? {
+            content: [{ type: "text", text: "MCP not initialized" }],
+            details: { error: "not_initialized" },
+        });
     }
-    const unavailableFeatures = (enable = [], tools) => enable.filter(feature => !tools.some(tool => tool.name === (feature === "gateway" ? "mcp" : "mcp_script")));
+    const unavailableFeatures = (enable = [], tools) => enable.filter((feature) => !tools.some((tool) => tool.name === (feature === "gateway" ? "mcp" : "mcp_script")));
     async function searchAndLoad(params, signal, ctx) {
         throwIfAborted(signal);
-        if (params.query === undefined && !params.enable?.length)
+        if (params.query === undefined && !params.enable?.length) {
             throw new Error("Provide query or enable.");
+        }
         // Loading front doors does not require initialization or connect to a server.
         if (params.query === undefined) {
             const tools = toolLoader.activate([], params.enable);
             const unavailable = unavailableFeatures(params.enable, tools);
-            return { content: [{ type: "text", text: `Loaded for the next request: ${JSON.stringify(tools)}${unavailable.length ? `. Unavailable under configuration or host policy: ${unavailable.join(", ")}` : ""}` }], details: { loaded: tools, unavailable }, tools };
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Loaded for the next request: ${JSON.stringify(tools)}${unavailable.length ? `. Unavailable under configuration or host policy: ${unavailable.join(", ")}` : ""}`,
+                    },
+                ],
+                details: { loaded: tools, unavailable },
+                tools,
+            };
         }
         const ready = await getToolState(signal);
-        if ("content" in ready)
+        if ("content" in ready) {
             return { ...ready, tools: [] };
+        }
         const proxy = await import("./proxy-modes.js");
         if (params.server && !ready.toolMetadata.has(params.server)) {
             const discovery = await proxy.executeConnect(ready, params.server, signal);
-            if (discovery.details.error)
+            if (discovery.details.error) {
                 return { ...discovery, tools: [] };
+            }
         }
         syncToolSurface(ctx);
-        const matches = params.query.trim() ? rankToolMatches(ready, params.query, params.server)
-            : params.server ? (ready.toolMetadata.get(params.server) ?? []).filter(tool => !tool.resourceUri).map(tool => ({ server: params.server, tool })).sort((a, b) => a.tool.name.localeCompare(b.tool.name)) : [];
+        const matches = params.query.trim()
+            ? rankToolMatches(ready, params.query, params.server)
+            : params.server
+                ? (ready.toolMetadata.get(params.server) ?? [])
+                    .filter((tool) => !tool.resourceUri)
+                    .map((tool) => ({ server: params.server, tool }))
+                    .sort((a, b) => a.tool.name.localeCompare(b.tool.name))
+                : [];
         const page = paginate(matches, params.offset ?? 0, params.limit ?? 5);
         const tools = toolLoader.activate(page.items, params.enable);
         const unavailable = unavailableFeatures(params.enable, tools);
-        const typedCount = tools.filter(tool => tool.name !== "mcp" && tool.name !== "mcp_script").length;
+        const typedCount = tools.filter((tool) => tool.name !== "mcp" && tool.name !== "mcp_script").length;
         const result = proxy.executeSearch(ready, params.query, params.server, typedCount < page.items.length, params.limit ?? 5, params.offset, "mcp_search");
         const guarded = await guardMcpOutput([
             ...result.content,
-            { type: "text", text: tools.length ? `Loaded for the next request: ${JSON.stringify(tools)}` : 'No direct tools loaded. Enable gateway or script with mcp_search({ enable: ["gateway"] }) or mcp_search({ enable: ["script"] }), then use mcp action call or tools.call with the returned exact names.' },
-            ...(unavailable.length ? [{ type: "text", text: `Unavailable under configuration or host policy: ${unavailable.join(", ")}` }] : []),
+            {
+                type: "text",
+                text: tools.length
+                    ? `Loaded for the next request: ${JSON.stringify(tools)}`
+                    : 'No direct tools loaded. Enable gateway or script with mcp_search({ enable: ["gateway"] }) or mcp_search({ enable: ["script"] }), then use mcp action call or tools.call with the returned exact names.',
+            },
+            ...(unavailable.length
+                ? [
+                    {
+                        type: "text",
+                        text: `Unavailable under configuration or host policy: ${unavailable.join(", ")}`,
+                    },
+                ]
+                : []),
         ], resolveMcpOutputGuardOptions(ready.config.settings, ready.outputDirectory));
-        return { content: guarded.content, details: { ...result.details, ...guardedMcpDetails(guarded), loaded: tools, ...(unavailable.length ? { unavailable } : {}) }, tools };
+        return {
+            content: guarded.content,
+            details: {
+                ...result.details,
+                ...guardedMcpDetails(guarded),
+                loaded: tools,
+                ...(unavailable.length ? { unavailable } : {}),
+            },
+            tools,
+        };
     }
     const searchDefinition = {
-        name: "mcp_search", label: "MCP Search",
+        name: "mcp_search",
+        label: "MCP Search",
         description: "Discover and load typed MCP tools for the next request. Use query; server discovers an uncached server (empty query browses it). Results report incomplete coverage. Or enable gateway for mcp status/list/search/describe/call/connect/instructions, resources/read-resource, read-result, auth-start/auth-complete and ui-messages; enable script for JavaScript composition, resources and saved-result readback. Enable alone performs no integration action. Loaded schemas stay available in this session/branch.",
         parameters: Type.Object({
             query: Type.Optional(Type.String()),
-            enable: Type.Optional(Type.Array(Type.Union([Type.Literal("gateway"), Type.Literal("script")]), { minItems: 1, uniqueItems: true })),
+            enable: Type.Optional(Type.Array(Type.Union([Type.Literal("gateway"), Type.Literal("script")]), {
+                minItems: 1,
+                uniqueItems: true,
+            })),
             server: Type.Optional(Type.String()),
-            limit: Type.Optional(Type.Integer({ minimum: 1, maximum: MAX_PAGE_SIZE, description: "Tools to load (default 5)." })),
+            limit: Type.Optional(Type.Integer({
+                minimum: 1,
+                maximum: MAX_PAGE_SIZE,
+                description: "Tools to load (default 5).",
+            })),
             offset: Type.Optional(Type.Integer({ minimum: 0 })),
-        }, { anyOf: [{ type: "object", required: ["query"] }, { type: "object", required: ["enable"] }] }),
+        }, {
+            anyOf: [
+                { type: "object", required: ["query"] },
+                { type: "object", required: ["enable"] },
+            ],
+        }),
         renderResult: renderMcpToolResult,
         async execute(toolCallId, params, signal, _onUpdate, ctx) {
             if (beforeExecute) {
-                if (currentOwner)
+                if (currentOwner) {
                     await currentOwner.runCallback("beforeExecute", () => beforeExecute(toolCallId, ctx));
-                else
+                }
+                else {
                     await beforeExecute(toolCallId, ctx);
+                }
             }
             return searchAndLoad(params, signal, ctx);
         },
@@ -568,8 +663,9 @@ function installMcpAdapter(pi, options) {
     pi.registerTool(searchDefinition);
     let scriptToolRegistered = false;
     function registerScriptTool() {
-        if (scriptToolRegistered)
+        if (scriptToolRegistered) {
             return;
+        }
         toolLoader.registerFeature("script", {
             ...(beforeExecute ? { executionMode: "sequential" } : {}),
             name: "mcp_script",
@@ -577,18 +673,26 @@ function installMcpAdapter(pi, options) {
             description: "Compose MCP calls with trusted JavaScript: await tools.search({query, server?}), tools.describe({path}), tools.call(path,args). Describe returns complete JSON schemas. Calls return {ok,data} with raw MCP results, or {ok:false,error,data?}. Resources: tools.resources({server}), tools.readResource({server,uri}). Saved results: tools.readResult({ref,path?,fields?,offset?,limit?}); never repeats a remote call. Use emit(value) to return selected data or content blocks. No Node, filesystem, or network globals. Prefer a direct tool for one call; use scripts for loops, filtering and chains.",
             promptSnippet: "Batch multiple MCP tool calls in one JavaScript request (loop, filter, chain)",
             parameters: Type.Object({
-                code: Type.String({ description: "Trusted JavaScript MCP script. Use tools.<prefixedToolName>(args) and emit(value)." }),
-                timeoutMs: Type.Optional(Type.Number({ minimum: 1, description: options.defaultScriptTimeoutMs === null
+                code: Type.String({
+                    description: "Trusted JavaScript MCP script. Use tools.<prefixedToolName>(args) and emit(value).",
+                }),
+                timeoutMs: Type.Optional(Type.Number({
+                    minimum: 1,
+                    description: options.defaultScriptTimeoutMs === null
                         ? "Execution timeout in milliseconds (no default deadline)"
-                        : `Execution timeout in milliseconds (default: ${options.defaultScriptTimeoutMs ?? DEFAULT_MCP_SCRIPT_TIMEOUT_MS})` })),
+                        : `Execution timeout in milliseconds (default: ${options.defaultScriptTimeoutMs ?? DEFAULT_MCP_SCRIPT_TIMEOUT_MS})`,
+                })),
             }),
             renderResult: renderMcpToolResult,
             async execute(toolCallId, params, signal, _onUpdate, ctx) {
                 const ready = await getToolState(signal);
-                if ("content" in ready)
+                if ("content" in ready) {
                     return ready;
+                }
                 const { runMcpScript } = await import("./mcp-code.js");
-                return runMcpScript(ready, params.code, params.timeoutMs ?? options.defaultScriptTimeoutMs, getPiTools, signal, toolCallId, beforeExecute ? (callSignal, operation) => beforeExecute(toolCallId, { ...ctx, signal: callSignal }, operation) : undefined);
+                return runMcpScript(ready, params.code, params.timeoutMs ?? options.defaultScriptTimeoutMs, getPiTools, signal, toolCallId, beforeExecute
+                    ? (callSignal, operation) => beforeExecute(toolCallId, { ...ctx, signal: callSignal }, operation)
+                    : undefined);
             },
         });
         scriptToolRegistered = true;
@@ -596,7 +700,9 @@ function installMcpAdapter(pi, options) {
     function registerProxyTool(description) {
         toolLoader.registerFeature("gateway", {
             ...(beforeExecute ? { executionMode: "sequential" } : {}),
-            name: "mcp", label: "MCP", description,
+            name: "mcp",
+            label: "MCP",
+            description,
             promptSnippet: "MCP server operations, resources, saved result readback, and fallback tool calls",
             renderCall: renderMcpProxyToolCall,
             parameters: gatewayParameters,
@@ -605,51 +711,78 @@ function installMcpAdapter(pi, options) {
             async execute(toolCallId, rawParams, signal, _onUpdate, ctx) {
                 const params = prepareGatewayArguments(rawParams);
                 if (beforeExecute && params.action !== "call" && params.action !== "read-resource") {
-                    if (currentOwner)
+                    if (currentOwner) {
                         await currentOwner.runCallback("beforeExecute", () => beforeExecute(toolCallId, ctx));
-                    else
+                    }
+                    else {
                         await beforeExecute(toolCallId, ctx);
+                    }
                 }
                 const ready = await getToolState(signal);
-                if ("content" in ready)
+                if ("content" in ready) {
                     return ready;
+                }
                 const proxy = await import("./proxy-modes.js");
                 const present = async (result) => {
                     const guarded = await guardMcpOutput(result.content, resolveMcpOutputGuardOptions(ready.config.settings, ready.outputDirectory));
-                    return { content: guarded.content, details: { ...result.details, ...guardedMcpDetails(guarded) } };
+                    return {
+                        content: guarded.content,
+                        details: { ...result.details, ...guardedMcpDetails(guarded) },
+                    };
                 };
                 const beforeDispatch = beforeExecute
                     ? (callSignal, operation) => beforeExecute(toolCallId, { ...ctx, signal: callSignal }, operation)
                     : undefined;
-                if (params.server && ["list", "search", "describe", "instructions"].includes(params.action) && !ready.toolMetadata.has(params.server)) {
+                if (params.server &&
+                    ["list", "search", "describe", "instructions"].includes(params.action) &&
+                    !ready.toolMetadata.has(params.server)) {
                     const discovery = await proxy.executeConnect(ready, params.server, signal);
-                    if (discovery.details.error)
+                    if (discovery.details.error) {
                         return discovery;
+                    }
                     syncToolSurface(ctx);
                 }
                 switch (params.action) {
-                    case "ui-messages": return proxy.executeUiMessages(ready);
-                    case "auth-start": return proxy.executeAuthStart(ready, params.server, signal);
+                    case "ui-messages":
+                        return proxy.executeUiMessages(ready);
+                    case "auth-start":
+                        return proxy.executeAuthStart(ready, params.server, signal);
                     case "auth-complete": {
                         const input = params.args?.redirectUrl ?? params.args?.code ?? params.args?.input;
-                        if (input !== undefined && (typeof input !== "string" || input.trim().length === 0))
+                        if (input !== undefined && (typeof input !== "string" || input.trim().length === 0)) {
                             throw new Error("auth-complete requires a non-empty redirectUrl, code, or input");
+                        }
                         return proxy.executeAuthComplete(ready, params.server, input, signal);
                     }
-                    case "call": return proxy.executeCall(ready, params.tool, params.args, params.server, getPiTools, signal, { toolCallId }, beforeDispatch);
+                    case "call":
+                        return proxy.executeCall(ready, params.tool, params.args, params.server, getPiTools, signal, { toolCallId }, beforeDispatch);
                     case "connect": {
                         const result = await proxy.executeConnect(ready, params.server, signal, params.limit, params.offset);
                         syncToolSurface(ctx);
                         return present(result);
                     }
-                    case "describe": return present(proxy.executeDescribe(ready, params.tool, params.server));
-                    case "instructions": return present(proxy.executeInstructions(ready, params.server));
-                    case "search": return present(proxy.executeSearch(ready, params.query, params.server, params.includeSchemas, params.limit, params.offset));
-                    case "list": return present(proxy.executeList(ready, params.server, params.limit, params.offset));
-                    case "resources": return present(await (await import("./resource-tools.js")).executeResourceList(ready, params.server, params.limit, params.offset, signal));
-                    case "read-resource": return (await import("./resource-tools.js")).executeResourceRead(ready, params.server, params.uri, signal, { toolCallId }, beforeDispatch);
-                    case "read-result": return readMcpResult({ ref: params.ref, ...(params.path !== undefined ? { path: params.path } : {}), ...(params.fields ? { fields: params.fields } : {}), ...(params.offset !== undefined ? { offset: params.offset } : {}), ...(params.limit !== undefined ? { limit: params.limit } : {}) }, resolveMcpOutputGuardOptions(ready.config.settings, ready.outputDirectory));
-                    case "status": return present(proxy.executeStatus(ready));
+                    case "describe":
+                        return present(proxy.executeDescribe(ready, params.tool, params.server));
+                    case "instructions":
+                        return present(proxy.executeInstructions(ready, params.server));
+                    case "search":
+                        return present(proxy.executeSearch(ready, params.query, params.server, params.includeSchemas, params.limit, params.offset));
+                    case "list":
+                        return present(proxy.executeList(ready, params.server, params.limit, params.offset));
+                    case "resources":
+                        return present(await (await import("./resource-tools.js")).executeResourceList(ready, params.server, params.limit, params.offset, signal));
+                    case "read-resource":
+                        return (await import("./resource-tools.js")).executeResourceRead(ready, params.server, params.uri, signal, { toolCallId }, beforeDispatch);
+                    case "read-result":
+                        return readMcpResult({
+                            ref: params.ref,
+                            ...(params.path !== undefined ? { path: params.path } : {}),
+                            ...(params.fields ? { fields: params.fields } : {}),
+                            ...(params.offset !== undefined ? { offset: params.offset } : {}),
+                            ...(params.limit !== undefined ? { limit: params.limit } : {}),
+                        }, resolveMcpOutputGuardOptions(ready.config.settings, ready.outputDirectory));
+                    case "status":
+                        return present(proxy.executeStatus(ready));
                 }
             },
         });
@@ -658,24 +791,30 @@ function installMcpAdapter(pi, options) {
     }
     function syncGateways(config, cache, directSpecs) {
         const policy = {};
-        if (config.settings?.scriptMode !== false)
+        if (config.settings?.scriptMode !== false) {
             policy.script = {};
+        }
         const missingConfiguredDirectToolServers = getMissingConfiguredDirectToolServers(config, cache, envRaw === undefined || envRaw === "__none__" ? undefined : envDirectToolOverride);
-        const hasPinnedResources = envRaw !== "__none__" && Object.entries(config.mcpServers).some(([server, definition]) => {
-            if (definition.disabled === true)
-                return false;
-            const selection = directToolSelection(config, server, envDirectToolOverride);
-            if (!selection)
-                return false;
-            const entry = cache?.servers[server];
-            const metadata = state?.toolMetadata.get(server) ?? (entry && isServerCacheValid(entry, definition)
-                ? reconstructToolMetadata(server, entry, config.settings?.toolPrefix ?? "server", definition) : []);
-            return metadata.some(tool => tool.resourceUri && (selection === true || selection.includes(tool.originalName)));
-        });
-        const shouldRegisterProxyTool = config.settings?.disableProxyTool !== true
-            || hasPinnedResources
-            || directSpecs.length === 0
-            || missingConfiguredDirectToolServers.length > 0;
+        const hasPinnedResources = envRaw !== "__none__" &&
+            Object.entries(config.mcpServers).some(([server, definition]) => {
+                if (definition.disabled === true) {
+                    return false;
+                }
+                const selection = directToolSelection(config, server, envDirectToolOverride);
+                if (!selection) {
+                    return false;
+                }
+                const entry = cache?.servers[server];
+                const metadata = state?.toolMetadata.get(server) ??
+                    (entry && isServerCacheValid(entry, definition)
+                        ? reconstructToolMetadata(server, entry, config.settings?.toolPrefix ?? "server", definition)
+                        : []);
+                return metadata.some((tool) => tool.resourceUri && (selection === true || selection.includes(tool.originalName)));
+            });
+        const shouldRegisterProxyTool = config.settings?.disableProxyTool !== true ||
+            hasPinnedResources ||
+            directSpecs.length === 0 ||
+            missingConfiguredDirectToolServers.length > 0;
         if (shouldRegisterProxyTool) {
             const description = buildProxyDescription(config);
             if (!proxyToolRegistered || proxyToolDescription !== description) {
@@ -683,8 +822,9 @@ function installMcpAdapter(pi, options) {
             }
             policy.gateway = { eager: hasPinnedResources };
         }
-        if (policy.script)
+        if (policy.script) {
             registerScriptTool();
+        }
         return policy;
     }
     // A transform needs the session context before any configured tool surface is registered.
@@ -694,8 +834,11 @@ function installMcpAdapter(pi, options) {
 }
 export function createMcpAdapter(options = {}) {
     const { defaultScriptTimeoutMs } = options;
-    if (defaultScriptTimeoutMs !== undefined && defaultScriptTimeoutMs !== null
-        && (!Number.isInteger(defaultScriptTimeoutMs) || defaultScriptTimeoutMs < 1 || defaultScriptTimeoutMs > 2_147_483_647)) {
+    if (defaultScriptTimeoutMs !== undefined &&
+        defaultScriptTimeoutMs !== null &&
+        (!Number.isInteger(defaultScriptTimeoutMs) ||
+            defaultScriptTimeoutMs < 1 ||
+            defaultScriptTimeoutMs > 2_147_483_647)) {
         throw new RangeError("defaultScriptTimeoutMs must be an integer from 1 to 2147483647, or null");
     }
     const factoryConfig = options.config !== undefined ? cloneMcpConfig(options.config) : undefined;
@@ -703,7 +846,9 @@ export function createMcpAdapter(options = {}) {
         installMcpAdapter(pi, {
             ...(options.configPath !== undefined ? { configPath: options.configPath } : {}),
             ...(defaultScriptTimeoutMs !== undefined ? { defaultScriptTimeoutMs } : {}),
-            ...(options.outputDirectory !== undefined ? { outputDirectory: options.outputDirectory } : {}),
+            ...(options.outputDirectory !== undefined
+                ? { outputDirectory: options.outputDirectory }
+                : {}),
             ...(factoryConfig !== undefined ? { config: cloneMcpConfig(factoryConfig) } : {}),
             ...(options.beforeExecute ? { beforeExecute: options.beforeExecute } : {}),
             ...(options.transformConfig ? { transformConfig: options.transformConfig } : {}),