@fitchmultz/pi-mcp-adapter 8.0.6 → 8.0.8

package/dist/proxy-modes.js

@@ -1,13 +1,13 @@
 import { isDeepStrictEqual } from "node:util";
-import { getServerPrefix, isServerDisabled, isNonInteractiveOAuth, parseUiPromptHandoff, resolveToolPrefix } from "./types.js";
-import { lazyConnect, markKeepAliveAfterConnect, notifyToolMetadataUpdated, updateServerMetadata, updateMetadataCache, getFailureAgeSeconds, updateStatusBar, clearFailure, recordFailure } from "./init.js";
+import { getServerPrefix, isServerDisabled, isNonInteractiveOAuth, parseUiPromptHandoff, resolveToolPrefix, } from "./types.js";
+import { lazyConnect, markKeepAliveAfterConnect, notifyToolMetadataUpdated, updateServerMetadata, updateMetadataCache, getFailureAgeSeconds, updateStatusBar, clearFailure, recordFailure, } from "./init.js";
 import { abortable, throwIfAborted } from "./abort.js";
 import { combineAbortSignals, isAbortError } from "./runtime-owner.js";
-import { buildToolMetadata, catalogCoverage, findToolByName, formatSchema, toToolDescriptor } from "./tool-metadata.js";
+import { buildToolMetadata, catalogCoverage, findToolByName, formatSchema, toToolDescriptor, } from "./tool-metadata.js";
 import { reconstructPromptMetadata } from "./metadata-cache.js";
 import { renderMcpResultContent } from "./tool-registrar.js";
-import { guardMcpOutput, guardedMcpDetails, retainMcpResult, resolveMcpOutputGuardOptions, formatMcpResultReference, saveMcpOutputStream } from "./mcp-output-guard.js";
-import { formatAuthRequiredMessage, formatMcpStatus, resolveServerUrl, truncateAtWord } from "./utils.js";
+import { guardMcpOutput, guardedMcpDetails, retainMcpResult, resolveMcpOutputGuardOptions, formatMcpResultReference, saveMcpOutputStream, } from "./mcp-output-guard.js";
+import { formatAuthRequiredMessage, formatMcpStatus, resolveServerUrl, truncateAtWord, } from "./utils.js";
 import { supportsOAuth } from "./mcp-oauth-runtime.js";
 import { paginate, rankSuggestions, rankToolMatches } from "./search-ranking.js";
 import { ensureToolCallApproved, isToolCallApprovalRequired } from "./tool-approval.js";
