@fitchmultz/pi-mcp-adapter 8.0.6 → 8.0.7

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 { SdkError, 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";
@@ -43,9 +43,12 @@ export async function trackToolCallOutcome(fn, signal) {
             return await fn();
         }
         catch (error) {
-            if (outcome.pending && error instanceof Error
-                && (signal?.aborted || (error instanceof SdkError
-                    && (error.code === SdkErrorCode.RequestTimeout || error.code === SdkErrorCode.ConnectionClosed)))) {
+            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);
@@ -54,8 +57,9 @@ export async function trackToolCallOutcome(fn, signal) {
             throw error;
         }
         finally {
-            for (const cleanup of outcome.cleanup)
+            for (const cleanup of outcome.cleanup) {
                 cleanup();
+            }
         }
     });
 }
@@ -63,8 +67,9 @@ const toolSend = new AsyncLocalStorage();
 /** Retain fetch/body-error origin without parsing or buffering the response. */
 export const trackToolTransportFailure = async (input, init) => {
     const pending = toolSend.getStore();
-    if (pending)
+    if (pending) {
         pending.bodyFailure = undefined;
+    }
     let toolPost = false;
     if (pending && init?.method === "POST" && typeof init.body === "string") {
         try {
@@ -73,18 +78,21 @@ export const trackToolTransportFailure = async (input, init) => {
         }
         catch { }
     }
-    if (toolPost && pending?.outcome)
+    if (toolPost && pending?.outcome) {
         pending.outcome.pending = true;
+    }
     try {
         const response = await fetch(input, init);
-        if (toolPost && !response.ok && response.status < 500 && pending?.outcome)
+        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)
+        if (!pending || !response.body || !observeBody) {
             return response;
+        }
         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();
@@ -96,28 +104,33 @@ export const trackToolTransportFailure = async (input, init) => {
                         controller.close();
                         reader.releaseLock();
                     }
-                    else
+                    else {
                         controller.enqueue(value);
+                    }
                 }
                 catch (error) {
                     // Native intentional closure suppresses onRequestStreamEnd.
-                    if (init?.signal?.aborted)
+                    if (init?.signal?.aborted) {
                         pending.finishSend();
+                    }
                     else if (error instanceof Error) {
                         pending.bodyFailure = error;
-                        if (!pending.streaming)
+                        if (!pending.streaming) {
                             interruptedToolCalls.add(error);
+                        }
                     }
                     controller.error(error);
                     reader.releaseLock();
                 }
             },
-            cancel: reason => reader.cancel(reason).finally(() => reader.releaseLock()),
+            cancel: (reason) => reader.cancel(reason).finally(() => reader.releaseLock()),
         }), response);
     }
     catch (error) {
-        if (error instanceof Error && !init?.signal?.aborted && init?.method === "POST"
-            && new Headers(init.headers).get("Mcp-Method") === "tools/call") {
+        if (error instanceof Error &&
+            !init?.signal?.aborted &&
+            init?.method === "POST" &&
+            new Headers(init.headers).get("Mcp-Method") === "tools/call") {
             toolTransportFailures.add(error);
         }
         throw error;
@@ -128,68 +141,89 @@ export function trackToolTransport(transport, http = false) {
     const requests = new Map();
     const onmessage = transport.onmessage;
     transport.onmessage = (message, extra) => {
-        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)) {
+        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)
+            if (pending.outcome) {
                 pending.outcome.pending = false;
+            }
             requests.delete(pending.id);
             pending.finishSend();
         }
         onmessage?.(message, extra);
     };
     const onerror = transport.onerror;
