@fitchmultz/pi-mcp-adapter 6.0.0 → 7.1.0

package/dist/mcp-panel.js

@@ -93,8 +93,6 @@ function estimateTokens(tool) {
     return Math.ceil((tool.name.length + descLen + schemaLen) / 4) + 10;
 }
 class McpPanel {
-    callbacks;
-    done;
     noticeLines;
     prefix;
     servers = [];
@@ -116,6 +114,8 @@ class McpPanel {
     keys;
     static MAX_VISIBLE = 12;
     static INACTIVITY_MS = 60_000;
+    callbacks;
+    done;
     constructor(config, cache, provenance, callbacks, tui, done, options = {}) {
         this.callbacks = callbacks;
         this.done = done;

package/dist/mcp-setup-panel.d.ts

@@ -31,10 +31,6 @@ export interface SetupPanelOptions {
     keybindings?: PanelKeybindings;
 }
 export declare class McpSetupPanel {
-    private discovery;
-    private callbacks;
-    private options;
-    private done;
     private screen;
     private actionCursor;
     private importCursor;
@@ -47,6 +43,10 @@ export declare class McpSetupPanel {
     private keys;
     private inactivityTimeout;
     private static readonly INACTIVITY_MS;
+    private discovery;
+    private callbacks;
+    private options;
+    private done;
     constructor(discovery: McpDiscoverySummary, callbacks: SetupPanelCallbacks, options: SetupPanelOptions, tui: {
         requestRender(): void;
     }, done: () => void);
@@ -72,6 +72,7 @@ export declare class McpSetupPanel {
     private previewWidth;
     private getActionPreview;
     private formatPreview;
+    private previewOrError;
     private formatWritePreview;
     private padLine;
     invalidate(): void;

package/dist/mcp-setup-panel.js

@@ -38,10 +38,6 @@ function wrapText(text, width) {
     return lines.length > 0 ? lines : [""];
 }
 export class McpSetupPanel {
-    discovery;
-    callbacks;
-    options;
-    done;
     screen;
     actionCursor = 0;
     importCursor = 0;
@@ -54,6 +50,10 @@ export class McpSetupPanel {
     keys;
     inactivityTimeout = null;
     static INACTIVITY_MS = 60_000;
+    discovery;
+    callbacks;
+    options;
+    done;
     constructor(discovery, callbacks, options, tui, done) {
         this.discovery = discovery;
         this.callbacks = callbacks;
@@ -361,7 +361,7 @@ export class McpSetupPanel {
             lines.push(this.padLine(fg(this.t.muted, `… ${actions.length - end} more below`), innerW));
         }
         lines.push(this.padLine("", innerW));
-        const preview = this.getActionPreview(this.getSelectedAction(), this.previewWidth(innerW));
+        const preview = this.previewOrError(width => this.getActionPreview(this.getSelectedAction(), width), innerW);
         for (const line of preview) {
             lines.push(this.padLine(line, innerW));
         }
@@ -384,8 +384,7 @@ export class McpSetupPanel {
         }
         lines.push(this.padLine("", innerW));
         const selected = this.discovery.imports.filter((entry) => this.selectedImports.has(entry.kind)).map((entry) => entry.kind);
-        const preview = this.callbacks.previewImports(selected);
-        for (const line of this.formatWritePreview("Compatibility import write preview", preview, [], this.previewWidth(innerW))) {
+        for (const line of this.previewOrError(width => this.formatWritePreview("Compatibility import write preview", this.callbacks.previewImports(selected), [], width), innerW)) {
             lines.push(this.padLine(line, innerW));
         }
         return lines;
@@ -522,6 +521,15 @@ export class McpSetupPanel {
         }
         return preview;
     }
+    previewOrError(preview, innerW) {
+        const width = this.previewWidth(innerW);
+        try {
+            return preview(width);
+        }
+        catch (error) {
+            return this.formatPreview([`Cannot preview write: ${error instanceof Error ? error.message : String(error)}`], width);
+        }
+    }
     formatWritePreview(title, preview, intro = [], width = DESKTOP_PREVIEW_WIDTH) {
         const lines = [];
         for (const line of intro) {

package/dist/mcp-trace.d.ts

@@ -52,7 +52,6 @@ export declare function createMcpTraceEvent(direction: McpTraceDirection, server
     durationMs?: number;
 }): McpTraceEvent;
 export declare class McpTraceWriter {
-    private readonly options;
     private readonly maxBytes;
     private readonly maxEvents;
     private readonly append;
@@ -65,6 +64,7 @@ export declare class McpTraceWriter {
     private initializationFailed;
     private persistenceError;
     private readonly fileReady;
+    private readonly options;
     constructor(options: McpTraceWriterOptions);
     get filePath(): string;
     get isDisabled(): boolean;

package/dist/mcp-trace.js

@@ -73,7 +73,6 @@ export function createMcpTraceEvent(direction, server, transport, message, statu
     return event;
 }
 export class McpTraceWriter {
-    options;
     maxBytes;
     maxEvents;
     append;
@@ -86,6 +85,7 @@ export class McpTraceWriter {
     initializationFailed = false;
     persistenceError;
     fileReady;
+    options;
     constructor(options) {
         this.options = options;
         this.maxBytes = boundedPositiveInteger(options.maxBytes, DEFAULT_MCP_TRACE_MAX_BYTES);

package/dist/npx-resolver.js

@@ -17,13 +17,15 @@ export async function resolveNpxBinary(command, args, signal) {
     if (!parsed)
         return null;
     const packageSpec = parsePackageSpec(parsed.packageSpec);
+    if (!packageSpec)
+        return null;
     const cacheKey = JSON.stringify([command, ...args]);
     const cache = loadCache();
     const cached = cache?.entries?.[cacheKey];
     if (cached
         && Date.now() - cached.resolvedAt < CACHE_TTL_MS
         && existsSync(cached.resolvedBin)
-        && (!packageSpec?.exactVersion || cached.packageVersion === packageSpec.exactVersion)) {
+        && (!packageSpec.exactVersion || cached.packageVersion === packageSpec.exactVersion)) {
         return { binPath: cached.resolvedBin, extraArgs: parsed.extraArgs, isJs: cached.isJs };
     }
     const resolved = resolveFromNpmCache(parsed.packageSpec, parsed.binName);
@@ -289,11 +291,13 @@ function parsePackageSpec(spec) {
     if (!packageName)
         return null;
     const normalizedVersion = requestedVersion?.replace(/^=/, "").replace(/^v/i, "");
+    // Let npm resolve ranges and tags rather than choosing an arbitrary cached version.
+    if (requestedVersion !== undefined && (!normalizedVersion || !EXACT_PACKAGE_VERSION_RE.test(normalizedVersion))) {
+        return null;
+    }
     return {
         packageName,
-        ...(normalizedVersion && EXACT_PACKAGE_VERSION_RE.test(normalizedVersion)
-            ? { exactVersion: normalizedVersion }
-            : {}),
+        ...(normalizedVersion ? { exactVersion: normalizedVersion } : {}),
     };
 }
 function defaultBinName(packageName) {

package/dist/proxy-modes.d.ts

@@ -9,7 +9,7 @@ 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, serverFilter?: string): ProxyToolResult;
-export declare function executeSearch(state: McpExtensionState, query: string, server?: string, includeSchemas?: boolean, limit?: number, offset?: number): ProxyToolResult;
+export declare function executeSearch(state: McpExtensionState, query: string, server?: string, includeSchemas?: boolean, limit?: number, offset?: number, caller?: "mcp" | "mcp_search"): ProxyToolResult;
 export declare function executeList(state: McpExtensionState, server: string, limit?: number, offset?: number): ProxyToolResult;
 export declare function executeInstructions(state: McpExtensionState, server: string): ProxyToolResult;
 export declare function executeConnect(state: McpExtensionState, serverName: string, signal?: AbortSignal, limit?: number, offset?: number): Promise<ProxyToolResult>;
@@ -63,10 +63,10 @@ export declare function prepareMcpConnection(state: McpExtensionState, serverNam
     recoverAuthConnection?: never;
     autoAuthAttempted?: never;
 } | {
+    error?: 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 {};

package/dist/proxy-modes.js

@@ -1,6 +1,6 @@
 import { DEFAULT_REQUEST_TIMEOUT_MSEC, UrlElicitationRequiredError } from "@modelcontextprotocol/client";
 import { getServerPrefix, isServerDisabled, isNonInteractiveOAuth, parseUiPromptHandoff, resolveToolPrefix } from "./types.js";
-import { lazyConnect, markKeepAliveAfterConnect, notifyToolMetadataUpdated, updateMetadataCache, getFailureAgeSeconds, updateStatusBar, clearFailure, recordFailure } from "./init.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";
@@ -10,7 +10,7 @@ import { guardMcpOutput, guardedMcpDetails, retainMcpResult, resolveMcpOutputGua
 import { maybeStartUiSession, summarizeUiSessionResult } from "./ui-session.js";
 import { formatAuthRequiredMessage, formatMcpStatus, resolveServerUrl, truncateAtWord } from "./utils.js";
 import { authenticate, completeAuthFromInput, startAuth, supportsOAuth } from "./mcp-auth-flow.js";
-import { isToolTransportFailure, SessionRecoveryAuthRequiredError, withSessionRecovery } from "./session-recovery.js";
+import { isInterruptedToolCall, isToolTransportFailure, trackToolCallOutcome, SessionRecoveryAuthRequiredError, withSessionRecovery } from "./session-recovery.js";
 import { paginate, rankSuggestions, rankToolMatches } from "./search-ranking.js";
 import { ensureToolCallApproved, isToolCallApprovalRequired } from "./tool-approval.js";
 const INSTRUCTIONS_PREVIEW_LENGTH = 300;
@@ -21,7 +21,7 @@ function disabledResult(mode, serverName) {
         details: { mode, error: "server_disabled", server: serverName, message },
     };
 }
-function getAuthRequiredMessage(state, serverName, defaultMessage = `Server "${serverName}" requires OAuth authentication. Run mcp({ action: "auth-start", server: "${serverName}" }) to get a browser URL, or /mcp-auth ${serverName} in an interactive local session.`) {
+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)
         defaultMessage = `Server "${serverName}" requires enterprise authorization. Check oauth.crossAppAccess IdP configuration and ID-token source, then retry.`;
@@ -33,7 +33,7 @@ function getAuthFailedMessage(state, serverName, message) {
     if (customGuidance || (oauth && oauth.crossAppAccess)) {
         return `OAuth authentication failed for "${serverName}": ${message}. ${getAuthRequiredMessage(state, serverName)}`;
     }
-    return `OAuth authentication failed for "${serverName}": ${message}. Run mcp({ action: "auth-start", server: "${serverName}" }) to get a browser URL, or /mcp-auth ${serverName} in an interactive local session.`;
+    return `OAuth authentication failed for "${serverName}": ${message}. 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.`;
 }
 function getRedirectPort(authorizationUrl) {
     try {
@@ -91,7 +91,7 @@ async function attemptAutoAuth(state, serverName, signal) {
     if (!state.ui && !isNonInteractiveOAuth(definition.oauth)) {
         return {
             status: "failed",
-            message: getAuthRequiredMessage(state, serverName, `Server "${serverName}" requires OAuth authentication. Run mcp({ action: "auth-start", server: "${serverName}" }) to get a browser URL, or /mcp-auth ${serverName} in an interactive local session.`),
+            message: getAuthRequiredMessage(state, serverName, `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.`),
         };
     }
     try {
@@ -268,7 +268,7 @@ 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.` }],
+            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 },
         };
     }
@@ -314,7 +314,7 @@ 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.` }],
+            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 },
         };
     }
@@ -372,7 +372,7 @@ export function executeDescribe(state, toolName, serverFilter) {
             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]}" }).`
+            ? `Did you mean: ${suggestions.join(", ")}. Inspect with mcp({ action: "describe", tool: "${suggestions[0]}" }). Load if inactive: mcp_search({ enable: ["gateway"] }).`
             : `Use mcp_search({ query: "..." }) to search.`;
         return {
             content: [{ type: "text", text: `Tool "${toolName}" not found. ${hint}` }],
@@ -387,9 +387,9 @@ export function executeDescribe(state, toolName, serverFilter) {
         details: { mode: "describe", tool: toolMeta, server: serverName },
     };
 }
-export function executeSearch(state, query, server, includeSchemas, limit = 12, offset = 0) {
+export function executeSearch(state, query, server, includeSchemas, limit = 12, offset = 0, caller = "mcp") {
     const showSchemas = includeSchemas !== false;
-    const searchCall = (nextOffset) => `mcp({ action: "search", query: ${JSON.stringify(query)}${server ? `, server: ${JSON.stringify(server)}` : ""}${showSchemas ? "" : ", includeSchemas: false"}, limit: ${limit}, offset: ${nextOffset} })`;
+    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]))
         return disabledResult("search", server);
     let matches;
@@ -461,7 +461,7 @@ 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.` }],
+            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" },
         };
     }
@@ -534,7 +534,7 @@ 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.` }],
+            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" },
         };
     }
@@ -565,7 +565,7 @@ 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.` }],
+            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 },
         };
     }
@@ -670,7 +670,7 @@ export async function runToolCall(state, serverName, target, args, options) {
         state.manager.touch(serverName);
         state.manager.incrementInFlight(serverName);
         uiSession = !target.resourceUri && target.uiResourceUri
-            ? await maybeStartUiSession(state, {
+            ? await abortable(maybeStartUiSession(state, {
                 serverName,
                 toolName: target.originalName,
                 toolArgs: args ?? {},
@@ -678,7 +678,7 @@ export async function runToolCall(state, serverName, target, args, options) {
                 ...(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;
@@ -720,7 +720,7 @@ export async function runToolCall(state, serverName, target, args, options) {
         };
         const result = target.resourceUri
             ? await dispatch(() => withSessionRecovery(recovery, serverName, conn => abortable(conn.client.readResource({ uri: target.resourceUri }, requestOptions), ownedSignal)))
-            : await dispatch(() => 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)));
+            : 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;
@@ -762,8 +762,8 @@ export async function runToolCall(state, serverName, target, args, options) {
                 details: { ...detailsBase, ...retained, error: isAbortError(error, callerSignal) ? "aborted" : "call_capture_failed", message, recovery: context },
             };
         }
-        if (isToolTransportFailure(error)) {
-            const message = `The outcome of MCP tool "${target.originalName}" on "${serverName}" is unknown after transport loss. Read back the original operation using its saved arguments and provider identity before continuing. Do not blindly repeat the call or rerun its script.`;
+        if (isToolTransportFailure(error) || isInterruptedToolCall(error)) {
+            const message = `The outcome of MCP tool "${target.originalName}" on "${serverName}" is unknown after the call was interrupted. Read back the original operation using its saved arguments and provider identity before continuing. Do not blindly repeat the call or rerun its script.`;
             uiSession?.sendToolCancelled(message);
             return {
                 content: [{ type: "text", text: message }],
@@ -962,6 +962,7 @@ export async function executeCall(state, toolName, args, serverOverride, getPiTo
         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.';
+        hint += ' If mcp is inactive, load it with mcp_search({ enable: ["gateway"] }).';
         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 {
@@ -973,7 +974,7 @@ export async function executeCall(state, toolName, args, serverOverride, getPiTo
         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.` }], details: { mode: "call", error: "server_not_found", server: serverName, requestedTool: toolName } };
+        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);

package/dist/sampling-handler.js

@@ -1,5 +1,6 @@
 import { truncateAtWord } from "./utils.js";
 import { throwIfAborted } from "./abort.js";
+import {} from "@modelcontextprotocol/client";
 export function registerSamplingHandler(client, options, own = run => run()) {
     // Own the handler's real promise, not the SDK caller's cancellable response facade.
     client.setRequestHandler("sampling/createMessage", request => own(() => handleSamplingRequest(options, request)));

package/dist/search-ranking.js

@@ -1,4 +1,4 @@
-import MiniSearch from "minisearch";
+import MiniSearch, {} from "minisearch";
 import { getServerPrefix, isServerDisabled, isToolAllowed, resolveToolPrefix } from "./types.js";
 export const MAX_PAGE_SIZE = 100;
 export const MAX_TOOL_NAME_LENGTH = 512;
@@ -69,7 +69,11 @@ function searchCatalog(state, query, server, options) {
         .sort((a, b) => b.score - a.score || a.tool.name.localeCompare(b.tool.name));
 }
 export function rankToolMatches(state, query, server) {
-    return searchCatalog(state, query, server);
+    const matches = searchCatalog(state, query, server);
+    const identity = query.trim();
+    const exact = ({ tool }) => tool.name === identity || (Boolean(server) && tool.originalName === identity);
+    // Stable partition retains MiniSearch order and scores within both groups.
+    return [...matches.filter(exact), ...matches.filter(match => !exact(match))];
 }
 export function paginate(items, offset, limit) {
     const safeOffset = Number.isFinite(offset) ? Math.max(0, Math.trunc(offset)) : 0;

package/dist/server-manager.d.ts

@@ -24,7 +24,6 @@ export interface ServerConnection {
 type UiStreamListener = (serverName: string, notification: ServerStreamResultPatchNotification["params"]) => void;
 type MetadataListChangedListener = (serverName: string, reason: string) => void;
 export declare class McpServerManager {
-    private readonly defaultCwd?;
     private ownedClients;
     private connections;
     private connectPromises;
@@ -56,7 +55,8 @@ export declare class McpServerManager {
      * Preserve existing property setters (including tracing) rather than replacing their behavior. */
     private fenceTransport;
     /** Default cwd for stdio servers without an explicit config `cwd`. */
-    constructor(defaultCwd?: string | undefined);
+    private readonly defaultCwd;
+    constructor(defaultCwd?: string);
     setSamplingConfig(config: ServerSamplingConfig | undefined): void;
     setMetadataListChangedListener(listener: MetadataListChangedListener | undefined): void;
     setElicitationConfig(config: ServerElicitationConfig | undefined): void;

package/dist/server-manager.js

@@ -2,7 +2,7 @@ import { AsyncLocalStorage } from "node:async_hooks";
 import { Client, StreamableHTTPClientTransport, SSEClientTransport, SdkHttpError, auth, extractWWWAuthenticateParams, UnauthorizedError, } from "@modelcontextprotocol/client";
 import { StdioClientTransport } from "@modelcontextprotocol/client/stdio";
 import { UnixSocketClientTransport } from "./unix-socket-transport.js";
-import { trackToolHttpFailures, trackToolTransportFailure } from "./session-recovery.js";
+import { trackToolTransport, trackToolTransportFailure } from "./session-recovery.js";
 import { isServerDisabled, isNonInteractiveOAuth, validateServerProtocolConfig, serverStreamResultPatchNotificationSchema, } from "./types.js";
 import { resolveNpxBinary } from "./npx-resolver.js";
 import { logger } from "./logger.js";
@@ -11,10 +11,10 @@ import { extractOAuthConfig, supportsOAuth, isOAuthChallenge, recordOAuthChallen
 import { getAuthBaseDir } from "./mcp-auth.js";
 import { registerSamplingHandler } from "./sampling-handler.js";
 import { handleUrlElicitation, registerElicitationHandler, } from "./elicitation-handler.js";
-import { normalizeRequestTimeoutMs, resolveBearerToken, resolveCommandSecret, resolveCommandSecretsRecord, resolveConfigPath, resolveServerUrl, } from "./utils.js";
+import { ADAPTER_VERSION, normalizeRequestTimeoutMs, resolveBearerToken, resolveCommandSecret, resolveCommandSecretsRecord, resolveConfigPath, resolveServerUrl, } from "./utils.js";
 import { abortable, throwIfAborted } from "./abort.js";
 import { combineAbortSignals } from "./runtime-owner.js";
-import { createMcpTraceWriter, isMcpTraceEnabled, traceTransportKind, wrapTransportWithMcpTrace, } from "./mcp-trace.js";
+import { createMcpTraceWriter, isMcpTraceEnabled, McpTraceWriter, traceTransportKind, wrapTransportWithMcpTrace, } from "./mcp-trace.js";
 const MAX_CAPTURED_STDERR_BYTES = 8 * 1024;
 const MAX_CAPTURED_STDERR_LINES = 3;
 const abortCleanupPromises = new WeakMap();
@@ -161,7 +161,6 @@ function appendStderrTail(tail, chunk) {
         : combined;
 }
 export class McpServerManager {
-    defaultCwd;
     // Includes native clients whose public connect/close facade ended before their send/auth tail.
     // Their operation promises remain in the same clientOperations authority until settlement.
     ownedClients = new Set();
@@ -267,6 +266,7 @@ export class McpServerManager {
         }
     }
     /** Default cwd for stdio servers without an explicit config `cwd`. */
+    defaultCwd;
     constructor(defaultCwd) {
         this.defaultCwd = defaultCwd;
     }
@@ -329,9 +329,30 @@ export class McpServerManager {
         throwIfAborted(ownedSignal);
         if (this.stopped)
             throw new Error("MCP server manager is closed");
+        const wait = (promise, attempt) => {
+            attempt.waiters++;
+            return abortable(promise, ownedSignal).finally(() => {
+                if (--attempt.waiters === 0 && ownedSignal?.aborted)
+                    attempt.controller.abort(ownedSignal.reason);
+            });
+        };
         // Dedupe concurrent connection attempts.
-        if (this.connectPromises.has(name)) {
-            return abortable(this.connectPromises.get(name), ownedSignal);
+        const pending = this.connectPromises.get(name);
+        if (pending) {
+            const attempt = this.connectAttempts.get(name);
+            if (attempt.controller.signal.aborted) {
+                // Finish the canceled attempt's cleanup before starting a fresh one.
+                try {
+                    await abortable(pending, ownedSignal);
+                }
+                catch (error) {
+                    throwIfAborted(ownedSignal);
+                    if (this.containsCleanupFailure(error))
+                        throw error;
+                }
+                return this.connect(name, definition, signal);
+            }
+            return wait(pending, attempt);
         }
         const existing = this.connections.get(name);
         if (existing?.status === "connected") {
@@ -339,10 +360,10 @@ export class McpServerManager {
             return existing;
         }
         const generation = this.closeGenerations.get(name) ?? 0;
-        const attemptController = new AbortController();
-        const attemptSignal = combineAbortSignals(ownedSignal, attemptController.signal);
-        const promise = this.createConnection(name, definition, attemptSignal, ownedSignal).then(async (connection) => {
-            if (attemptController.signal.aborted || (this.closeGenerations.get(name) ?? 0) !== generation) {
+        const attempt = { controller: new AbortController(), waiters: 0 };
+        const attemptSignal = combineAbortSignals(this.runtimeSignal, attempt.controller.signal);
+        const promise = this.createConnection(name, definition, attemptSignal, ownedSignal ? attemptSignal : undefined).then(async (connection) => {
+            if (connection.status === "closed" || attempt.controller.signal.aborted || (this.closeGenerations.get(name) ?? 0) !== generation) {
                 await this.disposeConnection(connection);
                 throwIfAborted(attemptSignal);
                 throw new Error(`MCP connection for ${name} was closed while connecting`);
@@ -350,18 +371,15 @@ export class McpServerManager {
             connection.inFlight = this.connections.get(name)?.inFlight ?? 0;
             this.connections.set(name, connection);
             return connection;
-        });
-        this.connectPromises.set(name, promise);
-        this.connectAttempts.set(name, attemptController);
-        try {
-            return await promise;
-        }
-        finally {
+        }).finally(() => {
             if (this.connectPromises.get(name) === promise)
                 this.connectPromises.delete(name);
-            if (this.connectAttempts.get(name) === attemptController)
+            if (this.connectAttempts.get(name) === attempt)
                 this.connectAttempts.delete(name);
-        }
+        });
+        this.connectPromises.set(name, promise);
+        this.connectAttempts.set(name, attempt);
+        return wait(promise, attempt);
     }
     /**
      * Reconnect a server whose connection was proven stale (e.g. by a 404
@@ -493,6 +511,8 @@ export class McpServerManager {
         else {
             transport = new UnixSocketClientTransport(resolveConfigPath(definition.socket));
         }
+        if (!definition.url)
+            trackToolTransport(transport);
         if (traceObserver) {
             const traceTransportKindValue = traceTransportKind(definition, transport);
             transport = wrapTransportWithMcpTrace(transport, name, traceTransportKindValue, traceObserver);
@@ -536,11 +556,9 @@ export class McpServerManager {
                         status: "connected",
                         oauthProvider,
                     };
-                    // The public client hook preserves native transport cleanup. An old
-                    // client's late close must never change its replacement's status.
+                    // Track closure during discovery too; this only changes this client's connection.
                     client.onclose = () => {
-                        if (this.connections.get(name) === connection)
-                            connection.status = "closed";
+                        connection.status = "closed";
                     };
                     const discoveryOptions = this.buildRequestOptions(definition, signal);
                     const catalogs = [
@@ -671,7 +689,7 @@ export class McpServerManager {
     createClient(serverName, definition) {
         const capabilities = this.buildClientCapabilities(definition);
         let client;
-        client = new ManagedClient({ name: `pi-mcp-${serverName}`, version: "4.3.1" }, {
+        client = new ManagedClient({ name: `pi-mcp-${serverName}`, version: ADAPTER_VERSION }, {
             versionNegotiation: { mode: definition.protocolVersion ?? (definition.url ? "auto" : "legacy") },
             listMaxPages: 0,
             ...(Object.keys(capabilities).length > 0 ? { capabilities } : {}),
@@ -936,8 +954,7 @@ export class McpServerManager {
                 onAuthChallenge?.(error);
             };
         }
-        if (!legacySse)
-            trackToolHttpFailures(transport);
+        trackToolTransport(transport, true);
         return { transport, oauthProvider: authProvider !== undefined };
     }
     async fetchAllTools(client, requestOptions) {
@@ -1021,7 +1038,7 @@ export class McpServerManager {
     async close(name) {
         this.beforeActivity();
         this.closeGenerations.set(name, (this.closeGenerations.get(name) ?? 0) + 1);
-        this.connectAttempts.get(name)?.abort(new Error(`MCP connection ${name} was closed`));
+        this.connectAttempts.get(name)?.controller.abort(new Error(`MCP connection ${name} was closed`));
         const pendingClose = this.closePromises.get(name);
         if (pendingClose)
             return pendingClose;

package/dist/session-recovery.d.ts

@@ -2,15 +2,18 @@ import { type FetchLike, type Transport } from "@modelcontextprotocol/client";
 import { type McpConfig } from "./types.ts";
 import type { McpServerManager, ServerConnection } from "./server-manager.ts";
 export declare function isToolTransportFailure(error: unknown): boolean;
-/** Retain fetch/body-error origin without parsing or buffering the SSE response. */
+export declare function isInterruptedToolCall(error: unknown): boolean;
+/** Interrupted outcome reporting is separate from the transport retry policy. */
+export declare function trackToolCallOutcome<T>(fn: () => Promise<T>, signal?: AbortSignal): Promise<T>;
+/** Retain fetch/body-error origin without parsing or buffering the response. */
 export declare const trackToolTransportFailure: FetchLike;
 /** Observe only the originating tool send, not OAuth or catalog requests. */
-export declare function trackToolHttpFailures(transport: Transport): void;
+export declare function trackToolTransport(transport: Transport, http?: boolean): void;
 export declare function isTerminatedSession(err: unknown, hadSessionId: boolean): boolean;
 export declare class SessionRecoveryAuthRequiredError extends Error {
     readonly serverName: string;
-    readonly authMessage?: string | undefined;
-    constructor(serverName: string, authMessage?: string | undefined);
+    readonly authMessage: string | undefined;
+    constructor(serverName: string, authMessage?: string);
 }
 export interface AuthChallengeContext {
     connection: ServerConnection;