@fitchmultz/pi-mcp-adapter 5.0.0 → 6.0.0

package/dist/mcp-panel.js

@@ -1,9 +1,8 @@
 import { matchesKey, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 import { copyToClipboard } from "@earendil-works/pi-coding-agent";
 import { createPanelKeys } from "./panel-keys.js";
-import { isServerDisabled, isToolAllowed } from "./types.js";
-import { resourceNameToToolName } from "./resource-tools.js";
 import { sanitizeTerminalText, stripOscSequences } from "./utils.js";
+import { reconstructToolMetadata } from "./metadata-cache.js";
 const DEFAULT_THEME = {
     border: "2",
     title: "2",
@@ -138,57 +137,24 @@ class McpPanel {
             else if (globalDirect) {
                 toolFilter = globalDirect;
             }
-            const tools = [];
-            if (serverCache && !this.authOnly && !isServerDisabled(definition)) {
-                for (const tool of serverCache.tools ?? []) {
-                    if (!isToolAllowed(tool.name, serverName, this.prefix, definition.includeTools, definition.excludeTools)) {
-                        continue;
-                    }
-                    const isDirect = toolFilter === true || (Array.isArray(toolFilter) && toolFilter.includes(tool.name));
-                    tools.push({
-                        name: tool.name,
-                        description: tool.description ?? "",
-                        isDirect,
-                        wasDirect: isDirect,
-                        estimatedTokens: estimateTokens(tool),
-                    });
-                }
-                if (definition.exposeResources !== false) {
-                    for (const resource of serverCache.resources ?? []) {
-                        const baseName = `read_${resourceNameToToolName(resource.name)}`;
-                        if (!isToolAllowed(baseName, serverName, this.prefix, definition.includeTools, definition.excludeTools)) {
-                            continue;
-                        }
-                        const isDirect = toolFilter === true || (Array.isArray(toolFilter) && toolFilter.includes(baseName));
-                        const ct = {
-                            name: baseName,
-                            ...(resource.description !== undefined ? { description: resource.description } : {}),
-                        };
-                        tools.push({
-                            name: baseName,
-                            description: resource.description ?? `Read resource: ${resource.uri}`,
-                            isDirect,
-                            wasDirect: isDirect,
-                            estimatedTokens: estimateTokens(ct),
-                        });
-                    }
-                }
-            }
             const status = callbacks.getConnectionStatus(serverName);
             const failureMessage = callbacks.getFailureMessage?.(serverName) ?? null;
-            this.servers.push({
+            const server = {
                 name: serverName,
                 expanded: false,
                 source: prov?.kind ?? "user",
                 ...(prov?.importKind !== undefined ? { importKind: prov.importKind } : {}),
-                ...(definition.includeTools !== undefined ? { includeTools: definition.includeTools } : {}),
-                ...(definition.excludeTools !== undefined ? { excludeTools: definition.excludeTools } : {}),
-                exposeResources: definition.exposeResources !== false,
+                definition,
+                toolFilter,
+                resourceCount: 0,
                 connectionStatus: status,
                 failureMessage,
-                tools,
+                tools: [],
                 hasCachedData: !!serverCache,
-            });
+            };
+            this.servers.push(server);
+            if (serverCache && !this.authOnly)
+                this.rebuildServerTools(server, serverCache);
         }
         this.rebuildVisibleItems();
         this.resetInactivityTimeout();
@@ -503,7 +469,6 @@ class McpPanel {
                 if (entry) {
                     this.rebuildServerTools(server, entry);
                 }
-                server.hasCachedData = true;
             }
             if (options.afterAuth) {
                 this.authNotice = connected && server.connectionStatus === "connected"
@@ -578,46 +543,22 @@ class McpPanel {
         this.cursorIndex = Math.max(0, Math.min(this.visibleItems.length - 1, this.cursorIndex + delta));
     }
     rebuildServerTools(server, entry) {
-        const existingState = new Map();
-        for (const t of server.tools)
-            existingState.set(t.name, t.isDirect);
-        const newTools = [];
-        for (const tool of entry.tools ?? []) {
-            if (!isToolAllowed(tool.name, server.name, this.prefix, server.includeTools, server.excludeTools)) {
-                continue;
-            }
-            const prev = existingState.get(tool.name);
-            const isDirect = prev !== undefined ? prev : false;
-            newTools.push({
-                name: tool.name,
-                description: tool.description ?? "",
-                isDirect,
-                wasDirect: prev !== undefined ? server.tools.find((t) => t.name === tool.name)?.wasDirect ?? false : false,
+        const existingState = new Map(server.tools.map(tool => [tool.name, tool]));
+        const metadata = reconstructToolMetadata(server.name, entry, this.prefix, server.definition);
+        server.resourceCount = metadata.filter(tool => tool.resourceUri !== undefined).length;
+        server.tools = metadata.filter(tool => tool.resourceUri === undefined).map(tool => {
+            const previous = existingState.get(tool.originalName);
+            const pinned = server.toolFilter === true
+                || (Array.isArray(server.toolFilter) && server.toolFilter.includes(tool.originalName));
+            return {
+                name: tool.originalName,
+                description: tool.description,
+                isDirect: previous?.isDirect ?? pinned,
+                wasDirect: previous?.wasDirect ?? pinned,
                 estimatedTokens: estimateTokens(tool),
-            });
-        }
-        if (server.exposeResources) {
-            for (const resource of entry.resources ?? []) {
-                const baseName = `read_${resourceNameToToolName(resource.name)}`;
-                if (!isToolAllowed(baseName, server.name, this.prefix, server.includeTools, server.excludeTools)) {
-                    continue;
-                }
-                const prev = existingState.get(baseName);
-                const isDirect = prev !== undefined ? prev : false;
-                const ct = {
-                    name: baseName,
-                    ...(resource.description !== undefined ? { description: resource.description } : {}),
-                };
-                newTools.push({
-                    name: baseName,
-                    description: resource.description ?? `Read resource: ${resource.uri}`,
-                    isDirect,
-                    wasDirect: prev !== undefined ? server.tools.find((t) => t.name === baseName)?.wasDirect ?? false : false,
-                    estimatedTokens: estimateTokens(ct),
-                });
-            }
-        }
-        server.tools = newTools;
+            };
+        });
+        server.hasCachedData = true;
         this.rebuildVisibleItems();
         this.updateDirty();
     }
@@ -677,6 +618,9 @@ class McpPanel {
                     continue;
                 if (item.type === "server") {
                     lines.push(row(this.renderServerRow(server, isCursor)));
+                    if (isCursor && !this.authOnly && server.resourceCount > 0) {
+                        lines.push(row(fg(t.hint, "    Resources: mcp actions resources / read-resource")));
+                    }
                     if (isCursor && server.connectionStatus === "failed" && server.failureMessage) {
                         for (const line of this.wrapText(sanitizeDisplayText(server.failureMessage), innerW - 6)) {
                             lines.push(row(`    ${fg(t.cancel, line)}`));
@@ -722,8 +666,9 @@ class McpPanel {
             else {
                 const directCount = this.servers.reduce((sum, s) => sum + s.tools.filter((t) => t.isDirect).length, 0);
                 const totalTokens = this.servers.reduce((sum, s) => sum + s.tools.filter((t) => t.isDirect).reduce((ts, t) => ts + t.estimatedTokens, 0), 0);
-                const stats = directCount > 0 ? `${directCount} direct  ~${totalTokens.toLocaleString()} tokens` : "no direct tools";
+                const stats = directCount > 0 ? `${directCount} pinned  ~${totalTokens.toLocaleString()} tokens` : "no pinned tools";
                 lines.push(row(fg(t.description, stats + (this.dirty ? fg(t.needsAuth, "  (unsaved)") : ""))));
+                lines.push(row(fg(t.hint, "Pins load at startup; discover more with mcp_search.")));
             }
         }
         lines.push(emptyRow());
@@ -737,7 +682,7 @@ class McpPanel {
             ]
             : [
                 italic("↑↓") + " navigate",
-                italic("space") + " toggle",
+                italic("space") + " pin/unpin",
                 italic("⏎") + " expand/auth",
                 italic("ctrl+a") + " auth",
                 italic("ctrl+r") + " reconnect",
@@ -781,7 +726,7 @@ class McpPanel {
         const importLabel = server.source === "import" ? fg(t.description, ` (${importKind})`) : "";
         const statusLabel = this.renderConnectionStatus(server);
         if (!server.hasCachedData && !this.authOnly) {
-            return `${prefix}   ${nameStr}${importLabel}  ${fg(t.description, "(not cached)")}${statusLabel}`;
+            return `${prefix}   ${nameStr}${importLabel}${statusLabel}  ${fg(t.description, "(undiscovered)")}`;
         }
         const directCount = server.tools.filter((t) => t.isDirect).length;
         const totalCount = server.tools.length;
@@ -792,16 +737,8 @@ class McpPanel {
         else if (directCount > 0) {
             toggleIcon = fg(t.needsAuth, "◐");
         }
-        let toolInfo = "";
-        if (totalCount > 0) {
-            toolInfo = `${directCount}/${totalCount}`;
-            if (directCount > 0) {
-                const tokens = server.tools.filter((t) => t.isDirect).reduce((s, t) => s + t.estimatedTokens, 0);
-                toolInfo += `  ~${tokens.toLocaleString()}`;
-            }
-            toolInfo = fg(t.description, toolInfo);
-        }
-        return `${prefix} ${toggleIcon} ${nameStr}${importLabel}  ${toolInfo}${statusLabel}`;
+        const toolInfo = this.authOnly ? "" : fg(t.description, `${totalCount} tool${totalCount === 1 ? "" : "s"}, ${directCount} pinned${server.resourceCount > 0 ? `, ${server.resourceCount} resource${server.resourceCount === 1 ? "" : "s"}` : ""}`);
+        return `${prefix} ${toggleIcon} ${nameStr}${importLabel}${statusLabel}  ${toolInfo}`;
     }
     selectedServerHasFailureMessage() {
         const item = this.visibleItems[this.cursorIndex];

package/dist/mcp-script-worker.mjs

@@ -69,7 +69,7 @@ const tools = new Proxy(Object.create(null), {
       return async (input) => request("search", { input });
     }
     if (property === "call") {
-      return async (path, args) => {
+      return async (path, args, server) => {
         // Invalid paths never reach dispatch and therefore never appear in the call trace.
         if (typeof path !== "string" || path.trim() === "") {
           return {
@@ -80,9 +80,12 @@ const tools = new Proxy(Object.create(null), {
             },
           };
         }
-        return request("call", { path, args });
+        if (server !== undefined && (typeof server !== "string" || !server)) return { ok: false, error: { code: "invalid_arguments", message: "server must be a non-empty string" } };
+        return request("call", { path, args, server });
       };
     }
+    if (property === "resources" || property === "listResources") return async (input) => request("resources", { input });
+    if (property === "readResource" || property === "readResult") return async (input) => request(property, { input });
     if (property === "describe") {
       return async (input) => request("describe", { input });
     }

package/dist/mcp-status.js

@@ -21,7 +21,7 @@ export function createMcpStatusSnapshot(state) {
         const disabled = definition?.disabled === true;
         const connection = disabled ? undefined : state.manager.getConnection(name);
         const metadata = disabled ? undefined : state.toolMetadata.get(name);
-        const toolCount = metadata?.length ?? (connection?.status === "connected" ? connection.tools.length : 0);
+        const toolCount = metadata?.filter(tool => !tool.resourceUri).length ?? (connection?.status === "connected" ? connection.tools.length : 0);
         const resourceCount = disabled
             ? undefined
             : state.resourceCounts?.get(name) ?? (connection?.status === "connected" ? connection.resources.length : undefined);
@@ -51,6 +51,7 @@ export function createMcpStatusSnapshot(state) {
             name,
             status,
             toolCount,
+            catalogKnown: metadata !== undefined || connection?.status === "connected",
             ...(resourceCount !== undefined ? { resourceCount } : {}),
             ...(status === "failed" && failedAgoSeconds !== undefined ? { failedAgoSeconds } : {}),
             disabled,

package/dist/metadata-cache.d.ts

@@ -11,7 +11,7 @@ export declare function parseDirectToolSelectors(selectors: string[]): {
     tools: Map<string, Set<string>>;
 };
 export declare function getMissingConfiguredDirectToolServers(config: McpConfig, cache: MetadataCache | null, envOverride?: string[]): string[];
-export declare function reconstructToolMetadata(serverName: string, entry: ServerCacheEntry, prefix: ToolPrefix, definition: Pick<ServerEntry, "exposeResources" | "includeTools" | "excludeTools" | "toolPrefix">): ToolMetadata[];
+export declare function reconstructToolMetadata(serverName: string, entry: ServerCacheEntry, prefix: ToolPrefix, definition: Pick<ServerEntry, "exposeResources" | "includeTools" | "excludeTools" | "toolPrefix" | "disabled">): ToolMetadata[];
 export declare function serializeTools(tools: McpTool[]): CachedTool[];
 export declare function serializeResources(resources: McpResource[]): CachedResource[];
 export declare function serializePrompts(prompts: McpPrompt[]): CachedPrompt[];

package/dist/metadata-cache.js

@@ -3,12 +3,11 @@ import { existsSync, readFileSync, writeFileSync, renameSync, mkdirSync } from "
 import { dirname } from "node:path";
 import { getAdapterPath } from "./agent-dir.js";
 import { createHash } from "node:crypto";
-import { getToolUiResourceUri } from "@modelcontextprotocol/ext-apps/app-bridge";
-import { formatPromptCommandName, formatToolName, isServerDisabled, isToolAllowed, resolveToolPrefix } from "./types.js";
-import { resourceNameToToolName } from "./resource-tools.js";
-import { extractToolUiStreamMode, interpolateEnvRecord, resolveBearerToken, resolveConfigPath, resolveServerUrl, } from "./utils.js";
-import { extractUiToolVisibility, isUiToolVisibleToModel } from "./ui-tool-visibility.js";
-const CACHE_VERSION = 1;
+import { formatPromptCommandName, isServerDisabled, resolveToolPrefix } from "./types.js";
+import { buildToolMetadata } from "./tool-metadata.js";
+import { interpolateEnvRecord, resolveBearerToken, resolveConfigPath, resolveServerUrl, } from "./utils.js";
+// Version 2 stores raw descriptors; version 1 readers cannot enforce raw UI visibility.
+const CACHE_VERSION = 2;
 const CACHE_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
 export function getMetadataCachePath() {
     return getAdapterPath("mcp-cache.json");
@@ -23,7 +22,7 @@ export function loadMetadataCache(enabled = true) {
         const raw = JSON.parse(readFileSync(cachePath, "utf-8"));
         if (!raw || typeof raw !== "object")
             return null;
-        if (raw.version !== CACHE_VERSION)
+        if (raw.version !== 1 && raw.version !== CACHE_VERSION)
             return null;
         if (!raw.servers || typeof raw.servers !== "object")
             return null;
@@ -43,7 +42,7 @@ export function saveMetadataCache(cache, enabled = true) {
     try {
         if (existsSync(cachePath)) {
             const existing = JSON.parse(readFileSync(cachePath, "utf-8"));
-            if (existing && existing.version === CACHE_VERSION && existing.servers) {
+            if (existing && (existing.version === 1 || existing.version === CACHE_VERSION) && existing.servers) {
                 merged.servers = { ...existing.servers };
             }
         }
@@ -139,83 +138,29 @@ export function getMissingConfiguredDirectToolServers(config, cache, envOverride
     return missing;
 }
 export function reconstructToolMetadata(serverName, entry, prefix, definition) {
-    const metadata = [];
-    const seenNames = new Set();
-    const effectivePrefix = resolveToolPrefix(definition, prefix);
-    for (const tool of entry.tools ?? []) {
-        if (!tool?.name)
-            continue;
-        if (!isUiToolVisibleToModel(tool.uiVisibility)) {
-            continue;
-        }
-        if (!isToolAllowed(tool.name, serverName, effectivePrefix, definition.includeTools, definition.excludeTools)) {
-            continue;
-        }
-        const name = formatToolName(tool.name, serverName, effectivePrefix);
-        if (seenNames.has(name)) {
-            continue;
-        }
-        seenNames.add(name);
-        metadata.push({
-            name,
-            originalName: tool.name,
-            description: tool.description ?? "",
-            ...(tool.inputSchema !== undefined ? { inputSchema: tool.inputSchema } : {}),
-            ...(tool.annotations !== undefined ? { annotations: tool.annotations } : {}),
-            ...(tool.uiResourceUri !== undefined ? { uiResourceUri: tool.uiResourceUri } : {}),
-            ...(tool.uiVisibility !== undefined ? { uiVisibility: tool.uiVisibility } : {}),
-            ...(tool.uiStreamMode !== undefined ? { uiStreamMode: tool.uiStreamMode } : {}),
-        });
-    }
-    if (definition.exposeResources !== false) {
-        for (const resource of entry.resources ?? []) {
-            if (!resource?.name || !resource?.uri)
-                continue;
-            const baseName = `read_${resourceNameToToolName(resource.name)}`;
-            if (!isToolAllowed(baseName, serverName, effectivePrefix, definition.includeTools, definition.excludeTools)) {
-                continue;
-            }
-            const name = formatToolName(baseName, serverName, effectivePrefix);
-            if (seenNames.has(name)) {
-                continue;
-            }
-            seenNames.add(name);
-            metadata.push({
-                name,
-                originalName: baseName,
-                description: resource.description ?? `Read resource: ${resource.uri}`,
-                resourceUri: resource.uri,
-            });
-        }
+    return buildToolMetadata((entry.tools ?? []).filter(tool => tool?.name).map(restoreCachedTool), entry.resources ?? [], definition, serverName, prefix).metadata;
+}
+function restoreCachedTool(tool) {
+    const { uiResourceUri, uiVisibility, uiStreamMode, ...descriptor } = tool;
+    if (descriptor._meta !== undefined || (uiResourceUri === undefined && uiVisibility === undefined && uiStreamMode === undefined)) {
+        return descriptor;
     }
-    return metadata;
+    return {
+        ...descriptor,
+        _meta: {
+            ui: {
+                ...(uiResourceUri !== undefined ? { resourceUri: uiResourceUri } : {}),
+                ...(uiVisibility !== undefined ? { visibility: uiVisibility } : {}),
+                ...(uiStreamMode !== undefined ? { "pi-mcp-adapter.streamMode": uiStreamMode } : {}),
+            },
+        },
+    };
 }
 export function serializeTools(tools) {
-    return tools
-        .filter(t => t?.name)
-        .map(t => {
-        const uiResourceUri = tryGetToolUiResourceUri(t);
-        const uiVisibility = extractUiToolVisibility(t._meta);
-        const uiStreamMode = extractToolUiStreamMode(t._meta);
-        return {
-            name: t.name,
-            ...(t.description !== undefined ? { description: t.description } : {}),
-            ...(t.inputSchema !== undefined ? { inputSchema: t.inputSchema } : {}),
-            ...(t.annotations !== undefined ? { annotations: t.annotations } : {}),
-            ...(uiResourceUri !== undefined ? { uiResourceUri } : {}),
-            ...(uiVisibility !== undefined ? { uiVisibility } : {}),
-            ...(uiStreamMode !== undefined ? { uiStreamMode } : {}),
-        };
-    });
+    return tools.filter(tool => tool?.name);
 }
 export function serializeResources(resources) {
-    return resources
-        .filter(r => r?.name && r?.uri)
-        .map(r => ({
-        uri: r.uri,
-        name: r.name,
-        ...(r.description !== undefined ? { description: r.description } : {}),
-    }));
+    return resources.filter(resource => resource?.name && resource?.uri);
 }
 export function serializePrompts(prompts) {
     return (prompts ?? [])
@@ -267,11 +212,3 @@ function stableStringify(value) {
     const keys = Object.keys(obj).sort();
     return `{${keys.map(k => `${JSON.stringify(k)}:${stableStringify(obj[k])}`).join(",")}}`;
 }
-function tryGetToolUiResourceUri(tool) {
-    try {
-        return getToolUiResourceUri({ _meta: tool._meta });
-    }
-    catch {
-        return undefined;
-    }
-}

package/dist/prompts.d.ts

@@ -4,7 +4,7 @@ import type { McpExtensionState } from "./state.ts";
 import { type McpConfig, type PromptMetadata } from "./types.ts";
 /**
  * Resolve prompt metadata for slash-command registration at extension load
- * time. Mirrors `resolveDirectTools`: reads the persistent metadata cache so
+ * time. Like typed tool registration, reads the persistent metadata cache so
  * commands are available before any server connects.
  */
 export declare function resolveCachedPrompts(config: McpConfig, cacheEnabled?: boolean): PromptMetadata[];

package/dist/prompts.js

@@ -5,7 +5,7 @@ import { logger } from "./logger.js";
 import { truncateAtWord } from "./utils.js";
 /**
  * Resolve prompt metadata for slash-command registration at extension load
- * time. Mirrors `resolveDirectTools`: reads the persistent metadata cache so
+ * time. Like typed tool registration, reads the persistent metadata cache so
  * commands are available before any server connects.
  */
 export function resolveCachedPrompts(config, cacheEnabled = true) {

package/dist/proxy-modes.d.ts

@@ -1,5 +1,6 @@
 import type { AgentToolResult, ToolInfo } from "@earendil-works/pi-coding-agent";
 import type { McpExtensionState } from "./state.ts";
+import type { ServerConnection } from "./server-manager.ts";
 import type { ToolMetadata, McpOperationContext, McpToolCallIdentity } from "./types.ts";
 import { type SessionRecoveryDeps } from "./session-recovery.ts";
 type ProxyToolResult = AgentToolResult<Record<string, unknown>>;
@@ -7,7 +8,7 @@ export declare function executeUiMessages(state: McpExtensionState): ProxyToolRe
 export declare function executeStatus(state: McpExtensionState): ProxyToolResult;
 export declare function executeAuthStart(state: McpExtensionState, serverName: string, signal?: AbortSignal): Promise<ProxyToolResult>;
 export declare function executeAuthComplete(state: McpExtensionState, serverName: string, input?: string, signal?: AbortSignal): Promise<ProxyToolResult>;
-export declare function executeDescribe(state: McpExtensionState, toolName: string): ProxyToolResult;
+export declare function executeDescribe(state: McpExtensionState, toolName: string, serverFilter?: string): ProxyToolResult;
 export declare function executeSearch(state: McpExtensionState, query: string, server?: string, includeSchemas?: boolean, limit?: number, offset?: number): ProxyToolResult;
 export declare function executeList(state: McpExtensionState, server: string, limit?: number, offset?: number): ProxyToolResult;
 export declare function executeInstructions(state: McpExtensionState, server: string): ProxyToolResult;
@@ -24,15 +25,48 @@ interface ToolCallOptions extends McpToolCallIdentity {
     recoverAuthConnection: NonNullable<SessionRecoveryDeps["onNeedsAuth"]>;
     authRequiredMessage: () => string;
     autoAuthAttempted: () => boolean;
-    onRawResult?: (result: unknown) => void;
+    raw?: boolean;
 }
 /**
  * Executes an already-approved tool call against a connected server.
  *
- * Both the `mcp` proxy and direct tools reach this with a resolved target and a
- * live connection; everything before this point (name resolution, connect and
- * auth strategy, approval) differs between them and stays with the caller.
+ * Direct, gateway, resource and script calls share executeCall preparation.
+ * Raw scripts skip content rendering but retain protocol results and artifacts.
  */
 export declare function runToolCall(state: McpExtensionState, serverName: string, target: ToolCallTarget, args: Record<string, unknown> | undefined, options: ToolCallOptions): Promise<ProxyToolResult>;
-export declare function executeCall(state: McpExtensionState, toolName: string, args?: Record<string, unknown>, serverOverride?: string, getPiTools?: () => ToolInfo[], signal?: AbortSignal, onRawResult?: (result: unknown) => void, identity?: McpToolCallIdentity, beforeDispatch?: (signal: AbortSignal | undefined, operation: McpOperationContext) => Promise<void>): Promise<ProxyToolResult>;
+export interface ExecuteCallOptions {
+    exactOriginalName?: boolean;
+    resourceUri?: string;
+    /** Scripts receive the raw protocol result without model-facing content transformation. */
+    raw?: boolean;
+}
+/** Connect/auth once for calls and resource discovery. Recovery stays bounded by withSessionRecovery. */
+export declare function prepareMcpConnection(state: McpExtensionState, serverName: string, signal?: AbortSignal): Promise<{
+    error: {
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        details: {
+            mode: string;
+            error: string;
+            server: string;
+            message: string;
+        };
+    };
+    connection?: never;
+    recoverAuthConnection?: never;
+    autoAuthAttempted?: never;
+} | {
+    error: ProxyToolResult;
+    connection?: never;
+    recoverAuthConnection?: never;
+    autoAuthAttempted?: never;
+} | {
+    connection: ServerConnection;
+    recoverAuthConnection: (serverName: string, signal?: AbortSignal, challenge?: import("./session-recovery.ts").AuthChallengeContext) => Promise<ServerConnection | undefined>;
+    autoAuthAttempted: () => boolean;
+    error?: never;
+}>;
+export declare function executeCall(state: McpExtensionState, toolName: string, args?: Record<string, unknown>, serverOverride?: string, getPiTools?: () => ToolInfo[], signal?: AbortSignal, identity?: McpToolCallIdentity, beforeDispatch?: (signal: AbortSignal | undefined, operation: McpOperationContext) => Promise<void>, options?: ExecuteCallOptions): Promise<ProxyToolResult>;
 export {};