-    transport.onerror = error => {
+    transport.onerror = (error) => {
         const pending = toolSend.getStore();
         // Reader failures are observed before the SDK reports them; earlier parser errors are not retryable.
-        if (pending && !pending.bodyFailure)
+        if (pending && !pending.bodyFailure) {
             pending.otherFailure ??= error;
+        }
         onerror?.(error);
     };
     const send = transport.send.bind(transport);
     transport.send = async (message, options) => {
         try {
             if (!("method" in message && message.method === "tools/call" && "id" in message)) {
-                return await toolSend.run(undefined, () => send(message, options));
+                await toolSend.run(undefined, () => send(message, options));
+                return;
             }
             const pending = {
-                id: message.id, outcome: toolCallOutcome.getStore(), streaming: false, responseReceived: false,
-                bodyFailure: undefined, otherFailure: undefined,
+                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)
+                if (!http) {
                     pending.outcome.pending = true;
+                }
             }
             try {
                 if (!options?.requestSignal) {
-                    return await toolSend.run(pending, () => send(message, options));
+                    await toolSend.run(pending, () => send(message, options));
+                    return;
                 }
                 await abortable(new Promise((resolve, reject) => {
                     pending.finishSend = resolve;
-                    void toolSend.run(pending, () => send(message, {
+                    void toolSend
+                        .run(pending, () => send(message, {
                         ...options,
                         onRequestStreamEnd: () => {
                             options.onRequestStreamEnd?.();
                             const error = pending.otherFailure ?? pending.bodyFailure;
                             if (!pending.responseReceived && error) {
-                                if (!pending.otherFailure)
+                                if (!pending.otherFailure) {
                                     toolTransportFailures.add(error);
+                                }
                                 reject(error);
                             }
-                            else
+                            else {
                                 resolve();
+                            }
                         },
-                    })).then(() => { if (!pending.streaming)
-                        resolve(); }, reject);
+                    }))
+                        .then(() => {
+                        if (!pending.streaming) {
+                            resolve();
+                        }
+                    }, reject);
                 }), options.requestSignal);
             }
             catch (error) {
                 // Local send failures are distinct from a sent request waiting for its reply.
-                if (!http && pending.outcome)
+                if (!http && pending.outcome) {
                     pending.outcome.pending = false;
+                }
                 throw error;
             }
             finally {
@@ -197,17 +231,21 @@ export function trackToolTransport(transport, http = false) {
             }
         }
         catch (error) {
-            if ("method" in message && message.method === "tools/call"
-                && error instanceof SdkHttpError && error.code === SdkErrorCode.ClientHttpNotImplemented
-                && error.status >= 500 && error.status < 600) {
+            if ("method" in message &&
+                message.method === "tools/call" &&
+                error instanceof SdkHttpError &&
+                error.code === SdkErrorCode.ClientHttpNotImplemented &&
+                error.status >= 500 &&
+                error.status < 600) {
                 let errorBody = false;
                 try {
                     const body = JSON.parse(String(error.data.text));
                     errorBody = body?.jsonrpc === "2.0" && body.error !== undefined;
                 }
                 catch { }
-                if (!errorBody)
+                if (!errorBody) {
                     toolTransportFailures.add(error);
+                }
             }
             throw error;
         }
@@ -229,17 +267,18 @@ const SERVER_NOT_INITIALIZED_MCP_MESSAGES = new Set([
     "Bad Request: Server not initialized",
 ]);
 export function isTerminatedSession(err, hadSessionId) {
-    if (!hadSessionId)
+    if (!hadSessionId) {
         return false;
+    }
     if (err instanceof SdkHttpError) {
-        return err.status === 404
-            || (err.status === 400
-                && /"code"\s*:\s*-32000/.test(err.message)
-                && /"message"\s*:\s*"Bad Request: Server not initialized"/.test(err.message));
+        return (err.status === 404 ||
+            (err.status === 400 &&
+                /"code"\s*:\s*-32000/.test(err.message) &&
+                /"message"\s*:\s*"Bad Request: Server not initialized"/.test(err.message)));
     }
-    return err instanceof ProtocolError
-        && err.code === -32000
-        && SERVER_NOT_INITIALIZED_MCP_MESSAGES.has(err.message);
+    return (err instanceof ProtocolError &&
+        err.code === -32000 &&
+        SERVER_NOT_INITIALIZED_MCP_MESSAGES.has(err.message));
 }
 function hasSessionId(connection) {
     // Only StreamableHTTPClientTransport exposes `sessionId`; stdio/SSE
@@ -273,8 +312,9 @@ export async function withSessionRecovery(deps, serverName, fn) {
     }
     const reconnect = async (stale, error) => {
         const definition = deps.config.mcpServers[serverName];
-        if (!definition)
+        if (!definition) {
             throw error;
+        }
         throwIfAborted(deps.signal);
         let fresh = stale;
         if (fresh.status !== "needs-auth") {
@@ -284,26 +324,32 @@ export async function withSessionRecovery(deps, serverName, fn) {
         }
         throwIfAborted(deps.signal);
         if (fresh.status === "needs-auth" && deps.onNeedsAuth) {
-            fresh = await abortable(deps.onNeedsAuth(serverName, deps.signal), deps.signal) ?? fresh;
+            fresh = (await abortable(deps.onNeedsAuth(serverName, deps.signal), deps.signal)) ?? fresh;
             throwIfAborted(deps.signal);
         }
-        if (fresh.status === "needs-auth")
+        if (fresh.status === "needs-auth") {
             throw new SessionRecoveryAuthRequiredError(serverName);
-        if (fresh.status !== "connected")
+        }
+        if (fresh.status !== "connected") {
             throw error;
+        }
         return fresh;
     };
     const isRecoverableAuth = (error, failed, activating = false) => {
         const definition = deps.config.mcpServers[serverName];
-        if (!definition || isServerDisabled(definition) || !supportsOAuth(definition))
+        if (!definition || isServerDisabled(definition) || !supportsOAuth(definition)) {
             return false;
+        }
         if (error instanceof SdkHttpError) {
             // A provider's exhausted native 401/M2M retry is terminal, not another consent cycle.
-            return failed.oauthProvider === false && error.status === 401 && error.code !== SdkErrorCode.ClientHttpAuthentication;
+            return (failed.oauthProvider === false &&
+                error.status === 401 &&
+                error.code !== SdkErrorCode.ClientHttpAuthentication);
         }
-        if (failed.oauthProvider && isNonInteractiveOAuth(definition.oauth))
+        if (failed.oauthProvider && isNonInteractiveOAuth(definition.oauth)) {
             return false;
-        return error instanceof InsufficientScopeError || (activating && error instanceof UnauthorizedError);
+        }
+        return (error instanceof InsufficientScopeError || (activating && error instanceof UnauthorizedError));
     };
     const terminalDispatch = async (fresh) => {
         throwIfAborted(deps.signal);
@@ -312,8 +358,9 @@ export async function withSessionRecovery(deps, serverName, fn) {
         }
         catch (error) {
             throwIfAborted(deps.signal);
-            if (isRecoverableAuth(error, fresh))
+            if (isRecoverableAuth(error, fresh)) {
                 throw new SessionRecoveryAuthRequiredError(serverName);
+            }
             throw error;
         }
     };
@@ -333,18 +380,22 @@ export async function withSessionRecovery(deps, serverName, fn) {
                 }
                 catch (providerError) {
                     throwIfAborted(deps.signal);
-                    if (!isRecoverableAuth(providerError, failed, true))
+                    if (!isRecoverableAuth(providerError, failed, true)) {
                         throw providerError;
+                    }
                     error = providerError;
                 }
             }
         }
-        if (isNonInteractiveOAuth(definition.oauth))
+        if (isNonInteractiveOAuth(definition.oauth)) {
             throw error;
-        const fresh = await abortable(deps.onNeedsAuth?.(serverName, deps.signal, { connection: failed, error }) ?? Promise.resolve(undefined), deps.signal);
+        }
+        const fresh = await abortable(deps.onNeedsAuth?.(serverName, deps.signal, { connection: failed, error }) ??
+            Promise.resolve(undefined), deps.signal);
         throwIfAborted(deps.signal);
-        if (!fresh || fresh === failed || fresh.status !== "connected")
+        if (!fresh || fresh === failed || fresh.status !== "connected") {
             throw new SessionRecoveryAuthRequiredError(serverName);
+        }
         return terminalDispatch(fresh);
     };
     // Nothing has been dispatched yet: wait for replacement/auth begun during UI preparation.
@@ -357,12 +408,13 @@ export async function withSessionRecovery(deps, serverName, fn) {
     }
     catch (err) {
         throwIfAborted(deps.signal);
-        if (isRecoverableAuth(err, connection))
+        if (isRecoverableAuth(err, connection)) {
             return recoverAuth(connection, err);
-        if (deps.retryOnTransportFailure === true
-            && deps.config.mcpServers[serverName]?.retryOnTransportFailure === true
-            && connection.client.getProtocolEra?.() === "modern"
-            && isToolTransportFailure(err)) {
+        }
+        if (deps.retryOnTransportFailure === true &&
+            deps.config.mcpServers[serverName]?.retryOnTransportFailure === true &&
+            connection.client.getProtocolEra?.() === "modern" &&
+            isToolTransportFailure(err)) {
             return terminalDispatch(connection);
         }
         if (!isTerminatedSession(err, hadSessionId)) {

package/dist/tool-approval.js

@@ -7,10 +7,12 @@ export function isToolCallApprovalRequired(config, serverName, toolMeta) {
     const approval = definition?.approveTools !== undefined
         ? definition.approveTools
         : config.settings?.approveTools;
-    if (approval === true)
+    if (approval === true) {
         return true;
-    if (!Array.isArray(approval) || approval.length === 0)
+    }
+    if (!Array.isArray(approval) || approval.length === 0) {
         return false;
+    }
     const prefix = resolveToolPrefix(definition, config.settings?.toolPrefix);
     return matchesToolPattern(getToolNameCandidates(toolMeta.originalName, serverName, prefix), approval);
 }
@@ -30,7 +32,11 @@ export async function ensureToolCallApproved(state, serverName, toolMeta, args,
     const preview = sanitized.length > 500 ? `${sanitized.slice(0, 500)}...` : sanitized;
     const title = `MCP: ${sanitizeTerminalText(serverName)} wants to run ${sanitizeTerminalText(toolMeta.originalName)}`;
     const ownedSignal = combineAbortSignals(state.owner?.signal, signal);
-    const decision = await abortable(state.ui.select(`${title}\n\nArguments:\n${preview}`, ["Allow once", "Allow for session", "Deny"]), ownedSignal);
+    const decision = await abortable(state.ui.select(`${title}\n\nArguments:\n${preview}`, [
+        "Allow once",
+        "Allow for session",
+        "Deny",
+    ]), ownedSignal);
     if (decision === "Allow once") {
         return { ok: true };
     }