@fitchmultz/pi-mcp-adapter 8.0.6 → 8.0.8

package/dist/server-manager.js

@@ -1,4 +1,4 @@
-import { clientOperations, drainClientCallbacks, drainClientOperations } from "./client-operations.js";
+import { clientOperations, drainClientCallbacks, drainClientOperations, } from "./client-operations.js";
 import { isServerDisabled, isNonInteractiveOAuth, validateServerProtocolConfig, } from "./types.js";
 import { resolveNpxBinary } from "./npx-resolver.js";
 import { logger } from "./logger.js";
@@ -7,7 +7,7 @@ import { getAuthBaseDir } from "./mcp-auth.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, McpTraceWriter, traceTransportKind, wrapTransportWithMcpTrace, } from "./mcp-trace.js";
+import { createMcpTraceWriter, isMcpTraceEnabled, traceTransportKind, wrapTransportWithMcpTrace, } from "./mcp-trace.js";
 const MAX_CAPTURED_STDERR_BYTES = 8 * 1024;
 const MAX_CAPTURED_STDERR_LINES = 3;
 const abortCleanupPromises = new WeakMap();
@@ -18,9 +18,7 @@ function boundedStderrChunk(chunk) {
     }
     // Limit string conversion before encoding; Buffer.from(largeString) would
     // otherwise allocate the entire stderr event before applying the cap.
-    const suffix = chunk.length > MAX_CAPTURED_STDERR_BYTES
-        ? chunk.slice(-MAX_CAPTURED_STDERR_BYTES)
-        : chunk;
+    const suffix = chunk.length > MAX_CAPTURED_STDERR_BYTES ? chunk.slice(-MAX_CAPTURED_STDERR_BYTES) : chunk;
     const bytes = Buffer.from(suffix, "utf8");
     return bytes.byteLength > MAX_CAPTURED_STDERR_BYTES
         ? Buffer.from(bytes.subarray(bytes.byteLength - MAX_CAPTURED_STDERR_BYTES))
@@ -28,10 +26,12 @@ function boundedStderrChunk(chunk) {
 }
 function appendStderrTail(tail, chunk) {
     const bytes = boundedStderrChunk(chunk);
-    if (bytes.length === 0)
+    if (bytes.length === 0) {
         return tail;
-    if (tail.length === 0)
+    }
+    if (tail.length === 0) {
         return bytes;
+    }
     const combined = Buffer.concat([tail, bytes]);
     return combined.length > MAX_CAPTURED_STDERR_BYTES
         ? Buffer.from(combined.subarray(combined.length - MAX_CAPTURED_STDERR_BYTES))
@@ -62,8 +62,9 @@ export class McpServerManager {
     traceWriter;
     stopped = false;
     releaseClientWhenSettled(client) {
-        if (this.ownedClients.has(client))
+        if (this.ownedClients.has(client)) {
             void drainClientOperations(client).then(() => this.ownedClients.delete(client));
+        }
     }
     /** Own native send/auth tails even after a public request has been cancelled. */
     ownTransportSends(transport, client) {
@@ -123,23 +124,28 @@ export class McpServerManager {
         };
     }
     async connect(name, definition, signal) {
-        if (isServerDisabled(definition))
+        if (isServerDisabled(definition)) {
             throw new Error(`MCP server "${name}" is disabled`);
-        if (this.stopped)
+        }
+        if (this.stopped) {
             throw new Error("MCP server manager is closed");
+        }
         const ownedSignal = combineAbortSignals(this.runtimeSignal, signal);
         throwIfAborted(ownedSignal);
         const closing = this.closePromises.get(name);
-        if (closing)
+        if (closing) {
             await abortable(closing, ownedSignal);
+        }
         throwIfAborted(ownedSignal);
-        if (this.stopped)
+        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)
+                if (--attempt.waiters === 0 && ownedSignal?.aborted) {
                     attempt.controller.abort(ownedSignal.reason);
+                }
             });
         };
         // Dedupe concurrent connection attempts.
@@ -153,8 +159,9 @@ export class McpServerManager {
                 }
                 catch (error) {
                     throwIfAborted(ownedSignal);
-                    if (this.containsCleanupFailure(error))
+                    if (this.containsCleanupFailure(error)) {
                         throw error;
+                    }
                 }
                 return this.connect(name, definition, signal);
             }
