@fitchmultz/pi-mcp-adapter 5.0.0 → 7.0.0

package/dist/resource-tools.d.ts

@@ -1 +1,16 @@
+import type { McpExtensionState } from "./state.ts";
+import { type McpOperationContext, type McpToolCallIdentity } from "./types.ts";
+export declare function executeResourceList(state: McpExtensionState, server: string, limit?: number, offset?: number, signal?: AbortSignal): Promise<import("@earendil-works/pi-agent-core").AgentToolResult<Record<string, unknown>> | {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    details: {
+        mode: string;
+        error: string;
+        server: string;
+        message: string;
+    };
+}>;
+export declare function executeResourceRead(state: McpExtensionState, server: string, uri: string, signal?: AbortSignal, identity?: McpToolCallIdentity, beforeDispatch?: (signal: AbortSignal | undefined, operation: McpOperationContext) => Promise<void>, raw?: boolean): Promise<import("@earendil-works/pi-agent-core").AgentToolResult<Record<string, unknown>>>;
 export declare function resourceNameToToolName(name: string): string;

package/dist/resource-tools.js

@@ -1,4 +1,29 @@
-// resource-tools.ts - MCP resource name utilities
+import { isServerDisabled, isToolAllowed, resolveToolPrefix } from "./types.js";
+import { executeCall, prepareMcpConnection } from "./proxy-modes.js";
+import { paginate } from "./search-ranking.js";
+import { throwIfAborted } from "./abort.js";
+import { combineAbortSignals } from "./runtime-owner.js";
+export async function executeResourceList(state, server, limit = 12, offset = 0, signal) {
+    throwIfAborted(combineAbortSignals(state.owner?.signal, signal));
+    const definition = state.config.mcpServers[server];
+    if (!definition || isServerDisabled(definition)) {
+        return { content: [{ type: "text", text: `Server "${server}" is ${definition ? "disabled" : "not configured"}.` }], details: { mode: "resources", server, error: definition ? "server_disabled" : "server_not_found" } };
+    }
+    if (!state.toolMetadata.has(server) || state.manager.getConnection(server)?.status === "connected") {
+        const prepared = await prepareMcpConnection(state, server, signal);
+        if (prepared.error)
+            return prepared.error;
+    }
+    const prefix = resolveToolPrefix(definition, state.config.settings?.toolPrefix);
+    const page = paginate((state.toolMetadata.get(server) ?? [])
+        .filter(tool => tool.resourceUri !== undefined && definition.exposeResources !== false
+        && isToolAllowed(tool.originalName, server, prefix, definition.includeTools, definition.excludeTools))
+        .map(tool => tool.resourceDescriptor ?? { uri: tool.resourceUri, description: tool.description }), offset, limit);
+    return { content: [{ type: "text", text: JSON.stringify({ server, ...page }, null, 2) }], details: { mode: "resources", server, ...page } };
+}
+export async function executeResourceRead(state, server, uri, signal, identity = {}, beforeDispatch, raw = false) {
+    return executeCall(state, uri, {}, server, undefined, signal, identity, beforeDispatch, { resourceUri: uri, raw });
+}
 export function resourceNameToToolName(name) {
     let result = name
         .replace(/[^a-zA-Z0-9]/g, "_")

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)));
@@ -28,12 +29,15 @@ export async function handleSamplingRequest(options, request) {
     throwIfAborted(signal);
     await confirmSampling(options, "Approve MCP sampling request", formatRequestApproval(options.serverName, `${model.provider}/${model.id}`, params.systemPrompt, messages));
     throwIfAborted(signal);
+    const supportsTemperature = model.compat && "supportsTemperature" in model.compat
+        ? model.compat.supportsTemperature !== false
+        : !(model.id === "gpt-6-astra" && (model.api === "openai-responses" || model.api === "openai-codex-responses"));
     const result = await options.modelRegistry.complete(model, {
         ...(params.systemPrompt !== undefined ? { systemPrompt: params.systemPrompt } : {}),
         messages,
     }, {
         maxTokens: params.maxTokens,
-        ...(params.temperature !== undefined ? { temperature: params.temperature } : {}),
+        ...(supportsTemperature && params.temperature !== undefined ? { temperature: params.temperature } : {}),
         ...(params.metadata !== undefined ? { metadata: params.metadata } : {}),
         ...(signal ? { signal } : {}),
     });

package/dist/search-ranking.d.ts

@@ -8,8 +8,6 @@ export interface RankedToolMatch {
     score: number;
 }
 export declare function normalizeSearchText(value: string): string;
-export declare function tokenize(value: string): string[];
-export declare function scoreToolMatch(tool: ToolMetadata, server: string, query: string): number | null;
 export declare function rankToolMatches(state: McpExtensionState, query: string, server?: string): RankedToolMatch[];
 export declare function paginate<T>(items: T[], offset: number, limit: number): {
     items: T[];

package/dist/search-ranking.js

@@ -1,98 +1,79 @@
-import { getServerPrefix, isServerDisabled, resolveToolPrefix } from "./types.js";
-/**
- * Shortest field token allowed to stem-match a longer query token.
- * Real descriptions tokenize possessives into single letters ("project's" -> ["project", "s"]),
- * which would otherwise make every query starting with that letter a match.
- */
-const MIN_STEM_LENGTH = 4;
+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;
-const FIELD_WEIGHTS = {
-    name: 12,
-    originalName: 10,
-    server: 8,
-    description: 5,
-};
 export function normalizeSearchText(value) {
     return value
         .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
         .replace(/[_./:-]+/g, " ")
         .toLowerCase();
 }
-export function tokenize(value) {
-    return normalizeSearchText(value).split(/[^a-z0-9]+/).filter(Boolean);
+function schemaSearchText(schema) {
+    if (!schema || typeof schema !== "object")
+        return "";
+    if (Array.isArray(schema))
+        return schema.map(schemaSearchText).join(" ");
+    return Object.entries(schema).flatMap(([key, value]) => {
+        if ((key === "description" || key === "title" || key === "const") && typeof value === "string")
+            return value;
+        if (key === "enum" && Array.isArray(value))
+            return value.filter(item => typeof item === "string");
+        if (key === "properties" && value && typeof value === "object")
+            return [Object.keys(value).join(" "), schemaSearchText(value)];
+        return schemaSearchText(value);
+    }).join(" ");
 }
-export function scoreToolMatch(tool, server, query) {
-    const normalizedQuery = normalizeSearchText(query).trim();
-    const queryTokens = tokenize(query);
-    if (queryTokens.length === 0)
-        return null;
-    const fields = {
-        name: normalizeSearchText(tool.name),
-        originalName: normalizeSearchText(tool.originalName),
-        server: normalizeSearchText(server),
-        description: normalizeSearchText(tool.description),
-    };
-    let score = 0;
-    let phraseMatched = false;
-    let wholeFieldExact = false;
-    const matchedTokens = new Set();
-    for (const [field, value] of Object.entries(fields)) {
-        const weight = FIELD_WEIGHTS[field];
-        const fieldTokens = tokenize(value);
-        if (value === normalizedQuery) {
-            score += weight * 14;
-            phraseMatched = true;
-            wholeFieldExact = true;
-        }
-        else if (value.startsWith(normalizedQuery)) {
-            score += weight * 9;
-            phraseMatched = true;
-        }
-        else if (value.includes(normalizedQuery)) {
-            score += weight * 6;
-            phraseMatched = true;
-        }
-        for (const token of queryTokens) {
-            if (fieldTokens.includes(token)) {
-                score += weight * 4;
-                matchedTokens.add(token);
-            }
-            else if (fieldTokens.some(fieldToken => fieldToken.startsWith(token) || (fieldToken.length >= MIN_STEM_LENGTH && token.startsWith(fieldToken)))) {
-                score += weight * 2;
-                matchedTokens.add(token);
-            }
-            else if (value.includes(token)) {
-                score += weight;
-                matchedTokens.add(token);
-            }
+const indexes = new WeakMap();
+function getIndex(state) {
+    const cached = indexes.get(state);
+    // Catalog publishers replace each server's metadata array on discovery/reconnect.
+    if (cached && cached.metadata.size === state.toolMetadata.size
+        && [...state.toolMetadata].every(([server, metadata]) => cached.metadata.get(server) === metadata)) {
+        return cached.index;
+    }
+    const index = new MiniSearch({
+        fields: ["name", "originalName", "description", "schema"],
+        storeFields: ["server", "tool"],
+        searchOptions: { fields: ["name", "description", "schema"], boost: { name: 2, description: 1, schema: 1 }, prefix: true },
+    });
+    let id = 0;
+    for (const [server, tools] of state.toolMetadata) {
+        for (const tool of tools) {
+            if (tool.resourceUri !== undefined)
+                continue;
+            index.add({
+                id: id++, server, tool,
+                name: normalizeSearchText(tool.name),
+                originalName: normalizeSearchText(tool.originalName),
+                description: normalizeSearchText([tool.title, tool.description].filter(Boolean).join(" ")),
+                schema: normalizeSearchText(schemaSearchText(tool.inputSchema)),
+            });
         }
     }
-    const coverage = matchedTokens.size / queryTokens.length;
-    if (!phraseMatched && (queryTokens.length <= 2 ? coverage !== 1 : coverage < 0.6))
-        return null;
-    score += coverage === 1 ? 25 : Math.round(coverage * 10);
-    const firstQueryToken = queryTokens[0];
-    if (firstQueryToken !== undefined && tokenize(fields.name).includes(firstQueryToken))
-        score += 8;
-    if (wholeFieldExact)
-        score += 20;
-    return score;
+    indexes.set(state, { metadata: new Map(state.toolMetadata), index });
+    return index;
+}
+function searchCatalog(state, query, server, options) {
+    return getIndex(state).search(normalizeSearchText(query), {
+        ...options,
+        filter: result => {
+            if (server && result.server !== server)
+                return false;
+            const definition = state.config.mcpServers[result.server];
+            if (!definition || isServerDisabled(definition))
+                return false;
+            const prefix = resolveToolPrefix(definition, state.config.settings?.toolPrefix);
+            return isToolAllowed(result.tool.originalName, result.server, prefix, definition.includeTools, definition.excludeTools);
+        },
+    }).map(({ server, tool, score }) => ({ server, tool, score }))
+        .sort((a, b) => b.score - a.score || a.tool.name.localeCompare(b.tool.name));
 }
 export function rankToolMatches(state, query, server) {
-    const matches = [];
-    for (const [serverName, metadata] of state.toolMetadata.entries()) {
-        if (server && serverName !== server)
-            continue;
-        if (isServerDisabled(state.config.mcpServers[serverName]))
-            continue;
-        for (const tool of metadata) {
-            const score = scoreToolMatch(tool, serverName, query);
-            if (score !== null)
-                matches.push({ server: serverName, tool, score });
-        }
-    }
-    return matches.sort((a, b) => b.score - a.score || a.tool.name.localeCompare(b.tool.name));
+    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;
@@ -107,36 +88,6 @@ export function paginate(items, offset, limit) {
         nextOffset: nextOffset < total ? nextOffset : null,
     };
 }
-function editDistance(a, b, maxDistance) {
-    if (Math.abs(a.length - b.length) > maxDistance)
-        return maxDistance + 1;
-    let previous = Array.from({ length: b.length + 1 }, (_, index) => index);
-    for (let i = 1; i <= a.length; i++) {
-        const current = [i];
-        let rowMin = i;
-        for (let j = 1; j <= b.length; j++) {
-            current[j] = Math.min(current[j - 1] + 1, previous[j] + 1, previous[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
-            rowMin = Math.min(rowMin, current[j]);
-        }
-        if (rowMin > maxDistance)
-            return maxDistance + 1;
-        previous = current;
-    }
-    return previous[b.length];
-}
-function rankClosest(tools, query, limit, candidateName) {
-    const normalizedQuery = normalizeSearchText(query).replace(/\s+/g, "_");
-    const maxDistance = Math.max(2, Math.floor(normalizedQuery.length * 0.2));
-    return tools
-        .map(tool => ({
-        tool,
-        distance: editDistance(normalizedQuery, normalizeSearchText(candidateName(tool)).replace(/\s+/g, "_"), maxDistance),
-    }))
-        .filter(({ distance }) => distance <= maxDistance)
-        .sort((a, b) => a.distance - b.distance || a.tool.name.localeCompare(b.tool.name))
-        .slice(0, limit)
-        .map(({ tool }) => tool.name);
-}
 export function rankSuggestions(state, name, limit, server) {
     if (name.length > MAX_TOOL_NAME_LENGTH)
         return [];
@@ -150,31 +101,13 @@ export function rankSuggestions(state, name, limit, server) {
         .filter((candidate) => Boolean(candidate.prefix) && name.startsWith(`${candidate.prefix}_`))
         .sort((a, b) => b.prefix.length - a.prefix.length)[0];
     const matchedServer = server ?? inferred?.server;
-    if (!matchedServer) {
-        const tools = [...state.toolMetadata.entries()]
-            .filter(([candidateServer]) => !isServerDisabled(state.config.mcpServers[candidateServer]))
-            .flatMap(([, metadata]) => metadata);
-        const closest = rankClosest(tools, name, limit, tool => tool.name);
-        return closest.length > 0 ? closest : rankToolMatches(state, name).slice(0, limit).map(match => match.tool.name);
-    }
-    const definition = state.config.mcpServers[matchedServer];
-    if (!definition || isServerDisabled(definition))
+    const definition = matchedServer ? state.config.mcpServers[matchedServer] : undefined;
+    if (matchedServer && (!definition || isServerDisabled(definition)))
         return [];
-    const prefix = inferred?.prefix ?? getServerPrefix(matchedServer, resolveToolPrefix(definition, globalPrefix));
+    const prefix = inferred?.prefix ?? (matchedServer ? getServerPrefix(matchedServer, resolveToolPrefix(definition, globalPrefix)) : "");
     const query = prefix && name.startsWith(`${prefix}_`) ? name.slice(prefix.length + 1) : name;
-    const tools = state.toolMetadata.get(matchedServer) ?? [];
-    const closest = rankClosest(tools, query, limit, tool => tool.originalName);
-    if (closest.length > 0)
-        return closest;
-    const queryTokens = tokenize(query);
-    const tokenMatches = rankToolMatches(state, query, matchedServer)
-        .filter(({ tool }) => {
-        const candidateTokens = tokenize(tool.originalName);
-        return queryTokens.every(token => candidateTokens.some(candidate => candidate === token
-            || candidate.startsWith(token)
-            || (candidate.length >= MIN_STEM_LENGTH && token.startsWith(candidate))));
-    })
-        .slice(0, limit)
-        .map(match => match.tool.name);
-    return tokenMatches.length > 0 || !server ? tokenMatches : rankSuggestions(state, name, limit);
+    const suggestions = searchCatalog(state, query, matchedServer, {
+        fields: [matchedServer ? "originalName" : "name"], combineWith: "AND", fuzzy: 2,
+    }).slice(0, limit).map(match => match.tool.name);
+    return suggestions.length > 0 || !server ? suggestions : rankSuggestions(state, name, limit);
 }

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;