@fitchmultz/pi-mcp-adapter 6.0.0 → 7.0.0

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;
@@ -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;
@@ -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 }],

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;

package/dist/session-recovery.js

@@ -21,7 +21,7 @@
 //   - treat generic -32000/ConnectionClosed errors as session expiry
 //   - treat AbortError/cancellation as a session failure
 import { AsyncLocalStorage } from "node:async_hooks";
-import { SdkHttpError, SdkErrorCode, ProtocolError, InsufficientScopeError, UnauthorizedError } from "@modelcontextprotocol/client";
+import { SdkError, SdkHttpError, SdkErrorCode, ProtocolError, InsufficientScopeError, UnauthorizedError } from "@modelcontextprotocol/client";
 import { logger } from "./logger.js";
 import { abortable, throwIfAborted } from "./abort.js";
 import { isServerDisabled, isNonInteractiveOAuth } from "./types.js";
@@ -30,18 +30,62 @@ const toolTransportFailures = new WeakSet();
 export function isToolTransportFailure(error) {
     return error instanceof Error && toolTransportFailures.has(error);
 }
+const interruptedToolCalls = new WeakSet();
+export function isInterruptedToolCall(error) {
+    return error instanceof Error && interruptedToolCalls.has(error);
+}
+const toolCallOutcome = new AsyncLocalStorage();
+/** Interrupted outcome reporting is separate from the transport retry policy. */
+export async function trackToolCallOutcome(fn, signal) {
+    const outcome = { pending: false, cleanup: new Set() };
+    return toolCallOutcome.run(outcome, async () => {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            if (outcome.pending && error instanceof Error
+                && (signal?.aborted || (error instanceof SdkError
+                    && (error.code === SdkErrorCode.RequestTimeout || error.code === SdkErrorCode.ConnectionClosed)))) {
+                // Abort reasons can be shared by calls that never reached dispatch.
+                const interrupted = new Error(error.message, { cause: error });
+                interruptedToolCalls.add(interrupted);
+                throw interrupted;
+            }
+            throw error;
+        }
+        finally {
+            for (const cleanup of outcome.cleanup)
+                cleanup();
+        }
+    });
+}
 const toolSend = new AsyncLocalStorage();