@@ -168,8 +175,11 @@ export class McpServerManager {
         const generation = this.closeGenerations.get(name) ?? 0;
         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) {
+        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`);
@@ -177,11 +187,14 @@ export class McpServerManager {
             connection.inFlight = this.connections.get(name)?.inFlight ?? 0;
             this.connections.set(name, connection);
             return connection;
-        }).finally(() => {
-            if (this.connectPromises.get(name) === promise)
+        })
+            .finally(() => {
+            if (this.connectPromises.get(name) === promise) {
                 this.connectPromises.delete(name);
-            if (this.connectAttempts.get(name) === attempt)
+            }
+            if (this.connectAttempts.get(name) === attempt) {
                 this.connectAttempts.delete(name);
+            }
         });
         this.connectPromises.set(name, promise);
         this.connectAttempts.set(name, attempt);
@@ -197,10 +210,12 @@ export class McpServerManager {
      * connection, that fresh connection is returned untouched.
      */
     async reconnect(name, definition, staleConnection, signal) {
-        if (isServerDisabled(definition))
+        if (isServerDisabled(definition)) {
             throw new Error(`MCP server "${name}" is disabled`);
-        if (this.stopped)
+        }
+        if (this.stopped) {
             throw new Error("MCP server manager is closed");
+        }
         const ownedSignal = combineAbortSignals(this.runtimeSignal, signal);
         throwIfAborted(ownedSignal);
         const inFlight = this.reconnectPromises.get(name);
@@ -222,8 +237,9 @@ export class McpServerManager {
         // longer holds the connection we were asked to replace, someone else
         // already reconnected (or connected) first.
         if (current !== staleConnection) {
-            if (!current)
+            if (!current) {
                 throw new Error(`Server "${name}" is not connected`);
+            }
             return current;
         }
         this.retire(name, staleConnection);
@@ -231,28 +247,34 @@ export class McpServerManager {
     }
     /** Retire only the expected current client; accepted native work drains before close. */
     retire(name, connection) {
-        if (this.connections.get(name) !== connection)
+        if (this.connections.get(name) !== connection) {
             return;
+        }
         connection.status = "closed";
         let retired = this.retiredConnections.get(name);
-        if (!retired)
-            this.retiredConnections.set(name, retired = new Set());
-        if (retired.has(connection))
+        if (!retired) {
+            this.retiredConnections.set(name, (retired = new Set()));
+        }
+        if (retired.has(connection)) {
             return;
+        }
         retired.add(connection);
         void (async () => {
             for (;;) {
                 const pending = [...(clientOperations.get(connection.client) ?? [])]
-                    .filter(([, kind]) => kind !== "subscription").map(([operation]) => operation);
-                if (!pending.length)
+                    .filter(([, kind]) => kind !== "subscription")
+                    .map(([operation]) => operation);
+                if (!pending.length) {
                     break;
+                }
                 await Promise.allSettled(pending);
             }
             await this.disposeConnection(connection);
             retired.delete(connection);
-            if (retired.size === 0 && this.retiredConnections.get(name) === retired)
+            if (retired.size === 0 && this.retiredConnections.get(name) === retired) {
                 this.retiredConnections.delete(name);
-        })().catch(error => {
+            }
+        })().catch((error) => {
             // Keep failed retirement owned so explicit shutdown also reports it.
             logger.debug(`MCP retired connection cleanup failed for ${name}: ${String(error)}`);
         });
@@ -261,7 +283,7 @@ export class McpServerManager {
         throwIfAborted(signal);
         validateServerProtocolConfig(definition);
         const runtime = await import("./connection-runtime.js");
-        const { StdioClientTransport, SdkHttpError, UnixSocketClientTransport, trackToolTransport, getOAuthRequest, isOAuthChallenge } = runtime;
+        const { StdioClientTransport, SdkHttpError, UnixSocketClientTransport, trackToolTransport, getOAuthRequest, isOAuthChallenge, } = runtime;
         throwIfAborted(signal);
         let client = this.createClient(name, definition, runtime);
         const tracingEnabled = isMcpTraceEnabled(definition, this.traceSettings);
@@ -269,17 +291,19 @@ export class McpServerManager {
             ? (this.traceWriter ??= createMcpTraceWriter(this.defaultCwd, this.traceSettings ?? {}))
             : undefined;
         const traceObserver = traceWriter
-            ? { record: event => traceWriter.write(event) }
+            ? { record: (event) => traceWriter.write(event) }
             : undefined;
         let transport;
-        let implicitOAuth = Boolean(definition.url && supportsOAuth(definition)
-            && getOAuthRequest(name, resolveServerUrl(definition), getAuthBaseDir(this.authStorageOptions), this.oauthRuntime));
+        let implicitOAuth = Boolean(definition.url &&
+            supportsOAuth(definition) &&
+            getOAuthRequest(name, resolveServerUrl(definition), getAuthBaseDir(this.authStorageOptions), this.oauthRuntime));
         let oauthProvider = false;
         let authError;
-        const onAuthChallenge = (error) => { authError = error; };
+        const onAuthChallenge = (error) => {
+            authError = error;
+        };
         let stderrTail = Buffer.alloc(0);
-        const configuredTransports = [definition.command, definition.url, definition.socket]
-            .filter(value => typeof value === "string" && value.length > 0);
+        const configuredTransports = [definition.command, definition.url, definition.socket].filter((value) => typeof value === "string" && value.length > 0);
         if (configuredTransports.length !== 1) {
             throw new Error(`Server ${name} must configure exactly one of command, url, or socket`);
         }
@@ -319,8 +343,9 @@ export class McpServerManager {
         else {
             transport = new UnixSocketClientTransport(resolveConfigPath(definition.socket));
         }
-        if (!definition.url)
+        if (!definition.url) {
             trackToolTransport(transport);
+        }
         if (traceObserver) {
             const traceTransportKindValue = traceTransportKind(definition, transport);
             transport = wrapTransportWithMcpTrace(transport, name, traceTransportKindValue, traceObserver);
@@ -337,16 +362,21 @@ export class McpServerManager {
                     }
                     catch (error) {
                         // Only handshake failures establish that the HTTP endpoint is unsupported.
-                        if (!definition.url || signal?.aborted || legacySse || !(error instanceof SdkHttpError)
-                            || ![404, 405, 406, 415].includes(error.status))
+                        if (!definition.url ||
+                            signal?.aborted ||
+                            legacySse ||
+                            !(error instanceof SdkHttpError) ||
+                            ![404, 405, 406, 415].includes(error.status)) {
                             throw error;
+                        }
                         legacySse = true;
                         await client.close();
                         this.releaseClientWhenSettled(client);
                         client = this.createClient(name, { ...definition, protocolVersion: "legacy" }, runtime);
                         ({ transport, oauthProvider } = this.createHttpTransport(runtime, definition, name, client, legacySse, implicitOAuth, onAuthChallenge));
-                        if (traceObserver)
+                        if (traceObserver) {
                             transport = wrapTransportWithMcpTrace(transport, name, traceTransportKind(definition, transport), traceObserver);
+                        }
                         continue;
                     }
                     this.attachAdapterNotificationHandlers(name, client, runtime.serverStreamResultPatchNotificationSchema);
@@ -376,11 +406,13 @@ export class McpServerManager {
                     ];
                     const [toolResult] = await Promise.allSettled(catalogs);
                     throwIfAborted(signal);
-                    if (toolResult.status === "rejected" && !isOAuthChallenge(toolResult.reason))
+                    if (toolResult.status === "rejected" && !isOAuthChallenge(toolResult.reason)) {
                         throw toolResult.reason;
+                    }
                     // Optional catalogs catch their errors; the native observer still sees auth challenges.
-                    if (authError)
+                    if (authError) {
                         throw authError;
+                    }
                     const [tools, resources, promptResult] = await Promise.all(catalogs);
                     connection.tools = tools;
                     connection.resources = resources;
@@ -389,16 +421,22 @@ export class McpServerManager {
                     return connection;
                 }
                 catch (error) {
-                    if (!definition.url || signal?.aborted || implicitOAuth || definition.auth !== undefined
-                        || !supportsOAuth(definition) || !isOAuthChallenge(error))
+                    if (!definition.url ||
+                        signal?.aborted ||
+                        implicitOAuth ||
+                        definition.auth !== undefined ||
+                        !supportsOAuth(definition) ||
+                        !isOAuthChallenge(error)) {
                         throw error;
+                    }
                     implicitOAuth = true;
                     await client.close();
                     this.releaseClientWhenSettled(client);
                     client = this.createClient(name, legacySse ? { ...definition, protocolVersion: "legacy" } : definition, runtime);
                     ({ transport, oauthProvider } = this.createHttpTransport(runtime, definition, name, client, legacySse, implicitOAuth, onAuthChallenge));
-                    if (traceObserver)
+                    if (traceObserver) {
                         transport = wrapTransportWithMcpTrace(transport, name, traceTransportKind(definition, transport), traceObserver);
+                    }
                 }
             }
         }
@@ -410,12 +448,10 @@ export class McpServerManager {
             const abortCleanupFailed = error instanceof AggregateError && error.message === "MCP connection abort cleanup failed";
             const cleanupResults = abortCleanupFailed
                 ? []
-                : await Promise.allSettled([
-                    abortCleanup ?? Promise.resolve().then(() => client.close()),
-                ]);
+                : await Promise.allSettled([abortCleanup ?? Promise.resolve().then(() => client.close())]);
             await drainClientCallbacks(client);
             this.releaseClientWhenSettled(client);
-            const cleanupFailures = cleanupResults.flatMap(result => result.status === "rejected" ? [result.reason] : []);
+            const cleanupFailures = cleanupResults.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
             let reportedError = error;
             if (cleanupFailures.length > 0) {
                 reportedError = new AggregateError([error, ...cleanupFailures], "MCP connection setup failed");
@@ -440,7 +476,10 @@ export class McpServerManager {
             }
             if (stderrTail.length > 0) {
                 const stderrText = stderrTail.toString("utf8").trim();
-                const lines = stderrText.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+                const lines = stderrText
+                    .split(/\r?\n/)
+                    .map((line) => line.trim())
+                    .filter(Boolean);
                 if (lines.length > 0) {
                     const baseMessage = reportedError instanceof Error ? reportedError.message : String(reportedError);
                     const detail = lines.slice(-MAX_CAPTURED_STDERR_LINES).join(" — ");
@@ -481,8 +520,14 @@ export class McpServerManager {
     buildClientCapabilities(definition) {
         return {
             ...(supportsOAuth(definition) && isNonInteractiveOAuth(definition.oauth)
-                ? { extensions: { [definition.oauth && definition.oauth.crossAppAccess
-                            ? "io.modelcontextprotocol/enterprise-managed-authorization" : "io.modelcontextprotocol/oauth-client-credentials"]: {} } } : {}),
+                ? {
+                    extensions: {
+                        [definition.oauth && definition.oauth.crossAppAccess
+                            ? "io.modelcontextprotocol/enterprise-managed-authorization"
+                            : "io.modelcontextprotocol/oauth-client-credentials"]: {},
+                    },
+                }
+                : {}),
             ...(this.samplingConfig ? { sampling: {} } : {}),
             ...(this.elicitationConfig
                 ? {
@@ -499,7 +544,9 @@ export class McpServerManager {
         const capabilities = this.buildClientCapabilities(definition);
         let client;
         client = new ManagedClient({ name: `pi-mcp-${serverName}`, version: ADAPTER_VERSION }, {
-            versionNegotiation: { mode: definition.protocolVersion ?? (definition.url ? "auto" : "legacy") },
+            versionNegotiation: {
+                mode: definition.protocolVersion ?? (definition.url ? "auto" : "legacy"),
+            },
             // ponytail: reject catalogs over 1024 pages; raise this native cap if a real catalog needs more.
             listMaxPages: 1024,
             ...(Object.keys(capabilities).length > 0 ? { capabilities } : {}),
@@ -524,23 +571,26 @@ export class McpServerManager {
         client.serverName = serverName;
         this.ownedClients.add(client);
         if (this.samplingConfig) {
-            registerSamplingHandler(client, { ...this.samplingConfig, serverName }, run => client.ownCallback("sampling callback", run));
+            registerSamplingHandler(client, { ...this.samplingConfig, serverName }, (run) => client.ownCallback("sampling callback", run));
         }
         if (this.elicitationConfig) {
             registerElicitationHandler(client, {
                 ...this.elicitationConfig,
                 serverName,
-                onUrlAccepted: elicitationId => this.rememberUrlElicitation(serverName, elicitationId),
-            }, run => client.ownCallback("elicitation callback", run));
+                onUrlAccepted: (elicitationId) => this.rememberUrlElicitation(serverName, elicitationId),
+            }, (run) => client.ownCallback("elicitation callback", run));
             if (this.elicitationConfig.allowUrl) {
-                client.setNotificationHandler("notifications/elicitation/complete", notification => {
-                    if (this.runtimeSignal?.aborted)
+                client.setNotificationHandler("notifications/elicitation/complete", (notification) => {
+                    if (this.runtimeSignal?.aborted) {
                         return;
+                    }
                     const accepted = this.acceptedUrlElicitations.get(serverName);
-                    if (!accepted?.delete(notification.params.elicitationId))
+                    if (!accepted?.delete(notification.params.elicitationId)) {
                         return;
-                    if (accepted.size === 0)
+                    }
+                    if (accepted.size === 0) {
                         this.acceptedUrlElicitations.delete(serverName);
+                    }
                     this.elicitationConfig?.ui.notify(`MCP browser interaction for ${serverName} completed. You can retry the tool now.`, "info");
                 });
             }
@@ -552,11 +602,13 @@ export class McpServerManager {
             logger.debug(`MCP: tools/list_changed refresh failed for ${serverName}: ${error.message}`);
             return;
         }
-        if (!tools)
+        if (!tools) {
             return;
+        }
         const connection = this.connections.get(serverName);
-        if (!connection || connection.client !== client || connection.status !== "connected")
+        if (!connection || connection.client !== client || connection.status !== "connected") {
             return;
+        }
         connection.tools = tools;
         this.metadataListChangedListener?.(serverName, "tools-list-changed");
     }
@@ -565,11 +617,13 @@ export class McpServerManager {
             logger.debug(`MCP: prompts/list_changed refresh failed for ${serverName}: ${error.message}`);
             return;
         }
-        if (!prompts)
+        if (!prompts) {
             return;
+        }
         const connection = this.connections.get(serverName);
-        if (!connection || connection.client !== client || connection.status !== "connected")
+        if (!connection || connection.client !== client || connection.status !== "connected") {
             return;
+        }
         connection.prompts = prompts;
         connection.promptDiscoveryFailed = false;
         this.metadataListChangedListener?.(serverName, "prompts-list-changed");
@@ -579,35 +633,41 @@ export class McpServerManager {
             logger.debug(`MCP: resources/list_changed refresh failed for ${serverName}: ${error.message}`);
             return;
         }
-        if (!resources)
+        if (!resources) {
             return;
+        }
         const connection = this.connections.get(serverName);
-        if (!connection || connection.client !== client || connection.status !== "connected")
+        if (!connection || connection.client !== client || connection.status !== "connected") {
             return;
+        }
         connection.resources = resources;
         this.metadataListChangedListener?.(serverName, "resources-list-changed");
     }
     async handleUrlElicitationRequired(serverName, error) {
-        if (this.runtimeSignal?.aborted || !this.elicitationConfig?.allowUrl)
+        if (this.runtimeSignal?.aborted || !this.elicitationConfig?.allowUrl) {
             return "cancel";
+        }
         const { handleUrlElicitation } = await import("./elicitation-handler.js");
         // The import yields; recheck cancellation and URL support before prompting.
-        if (this.runtimeSignal?.aborted || !this.elicitationConfig?.allowUrl)
+        if (this.runtimeSignal?.aborted || !this.elicitationConfig?.allowUrl) {
             return "cancel";
+        }
         for (const params of error.elicitations) {
             const result = await handleUrlElicitation({
                 ...this.elicitationConfig,
                 serverName,
-                onUrlAccepted: elicitationId => this.rememberUrlElicitation(serverName, elicitationId),
+                onUrlAccepted: (elicitationId) => this.rememberUrlElicitation(serverName, elicitationId),
             }, params);
-            if (result.action !== "accept")
+            if (result.action !== "accept") {
                 return result.action;
+            }
         }
         return "accept";
     }
     rememberUrlElicitation(serverName, elicitationId) {
-        if (this.runtimeSignal?.aborted)
+        if (this.runtimeSignal?.aborted) {
             return;
+        }
         let accepted = this.acceptedUrlElicitations.get(serverName);
         if (!accepted) {
             accepted = new Set();
@@ -622,13 +682,14 @@ export class McpServerManager {
         const storageBase = getAuthBaseDir(this.authStorageOptions);
         const runtime = this.oauthRuntime;
         const generation = this.closeGenerations.get(serverName) ?? 0;
-        const active = () => !this.stopped && !this.runtimeSignal?.aborted && !runtime?.signal.aborted
-            && (this.closeGenerations.get(serverName) ?? 0) === generation;
+        const active = () => !this.stopped &&
+            !this.runtimeSignal?.aborted &&
+            !runtime?.signal.aborted &&
+            (this.closeGenerations.get(serverName) ?? 0) === generation;
         let issuer;
         // Resolve secret commands only for this connection attempt, without mutating config.
-        const hasCommandHeader = Object.values(definition.headers ?? {})
-            .some(value => value.startsWith("!") && !value.startsWith("!!"));
-        const headers = resolveCommandSecretsRecord(definition.headers, key => `MCP server "${serverName}" HTTP header "${key}"`) ?? {};
+        const hasCommandHeader = Object.values(definition.headers ?? {}).some((value) => value.startsWith("!") && !value.startsWith("!!"));
+        const headers = resolveCommandSecretsRecord(definition.headers, (key) => `MCP server "${serverName}" HTTP header "${key}"`) ?? {};
         // For bearer auth, add the token to headers BEFORE creating requestInit
         const commandBearer = definition.bearerToken?.startsWith("!") && !definition.bearerToken.startsWith("!!")
             ? definition.bearerToken
@@ -637,8 +698,9 @@ export class McpServerManager {
             const token = commandBearer
                 ? resolveCommandSecret(commandBearer, `MCP server "${serverName}" HTTP bearer token`)
                 : resolveBearerToken(definition);
-            if (token)
+            if (token) {
                 headers["Authorization"] = `Bearer ${token}`;
+            }
         }
         if (hasCommandHeader || commandBearer) {
             try {
@@ -654,37 +716,45 @@ export class McpServerManager {
             onRedirect: async (_authUrl) => {
                 // URL is captured by startAuth, no need to log
             },
-            onDiscoveryState: state => {
+            onDiscoveryState: (state) => {
                 issuer = state.authorizationServerMetadata?.issuer ?? state.authorizationServerUrl;
-                if (active())
+                if (active()) {
                     bindOAuthRequestIssuer(serverName, serverUrl, storageBase, issuer, runtime);
+                }
             },
         }, this.authStorageOptions, this.oauthRuntime?.signal);
         const authProvider = supportsOAuth(definition) && (definition.auth === "oauth" || implicitOAuth)
-            ? createAuthProvider() : undefined;
+            ? createAuthProvider()
+            : undefined;
         client.oauthProvider = authProvider;
         let transportClosed = false;
         // The SDK launches legacy GET bootstrap/reconnect outside send(). Fence every
         // provider entry and own its ACTUAL promise (including signing/storage after
         // cancellation). Keep the OAuthClientProvider shape: native 401/403 behavior,
         // issuer validation and noninteractive grants remain SDK-owned.
-        const ownedProvider = authProvider && new Proxy(authProvider, {
-            get: (provider, key) => {
-                const value = Reflect.get(provider, key, provider);
-                if (typeof value !== "function")
-                    return value;
-                return (...args) => client.ownNative(async () => {
-                    provider.lifetimeSignal.throwIfAborted();
-                    return Reflect.apply(value, provider, args);
-                });
-            },
-        });
+        const ownedProvider = authProvider &&
+            new Proxy(authProvider, {
+                get: (provider, key) => {
+                    const value = Reflect.get(provider, key, provider);
+                    if (typeof value !== "function") {
+                        return value;
+                    }
+                    return (...args) => client.ownNative(async () => {
+                        provider.lifetimeSignal.throwIfAborted();
+                        return Reflect.apply(value, provider, args);
+                    });
+                },
+            });
         const fetch = (input, init) => client.ownNative(async () => {
-            if (transportClosed)
+            if (transportClosed) {
                 throw new Error("MCP transport is closed");
-            const response = await trackToolTransportFailure(input, authProvider ? {
-                ...init, signal: combineAbortSignals(init?.signal ?? undefined, init?.signal ? authProvider.lifetimeSignal : authProvider.signal),
-            } : init);
+            }
+            const response = await trackToolTransportFailure(input, authProvider
+                ? {
+                    ...init,
+                    signal: combineAbortSignals(init?.signal ?? undefined, init?.signal ? authProvider.lifetimeSignal : authProvider.signal),
+                }
+                : init);
             // Fetch resolves at headers. Native auth/discovery subsequently consumes
             // text/JSON bodies; keep those real reads owned too. Never count the idle
             // SSE body as a perpetual request: its messages use the ingress fence.
@@ -700,43 +770,55 @@ export class McpServerManager {
         // provider calls. Noninteractive transports retain OAuthClientProvider so
         // the SDK's 403 scope-union/retry policy is unchanged; all their asynchronous
         // effects are provider calls (including JWT signing) and fetch/body reads.
-        const transportAuth = ownedProvider
-            && !isNonInteractiveOAuth(definition.oauth) && !legacySse ? {
-            // Preserve transport configuration introspection; auth() uses this same provider.
-            get redirectUrl() { return ownedProvider.redirectUrl; },
-            get clientMetadata() { return ownedProvider.clientMetadata; },
-            token: () => client.ownNative(async () => (await ownedProvider.tokens())?.access_token),
-            onUnauthorized: context => client.ownNative(async () => {
-                const { resourceMetadataUrl, scope } = extractWWWAuthenticateParams(context.response);
-                const result = await auth(ownedProvider, {
-                    serverUrl: context.serverUrl, fetchFn: context.fetchFn,
-                    ...(resourceMetadataUrl !== undefined ? { resourceMetadataUrl } : {}),
-                    ...(scope !== undefined ? { scope } : {}),
-                    skipIssuerMetadataValidation: definition.oauth !== false && definition.oauth?.skipIssuerMetadataValidation === true,
-                });
-                if (result !== "AUTHORIZED")
-                    throw new UnauthorizedError();
-            }),
-        } : ownedProvider;
+        const transportAuth = ownedProvider && !isNonInteractiveOAuth(definition.oauth) && !legacySse
+            ? {
+                // Preserve transport configuration introspection; auth() uses this same provider.
+                get redirectUrl() {
+                    return ownedProvider.redirectUrl;
+                },
+                get clientMetadata() {
+                    return ownedProvider.clientMetadata;
+                },
+                token: () => client.ownNative(async () => (await ownedProvider.tokens())?.access_token),
+                onUnauthorized: (context) => client.ownNative(async () => {
+                    const { resourceMetadataUrl, scope } = extractWWWAuthenticateParams(context.response);
+                    const result = await auth(ownedProvider, {
+                        serverUrl: context.serverUrl,
+                        fetchFn: context.fetchFn,
+                        ...(resourceMetadataUrl !== undefined ? { resourceMetadataUrl } : {}),
+                        ...(scope !== undefined ? { scope } : {}),
+                        skipIssuerMetadataValidation: definition.oauth !== false &&
+                            definition.oauth?.skipIssuerMetadataValidation === true,
+                    });
+                    if (result !== "AUTHORIZED") {
+                        throw new UnauthorizedError();
+                    }
+                }),
+            }
+            : ownedProvider;
         const options = {
             ...(requestInit !== undefined ? { requestInit } : {}),
             ...(transportAuth !== undefined ? { authProvider: transportAuth } : {}),
             skipIssuerMetadataValidation: definition.oauth !== false && definition.oauth?.skipIssuerMetadataValidation === true,
             fetch,
         };
-        const transport = legacySse ? new SSEClientTransport(url, options) : new StreamableHTTPClientTransport(url, {
-            ...options,
-            reconnectionScheduler: (reconnect, delay) => {
-                const timer = setTimeout(() => {
-                    if (transportClosed)
-                        return;
-                    reconnect();
-                }, delay);
-                return () => clearTimeout(timer);
-            },
-            ...(supportsOAuth(definition) && !isNonInteractiveOAuth(definition.oauth)
-                ? { onInsufficientScope: "throw" } : {}),
-        });
+        const transport = legacySse
+            ? new SSEClientTransport(url, options)
+            : new StreamableHTTPClientTransport(url, {
+                ...options,
+                reconnectionScheduler: (reconnect, delay) => {
+                    const timer = setTimeout(() => {
+                        if (transportClosed) {
+                            return;
+                        }
+                        reconnect();
+                    }, delay);
+                    return () => clearTimeout(timer);
+                },
+                ...(supportsOAuth(definition) && !isNonInteractiveOAuth(definition.oauth)
+                    ? { onInsufficientScope: "throw" }
+                    : {}),
+            });
         if (authProvider) {
             const send = transport.send.bind(transport);
             transport.send = async (message, options) => authProvider.runWithSignal(options?.requestSignal, () => send(message, options));
@@ -750,16 +832,21 @@ export class McpServerManager {
         };
         if (!legacySse && supportsOAuth(definition)) {
             const previous = transport.onerror;
-            transport.onerror = error => {
+            transport.onerror = (error) => {
                 previous?.(error);
-                if (!active() || isServerDisabled(definition) || !supportsOAuth(definition) || !isOAuthChallenge(error))
+                if (!active() ||
+                    isServerDisabled(definition) ||
+                    !supportsOAuth(definition) ||
+                    !isOAuthChallenge(error)) {
                     return;
+                }
                 recordOAuthChallenge(serverName, serverUrl, storageBase, error, runtime);
                 // A known issuer was validated by the native discovery hook, never inferred from the challenge.
                 if (issuer) {
                     const request = getOAuthRequest(serverName, serverUrl, storageBase, runtime);
-                    if (request && !request.issuer)
+                    if (request && !request.issuer) {
                         request.issuer = issuer;
+                    }
                 }
                 onAuthChallenge?.(error);
             };
@@ -772,15 +859,20 @@ export class McpServerManager {
     }
     async fetchAllPrompts(client, requestOptions) {
         const capabilities = client.getServerCapabilities?.();
-        if (!capabilities?.prompts)
+        if (!capabilities?.prompts) {
             return { prompts: [], failed: false };
+        }
         try {
-            const { prompts } = await client.listPrompts(undefined, { ...requestOptions, cacheMode: "refresh" });
+            const { prompts } = await client.listPrompts(undefined, {
+                ...requestOptions,
+                cacheMode: "refresh",
+            });
             return { prompts, failed: false };
         }
         catch (error) {
-            if (requestOptions?.signal?.aborted)
+            if (requestOptions?.signal?.aborted) {
                 throwIfAborted(requestOptions.signal);
+            }
             const message = error instanceof Error ? error.message : String(error);
             logger.debug(`MCP: prompts/list failed: ${message}`);
             return { prompts: [], failed: true };
@@ -788,10 +880,12 @@ export class McpServerManager {
     }
     async fetchAllResources(client, requestOptions) {
         const capabilities = client.getServerCapabilities?.();
-        if (!capabilities?.resources)
+        if (!capabilities?.resources) {
             return [];
+        }
         try {
-            return (await client.listResources(undefined, { ...requestOptions, cacheMode: "refresh" })).resources;
+            return (await client.listResources(undefined, { ...requestOptions, cacheMode: "refresh" }))
+                .resources;
         }
         catch {
             if (requestOptions?.signal?.aborted) {
@@ -802,7 +896,7 @@ export class McpServerManager {
         }
     }
     attachAdapterNotificationHandlers(serverName, client, schema) {
-        client.setNotificationHandler(schema.shape.method.value, { params: schema.shape.params }, params => {
+        client.setNotificationHandler(schema.shape.method.value, { params: schema.shape.params }, (params) => {
             this.uiStreamListeners.get(params.streamToken)?.(serverName, params);
         });
     }
@@ -847,106 +941,125 @@ export class McpServerManager {
     }
     async close(name) {
         this.closeGenerations.set(name, (this.closeGenerations.get(name) ?? 0) + 1);
-        this.connectAttempts.get(name)?.controller.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)
+        if (pendingClose) {
             return pendingClose;
+        }
         const owned = new Set(this.retiredConnections.get(name));
         const connection = this.connections.get(name);
-        if (connection)
+        if (connection) {
             owned.add(connection);
+        }
         // Keep failed cleanup/callback tails owned even after removal from the active connection map.
-        if (owned.size)
+        if (owned.size) {
             this.retiredConnections.set(name, owned);
+        }
         // Remove the placeholder before awaiting cleanup; stale callers cannot resurrect it.
         this.connections.delete(name);
         this.acceptedUrlElicitations.delete(name);
-        for (const item of owned)
+        for (const item of owned) {
             item.status = "closed";
+        }
         const pendingConnect = this.connectPromises.get(name);
         const closing = (async () => {
             const results = await Promise.allSettled([
-                ...[...owned].map(item => this.disposeConnection(item)),
-                pendingConnect?.catch(error => {
-                    if (this.containsCleanupFailure(error))
+                ...[...owned].map((item) => this.disposeConnection(item)),
+                pendingConnect?.catch((error) => {
+                    if (this.containsCleanupFailure(error)) {
                         throw error;
+                    }
                 }),
             ]);
-            const failures = results.flatMap(result => result.status === "rejected" ? [result.reason] : []);
-            if (failures.length > 0)
+            const failures = results.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
+            if (failures.length > 0) {
                 throw new AggregateError(failures, "MCP connection cleanup failed");
+            }
             this.retiredConnections.delete(name);
         })().finally(() => {
-            if (this.closePromises.get(name) === closing)
+            if (this.closePromises.get(name) === closing) {
                 this.closePromises.delete(name);
+            }
         });
         this.closePromises.set(name, closing);
         return closing;
     }
     disposeConnection(connection) {
         const existing = this.disposePromises.get(connection);
-        if (existing)
+        if (existing) {
             return existing;
+        }
         const closing = (async () => {
             const results = await Promise.allSettled([
                 // The SDK client owns its transport.
                 Promise.resolve().then(() => connection.client.close()),
                 this.traceWriter?.flush() ?? Promise.resolve(),
             ]);
-            const failures = results.flatMap(result => result.status === "rejected" ? [result.reason] : []);
+            const failures = results.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
             // Keep ordinary per-server cancellation prompt, but retain native send/auth tails for
             // readiness and final shutdown. Inbound handler promises still drain before disposal.
             await drainClientCallbacks(connection.client);
-            if (failures.length > 0)
+            if (failures.length > 0) {
                 throw new AggregateError(failures, "MCP connection cleanup failed");
+            }
             this.releaseClientWhenSettled(connection.client);
         })();
         this.disposePromises.set(connection, closing);
         void closing.catch(() => {
             // Native close retains its transport until onclose. Retry only on an
             // explicit later close, retaining the connection/operations veto meanwhile.
-            if (connection.client.transport === connection.transport && this.disposePromises.get(connection) === closing)
+            if (connection.client.transport === connection.transport &&
+                this.disposePromises.get(connection) === closing) {
                 this.disposePromises.delete(connection);
+            }
         });
         return closing;
     }
     async closeAll() {
         this.stopped = true;
         const names = new Set([
-            ...this.connections.keys(), ...this.retiredConnections.keys(),
-            ...this.connectPromises.keys(), ...this.closePromises.keys(),
+            ...this.connections.keys(),
+            ...this.retiredConnections.keys(),
+            ...this.connectPromises.keys(),
+            ...this.closePromises.keys(),
         ]);
-        const results = await Promise.allSettled([...names].map(name => this.close(name)));
-        const failures = results.flatMap(result => result.status === "rejected" ? [result.reason] : []);
+        const results = await Promise.allSettled([...names].map((name) => this.close(name)));
+        const failures = results.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
         this.uiStreamListeners.clear();
         this.acceptedUrlElicitations.clear();
         this.samplingConfig = undefined;
         this.elicitationConfig = undefined;
-        await Promise.all([...this.ownedClients].map(client => drainClientOperations(client)));
+        await Promise.all([...this.ownedClients].map((client) => drainClientOperations(client)));
         try {
             await this.traceWriter?.flush();
         }
         catch (error) {
             failures.push(error);
         }
-        if (failures.length > 0)
+        if (failures.length > 0) {
             throw new AggregateError(failures, "MCP manager cleanup failed");
+        }
     }
     containsCleanupFailure(error) {
         const pending = [error];
         const seen = new Set();
         while (pending.length > 0) {
             const current = pending.pop();
-            if (!(current instanceof Error) || seen.has(current))
+            if (!(current instanceof Error) || seen.has(current)) {
                 continue;
+            }
             seen.add(current);
             if (current instanceof AggregateError) {
-                if (/cleanup failed|setup failed/.test(current.message))
+                if (/cleanup failed|setup failed/.test(current.message)) {
                     return true;
+                }
                 pending.push(...current.errors);
             }
-            if (current.cause !== undefined)
+            if (current.cause !== undefined) {
                 pending.push(current.cause);
+            }
         }
         return false;
     }
@@ -976,15 +1089,18 @@ export class McpServerManager {
     }
     isIdle(name, timeoutMs) {
         const connection = this.connections.get(name);
-        if (!connection || connection.status !== "connected")
+        if (!connection || connection.status !== "connected") {
             return false;
-        if (connection.inFlight > 0)
+        }
+        if (connection.inFlight > 0) {
             return false;
+        }
         // Background subscriptions keep their existing idle policy, but accepted requests and
         // callbacks (including cancellation tails) must not be closed as idle while unfinished.
-        if ([...(clientOperations.get(connection.client)?.values() ?? [])].some(kind => kind !== "subscription"))
+        if ([...(clientOperations.get(connection.client)?.values() ?? [])].some((kind) => kind !== "subscription")) {
             return false;
-        return (Date.now() - connection.lastUsedAt) > timeoutMs;
+        }
+        return Date.now() - connection.lastUsedAt > timeoutMs;
     }
 }
 /**
@@ -993,9 +1109,10 @@ export class McpServerManager {
 function resolveEnv(env, serverName) {
     const resolved = {};
     for (const [key, value] of Object.entries(process.env)) {
-        if (value !== undefined)
+        if (value !== undefined) {
             resolved[key] = value;
+        }
     }
-    const overrides = resolveCommandSecretsRecord(env, key => `MCP server "${serverName}" stdio env "${key}"`);
+    const overrides = resolveCommandSecretsRecord(env, (key) => `MCP server "${serverName}" stdio env "${key}"`);
     return overrides ? { ...resolved, ...overrides } : resolved;
 }