@@ -22,8 +22,9 @@ function disabledResult(mode, serverName) {
 }
 function getAuthRequiredMessage(state, serverName, defaultMessage = `Server "${serverName}" requires OAuth authentication. If mcp is inactive, first mcp_search({ enable: ["gateway"] }). Run mcp({ action: "auth-start", server: "${serverName}" }) to get a browser URL, or /mcp-auth ${serverName} in an interactive local session.`) {
     const oauth = state.config.mcpServers[serverName]?.oauth;
-    if (oauth && oauth.crossAppAccess)
+    if (oauth && oauth.crossAppAccess) {
         defaultMessage = `Server "${serverName}" requires enterprise authorization. Check oauth.crossAppAccess IdP configuration and ID-token source, then retry.`;
+    }
     return formatAuthRequiredMessage(state.config, serverName, defaultMessage);
 }
 function getAuthFailedMessage(state, serverName, message) {
@@ -37,8 +38,9 @@ function getAuthFailedMessage(state, serverName, message) {
 function getRedirectPort(authorizationUrl) {
     try {
         const redirectUri = new URL(authorizationUrl).searchParams.get("redirect_uri");
-        if (!redirectUri)
+        if (!redirectUri) {
             return undefined;
+        }
         const port = Number.parseInt(new URL(redirectUri).port, 10);
         return Number.isInteger(port) ? port : undefined;
     }
@@ -66,7 +68,9 @@ function formatManualAuthInstructions(serverName, authorizationUrl) {
         "",
         'You can also pass just the `code` query parameter as `args: { code: "PASTE_CODE_HERE" }`.',
         portNote.trimEnd(),
-    ].filter(Boolean).join("\n");
+    ]
+        .filter(Boolean)
+        .join("\n");
 }
 async function attemptAutoAuth(state, serverName, signal) {
     if (state.config.settings?.autoAuth !== true) {
@@ -102,7 +106,10 @@ async function attemptAutoAuth(state, serverName, signal) {
         }
         else {
             if (signal) {
-                await authenticate(serverName, serverUrl, definition, { signal, runtime: state.oauthRuntime });
+                await authenticate(serverName, serverUrl, definition, {
+                    signal,
+                    runtime: state.oauthRuntime,
+                });
             }
             else {
                 await authenticate(serverName, serverUrl, definition, { runtime: state.oauthRuntime });
@@ -111,8 +118,9 @@ async function attemptAutoAuth(state, serverName, signal) {
         return { status: "success" };
     }
     catch (error) {
-        if (isAbortError(error, signal))
+        if (isAbortError(error, signal)) {
             throw error;
+        }
         const message = error instanceof Error ? error.message : String(error);
         return {
             status: "failed",
@@ -124,8 +132,9 @@ async function* uiSessionText(session) {
     yield `\n## ${session.serverName} / ${session.toolName} (${session.completedAt.toLocaleTimeString()}, ${session.reason})`;
     let heading = false;
     for await (const prompt of uiMessages(session.messages, "prompts")) {
-        if (parseUiPromptHandoff(prompt))
+        if (parseUiPromptHandoff(prompt)) {
             continue;
+        }
         if (!heading) {
             yield "\n\n### Prompts:";
             heading = true;
@@ -143,8 +152,9 @@ async function* uiSessionText(session) {
     }
     for await (const prompt of uiMessages(session.messages, "prompts")) {
         const handoff = parseUiPromptHandoff(prompt);
-        if (!handoff)
+        if (!handoff) {
             continue;
+        }
         if (!heading) {
             yield "\n\n### Intents:";
             heading = true;
@@ -153,8 +163,9 @@ async function* uiSessionText(session) {
     }
     if (session.messages.contexts.length) {
         yield "\n\n### Context updates:";
-        for (const context of session.messages.contexts)
+        for (const context of session.messages.contexts) {
             yield `\n- ${context.summary}${context.truncated ? " (truncated)" : ""}`;
+        }
     }
     heading = false;
     for await (const notification of uiMessages(session.messages, "notifications")) {
@@ -169,30 +180,69 @@ export async function executeUiMessages(state) {
     const pending = [...state.completedUiSessions];
     const options = resolveMcpOutputGuardOptions(state.config?.settings, state.outputDirectory);
     // Bound both inline output and details. Large retrieval streams; it never flattens all events.
-    const size = pending.reduce((bytes, session) => bytes + (session.messages.historyBytes ?? 0) + Buffer.byteLength(JSON.stringify(session.messages)), 0);
+    const size = pending.reduce((bytes, session) => bytes +
+        (session.messages.historyBytes ?? 0) +
+        Buffer.byteLength(JSON.stringify(session.messages)), 0);
     const large = size > Math.min(options.maxBytes, options.detailsMaxBytes);
-    const warnings = pending.flatMap(session => session.messages.historyError ? [session.messages.historyError] : []);
+    const warnings = pending.flatMap((session) => session.messages.historyError ? [session.messages.historyError] : []);
     const paged = async () => {
         async function* output() {
             yield `UI Session Messages (${pending.length} sessions):\n`;
-            for (const session of pending)
+            for (const session of pending) {
                 yield* uiSessionText(session);
+            }
         }
         const artifact = await saveMcpOutputStream(output(), state.outputDirectory);
-        if (!artifact.path)
-            return { content: [{ type: "text", text: `UI messages remain available; retrieval could not be saved: ${artifact.error}` }], isError: true, details: { error: "ui_history_delivery_failed", cleared: false } };
+        if (!artifact.path) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `UI messages remain available; retrieval could not be saved: ${artifact.error}`,
+                    },
+                ],
+                isError: true,
+                details: { error: "ui_history_delivery_failed", cleared: false },
+            };
+        }
         // Newly completed sessions during I/O are not part of this drain.
-        state.completedUiSessions = state.completedUiSessions.filter(session => !pending.includes(session));
-        return { content: [{ type: "text", text: `UI Session Messages (${pending.length} sessions). ${formatMcpResultReference(artifact.path)}${warnings.length ? `\nHistory persistence warning: ${warnings.join("; ")}` : ""}` }], details: { sessions: pending.length, resultRef: artifact.path, historyRefs: pending.flatMap(session => session.messages.historyRef ? [session.messages.historyRef] : []), cleared: true } };
+        state.completedUiSessions = state.completedUiSessions.filter((session) => !pending.includes(session));
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `UI Session Messages (${pending.length} sessions). ${formatMcpResultReference(artifact.path)}${warnings.length ? `\nHistory persistence warning: ${warnings.join("; ")}` : ""}`,
+                },
+            ],
+            details: {
+                sessions: pending.length,
+                resultRef: artifact.path,
+                historyRefs: pending.flatMap((session) => session.messages.historyRef ? [session.messages.historyRef] : []),
+                cleared: true,
+            },
+        };
     };
-    if (large)
+    if (large) {
         return paged();
+    }
     let sessions;
     try {
-        sessions = await Promise.all(pending.map(async (session) => ({ ...session, messages: await materializeUiMessages(session.messages) })));
+        sessions = await Promise.all(pending.map(async (session) => ({
+            ...session,
+            messages: await materializeUiMessages(session.messages),
+        })));
     }
     catch (error) {
-        return { content: [{ type: "text", text: `UI messages remain available; history could not be read: ${String(error)}` }], isError: true, details: { error: "ui_history_delivery_failed", cleared: false } };
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `UI messages remain available; history could not be read: ${String(error)}`,
+                },
+            ],
+            isError: true,
+            details: { error: "ui_history_delivery_failed", cleared: false },
+        };
     }
     if (sessions.length === 0) {
         return {
@@ -230,7 +280,7 @@ export async function executeUiMessages(state) {
             ...session.messages.intents,
             ...session.messages.prompts
                 .map((prompt) => parseUiPromptHandoff(prompt))
-                .filter((handoff) => !!handoff)
+                .filter((handoff) => Boolean(handoff))
                 .map((handoff) => ({ intent: handoff.intent, params: handoff.params })),
         ];
         if (intentsForSession.length > 0) {
@@ -256,7 +306,13 @@ export async function executeUiMessages(state) {
     }
     const count = sessions.length;
     const inline = {
-        content: [{ type: "text", text: output.join("\n") + (warnings.length ? `\nHistory persistence warning: ${warnings.join("; ")}` : "") }],
+        content: [
+            {
+                type: "text",
+                text: output.join("\n") +
+                    (warnings.length ? `\nHistory persistence warning: ${warnings.join("; ")}` : ""),
+            },
+        ],
         details: {
             sessions: count,
             prompts: allPrompts,
@@ -266,10 +322,13 @@ export async function executeUiMessages(state) {
             cleared: true,
         },
     };
-    const text = inline.content.map(block => block.type === "text" ? block.text : "").join("\n");
-    if (Buffer.byteLength(JSON.stringify(inline.details)) > options.detailsMaxBytes || Buffer.byteLength(text) > options.maxBytes || text.split("\n").length > options.maxLines)
+    const text = inline.content.map((block) => (block.type === "text" ? block.text : "")).join("\n");
+    if (Buffer.byteLength(JSON.stringify(inline.details)) > options.detailsMaxBytes ||
+        Buffer.byteLength(text) > options.maxBytes ||
+        text.split("\n").length > options.maxLines) {
         return paged();
-    state.completedUiSessions = state.completedUiSessions.filter(session => !pending.includes(session));
+    }
+    state.completedUiSessions = state.completedUiSessions.filter((session) => !pending.includes(session));
     return inline;
 }
 export function executeStatus(state) {
@@ -279,7 +338,7 @@ export function executeStatus(state) {
         const disabled = isServerDisabled(definition);
         const connection = disabled ? undefined : state.manager.getConnection(name);
         const metadata = disabled ? undefined : state.toolMetadata.get(name);
-        const toolCount = metadata?.filter(tool => !tool.resourceUri).length ?? 0;
+        const toolCount = metadata?.filter((tool) => !tool.resourceUri).length ?? 0;
         const failedAgo = disabled ? null : getFailureAgeSeconds(state, name);
         let status = disabled ? "disabled" : "not connected";
         if (!disabled && connection?.status === "connected") {
@@ -296,14 +355,15 @@ export function executeStatus(state) {
         }
         servers.push({ name, status, toolCount, failedAgo, ...(disabled ? { disabled: true } : {}) });
     }
-    const disabledCount = servers.filter(s => s.disabled).length;
-    const enabledServers = servers.filter(s => !s.disabled);
+    const disabledCount = servers.filter((s) => s.disabled).length;
+    const enabledServers = servers.filter((s) => !s.disabled);
     const totalTools = enabledServers.reduce((sum, s) => sum + s.toolCount, 0);
-    const connectedCount = enabledServers.filter(s => s.status === "connected").length;
+    const connectedCount = enabledServers.filter((s) => s.status === "connected").length;
     const coverage = catalogCoverage(state);
     let text = `MCP: ${connectedCount}/${enabledServers.length} connected, ${totalTools} tools available (calls connect lazily)`;
-    if (disabledCount > 0)
+    if (disabledCount > 0) {
         text += ` (${disabledCount} disabled)`;
+    }
     text += "\n\n";
     for (const server of servers) {
         if (server.disabled) {
@@ -330,8 +390,9 @@ export function executeStatus(state) {
     }
     if (servers.length > 0) {
         text += `\nmcp_search({ query: "...", server: "name" }) to discover tools; mcp({ action: "resources", server: "name" }) for resources.`;
-        if (!coverage.complete)
+        if (!coverage.complete) {
             text += `\nPartial catalog: ${coverage.unknownServers.length} undiscovered server(s).`;
+        }
     }
     return {
         content: [{ type: "text", text: text.trim() }],
@@ -345,42 +406,69 @@ export async function executeAuthStart(state, serverName, signal) {
     const definition = state.config.mcpServers[serverName];
     if (!definition) {
         return {
-            content: [{ type: "text", text: `Server "${serverName}" not found. Use mcp({ action: "status" }) to see available servers (load it first with mcp_search({ enable: ["gateway"] }) if inactive).` }],
+            content: [
+                {
+                    type: "text",
+                    text: `Server "${serverName}" not found. Use mcp({ action: "status" }) to see available servers (load it first with mcp_search({ enable: ["gateway"] }) if inactive).`,
+                },
+            ],
             details: { mode: "auth-start", error: "not_found", server: serverName },
         };
     }
-    if (isServerDisabled(definition))
+    if (isServerDisabled(definition)) {
         return disabledResult("auth-start", serverName);
+    }
     try {
         const serverUrl = resolveServerUrl(definition);
         if (!serverUrl || !supportsOAuth(definition)) {
             return {
-                content: [{ type: "text", text: `Server "${serverName}" is not configured for OAuth over HTTP.` }],
+                content: [
+                    {
+                        type: "text",
+                        text: `Server "${serverName}" is not configured for OAuth over HTTP.`,
+                    },
+                ],
                 details: { mode: "auth-start", error: "oauth_not_supported", server: serverName },
             };
         }
         const { authorizationUrl } = state.authStorageOptions
             ? ownedSignal
-                ? await startAuth(serverName, serverUrl, definition, { authStorageOptions: state.authStorageOptions, signal: ownedSignal, runtime: state.oauthRuntime })
-                : await startAuth(serverName, serverUrl, definition, { authStorageOptions: state.authStorageOptions, runtime: state.oauthRuntime })
+                ? await startAuth(serverName, serverUrl, definition, {
+                    authStorageOptions: state.authStorageOptions,
+                    signal: ownedSignal,
+                    runtime: state.oauthRuntime,
+                })
+                : await startAuth(serverName, serverUrl, definition, {
+                    authStorageOptions: state.authStorageOptions,
+                    runtime: state.oauthRuntime,
+                })
             : ownedSignal
-                ? await startAuth(serverName, serverUrl, definition, { signal: ownedSignal, runtime: state.oauthRuntime })
+                ? await startAuth(serverName, serverUrl, definition, {
+                    signal: ownedSignal,
+                    runtime: state.oauthRuntime,
+                })
                 : await startAuth(serverName, serverUrl, definition, { runtime: state.oauthRuntime });
         if (!authorizationUrl) {
             return {
-                content: [{ type: "text", text: `OAuth authentication successful for "${serverName}".` }],
+                content: [
+                    { type: "text", text: `OAuth authentication successful for "${serverName}".` },
+                ],
                 details: { mode: "auth-start", server: serverName, authenticated: true },
             };
         }
         return {
-            content: [{ type: "text", text: formatManualAuthInstructions(serverName, authorizationUrl) }],
+            content: [
+                { type: "text", text: formatManualAuthInstructions(serverName, authorizationUrl) },
+            ],
             details: { mode: "auth-start", server: serverName, authorizationUrl },
         };
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
         return {
-            content: [{ type: "text", text: `Failed to start OAuth for "${serverName}": ${message}` }],
+            content: [
+                { type: "text", text: `Failed to start OAuth for "${serverName}": ${message}` },
+            ],
             details: { mode: "auth-start", error: "auth_start_failed", server: serverName, message },
         };
     }
@@ -392,62 +480,111 @@ export async function executeAuthComplete(state, serverName, input, signal) {
     const definition = state.config.mcpServers[serverName];
     if (!definition) {
         return {
-            content: [{ type: "text", text: `Server "${serverName}" not found. Use mcp({ action: "status" }) to see available servers (load it first with mcp_search({ enable: ["gateway"] }) if inactive).` }],
+            content: [
+                {
+                    type: "text",
+                    text: `Server "${serverName}" not found. Use mcp({ action: "status" }) to see available servers (load it first with mcp_search({ enable: ["gateway"] }) if inactive).`,
+                },
+            ],
             details: { mode: "auth-complete", error: "not_found", server: serverName },
         };
     }
-    if (isServerDisabled(definition))
+    if (isServerDisabled(definition)) {
         return disabledResult("auth-complete", serverName);
+    }
     try {
         const previousConnection = state.manager.getConnection(serverName);
         const status = state.authStorageOptions
             ? ownedSignal
-                ? await completeAuthFromInput(serverName, input, { authStorageOptions: state.authStorageOptions, signal: ownedSignal, runtime: state.oauthRuntime })
-                : await completeAuthFromInput(serverName, input, { authStorageOptions: state.authStorageOptions, runtime: state.oauthRuntime })
+                ? await completeAuthFromInput(serverName, input, {
+                    authStorageOptions: state.authStorageOptions,
+                    signal: ownedSignal,
+                    runtime: state.oauthRuntime,
+                })
+                : await completeAuthFromInput(serverName, input, {
+                    authStorageOptions: state.authStorageOptions,
+                    runtime: state.oauthRuntime,
+                })
             : ownedSignal
-                ? await completeAuthFromInput(serverName, input, { signal: ownedSignal, runtime: state.oauthRuntime })
+                ? await completeAuthFromInput(serverName, input, {
+                    signal: ownedSignal,
+                    runtime: state.oauthRuntime,
+                })
                 : await completeAuthFromInput(serverName, input, { runtime: state.oauthRuntime });
         if (status !== "authenticated") {
             return {
-                content: [{ type: "text", text: `OAuth authentication did not complete for "${serverName}".` }],
+                content: [
+                    {
+                        type: "text",
+                        text: `OAuth authentication did not complete for "${serverName}".`,
+                    },
+                ],
                 details: { mode: "auth-complete", error: "not_authenticated", server: serverName, status },
             };
         }
-        if (previousConnection)
+        if (previousConnection) {
             state.manager.retire(serverName, previousConnection);
+        }
         clearFailure(state, serverName);
         updateStatusBar(state);
         return {
-            content: [{ type: "text", text: `OAuth authentication successful for "${serverName}". Run mcp({ action: "connect", server: "${serverName}" }) to connect with the new token.` }],
+            content: [
+                {
+                    type: "text",
+                    text: `OAuth authentication successful for "${serverName}". Run mcp({ action: "connect", server: "${serverName}" }) to connect with the new token.`,
+                },
+            ],
             details: { mode: "auth-complete", server: serverName, authenticated: true },
         };
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
         return {
-            content: [{ type: "text", text: `Failed to complete OAuth for "${serverName}": ${message}` }],
-            details: { mode: "auth-complete", error: "auth_complete_failed", server: serverName, message },
+            content: [
+                { type: "text", text: `Failed to complete OAuth for "${serverName}": ${message}` },
+            ],
+            details: {
+                mode: "auth-complete",
+                error: "auth_complete_failed",
+                server: serverName,
+                message,
+            },
         };
     }
 }
 export function executeDescribe(state, toolName, serverFilter) {
-    if (serverFilter && isServerDisabled(state.config.mcpServers[serverFilter]))
+    if (serverFilter && isServerDisabled(state.config.mcpServers[serverFilter])) {
         return disabledResult("describe", serverFilter);
-    const catalog = [...state.toolMetadata].flatMap(([server, tools]) => (!serverFilter || serverFilter === server) && state.config.mcpServers[server] && !isServerDisabled(state.config.mcpServers[server])
-        ? tools.map(tool => ({ server, tool })) : []);
-    const originals = serverFilter ? catalog.filter(({ tool }) => tool.originalName === toolName) : [];
+    }
+    const catalog = [...state.toolMetadata].flatMap(([server, tools]) => (!serverFilter || serverFilter === server) &&
+        state.config.mcpServers[server] &&
+        !isServerDisabled(state.config.mcpServers[server])
+        ? tools.map((tool) => ({ server, tool }))
+        : []);
+    const originals = serverFilter
+        ? catalog.filter(({ tool }) => tool.originalName === toolName)
+        : [];
     const exact = originals.length ? originals : catalog.filter(({ tool }) => tool.name === toolName);
-    const matches = exact.length ? exact : catalog.filter(({ tool }) => tool.name.replace(/-/g, "_") === toolName.replace(/-/g, "_"));
-    if (matches.length > 1)
+    const matches = exact.length
+        ? exact
+        : catalog.filter(({ tool }) => tool.name.replace(/-/g, "_") === toolName.replace(/-/g, "_"));
+    if (matches.length > 1) {
         return {
-            content: [{ type: "text", text: `Tool ${JSON.stringify(toolName)} is ambiguous. Specify server and original tool name: ${JSON.stringify(matches.map(({ server, tool }) => ({ server, tool: tool.originalName })))}` }],
+            content: [
+                {
+                    type: "text",
+                    text: `Tool ${JSON.stringify(toolName)} is ambiguous. Specify server and original tool name: ${JSON.stringify(matches.map(({ server, tool }) => ({ server, tool: tool.originalName })))}`,
+                },
+            ],
             details: { mode: "describe", error: "ambiguous_tool", requestedTool: toolName },
         };
+    }
     const match = matches[0];
     if (!match) {
         const disabled = [...state.toolMetadata].find(([server, tools]) => isServerDisabled(state.config.mcpServers[server]) && findToolByName(tools, toolName));
-        if (disabled)
+        if (disabled) {
             return disabledResult("describe", disabled[0]);
+        }
         const suggestions = rankSuggestions(state, toolName, 5, serverFilter);
         const hint = suggestions.length > 0
             ? `Did you mean: ${suggestions.join(", ")}. Inspect with mcp({ action: "describe", tool: "${suggestions[0]}" }). Load if inactive: mcp_search({ enable: ["gateway"] }).`
@@ -461,15 +598,34 @@ export function executeDescribe(state, toolName, serverFilter) {
     const descriptor = toToolDescriptor(serverName, toolMeta);
     const approvalRequired = isToolCallApprovalRequired(state.config, serverName, toolMeta);
     return {
-        content: [{ type: "text", text: JSON.stringify({ ...descriptor, ...(toolMeta.resourceUri ? { resourceUri: toolMeta.resourceUri, readWith: { action: "read-resource", server: serverName, uri: toolMeta.resourceUri } } : {}), ...(approvalRequired ? { approvalRequired: true } : {}) }, null, 2) }],
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify({
+                    ...descriptor,
+                    ...(toolMeta.resourceUri
+                        ? {
+                            resourceUri: toolMeta.resourceUri,
+                            readWith: {
+                                action: "read-resource",
+                                server: serverName,
+                                uri: toolMeta.resourceUri,
+                            },
+                        }
+                        : {}),
+                    ...(approvalRequired ? { approvalRequired: true } : {}),
+                }, null, 2),
+            },
+        ],
         details: { mode: "describe", tool: toolMeta, server: serverName },
     };
 }
 export function executeSearch(state, query, server, includeSchemas, limit = 12, offset = 0, caller = "mcp") {
     const showSchemas = includeSchemas !== false;
     const searchCall = (nextOffset) => `${caller}({ ${caller === "mcp" ? 'action: "search", ' : ""}query: ${JSON.stringify(query)}${server ? `, server: ${JSON.stringify(server)}` : ""}${caller === "mcp" && !showSchemas ? ", includeSchemas: false" : ""}, limit: ${limit}, offset: ${nextOffset} })`;
-    if (server && isServerDisabled(state.config.mcpServers[server]))
+    if (server && isServerDisabled(state.config.mcpServers[server])) {
         return disabledResult("search", server);
+    }
     let matches;
     if (query.trim().length === 0) {
         if (!server) {
@@ -478,8 +634,9 @@ export function executeSearch(state, query, server, includeSchemas, limit = 12,
                 details: { mode: "search", error: "empty_query" },
             };
         }
-        matches = (state.toolMetadata.get(server) ?? []).filter(tool => !tool.resourceUri)
-            .map(tool => ({ server, tool, score: 0 }))
+        matches = (state.toolMetadata.get(server) ?? [])
+            .filter((tool) => !tool.resourceUri)
+            .map((tool) => ({ server, tool, score: 0 }))
             .sort((a, b) => a.tool.name.localeCompare(b.tool.name));
     }
     else {
@@ -487,19 +644,44 @@ export function executeSearch(state, query, server, includeSchemas, limit = 12,
     }
     const page = paginate(matches, offset, limit);
     const coverage = catalogCoverage(state, server);
-    const coverageNotice = coverage.complete ? "" : `\nCatalog is incomplete. Undiscovered servers: ${coverage.unknownServers.join(", ")}. Search with server to discover one.`;
+    const coverageNotice = coverage.complete
+        ? ""
+        : `\nCatalog is incomplete. Undiscovered servers: ${coverage.unknownServers.join(", ")}. Search with server to discover one.`;
     if (page.total === 0) {
-        const msg = server ? `No tools matching "${query}" in "${server}"` : `No tools matching "${query}"`;
+        const msg = server
+            ? `No tools matching "${query}" in "${server}"`
+            : `No tools matching "${query}"`;
         return {
             content: [{ type: "text", text: msg + coverageNotice }],
-            details: { mode: "search", matches: [], count: 0, hasMore: false, nextOffset: null, query, coverage },
+            details: {
+                mode: "search",
+                matches: [],
+                count: 0,
+                hasMore: false,
+                nextOffset: null,
+                query,
+                coverage,
+            },
         };
     }
     if (page.items.length === 0) {
         const retry = searchCall(0);
         return {
-            content: [{ type: "text", text: `No search results at offset ${offset}; ${page.total} tools match. Retry with ${retry}.` }],
-            details: { mode: "search", error: "offset_out_of_range", matches: [], count: page.total, hasMore: false, nextOffset: null, query },
+            content: [
+                {
+                    type: "text",
+                    text: `No search results at offset ${offset}; ${page.total} tools match. Retry with ${retry}.`,
+                },
+            ],
+            details: {
+                mode: "search",
+                error: "offset_out_of_range",
+                matches: [],
+                count: page.total,
+                hasMore: false,
+                nextOffset: null,
+                query,
+            },
         };
     }
     let text = `Found ${page.total} tool${page.total === 1 ? "" : "s"} matching "${query}":\n\n`;
@@ -512,8 +694,9 @@ export function executeSearch(state, query, server, includeSchemas, limit = 12,
         }
         else {
             text += `- ${match.tool.name}${approvalMarker}`;
-            if (match.tool.description)
+            if (match.tool.description) {
                 text += ` - ${truncateAtWord(match.tool.description, 50)}`;
+            }
             text += "\n";
         }
     }
@@ -527,7 +710,11 @@ export function executeSearch(state, query, server, includeSchemas, limit = 12,
         details: {
             mode: "search",
             coverage,
-            matches: page.items.map(match => ({ server: match.server, tool: match.tool.name, score: match.score })),
+            matches: page.items.map((match) => ({
+                server: match.server,
+                tool: match.tool.name,
+                score: match.score,
+            })),
             count: page.total,
             hasMore: page.hasMore,
             nextOffset: page.nextOffset,
@@ -539,13 +726,19 @@ export function executeList(state, server, limit = 12, offset = 0) {
     const definition = state.config.mcpServers[server];
     if (!definition) {
         return {
-            content: [{ type: "text", text: `Server "${server}" not found. Use mcp({ action: "status" }) to see available servers (load it first with mcp_search({ enable: ["gateway"] }) if inactive).` }],
+            content: [
+                {
+                    type: "text",
+                    text: `Server "${server}" not found. Use mcp({ action: "status" }) to see available servers (load it first with mcp_search({ enable: ["gateway"] }) if inactive).`,
+                },
+            ],
             details: { mode: "list", server, tools: [], count: 0, error: "not_found" },
         };
     }
-    if (isServerDisabled(definition))
+    if (isServerDisabled(definition)) {
         return disabledResult("list", server);
-    const metadata = state.toolMetadata.get(server)?.filter(tool => !tool.resourceUri);
+    }
+    const metadata = state.toolMetadata.get(server)?.filter((tool) => !tool.resourceUri);
     const connection = state.manager.getConnection(server);
     const instructions = state.serverInstructions.get(server);
     let instructionsText = "";
@@ -559,26 +752,72 @@ export function executeList(state, server, limit = 12, offset = 0) {
     if (!metadata?.length) {
         if (connection?.status === "connected") {
             return {
-                content: [{ type: "text", text: `Server "${server}" has no tools.${instructionsText}` }],
-                details: { mode: "list", server, tools: [], count: 0, hasInstructions: Boolean(instructions) },
+                content: [
+                    { type: "text", text: `Server "${server}" has no tools.${instructionsText}` },
+                ],
+                details: {
+                    mode: "list",
+                    server,
+                    tools: [],
+                    count: 0,
+                    hasInstructions: Boolean(instructions),
+                },
             };
         }
         if (metadata !== undefined) {
             return {
-                content: [{ type: "text", text: `Server "${server}" has no cached tools (not connected).${instructionsText}` }],
-                details: { mode: "list", server, tools: [], count: 0, cached: true, hasInstructions: Boolean(instructions) },
+                content: [
+                    {
+                        type: "text",
+                        text: `Server "${server}" has no cached tools (not connected).${instructionsText}`,
+                    },
+                ],
+                details: {
+                    mode: "list",
+                    server,
+                    tools: [],
+                    count: 0,
+                    cached: true,
+                    hasInstructions: Boolean(instructions),
+                },
             };
         }
         return {
-            content: [{ type: "text", text: `Server "${server}" is configured but not connected. Use mcp({ action: "connect", server: "${server}" }) or /mcp reconnect ${server} to retry.${instructionsText}` }],
-            details: { mode: "list", server, tools: [], count: 0, error: "not_connected", hasInstructions: Boolean(instructions) },
+            content: [
+                {
+                    type: "text",
+                    text: `Server "${server}" is configured but not connected. Use mcp({ action: "connect", server: "${server}" }) or /mcp reconnect ${server} to retry.${instructionsText}`,
+                },
+            ],
+            details: {
+                mode: "list",
+                server,
+                tools: [],
+                count: 0,
+                error: "not_connected",
+                hasInstructions: Boolean(instructions),
+            },
         };
     }
     const page = paginate(metadata, offset, limit);
     if (page.items.length === 0) {
         return {
-            content: [{ type: "text", text: `No tools at offset ${offset}; "${server}" has ${page.total} tools. Retry with mcp({ action: "list", server: ${JSON.stringify(server)}, limit: ${limit}, offset: 0 }).` }],
-            details: { mode: "list", error: "offset_out_of_range", server, tools: [], count: page.total, hasMore: false, nextOffset: null, hasInstructions: Boolean(instructions) },
+            content: [
+                {
+                    type: "text",
+                    text: `No tools at offset ${offset}; "${server}" has ${page.total} tools. Retry with mcp({ action: "list", server: ${JSON.stringify(server)}, limit: ${limit}, offset: 0 }).`,
+                },
+            ],
+            details: {
+                mode: "list",
+                error: "offset_out_of_range",
+                server,
+                tools: [],
+                count: page.total,
+                hasMore: false,
+                nextOffset: null,
+                hasInstructions: Boolean(instructions),
+            },
         };
     }
     const cachedNote = connection?.status === "connected" ? "" : ", not connected, cached";
@@ -586,8 +825,9 @@ export function executeList(state, server, limit = 12, offset = 0) {
     for (const tool of page.items) {
         const description = truncateAtWord(tool.description, 50);
         text += `- ${tool.name}`;
-        if (description)
+        if (description) {
             text += ` - ${description}`;
+        }
         text += "\n";
     }
     const first = (Number.isFinite(offset) ? Math.max(0, Math.trunc(offset)) : 0) + 1;
@@ -600,7 +840,7 @@ export function executeList(state, server, limit = 12, offset = 0) {
         details: {
             mode: "list",
             server,
-            tools: page.items.map(tool => tool.name),
+            tools: page.items.map((tool) => tool.name),
             count: page.total,
             hasMore: page.hasMore,
             nextOffset: page.nextOffset,
@@ -612,12 +852,18 @@ export function executeInstructions(state, server) {
     const definition = state.config.mcpServers[server];
     if (!definition) {
         return {
-            content: [{ type: "text", text: `Server "${server}" not found. Use mcp({ action: "status" }) to see available servers (load it first with mcp_search({ enable: ["gateway"] }) if inactive).` }],
+            content: [
+                {
+                    type: "text",
+                    text: `Server "${server}" not found. Use mcp({ action: "status" }) to see available servers (load it first with mcp_search({ enable: ["gateway"] }) if inactive).`,
+                },
+            ],
             details: { mode: "instructions", server, error: "not_found" },
         };
     }
-    if (isServerDisabled(definition))
+    if (isServerDisabled(definition)) {
         return disabledResult("instructions", server);
+    }
     const instructions = state.serverInstructions.get(server);
     if (instructions) {
         return {
@@ -628,12 +874,19 @@ export function executeInstructions(state, server) {
     const connection = state.manager.getConnection(server);
     if (connection?.status === "connected") {
         return {
-            content: [{ type: "text", text: `Server "${server}" does not provide instructions.` }],
+            content: [
+                { type: "text", text: `Server "${server}" does not provide instructions.` },
+            ],
             details: { mode: "instructions", server, error: "no_instructions" },
         };
     }
     return {
-        content: [{ type: "text", text: `No instructions cached for "${server}". Use mcp({ action: "connect", server: "${server}" }) to connect and refresh.` }],
+        content: [
+            {
+                type: "text",
+                text: `No instructions cached for "${server}". Use mcp({ action: "connect", server: "${server}" }) to connect and refresh.`,
+            },
+        ],
         details: { mode: "instructions", server, error: "not_connected" },
     };
 }
@@ -643,12 +896,18 @@ export async function executeConnect(state, serverName, signal, limit, offset) {
     const definition = state.config.mcpServers[serverName];
     if (!definition) {
         return {
-            content: [{ type: "text", text: `Server "${serverName}" not found. Use mcp({ action: "status" }) to see available servers (load it first with mcp_search({ enable: ["gateway"] }) if inactive).` }],
+            content: [
+                {
+                    type: "text",
+                    text: `Server "${serverName}" not found. Use mcp({ action: "status" }) to see available servers (load it first with mcp_search({ enable: ["gateway"] }) if inactive).`,
+                },
+            ],
             details: { mode: "connect", error: "not_found", server: serverName },
         };
     }
-    if (isServerDisabled(definition))
+    if (isServerDisabled(definition)) {
         return disabledResult("connect", serverName);
+    }
     try {
         if (state.ui) {
             state.ui.setStatus("mcp", formatMcpStatus(state.config, `connecting to ${serverName}...`));
@@ -662,7 +921,12 @@ export async function executeConnect(state, serverName, signal, limit, offset) {
             if (autoAuth.status === "failed") {
                 return {
                     content: [{ type: "text", text: autoAuth.message }],
-                    details: { mode: "connect", error: "auth_required", server: serverName, message: autoAuth.message },
+                    details: {
+                        mode: "connect",
+                        error: "auth_required",
+                        server: serverName,
+                        message: autoAuth.message,
+                    },
                 };
             }
             if (autoAuth.status === "success") {
@@ -700,12 +964,20 @@ export async function executeConnect(state, serverName, signal, limit, offset) {
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
-        if (!isAbortError(error, ownedSignal))
+        if (!isAbortError(error, ownedSignal)) {
             recordFailure(state, serverName, message);
+        }
         updateStatusBar(state);
         return {
-            content: [{ type: "text", text: `Failed to connect to "${serverName}": ${message}` }],
-            details: { mode: "connect", error: isAbortError(error, ownedSignal) ? "aborted" : "connect_failed", server: serverName, message },
+            content: [
+                { type: "text", text: `Failed to connect to "${serverName}": ${message}` },
+            ],
+            details: {
+                mode: "connect",
+                error: isAbortError(error, ownedSignal) ? "aborted" : "connect_failed",
+                server: serverName,
+                message,
+            },
         };
     }
 }
@@ -716,9 +988,11 @@ export async function executeConnect(state, serverName, signal, limit, offset) {
  * Raw scripts skip content rendering but retain protocol results and artifacts.
  */
 export async function runToolCall(state, serverName, target, args, options) {
-    const { DEFAULT_REQUEST_TIMEOUT_MSEC, UrlElicitationRequiredError } = await import("@modelcontextprotocol/client");
-    const { isInterruptedToolCall, isToolTransportFailure, trackToolCallOutcome, SessionRecoveryAuthRequiredError, withSessionRecovery } = await import("./session-recovery.js");
-    const { maybeStartUiSession, summarizeUiSessionResult } = await import("./ui-session.js");
+    const [{ DEFAULT_REQUEST_TIMEOUT_MSEC, UrlElicitationRequiredError }, { isInterruptedToolCall, isToolTransportFailure, trackToolCallOutcome, SessionRecoveryAuthRequiredError, withSessionRecovery, }, { maybeStartUiSession, summarizeUiSessionResult },] = await Promise.all([
+        import("@modelcontextprotocol/client"),
+        import("./session-recovery.js"),
+        import("./ui-session.js"),
+    ]);
     const { detailsBase, signal, recoverAuthConnection, authRequiredMessage, autoAuthAttempted } = options;
     const configuredOptions = state.manager.getRequestOptions?.(serverName, options.ownedSignal);
     const callerSignal = combineAbortSignals(configuredOptions?.signal, options.ownedSignal);
@@ -728,15 +1002,17 @@ export async function runToolCall(state, serverName, target, args, options) {
     const schemaSuffix = () => target.inputSchema ? `\n\nExpected parameters:\n${formatSchema(target.inputSchema)}` : "";
     let uiSession = null;
     const identity = {
-        server: serverName, tool: target.originalName,
+        server: serverName,
+        tool: target.originalName,
         ...(options.toolCallId !== undefined ? { toolCallId: options.toolCallId } : {}),
         ...(options.innerCallId !== undefined ? { innerCallId: options.innerCallId } : {}),
     };
     let beforeDispatchPending = false;
     let captureFailure;
     const capture = async (event) => {
-        if (!state.onToolCall)
+        if (!state.onToolCall) {
             return;
+        }
         try {
             const run = () => state.onToolCall(event);
             await abortable(state.owner ? state.owner.runCallback("onToolCall", run) : run(), event.signal);
@@ -752,31 +1028,34 @@ export async function runToolCall(state, serverName, target, args, options) {
         state.manager.incrementInFlight(serverName);
         // Loading the connection-only modules can yield to cancellation or shutdown.
         throwIfAborted(callerSignal);
-        uiSession = !target.resourceUri && target.uiResourceUri
-            ? await abortable(maybeStartUiSession(state, {
-                serverName,
-                toolName: target.originalName,
-                toolArgs: args ?? {},
-                uiResourceUri: target.uiResourceUri,
-                ...(target.uiStreamMode !== undefined ? { streamMode: target.uiStreamMode } : {}),
-                ...(signal ? { signal } : {}),
-                onNeedsAuth: recoverAuthConnection,
-            }), callerSignal)
-            : null;
+        uiSession =
+            !target.resourceUri && target.uiResourceUri
+                ? await abortable(maybeStartUiSession(state, {
+                    serverName,
+                    toolName: target.originalName,
+                    toolArgs: args ?? {},
+                    uiResourceUri: target.uiResourceUri,
+                    ...(target.uiStreamMode !== undefined ? { streamMode: target.uiStreamMode } : {}),
+                    ...(signal ? { signal } : {}),
+                    onNeedsAuth: recoverAuthConnection,
+                }), callerSignal)
+                : null;
         // UI preparation can replace the connection; use its current annotations.
         const liveTools = state.manager.getConnection(serverName)?.tools;
         const annotations = liveTools
-            ? liveTools.find(tool => tool.name === target.originalName)?.annotations
+            ? liveTools.find((tool) => tool.name === target.originalName)?.annotations
             : target.annotations;
         const operation = {
-            ...identity, args: args ?? {},
+            ...identity,
+            args: args ?? {},
             ...(annotations !== undefined ? { annotations } : {}),
             ...(target.resourceUri ? { resourceUri: target.resourceUri } : {}),
         };
         if (options.beforeDispatch) {
             beforeDispatchPending = true;
             const run = () => options.beforeDispatch(callerSignal, {
-                ...operation, annotationsTrusted: state.config.mcpServers[serverName]?.retryOnTransportFailure === true,
+                ...operation,
+                annotationsTrusted: state.config.mcpServers[serverName]?.retryOnTransportFailure === true,
             });
             await abortable(state.owner ? state.owner.runCallback("beforeExecute", run) : run(), callerSignal);
             beforeDispatchPending = false;
@@ -785,7 +1064,12 @@ export async function runToolCall(state, serverName, target, args, options) {
         // Approval and UI preparation do not consume the service deadline.
         const ownedSignal = combineAbortSignals(callerSignal, AbortSignal.timeout(Math.ceil(configuredOptions?.timeout ?? DEFAULT_REQUEST_TIMEOUT_MSEC)));
         const requestOptions = { ...configuredOptions, signal: ownedSignal };
-        const recovery = { manager: state.manager, config: state.config, signal: ownedSignal, onNeedsAuth: recoverAuthConnection };
+        const recovery = {
+            manager: state.manager,
+            config: state.config,
+            signal: ownedSignal,
+            onNeedsAuth: recoverAuthConnection,
+        };
         const call = { ...operation, signal: ownedSignal };
         await capture({ ...call, phase: "before" });
         throwIfAborted(ownedSignal);
@@ -802,36 +1086,71 @@ export async function runToolCall(state, serverName, target, args, options) {
             return result;
         };
         const result = target.resourceUri
-            ? await dispatch(() => withSessionRecovery(recovery, serverName, conn => abortable(conn.client.readResource({ uri: target.resourceUri }, requestOptions), ownedSignal)))
-            : await dispatch(() => trackToolCallOutcome(() => withSessionRecovery({ ...recovery, retryOnTransportFailure: annotations?.readOnlyHint === true || annotations?.idempotentHint === true }, serverName, conn => abortable(conn.client.callTool({ name: target.originalName, arguments: args ?? {}, _meta: uiSession?.requestMeta }, requestOptions), ownedSignal)), ownedSignal));
-        if (!target.resourceUri)
+            ? await dispatch(() => withSessionRecovery(recovery, serverName, (conn) => abortable(conn.client.readResource({ uri: target.resourceUri }, requestOptions), ownedSignal)))
+            : await dispatch(() => trackToolCallOutcome(() => withSessionRecovery({
+                ...recovery,
+                retryOnTransportFailure: annotations?.readOnlyHint === true || annotations?.idempotentHint === true,
+            }, serverName, (conn) => abortable(conn.client.callTool({
+                name: target.originalName,
+                arguments: args ?? {},
+                _meta: uiSession?.requestMeta,
+            }, requestOptions), ownedSignal)), ownedSignal));
+        if (!target.resourceUri) {
             uiSession?.sendToolResult(result);
+        }
         const record = result;
         const isError = record.isError === true;
         const uiSummary = target.uiResourceUri ? summarizeUiSessionResult(uiSession) : undefined;
         const details = {
             ...detailsBase,
             ...(isError ? { error: "tool_error" } : {}),
-            ...(uiSummary ? { uiOpen: uiSummary.uiOpen, uiViewer: uiSummary.uiViewer, uiUrl: uiSummary.uiUrl } : {}),
+            ...(uiSummary
+                ? { uiOpen: uiSummary.uiOpen, uiViewer: uiSummary.uiViewer, uiUrl: uiSummary.uiUrl }
+                : {}),
         };
         const retained = await retainMcpResult(result, outputGuardOptions, options.raw);
         if (options.raw) {
             const message = isError
-                ? (Array.isArray(record.content) ? record.content.filter(block => block.type === "text").map(block => block.text).join("\n") : "") || "Tool execution failed" : undefined;
-            return { content: [], ...(isError ? { isError: true } : {}), details: { ...details, ...retained, ...(message ? { message } : {}) } };
+                ? (Array.isArray(record.content)
+                    ? record.content
+                        .filter((block) => block.type === "text")
+                        .map((block) => block.text)
+                        .join("\n")
+                    : "") || "Tool execution failed"
+                : undefined;
+            return {
+                content: [],
+                ...(isError ? { isError: true } : {}),
+                details: { ...details, ...retained, ...(message ? { message } : {}) },
+            };
         }
         const content = renderMcpResultContent(record, retained.payloadFiles);
-        const guarded = await guardMcpOutput(content.length ? content : [{ type: "text", text: target.resourceUri ? "(empty resource)" : "(empty result)" }], {
-            ...outputGuardOptions, retainedMcpResult: retained,
-            ...(isError ? { prefix: "Error: ", suffix: schemaSuffix(), emptyTextFallback: "Tool execution failed" }
-                : uiSummary ? { suffix: `\n\n${uiSummary.message}` } : {}),
+        const guarded = await guardMcpOutput(content.length
+            ? content
+            : [{ type: "text", text: target.resourceUri ? "(empty resource)" : "(empty result)" }], {
+            ...outputGuardOptions,
+            retainedMcpResult: retained,
+            ...(isError
+                ? {
+                    prefix: "Error: ",
+                    suffix: schemaSuffix(),
+                    emptyTextFallback: "Tool execution failed",
+                }
+                : uiSummary
+                    ? { suffix: `\n\n${uiSummary.message}` }
+                    : {}),
         });
-        return { content: guarded.content, ...(isError ? { isError: true } : {}), details: { ...details, ...guardedMcpDetails(guarded) } };
+        return {
+            content: guarded.content,
+            ...(isError ? { isError: true } : {}),
+            details: { ...details, ...guardedMcpDetails(guarded) },
+        };
     }
     catch (error) {
         // Direct/proxy host errors throw; scripts retain their failed-call envelope.
-        if (beforeDispatchPending && options.innerCallId === undefined)
+        if (beforeDispatchPending && options.innerCallId === undefined) {
             throw error;
+        }
         if (captureFailure) {
             const { signal: _signal, ...context } = captureFailure;
             const message = captureFailure.phase === "before"
@@ -839,11 +1158,27 @@ export async function runToolCall(state, serverName, target, args, options) {
                 : "MCP outcome capture failed. Use the retained outcome to continue the original work; do not repeat a completed call or rerun the script.";
             uiSession?.sendToolCancelled(message);
             const retained = "result" in captureFailure && captureFailure.result !== undefined
-                ? await retainMcpResult(captureFailure.result, { ...outputGuardOptions, enabled: true, detailsMaxBytes: 1 }) : {};
+                ? await retainMcpResult(captureFailure.result, {
+                    ...outputGuardOptions,
+                    enabled: true,
+                    detailsMaxBytes: 1,
+                })
+                : {};
             return {
-                content: [{ type: "text", text: message }, ...(retained.resultRef ? [{ type: "text", text: formatMcpResultReference(retained.resultRef) }] : [])],
+                content: [
+                    { type: "text", text: message },
+                    ...(retained.resultRef
+                        ? [{ type: "text", text: formatMcpResultReference(retained.resultRef) }]
+                        : []),
+                ],
                 isError: true,
-                details: { ...detailsBase, ...retained, error: isAbortError(error, callerSignal) ? "aborted" : "call_capture_failed", message, recovery: context },
+                details: {
+                    ...detailsBase,
+                    ...retained,
+                    error: isAbortError(error, callerSignal) ? "aborted" : "call_capture_failed",
+                    message,
+                    recovery: context,
+                },
             };
         }
         if (isToolTransportFailure(error) || isInterruptedToolCall(error)) {
@@ -852,7 +1187,12 @@ export async function runToolCall(state, serverName, target, args, options) {
             return {
                 content: [{ type: "text", text: message }],
                 isError: true,
-                details: { ...detailsBase, error: "ambiguous_outcome", message, recovery: { ...identity, action: "readback" } },
+                details: {
+                    ...detailsBase,
+                    error: "ambiguous_outcome",
+                    message,
+                    recovery: { ...identity, action: "readback" },
+                },
             };
         }
         if (error instanceof SessionRecoveryAuthRequiredError) {
@@ -860,7 +1200,12 @@ export async function runToolCall(state, serverName, target, args, options) {
             uiSession?.sendToolCancelled(message);
             return {
                 content: [{ type: "text", text: message }],
-                details: { ...detailsBase, error: "auth_required", message, autoAuthAttempted: autoAuthAttempted() },
+                details: {
+                    ...detailsBase,
+                    error: "auth_required",
+                    message,
+                    autoAuthAttempted: autoAuthAttempted(),
+                },
             };
         }
         if (error instanceof UrlElicitationRequiredError) {
@@ -876,7 +1221,11 @@ export async function runToolCall(state, serverName, target, args, options) {
         }
         const message = error instanceof Error ? error.message : String(error);
         uiSession?.sendToolCancelled(message);
-        const guarded = await guardMcpOutput([{ type: "text", text: message }], { ...outputGuardOptions, prefix: "Failed to call tool: ", suffix: schemaSuffix() });
+        const guarded = await guardMcpOutput([{ type: "text", text: message }], {
+            ...outputGuardOptions,
+            prefix: "Failed to call tool: ",
+            suffix: schemaSuffix(),
+        });
         return {
             content: guarded.content,
             isError: true,
@@ -905,19 +1254,22 @@ export async function prepareMcpConnection(state, serverName, signal) {
     const recoverAuthConnection = async (_name, recoverySignal = ownedSignal, challenge) => {
         throwIfAborted(recoverySignal);
         const current = state.manager.getConnection(serverName);
-        if (current?.status === "connected" && current !== challenge?.connection)
+        if (current?.status === "connected" && current !== challenge?.connection) {
             return current;
+        }
         if (!autoAuthAttempted) {
             autoAuthAttempted = true;
             const auth = await attemptAutoAuth(state, serverName, recoverySignal);
             throwIfAborted(recoverySignal);
-            if (auth.status === "failed")
+            if (auth.status === "failed") {
                 throw new SessionRecoveryAuthRequiredError(serverName, auth.message);
+            }
             if (auth.status === "success" && current) {
                 clearFailure(state, serverName);
                 const definition = state.config.mcpServers[serverName];
-                if (!definition)
+                if (!definition) {
                     return undefined;
+                }
                 state.ui?.setStatus("mcp", formatMcpStatus(state.config, `connecting to ${serverName}...`));
                 await state.manager.reconnect(serverName, definition, current, recoverySignal);
                 if (await lazyConnect(state, serverName, recoverySignal)) {
@@ -933,10 +1285,12 @@ export async function prepareMcpConnection(state, serverName, signal) {
         details: { mode: "call", error, server: serverName, message },
     });
     const definition = state.config.mcpServers[serverName];
-    if (!definition)
+    if (!definition) {
         return { error: failure("server_not_found", `Server "${serverName}" not found.`) };
-    if (isServerDisabled(definition))
+    }
+    if (isServerDisabled(definition)) {
         return { error: disabledResult("call", serverName) };
+    }
     try {
         // Connected metadata is read below, so it does not require another connection attempt.
         let connection = state.manager.getConnection(serverName);
@@ -947,162 +1301,285 @@ export async function prepareMcpConnection(state, serverName, signal) {
         else {
             markKeepAliveAfterConnect(state, serverName);
         }
-        if (connection?.status === "needs-auth")
+        if (connection?.status === "needs-auth") {
             connection = await recoverAuthConnection(serverName, ownedSignal);
-        if (connection?.status === "needs-auth")
+        }
+        if (connection?.status === "needs-auth") {
             throw new SessionRecoveryAuthRequiredError(serverName);
+        }
         if (connection?.status !== "connected") {
             const failedAgo = getFailureAgeSeconds(state, serverName);
-            return { error: failure(failedAgo === null ? "server_unavailable" : "server_backoff", `Server "${serverName}" not available${failedAgo === null ? "" : ` (last failed ${failedAgo}s ago)`}`) };
+            return {
+                error: failure(failedAgo === null ? "server_unavailable" : "server_backoff", `Server "${serverName}" not available${failedAgo === null ? "" : ` (last failed ${failedAgo}s ago)`}`),
+            };
         }
         // Use the live descriptor for visibility, filtering, approval, schema and UI hints.
         if (connection.tools) {
             const { metadata } = buildToolMetadata(connection.tools, connection.resources ?? [], definition, serverName, state.config.settings?.toolPrefix ?? "server");
             // Search indexes by metadata-array identity, so retain it for unchanged projections.
-            if (!isDeepStrictEqual(state.toolMetadata.get(serverName), metadata))
+            if (!isDeepStrictEqual(state.toolMetadata.get(serverName), metadata)) {
                 state.toolMetadata.set(serverName, metadata);
+            }
         }
         return { connection, recoverAuthConnection, autoAuthAttempted: () => autoAuthAttempted };
     }
     catch (error) {
-        if (isAbortError(error, ownedSignal))
+        if (isAbortError(error, ownedSignal)) {
             throw error;
+        }
         const message = error instanceof SessionRecoveryAuthRequiredError
-            ? error.authMessage ?? getAuthRequiredMessage(state, serverName)
-            : error instanceof Error ? error.message : String(error);
+            ? (error.authMessage ?? getAuthRequiredMessage(state, serverName))
+            : error instanceof Error
+                ? error.message
+                : String(error);
         if (!(error instanceof SessionRecoveryAuthRequiredError)) {
             recordFailure(state, serverName, message);
             updateStatusBar(state);
         }
-        return { error: failure(error instanceof SessionRecoveryAuthRequiredError ? "auth_required" : "connect_failed", message) };
+        return {
+            error: failure(error instanceof SessionRecoveryAuthRequiredError ? "auth_required" : "connect_failed", message),
+        };
     }
 }
 export async function executeCall(state, toolName, args, serverOverride, getPiTools, signal, identity = {}, beforeDispatch, options = {}) {
     const ownedSignal = combineAbortSignals(state.owner?.signal, signal);
     throwIfAborted(ownedSignal);
-    if (typeof toolName !== "string" || !toolName.trim() || (serverOverride !== undefined && (typeof serverOverride !== "string" || !serverOverride)))
+    if (typeof toolName !== "string" ||
+        !toolName.trim() ||
+        (serverOverride !== undefined && (typeof serverOverride !== "string" || !serverOverride))) {
         return {
-            content: [{ type: "text", text: "Specify a non-empty tool name and, when supplied, server." }],
+            content: [
+                { type: "text", text: "Specify a non-empty tool name and, when supplied, server." },
+            ],
             details: { mode: "call", error: "invalid_arguments" },
         };
-    if (args !== undefined && (args === null || typeof args !== "object" || Array.isArray(args)))
+    }
+    if (args !== undefined && (args === null || typeof args !== "object" || Array.isArray(args))) {
         return {
             content: [{ type: "text", text: "Tool arguments must be an object." }],
             details: { mode: "call", error: "invalid_arguments", requestedTool: toolName },
         };
+    }
     let serverName = serverOverride;
     const matches = (metadata = []) => {
-        if (options.resourceUri !== undefined)
-            return metadata.filter(tool => tool.resourceUri === options.resourceUri);
-        if (options.exactOriginalName)
-            return metadata.filter(tool => tool.originalName === toolName && !tool.resourceUri);
+        if (options.resourceUri !== undefined) {
+            return metadata.filter((tool) => tool.resourceUri === options.resourceUri);
+        }
+        if (options.exactOriginalName) {
+            return metadata.filter((tool) => tool.originalName === toolName && !tool.resourceUri);
+        }
         if (serverOverride) {
-            const originals = metadata.filter(tool => tool.originalName === toolName);
-            if (originals.length)
+            const originals = metadata.filter((tool) => tool.originalName === toolName);
+            if (originals.length) {
                 return originals;
+            }
         }
-        const exact = metadata.filter(tool => tool.name === toolName);
-        if (exact.length)
+        const exact = metadata.filter((tool) => tool.name === toolName);
+        if (exact.length) {
             return exact;
-        return metadata.filter(tool => tool.name.replace(/-/g, "_") === toolName.replace(/-/g, "_"));
+        }
+        return metadata.filter((tool) => tool.name.replace(/-/g, "_") === toolName.replace(/-/g, "_"));
     };
     const ambiguous = () => ({
-        content: [{ type: "text", text: `Tool "${toolName}" is ambiguous. Specify its exact server and tool name; no call was dispatched.` }],
-        details: { mode: "call", error: "ambiguous_tool", requestedTool: toolName, ...(serverName ? { server: serverName } : {}) },
+        content: [
+            {
+                type: "text",
+                text: `Tool "${toolName}" is ambiguous. Specify its exact server and tool name; no call was dispatched.`,
+            },
+        ],
+        details: {
+            mode: "call",
+            error: "ambiguous_tool",
+            requestedTool: toolName,
+            ...(serverName ? { server: serverName } : {}),
+        },
     });
     if (!serverName) {
-        const candidates = [...state.toolMetadata].flatMap(([server, metadata]) => isServerDisabled(state.config.mcpServers[server]) ? [] : matches(metadata).map(tool => ({ server, tool })));
-        if (candidates.length > 1)
+        const candidates = [...state.toolMetadata].flatMap(([server, metadata]) => isServerDisabled(state.config.mcpServers[server])
+            ? []
+            : matches(metadata).map((tool) => ({ server, tool })));
+        if (candidates.length > 1) {
             return ambiguous();
+        }
         serverName = candidates[0]?.server;
         if (!serverName) {
             const disabled = [...state.toolMetadata].find(([server, metadata]) => isServerDisabled(state.config.mcpServers[server]) && matches(metadata).length > 0);
-            if (disabled)
+            if (disabled) {
                 return disabledResult("call", disabled[0]);
+            }
             const prefixes = Object.entries(state.config.mcpServers)
                 .filter(([, definition]) => !isServerDisabled(definition))
-                .map(([server, definition]) => ({ server, prefix: getServerPrefix(server, resolveToolPrefix(definition, state.config.settings?.toolPrefix ?? "server")) }))
+                .map(([server, definition]) => ({
+                server,
+                prefix: getServerPrefix(server, resolveToolPrefix(definition, state.config.settings?.toolPrefix ?? "server")),
+            }))
                 .filter(({ prefix }) => prefix && toolName.startsWith(`${prefix}_`))
                 .sort((a, b) => b.prefix.length - a.prefix.length);
-            if (prefixes.length > 1 && prefixes[0]?.prefix === prefixes[1]?.prefix)
+            if (prefixes.length > 1 && prefixes[0]?.prefix === prefixes[1]?.prefix) {
                 return ambiguous();
+            }
             serverName = prefixes[0]?.server;
         }
     }
     const missing = () => {
-        const nativeTool = !serverOverride && getPiTools?.().find(tool => tool.name === toolName && tool.name !== "mcp");
-        if (nativeTool)
+        const nativeTool = !serverOverride &&
+            getPiTools?.().find((tool) => tool.name === toolName && tool.name !== "mcp");
+        if (nativeTool) {
             return {
-                content: [{ type: "text", text: `"${toolName}" is a native Pi tool. Call ${toolName} directly instead of using mcp({ action: "call", tool: "${toolName}" }).` }],
+                content: [
+                    {
+                        type: "text",
+                        text: `"${toolName}" is a native Pi tool. Call ${toolName} directly instead of using mcp({ action: "call", tool: "${toolName}" }).`,
+                    },
+                ],
                 details: { mode: "call", error: "native_tool", requestedTool: toolName },
             };
+        }
         const normalizedName = toolName.replace(/-/g, "_");
-        const localOriginal = serverOverride && state.toolMetadata.get(serverOverride)?.some(tool => tool.originalName.replace(/-/g, "_") === normalizedName);
+        const localOriginal = serverOverride &&
+            state.toolMetadata
+                .get(serverOverride)
+                ?.some((tool) => tool.originalName.replace(/-/g, "_") === normalizedName);
         const owners = serverOverride && !localOriginal
-            ? [...state.toolMetadata].filter(([server, metadata]) => server !== serverOverride && !isServerDisabled(state.config.mcpServers[server]) && matches(metadata).length === 1)
+            ? [...state.toolMetadata].filter(([server, metadata]) => server !== serverOverride &&
+                !isServerDisabled(state.config.mcpServers[server]) &&
+                matches(metadata).length === 1)
             : [];
         const suggestedOwner = owners.length === 1 ? owners[0] : undefined;
-        if (suggestedOwner)
+        if (suggestedOwner) {
             return {
-                content: [{ type: "text", text: `Tool ${JSON.stringify(toolName)} is on server ${JSON.stringify(suggestedOwner[0])}, not ${JSON.stringify(serverOverride)}. Retry the same call with server: ${JSON.stringify(suggestedOwner[0])} or omit server.` }],
-                details: { mode: "call", error: "tool_not_found", requestedTool: toolName, hintServer: serverName, suggestedServer: suggestedOwner[0], suggestions: matches(suggestedOwner[1]).map(tool => tool.name) },
+                content: [
+                    {
+                        type: "text",
+                        text: `Tool ${JSON.stringify(toolName)} is on server ${JSON.stringify(suggestedOwner[0])}, not ${JSON.stringify(serverOverride)}. Retry the same call with server: ${JSON.stringify(suggestedOwner[0])} or omit server.`,
+                    },
+                ],
+                details: {
+                    mode: "call",
+                    error: "tool_not_found",
+                    requestedTool: toolName,
+                    hintServer: serverName,
+                    suggestedServer: suggestedOwner[0],
+                    suggestions: matches(suggestedOwner[1]).map((tool) => tool.name),
+                },
             };
+        }
         const suggestions = rankSuggestions(state, toolName, 5, serverName);
         let hint = suggestions.length
             ? ` Did you mean: ${suggestions.join(", ")}. Inspect with mcp({ action: "describe", tool: ${JSON.stringify(suggestions[0])} }).`
-            : serverName ? ` Search with mcp({ action: "search", query: ${JSON.stringify(toolName)}, server: ${JSON.stringify(serverName)} }).` : ' Use mcp({ action: "search", query: "..." }) to search.';
+            : serverName
+                ? ` Search with mcp({ action: "search", query: ${JSON.stringify(toolName)}, server: ${JSON.stringify(serverName)} }).`
+                : ' Use mcp({ action: "search", query: "..." }) to search.';
         hint += ' If mcp is inactive, load it with mcp_search({ enable: ["gateway"] }).';
-        if (serverName && state.toolMetadata.has(serverName) && state.manager.getConnection(serverName)?.status !== "connected")
+        if (serverName &&
+            state.toolMetadata.has(serverName) &&
+            state.manager.getConnection(serverName)?.status !== "connected") {
             hint += ` Refresh a stale catalog with mcp({ action: "connect", server: ${JSON.stringify(serverName)} }).`;
+        }
         return {
             content: [{ type: "text", text: `Tool "${toolName}" not found.${hint}` }],
-            details: { mode: "call", error: "tool_not_found", requestedTool: toolName, hintServer: serverName, suggestions },
+            details: {
+                mode: "call",
+                error: "tool_not_found",
+                requestedTool: toolName,
+                hintServer: serverName,
+                suggestions,
+            },
         };
     };
-    if (!serverName)
+    if (!serverName) {
         return missing();
+    }
     const definition = state.config.mcpServers[serverName];
-    if (!definition)
-        return { content: [{ type: "text", text: `Server "${serverName}" not found. Use mcp({ action: "status" }) to see available servers (load it first with mcp_search({ enable: ["gateway"] }) if inactive).` }], details: { mode: "call", error: "server_not_found", server: serverName, requestedTool: toolName } };
-    if (isServerDisabled(definition))
+    if (!definition) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Server "${serverName}" not found. Use mcp({ action: "status" }) to see available servers (load it first with mcp_search({ enable: ["gateway"] }) if inactive).`,
+                },
+            ],
+            details: {
+                mode: "call",
+                error: "server_not_found",
+                server: serverName,
+                requestedTool: toolName,
+            },
+        };
+    }
+    if (isServerDisabled(definition)) {
         return disabledResult("call", serverName);
+    }
     const cached = state.toolMetadata.get(serverName);
-    if (matches(cached).length > 1)
+    if (matches(cached).length > 1) {
         return ambiguous();
+    }
     // Misspellings in a known catalog do not cause connection churn or guessed execution.
-    if (cached && !matches(cached).length && !options.exactOriginalName && options.resourceUri === undefined)
+    if (cached &&
+        !matches(cached).length &&
+        !options.exactOriginalName &&
+        options.resourceUri === undefined) {
         return missing();
+    }
     const prepared = await prepareMcpConnection(state, serverName, ownedSignal);
     if (prepared.error) {
         const cachedTarget = matches(cached)[0];
-        return { ...prepared.error, details: { ...prepared.error.details, ...(cachedTarget
-                    ? cachedTarget.resourceUri ? { resourceUri: cachedTarget.resourceUri } : { tool: cachedTarget.originalName }
-                    : { requestedTool: toolName }) } };
+        return {
+            ...prepared.error,
+            details: {
+                ...prepared.error.details,
+                ...(cachedTarget
+                    ? cachedTarget.resourceUri
+                        ? { resourceUri: cachedTarget.resourceUri }
+                        : { tool: cachedTarget.originalName }
+                    : { requestedTool: toolName }),
+            },
+        };
     }
     const targets = matches(state.toolMetadata.get(serverName));
-    if (targets.length > 1)
+    if (targets.length > 1) {
         return ambiguous();
+    }
     const toolMeta = targets[0];
-    if (!toolMeta)
+    if (!toolMeta) {
         return missing();
-    if (isServerDisabled(state.config.mcpServers[serverName]))
+    }
+    if (isServerDisabled(state.config.mcpServers[serverName])) {
         return disabledResult("call", serverName);
+    }
     const approval = await ensureToolCallApproved(state, serverName, toolMeta, args, ownedSignal);
     if (!approval.ok) {
         const denied = approval.reason === "denied";
         return {
-            content: [{ type: "text", text: denied
+            content: [
+                {
+                    type: "text",
+                    text: denied
                         ? `The user declined approval to run MCP tool "${toolMeta.originalName}" on server "${serverName}".`
-                        : `MCP tool "${toolMeta.originalName}" on server "${serverName}" is approval-gated and requires an interactive session.` }],
-            details: { mode: "call", error: denied ? "approval_denied" : "approval_required", server: serverName, tool: toolMeta.originalName },
+                        : `MCP tool "${toolMeta.originalName}" on server "${serverName}" is approval-gated and requires an interactive session.`,
+                },
+            ],
+            details: {
+                mode: "call",
+                error: denied ? "approval_denied" : "approval_required",
+                server: serverName,
+                tool: toolMeta.originalName,
+            },
         };
     }
     return runToolCall(state, serverName, toolMeta, args, {
         ...identity,
         ...(beforeDispatch ? { beforeDispatch } : {}),
         ...(options.raw !== undefined ? { raw: options.raw } : {}),
-        detailsBase: { mode: "call", server: serverName, ...(toolMeta.resourceUri ? { resourceUri: toolMeta.resourceUri } : { tool: toolMeta.originalName }) },
-        ownedSignal, signal,
+        detailsBase: {
+            mode: "call",
+            server: serverName,
+            ...(toolMeta.resourceUri
+                ? { resourceUri: toolMeta.resourceUri }
+                : { tool: toolMeta.originalName }),
+        },
+        ownedSignal,
+        signal,
         recoverAuthConnection: prepared.recoverAuthConnection,
         authRequiredMessage: () => getAuthRequiredMessage(state, serverName),
         autoAuthAttempted: prepared.autoAuthAttempted,