-/** Retain fetch/body-error origin without parsing or buffering the SSE response. */
+/** Retain fetch/body-error origin without parsing or buffering the response. */
 export const trackToolTransportFailure = async (input, init) => {
     const pending = toolSend.getStore();
     if (pending)
         pending.bodyFailure = undefined;
+    let toolPost = false;
+    if (pending && init?.method === "POST" && typeof init.body === "string") {
+        try {
+            const request = JSON.parse(init.body);
+            toolPost = request.method === "tools/call" && request.id === pending.id;
+        }
+        catch { }
+    }
+    if (toolPost && pending?.outcome)
+        pending.outcome.pending = true;
     try {
         const response = await fetch(input, init);
-        if (!pending || !response.ok || !response.body
-            || response.headers.get("content-type")?.split(";", 1)[0]?.trim().toLowerCase() !== "text/event-stream")
+        if (toolPost && !response.ok && response.status < 500 && pending?.outcome)
+            pending.outcome.pending = false;
+        const mediaType = response.headers.get("content-type")?.split(";", 1)[0]?.trim().toLowerCase();
+        const observeBody = response.ok
+            ? mediaType === "text/event-stream" || (toolPost && mediaType === "application/json")
+            : toolPost && response.status >= 500;
+        if (!pending || !response.body || !observeBody)
             return response;
-        pending.streaming = true;
+        pending.streaming = response.ok && mediaType === "text/event-stream";
         // The native end hook has no error argument. Only a failed body read proves loss.
         const reader = response.body.getReader();
         return new Response(new ReadableStream({
@@ -59,8 +103,11 @@ export const trackToolTransportFailure = async (input, init) => {
                     // Native intentional closure suppresses onRequestStreamEnd.
                     if (init?.signal?.aborted)
                         pending.finishSend();
-                    else if (error instanceof Error)
+                    else if (error instanceof Error) {
                         pending.bodyFailure = error;
+                        if (!pending.streaming)
+                            interruptedToolCalls.add(error);
+                    }
                     controller.error(error);
                     reader.releaseLock();
                 }
@@ -77,12 +124,16 @@ export const trackToolTransportFailure = async (input, init) => {
     }
 };
 /** Observe only the originating tool send, not OAuth or catalog requests. */
-export function trackToolHttpFailures(transport) {
+export function trackToolTransport(transport, http = false) {
+    const requests = new Map();
     const onmessage = transport.onmessage;
     transport.onmessage = (message, extra) => {
-        const pending = toolSend.getStore();
+        const pending = ("id" in message && message.id !== undefined ? requests.get(message.id) : undefined) ?? toolSend.getStore();
         if (pending && "id" in message && message.id === pending.id && ("result" in message || "error" in message)) {
             pending.responseReceived = true;
+            if (pending.outcome)
+                pending.outcome.pending = false;
+            requests.delete(pending.id);
             pending.finishSend();
         }
         onmessage?.(message, extra);
@@ -98,15 +149,24 @@ export function trackToolHttpFailures(transport) {
     const send = transport.send.bind(transport);
     transport.send = async (message, options) => {
         try {
-            if (!("method" in message && message.method === "tools/call" && "id" in message && options?.requestSignal)) {
+            if (!("method" in message && message.method === "tools/call" && "id" in message)) {
                 return await toolSend.run(undefined, () => send(message, options));
             }
             const pending = {
-                id: message.id, streaming: false, responseReceived: false,
+                id: message.id, outcome: toolCallOutcome.getStore(), streaming: false, responseReceived: false,
                 bodyFailure: undefined, otherFailure: undefined,
                 finishSend: () => { },
             };
+            if (pending.outcome) {
+                requests.set(message.id, pending);
+                pending.outcome.cleanup.add(() => requests.delete(message.id));
+                if (!http)
+                    pending.outcome.pending = true;
+            }
             try {
+                if (!options?.requestSignal) {
+                    return await toolSend.run(pending, () => send(message, options));
+                }
                 await abortable(new Promise((resolve, reject) => {
                     pending.finishSend = resolve;
                     void toolSend.run(pending, () => send(message, {
@@ -126,6 +186,12 @@ export function trackToolHttpFailures(transport) {
                         resolve(); }, reject);
                 }), options.requestSignal);
             }
+            catch (error) {
+                // Local send failures are distinct from a sent request waiting for its reply.
+                if (!http && pending.outcome)
+                    pending.outcome.pending = false;
+                throw error;
+            }
             finally {
                 pending.finishSend = () => { };
             }

package/dist/tool-metadata.d.ts

@@ -6,10 +6,20 @@ export declare function buildToolMetadata(tools: McpTool[], resources: McpResour
 };
 export declare function totalToolCount(state: McpExtensionState): number;
 export declare function toToolDescriptor(server: string, tool: ToolMetadata): {
-    server: string;
-    path: string;
-    name: string;
-    description: string;
+    outputSchema?: {
+        [x: string]: unknown;
+        $schema?: string | undefined;
+    } | undefined;
+    annotations?: {
+        title?: string | undefined;
+        readOnlyHint?: boolean | undefined;
+        destructiveHint?: boolean | undefined;
+        idempotentHint?: boolean | undefined;
+        openWorldHint?: boolean | undefined;
+    } | undefined;
+    execution?: {
+        taskSupport?: "forbidden" | "optional" | "required" | undefined;
+    } | undefined;
     _meta?: {
         [x: string]: unknown;
     } | undefined;
@@ -17,55 +27,45 @@ export declare function toToolDescriptor(server: string, tool: ToolMetadata): {
         src: string;
         mimeType?: string | undefined;
         sizes?: string[] | undefined;
-        theme?: "light" | "dark" | undefined;
+        theme?: "dark" | "light" | undefined;
     }[] | undefined;
     title?: string | undefined;
     inputSchema?: {
         [x: string]: unknown;
         type: "object";
         properties?: {
-            [x: string]: string | number | boolean | {
-                [x: string]: string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null;
-            } | (string | number | boolean | {
-                [x: string]: string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null;
-            } | (string | number | boolean | {
-                [x: string]: string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null;
-            } | (string | number | boolean | {
-                [x: string]: string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null;
-            } | (string | number | boolean | {
-                [x: string]: string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null;
-            } | (string | number | boolean | {
-                [x: string]: string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null;
-            } | (string | number | boolean | {
-                [x: string]: string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | null)[] | null)[] | null)[] | null)[] | null;
-            } | (string | number | boolean | {
-                [x: string]: string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | null)[] | null)[] | null)[] | null;
-            } | (string | number | boolean | {
-                [x: string]: string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | null)[] | null)[] | null;
-            } | (string | number | boolean | {
-                [x: string]: string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | null)[] | null;
-            } | (string | number | boolean | {
-                [x: string]: string | number | boolean | /*elided*/ any | (string | number | boolean | /*elided*/ any | /*elided*/ any | null)[] | null;
-            } | (string | number | boolean | {
+            [x: string]: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | /*elided*/ any | {
                 [x: string]: string | number | boolean | /*elided*/ any | /*elided*/ any | null;
-            } | /*elided*/ any | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null)[] | null;
+            } | null)[] | {
+                [x: string]: string | number | boolean | any | any | null;
+            } | null)[] | {
+                [x: string]: string | number | boolean | any | any | null;
+            } | null)[] | {
+                [x: string]: string | number | boolean | any | any | null;
+            } | null)[] | {
+                [x: string]: string | number | boolean | any | any | null;
+            } | null)[] | {
+                [x: string]: string | number | boolean | any | any | null;
+            } | null)[] | {
+                [x: string]: string | number | boolean | any | any | null;
+            } | null)[] | {
+                [x: string]: string | number | boolean | any | any | null;
+            } | null)[] | {
+                [x: string]: string | number | boolean | any | any | null;
+            } | null)[] | {
+                [x: string]: string | number | boolean | any | any | null;
+            } | null)[] | {
+                [x: string]: string | number | boolean | any | any | null;
+            } | null)[] | {
+                [x: string]: string | number | boolean | any | any | null;
+            } | null;
         } | undefined;
         required?: string[] | undefined;
     };
-    outputSchema?: {
-        [x: string]: unknown;
-        $schema?: string | undefined;
-    } | undefined;
-    annotations?: {
-        title?: string | undefined;
-        readOnlyHint?: boolean | undefined;
-        destructiveHint?: boolean | undefined;
-        idempotentHint?: boolean | undefined;
-        openWorldHint?: boolean | undefined;
-    } | undefined;
-    execution?: {
-        taskSupport?: "optional" | "required" | "forbidden" | undefined;
-    } | undefined;
+    description: string;
+    server: string;
+    path: string;
+    name: string;
 };
 export declare function catalogCoverage(state: McpExtensionState, server?: string): {
     complete: boolean;

package/dist/tool-result-renderer.d.ts

@@ -25,15 +25,15 @@ export interface McpToolResultDisplay {
     truncated: boolean;
 }
 declare class CollapsibleText implements Component {
+    private readonly fullText;
+    private readonly footerText;
+    private collapsedText;
     private readonly text;
     private readonly expanded;
     private readonly maxCollapsedLines;
     private readonly ellipsis;
     private readonly expandHint;
     private readonly preTruncated;
-    private readonly fullText;
-    private readonly footerText;
-    private collapsedText;
     constructor(text: string, expanded: boolean, maxCollapsedLines: number, ellipsis: string, expandHint: string, preTruncated?: boolean);
     render(width: number): string[];
     invalidate(): void;

package/dist/tool-result-renderer.js

@@ -9,15 +9,15 @@ const DEFAULT_MAX_COLLAPSED_LINES = 3;
 const DEFAULT_MAX_COLLAPSED_CHARS = 8000;
 const COLLAPSED_RENDER_CHAR_SLACK = 8;
 class CollapsibleText {
+    fullText;
+    footerText;
+    collapsedText = null;
     text;
     expanded;
     maxCollapsedLines;
     ellipsis;
     expandHint;
     preTruncated;
-    fullText;
-    footerText;
-    collapsedText = null;
     constructor(text, expanded, maxCollapsedLines, ellipsis, expandHint, preTruncated = false) {
         this.text = text;
         this.expanded = expanded;

package/dist/ui-resource-handler.d.ts

@@ -7,10 +7,10 @@ interface ReadUiResourceOptions {
     onNeedsAuth?: SessionRecoveryDeps["onNeedsAuth"];
 }
 export declare class UiResourceHandler {
+    private log;
     private manager;
     private config;
-    private log;
-    constructor(manager: McpServerManager, config?: McpConfig | undefined);
+    constructor(manager: McpServerManager, config?: McpConfig);
     readUiResource(serverName: string, uri: string, options?: ReadUiResourceOptions): Promise<UiResourceContent>;
     private getListResourceMeta;
 }

package/dist/ui-resource-handler.js

@@ -4,10 +4,10 @@ import { logger } from "./logger.js";
 import { SessionRecoveryAuthRequiredError, withSessionRecovery } from "./session-recovery.js";
 import { isServerDisabled } from "./types.js";
 export class UiResourceHandler {
+    log = logger.child({ component: "UiResourceHandler" });
     manager;
     config;
-    log = logger.child({ component: "UiResourceHandler" });
-    constructor(manager, config = undefined) {
+    constructor(manager, config) {
         this.manager = manager;
         this.config = config;
     }