@fitchmultz/pi-mcp-adapter 8.0.6 → 8.0.8

package/dist/resource-tools.js

@@ -1,4 +1,4 @@
-import { isServerDisabled, isToolAllowed, resolveToolPrefix } from "./types.js";
+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";
@@ -7,20 +7,41 @@ export async function executeResourceList(state, server, limit = 12, offset = 0,
     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" } };
+        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") {
+    if (!state.toolMetadata.has(server) ||
+        state.manager.getConnection(server)?.status === "connected") {
         const prepared = await prepareMcpConnection(state, server, signal);
-        if (prepared.error)
+        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 } };
+        .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 });
+    return executeCall(state, uri, {}, server, undefined, signal, identity, beforeDispatch, {
+        resourceUri: uri,
+        raw,
+    });
 }

package/dist/runtime-owner.js

@@ -7,11 +7,13 @@ export function createMcpRuntimeOwner() {
     // promises through settlement, without cancelling, serializing, or replaying callback work.
     const callbacks = { beforeExecute: 0, onToolCall: 0 };
     const pendingCallback = () => {
-        if (callbacks.beforeExecute)
+        if (callbacks.beforeExecute) {
             return "MCP beforeExecute callback is pending";
-        if (callbacks.onToolCall)
+        }
+        if (callbacks.onToolCall) {
             return "MCP onToolCall callback is pending";
-        return undefined;
+        }
+        return;
     };
     const reportCleanupFailure = (error, late) => {
         console.error(`MCP: ${late ? "late " : ""}runtime cleanup failed: ${formatTerminalError(error)}`);
@@ -30,23 +32,30 @@ export function createMcpRuntimeOwner() {
             }
         },
         isActive: () => !controller.signal.aborted,
-        addCleanup: cleanup => {
+        addCleanup: (cleanup) => {
             if (controller.signal.aborted) {
-                void Promise.resolve().then(cleanup).catch(error => reportCleanupFailure(error, true));
+                void Promise.resolve()
+                    .then(cleanup)
+                    .catch((error) => reportCleanupFailure(error, true));
                 return;
             }
             cleanups.push(cleanup);
         },
         stop: (reason = "MCP extension runtime stopped") => {
-            if (stopPromise)
+            if (stopPromise) {
                 return stopPromise;
+            }
             controller.abort(new Error(reason));
-            const pendingCleanups = cleanups.splice(0).reverse().map(cleanup => Promise.resolve().then(cleanup));
-            stopPromise = Promise.allSettled(pendingCleanups).then(results => {
-                const failures = results.flatMap(result => result.status === "rejected" ? [result.reason] : []);
+            const pendingCleanups = cleanups
+                .splice(0)
+                .reverse()
+                .map((cleanup) => Promise.resolve().then(cleanup));
+            stopPromise = Promise.allSettled(pendingCleanups).then((results) => {
+                const failures = results.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
                 const callback = pendingCallback();
-                if (callback)
+                if (callback) {
                     failures.push(new Error(callback));
+                }
                 if (failures.length > 0) {
                     const aggregate = new AggregateError(failures, "MCP runtime cleanup failed");
                     console.error(`MCP: runtime cleanup failed: ${formatTerminalError(aggregate)}`);
@@ -55,15 +64,19 @@ export function createMcpRuntimeOwner() {
             });
             return stopPromise;
         },
-        throwIfInactive: () => { controller.signal.throwIfAborted(); },
+        throwIfInactive: () => {
+            controller.signal.throwIfAborted();
+        },
     };
 }
 export function combineAbortSignals(...signals) {
     const active = signals.filter((signal) => signal !== undefined);
-    if (active.length === 0)
+    if (active.length === 0) {
         return undefined;
-    if (active.length === 1)
+    }
+    if (active.length === 1) {
         return active[0];
+    }
     return AbortSignal.any(active);
 }
 /** Fence session-bound UI calls after the owning extension runtime stops. */
@@ -75,17 +88,20 @@ export function createOwnedUi(ui, owner) {
         }
         const object = value;
         const existing = proxies.get(object);
-        if (existing)
+        if (existing) {
             return existing;
+        }
         const proxy = new Proxy(object, {
             get(target, property, receiver) {
-                if (!owner.isActive())
+                if (!owner.isActive()) {
                     return undefined;
+                }
                 const member = Reflect.get(target, property, receiver);
                 if (typeof member === "function") {
                     return (...args) => {
-                        if (!owner.isActive())
+                        if (!owner.isActive()) {
                             return undefined;
+                        }
                         return Reflect.apply(member, target, args);
                     };
                 }
@@ -98,7 +114,9 @@ export function createOwnedUi(ui, owner) {
     return wrap(ui);
 }
 export function isAbortError(error, signal) {
-    if (signal?.aborted)
+    if (signal?.aborted) {
         return true;
-    return error instanceof Error && (error.name === "AbortError" || error.message === "MCP extension runtime stopped");
+    }
+    return (error instanceof Error &&
+        (error.name === "AbortError" || error.message === "MCP extension runtime stopped"));
 }

package/dist/sampling-handler.d.ts

@@ -1,7 +1,6 @@
 import type { Api, Model } from "@earendil-works/pi-ai";
 import type { ExtensionUIContext, ModelRegistry } from "@earendil-works/pi-coding-agent";
-import type { Client } from "@modelcontextprotocol/client";
-import { type CreateMessageRequest, type CreateMessageResult } from "@modelcontextprotocol/client";
+import { type Client, type CreateMessageRequest, type CreateMessageResult } from "@modelcontextprotocol/client";
 export interface SamplingHandlerOptions {
     serverName: string;
     autoApprove: boolean;

package/dist/sampling-handler.js

@@ -1,9 +1,9 @@
 import { truncateAtWord } from "./utils.js";
 import { throwIfAborted } from "./abort.js";
 import {} from "@modelcontextprotocol/client";
-export function registerSamplingHandler(client, options, own = run => run()) {
+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)));
+    client.setRequestHandler("sampling/createMessage", (request) => own(() => handleSamplingRequest(options, request)));
 }
 export async function handleSamplingRequest(options, request) {
     const params = request.params;
@@ -31,13 +31,16 @@ export async function handleSamplingRequest(options, request) {
     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"));
+        : !(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,
-        ...(supportsTemperature && params.temperature !== undefined ? { temperature: params.temperature } : {}),
+        ...(supportsTemperature && params.temperature !== undefined
+            ? { temperature: params.temperature }
+            : {}),
         ...(params.metadata !== undefined ? { metadata: params.metadata } : {}),
         ...(signal ? { signal } : {}),
     });
@@ -47,7 +50,9 @@ export async function handleSamplingRequest(options, request) {
     return converted;
 }
 function formatRequestApproval(serverName, modelName, systemPrompt, messages) {
-    const lines = [`${serverName} wants to sample ${messages.length} message${messages.length === 1 ? "" : "s"} with ${modelName}.`];
+    const lines = [
+        `${serverName} wants to sample ${messages.length} message${messages.length === 1 ? "" : "s"} with ${modelName}.`,
+    ];
     if (systemPrompt) {
         lines.push(`System: ${truncateAtWord(systemPrompt, 400)}`);
     }
@@ -61,27 +66,35 @@ function formatResponseApproval(serverName, response) {
     return `${serverName} will receive this response from ${response.model}:\n\n${truncateAtWord(text, 1000)}`;
 }
 function messageText(message) {
-    if (typeof message.content === "string")
+    if (typeof message.content === "string") {
         return message.content;
-    return message.content.map((block) => {
-        if (block.type === "text")
+    }
+    return message.content
+        .map((block) => {
+        if (block.type === "text") {
             return block.text;
-        if (block.type === "image")
+        }
+        if (block.type === "image") {
             return `[image: ${block.mimeType}]`;
-        if (block.type === "thinking")
+        }
+        if (block.type === "thinking") {
             return "[thinking]";
-        if (block.type === "toolCall")
+        }
+        if (block.type === "toolCall") {
             return `[tool call: ${block.name}]`;
+        }
         return "[content]";
-    }).join("\n");
+    })
+        .join("\n");
 }
 async function resolveSamplingModel(options, modelPreferences) {
     const candidates = [];
     const availableModels = options.modelRegistry.getAvailable();
     for (const hint of modelPreferences?.hints ?? []) {
         const normalizedHint = hint.name?.trim().toLowerCase();
-        if (!normalizedHint)
+        if (!normalizedHint) {
             continue;
+        }
         for (const model of availableModels) {
             const searchableNames = [`${model.provider}/${model.id}`, model.id, model.name];
             if (searchableNames.some((name) => name.toLowerCase().includes(normalizedHint))) {
@@ -90,8 +103,9 @@ async function resolveSamplingModel(options, modelPreferences) {
         }
     }
     const currentModel = options.getCurrentModel();
-    if (currentModel)
+    if (currentModel) {
         addSamplingCandidate(candidates, currentModel);
+    }
     for (const model of availableModels) {
         addSamplingCandidate(candidates, model);
     }
@@ -101,7 +115,7 @@ async function resolveSamplingModel(options, modelPreferences) {
         throwIfAborted(signal);
         const auth = await options.modelRegistry.getApiKeyAndHeaders(model);
         throwIfAborted(signal);
-        if (auth.ok === false) {
+        if (!auth.ok) {
             errors.push(`${model.provider}/${model.id}: ${auth.error}`);
             continue;
         }
@@ -118,8 +132,9 @@ function addSamplingCandidate(candidates, model) {
     }
 }
 async function confirmSampling(options, title, message) {
-    if (options.autoApprove)
+    if (options.autoApprove) {
         return;
+    }
     if (!options.ui) {
         throw new Error("MCP sampling requires interactive approval. Set settings.samplingAutoApprove to true to allow it without UI.");
     }
@@ -169,10 +184,12 @@ function convertAssistantResult(message) {
     }
     const text = message.content
         .map((block) => {
-        if (block.type === "text")
+        if (block.type === "text") {
             return block.text;
-        if (block.type === "thinking")
+        }
+        if (block.type === "thinking") {
             return undefined;
+        }
         throw new Error(`MCP sampling result ${block.type} content is not supported`);
     })
         .filter((value) => value !== undefined)
@@ -189,12 +206,15 @@ function convertAssistantResult(message) {
     };
 }
 function mapStopReason(reason) {
-    if (reason === "stop")
+    if (reason === "stop") {
         return "endTurn";
-    if (reason === "length")
+    }
+    if (reason === "length") {
         return "maxTokens";
-    if (reason === "toolUse")
+    }
+    if (reason === "toolUse") {
         return "toolUse";
+    }
     return reason;
 }
 function zeroUsage() {

package/dist/search-ranking.d.ts

@@ -1,5 +1,5 @@
 import type { McpExtensionState } from "./state.ts";
-import type { ToolMetadata } from "./types.ts";
+import { type ToolMetadata } from "./types.ts";
 export declare const MAX_PAGE_SIZE = 100;
 export declare const MAX_TOOL_NAME_LENGTH = 512;
 export interface RankedToolMatch {

package/dist/search-ranking.js

@@ -1,5 +1,5 @@
 import MiniSearch, {} from "minisearch";
-import { getServerPrefix, isServerDisabled, isToolAllowed, resolveToolPrefix } from "./types.js";
+import { getServerPrefix, isServerDisabled, isToolAllowed, resolveToolPrefix, } from "./types.js";
 export const MAX_PAGE_SIZE = 100;
 export const MAX_TOOL_NAME_LENGTH = 512;
 export function normalizeSearchText(value) {
@@ -9,40 +9,56 @@ export function normalizeSearchText(value) {
         .toLowerCase();
 }
 function schemaSearchText(schema) {
-    if (!schema || typeof schema !== "object")
+    if (!schema || typeof schema !== "object") {
         return "";
-    if (Array.isArray(schema))
+    }
+    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 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")
+        }
+        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(" ");
+    })
+        .join(" ");
 }
 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)) {
+    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 },
+        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)
+            if (tool.resourceUri !== undefined) {
                 continue;
+            }
             index.add({
-                id: id++, server, tool,
+                id: id++,
+                server,
+                tool,
                 name: normalizeSearchText(tool.name),
                 originalName: normalizeSearchText(tool.originalName),
                 description: normalizeSearchText([tool.title, tool.description].filter(Boolean).join(" ")),
@@ -54,18 +70,22 @@ function getIndex(state) {
     return index;
 }
 function searchCatalog(state, query, server, options) {
-    return getIndex(state).search(normalizeSearchText(query), {
+    return getIndex(state)
+        .search(normalizeSearchText(query), {
         ...options,
-        filter: result => {
-            if (server && result.server !== server)
+        filter: (result) => {
+            if (server && result.server !== server) {
                 return false;
+            }
             const definition = state.config.mcpServers[result.server];
-            if (!definition || isServerDisabled(definition))
+            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 }))
+    })
+        .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) {
@@ -73,11 +93,13 @@ export function rankToolMatches(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))];
+    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;
-    const safeLimit = Number.isFinite(limit) ? Math.min(MAX_PAGE_SIZE, Math.max(1, Math.trunc(limit))) : 1;
+    const safeLimit = Number.isFinite(limit)
+        ? Math.min(MAX_PAGE_SIZE, Math.max(1, Math.trunc(limit)))
+        : 1;
     const total = items.length;
     const page = items.slice(safeOffset, safeOffset + safeLimit);
     const nextOffset = safeOffset + page.length;
@@ -89,25 +111,36 @@ export function paginate(items, offset, limit) {
     };
 }
 export function rankSuggestions(state, name, limit, server) {
-    if (name.length > MAX_TOOL_NAME_LENGTH)
+    if (name.length > MAX_TOOL_NAME_LENGTH) {
         return [];
+    }
     const globalPrefix = state.config.settings?.toolPrefix ?? "server";
-    const inferred = server ? undefined : Object.entries(state.config.mcpServers)
-        .filter(([, definition]) => !isServerDisabled(definition))
-        .map(([candidateServer, definition]) => ({
-        server: candidateServer,
-        prefix: getServerPrefix(candidateServer, resolveToolPrefix(definition, globalPrefix)),
-    }))
-        .filter((candidate) => Boolean(candidate.prefix) && name.startsWith(`${candidate.prefix}_`))
-        .sort((a, b) => b.prefix.length - a.prefix.length)[0];
+    const inferred = server
+        ? undefined
+        : Object.entries(state.config.mcpServers)
+            .filter(([, definition]) => !isServerDisabled(definition))
+            .map(([candidateServer, definition]) => ({
+            server: candidateServer,
+            prefix: getServerPrefix(candidateServer, resolveToolPrefix(definition, globalPrefix)),
+        }))
+            .filter((candidate) => Boolean(candidate.prefix) && name.startsWith(`${candidate.prefix}_`))
+            .sort((a, b) => b.prefix.length - a.prefix.length)[0];
     const matchedServer = server ?? inferred?.server;
     const definition = matchedServer ? state.config.mcpServers[matchedServer] : undefined;
-    if (matchedServer && (!definition || isServerDisabled(definition)))
+    if (matchedServer && (!definition || isServerDisabled(definition))) {
         return [];
-    const prefix = inferred?.prefix ?? (matchedServer ? 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 suggestions = searchCatalog(state, query, matchedServer, {
-        fields: [matchedServer ? "originalName" : "name"], combineWith: "AND", fuzzy: 2,
-    }).slice(0, limit).map(match => match.tool.name);
+        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

@@ -23,24 +23,24 @@ export interface ServerConnection {
 type UiStreamListener = (serverName: string, notification: ServerStreamResultPatchNotification["params"]) => void;
 type MetadataListChangedListener = (serverName: string, reason: string) => void;
 export declare class McpServerManager {
-    private ownedClients;
-    private connections;
-    private connectPromises;
-    private reconnectPromises;
-    private retiredConnections;
-    private disposePromises;
-    private uiStreamListeners;
+    private readonly ownedClients;
+    private readonly connections;
+    private readonly connectPromises;
+    private readonly reconnectPromises;
+    private readonly retiredConnections;
+    private readonly disposePromises;
+    private readonly uiStreamListeners;
     private samplingConfig;
     private metadataListChangedListener;
     private elicitationConfig;
     private authStorageOptions;
     private oauthRuntime;
-    private acceptedUrlElicitations;
+    private readonly acceptedUrlElicitations;
     private defaultRequestTimeoutMs;
     private runtimeSignal;
-    private closePromises;
-    private closeGenerations;
-    private connectAttempts;
+    private readonly closePromises;
+    private readonly closeGenerations;
+    private readonly connectAttempts;
     private traceSettings;
     private traceWriter;
     private stopped;