@fitchmultz/pi-mcp-adapter 6.0.0 → 7.1.0

package/dist/session-recovery.js

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

package/dist/tool-loader.d.ts

@@ -7,6 +7,10 @@ type Reference = {
     name: string;
     namespace?: string;
 };
+export type Feature = "gateway" | "script";
+export type FeaturePolicy = Partial<Record<Feature, {
+    eager?: boolean;
+}>>;
 type SearchDefinition<TParams extends TSchema, TDetails> = Omit<ToolDefinition<TParams, TDetails>, "execute"> & {
     execute: (...args: Parameters<ToolDefinition<TParams, TDetails>["execute"]>) => Promise<AgentToolResult<TDetails> & {
         tools: Reference[];
@@ -20,12 +24,13 @@ export type SearchAPI = ExtensionAPI & {
 export declare function supportsNativeAsync(ctx: ExtensionContext): boolean;
 export declare function createToolLoader(pi: SearchAPI, getState: () => McpExtensionState | null, getInitPromise: () => Promise<McpExtensionState> | null, beforeExecute?: McpAdapterOptions["beforeExecute"]): {
     native: boolean;
+    registerFeature: <TParams extends TSchema, TDetails>(feature: Feature, definition: ToolDefinition<TParams, TDetails>) => void;
     restore: (ctx: ExtensionContext) => void;
-    sync: (config: McpConfig, cache: MetadataCache | null, env?: string[] | null, asyncSupported?: boolean, registerGateways?: (pins: DirectToolSpec[]) => void) => DirectToolSpec[];
+    sync: (config: McpConfig, cache: MetadataCache | null, env?: string[] | null, asyncSupported?: boolean, registerGateways?: (pins: DirectToolSpec[]) => FeaturePolicy) => DirectToolSpec[];
     activate: (matches: Array<{
         server: string;
         tool: ToolMetadata;
-    }>) => Reference[];
+    }>, enable?: Feature[]) => Reference[];
     persist: () => void;
     selectedServers: () => string[];
 };

package/dist/tool-loader.js

@@ -5,6 +5,7 @@ import { createMcpDirectToolCallRenderer, renderMcpToolResult } from "./tool-res
 import { isServerDisabled } from "./types.js";
 import { normalizeDirectToolInputSchema } from "./utils.js";
 import { isToolCallApprovalRequired } from "./tool-approval.js";
+const featureRefs = { gateway: { name: "mcp" }, script: { name: "mcp_script" } };
 const ENTRY = "mcp-tool-selection";
 const key = (value) => JSON.stringify([value.server, value.tool]);
 const refKey = (value) => JSON.stringify([value.namespace ?? null, value.name]);
@@ -23,6 +24,10 @@ export function createToolLoader(pi, getState, getInitPromise, beforeExecute) {
     let available = new Set();
     let selected = new Map();
     let inactive = new Map();
+    let features = {};
+    let selectedFeatures = new Set();
+    let inactiveFeatures = new Set();
+    const registeredFeatures = new Set();
     let restoring = true;
     const active = () => native ? pi.getActiveToolReferences() : pi.getActiveTools().map(name => ({ name }));
     const setActive = (refs) => {
@@ -34,8 +39,24 @@ export function createToolLoader(pi, getState, getInitPromise, beforeExecute) {
         else
             pi.setActiveTools(unique.map(ref => ref.name));
     };
+    function registerFeature(feature, definition) {
+        pi.registerTool(definition);
+        registeredFeatures.add(feature);
+    }
     function capture() {
         const current = new Set(active().map(refKey));
+        for (const feature of Object.keys(features)) {
+            if (current.has(refKey(featureRefs[feature]))) {
+                if (!features[feature]?.eager)
+                    selectedFeatures.add(feature);
+                inactiveFeatures.delete(feature);
+            }
+            else {
+                selectedFeatures.delete(feature);
+                if (features[feature]?.eager)
+                    inactiveFeatures.add(feature);
+            }
+        }
         for (const [id, { selection, ref, pinned }] of registered) {
             if (!available.has(id))
                 continue;
@@ -53,15 +74,19 @@ export function createToolLoader(pi, getState, getInitPromise, beforeExecute) {
     }
     function persist() {
         capture();
-        pi.appendEntry(ENTRY, { selected: [...selected.values()], inactive: [...inactive.values()] });
+        pi.appendEntry(ENTRY, { selected: [...selected.values()], inactive: [...inactive.values()], features: [...selectedFeatures], inactiveFeatures: [...inactiveFeatures] });
     }
     function restore(ctx) {
         selected = new Map();
         inactive = new Map();
+        selectedFeatures = new Set();
+        inactiveFeatures = new Set();
         for (const entry of ctx.sessionManager.getBranch()) {
             if (entry.type !== "custom" || entry.customType !== ENTRY || !entry.data || typeof entry.data !== "object")
                 continue;
             const data = entry.data;
+            selectedFeatures = new Set(Array.isArray(data.features) ? data.features.filter(value => value === "gateway" || value === "script") : []);
+            inactiveFeatures = new Set(Array.isArray(data.inactiveFeatures) ? data.inactiveFeatures.filter(value => value === "gateway" || value === "script") : []);
             for (const [field, target] of [[data.selected, selected], [data.inactive, inactive]]) {
                 target.clear();
                 for (const selection of Array.isArray(field) ? field : []) {
@@ -125,28 +150,54 @@ export function createToolLoader(pi, getState, getInitPromise, beforeExecute) {
         }
         const permitted = new Set(pi.getAllTools().map(refKey));
         const pins = specs.filter(item => item.pinned && available.has(key(item.selection)) && permitted.has(refKey(item.ref))).map(item => item.spec);
-        registerGateways?.(pins);
+        const policy = registerGateways?.(pins);
+        if (policy) {
+            const permittedFeatures = new Set(pi.getAllTools().map(refKey));
+            const loaderMissing = !permittedFeatures.has(refKey({ name: "mcp_search" }));
+            features = {};
+            for (const feature of Object.keys(featureRefs)) {
+                if (policy[feature] && permittedFeatures.has(refKey(featureRefs[feature]))) {
+                    features[feature] = { eager: policy[feature].eager || loaderMissing };
+                    if (selectedFeatures.has(feature) || (features[feature]?.eager && !inactiveFeatures.has(feature)))
+                        enabled.push(featureRefs[feature]);
+                }
+                else {
+                    selectedFeatures.delete(feature);
+                    inactiveFeatures.delete(feature);
+                }
+            }
+        }
         // Official 0.87 reactivates allowlisted definitions on registration. Apply our loadout last.
         const ownedRefs = new Set([...previousRefs, ...[...registered.values()].map(item => refKey(item.ref))]);
+        for (const feature of registeredFeatures)
+            ownedRefs.add(refKey(featureRefs[feature]));
         setActive([...active().filter(ref => !ownedRefs.has(refKey(ref))), ...enabled]);
         restoring = false;
         return pins;
     }
-    function activate(matches) {
+    function activate(matches, enable = []) {
         const requested = matches.flatMap(({ server, tool }) => {
             const id = key({ server, tool: tool.originalName });
             const registration = available.has(id) ? registered.get(id) : undefined;
             return registration ? [registration] : [];
         });
         // No await between reading and extending the current loadout: parallel searches union their selections.
-        setActive([...active(), ...requested.map(item => item.ref)]);
+        const permitted = new Set(pi.getAllTools().map(refKey));
+        const requestedFeatures = [...new Set(enable)].filter(feature => features[feature] && permitted.has(refKey(featureRefs[feature])));
+        setActive([...active(), ...requested.map(item => item.ref), ...requestedFeatures.map(feature => featureRefs[feature])]);
         const current = new Set(active().map(refKey));
         const tools = requested.filter(item => current.has(refKey(item.ref))).map(({ selection, ref }) => {
             selected.set(key(selection), selection);
             return ref;
         });
+        for (const feature of requestedFeatures) {
+            if (!current.has(refKey(featureRefs[feature])))
+                continue;
+            selectedFeatures.add(feature);
+            tools.push(featureRefs[feature]);
+        }
         persist();
         return tools;
     }
-    return { native, restore, sync, activate, persist, selectedServers: () => [...new Set([...selected.values()].map(item => item.server))] };
+    return { native, registerFeature, restore, sync, activate, persist, selectedServers: () => [...new Set([...selected.values()].map(item => item.server))] };
 }

package/dist/tool-metadata.d.ts

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

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

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

package/dist/tool-result-renderer.js

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

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

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

package/dist/ui-resource-handler.js

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

package/dist/ui-server.js

@@ -1,4 +1,4 @@
-import http from "node:http";
+import http, {} from "node:http";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { randomUUID } from "node:crypto";
@@ -10,7 +10,7 @@ import { logger } from "./logger.js";
 import { SessionRecoveryAuthRequiredError, withSessionRecovery } from "./session-recovery.js";
 import { ensureToolCallApproved, isToolCallApprovalRequired } from "./tool-approval.js";
 import { extractUiToolVisibility, isUiToolCallableByApp } from "./ui-tool-visibility.js";
-import { createUiModelContextUpdate, extractUiPromptText, getVisualizationStreamEnvelope, isServerDisabled, } from "./types.js";
+import { createUiModelContextUpdate, extractUiPromptText, getVisualizationStreamEnvelope, isServerDisabled, isToolAllowed, resolveToolPrefix, } from "./types.js";
 const MAX_BODY_SIZE = 2 * 1024 * 1024;
 const ABANDONED_GRACE_MS = 60_000;
 const WATCHDOG_INTERVAL_MS = 5_000;
@@ -299,9 +299,10 @@ export async function startUiServer(options) {
                     sendJson(res, 503, { ok: false, error: `Server "${options.serverName}" is disabled` });
                     return;
                 }
+                const definition = options.config?.mcpServers[options.serverName] ?? connection.definition;
                 const toolDefinitions = Array.isArray(connection.tools) ? connection.tools : [];
                 const toolDefinition = toolDefinitions.find((tool) => tool.name === callParams.name);
-                if (!toolDefinition) {
+                if (!toolDefinition || !isToolAllowed(callParams.name, options.serverName, resolveToolPrefix(definition, options.config?.settings?.toolPrefix), definition?.includeTools, definition?.excludeTools)) {
                     sendJson(res, 403, { ok: false, error: `MCP tool "${callParams.name}" is not callable by apps` });
                     return;
                 }
@@ -480,7 +481,7 @@ export async function startUiServer(options) {
         }
         catch (error) {
             if (error instanceof SessionRecoveryAuthRequiredError) {
-                const fallback = `Server "${options.serverName}" requires OAuth authentication. Run mcp({ action: "auth-start", server: "${options.serverName}" }) to get a browser URL, or /mcp-auth ${options.serverName} in an interactive local session.`;
+                const fallback = `Server "${options.serverName}" requires OAuth authentication. If mcp is inactive, first mcp_search({ enable: ["gateway"] }). Run mcp({ action: "auth-start", server: "${options.serverName}" }) to get a browser URL, or /mcp-auth ${options.serverName} in an interactive local session.`;
                 const message = error.authMessage ?? (options.config
                     ? formatAuthRequiredMessage(options.config, options.serverName, fallback)
                     : fallback);

package/dist/ui-stream-types.d.ts

@@ -10,17 +10,17 @@ export declare const uiStreamModeSchema: z.ZodEnum<{
 }>;
 export type UiStreamMode = z.infer<typeof uiStreamModeSchema>;
 export declare const visualizationStreamPhaseSchema: z.ZodEnum<{
-    shell: "shell";
-    narrative: "narrative";
-    structure: "structure";
     detail: "detail";
+    narrative: "narrative";
     settled: "settled";
+    shell: "shell";
+    structure: "structure";
 }>;
 export type VisualizationStreamPhase = z.infer<typeof visualizationStreamPhaseSchema>;
 export declare const visualizationStreamFrameTypeSchema: z.ZodEnum<{
-    patch: "patch";
     checkpoint: "checkpoint";
     final: "final";
+    patch: "patch";
 }>;
 export type VisualizationStreamFrameType = z.infer<typeof visualizationStreamFrameTypeSchema>;
 export declare const visualizationStreamStatusSchema: z.ZodEnum<{
@@ -42,16 +42,16 @@ export declare const visualizationStreamEnvelopeSchema: z.ZodObject<{
     streamId: z.ZodString;
     sequence: z.ZodNumber;
     frameType: z.ZodEnum<{
-        patch: "patch";
         checkpoint: "checkpoint";
         final: "final";
+        patch: "patch";
     }>;
     phase: z.ZodEnum<{
-        shell: "shell";
-        narrative: "narrative";
-        structure: "structure";
         detail: "detail";
+        narrative: "narrative";
         settled: "settled";
+        shell: "shell";
+        structure: "structure";
     }>;
     status: z.ZodEnum<{
         error: "error";

package/dist/unix-socket-transport.d.ts

@@ -2,12 +2,12 @@ import type { Transport } from "@modelcontextprotocol/client";
 import type { JSONRPCMessage } from "@modelcontextprotocol/client";
 /** MCP JSONL transport for an explicitly configured Unix-domain socket. */
 export declare class UnixSocketClientTransport implements Transport {
-    private readonly socketPath;
     private socket;
     private readonly readBuffer;
     onclose?: () => void;
     onerror?: (error: Error) => void;
     onmessage?: (message: JSONRPCMessage) => void;
+    private readonly socketPath;
     constructor(socketPath: string);
     start(): Promise<void>;
     close(): Promise<void>;

package/dist/unix-socket-transport.js

@@ -2,12 +2,12 @@ import { createConnection } from "node:net";
 import { ReadBuffer, serializeMessage } from "@modelcontextprotocol/client";
 /** MCP JSONL transport for an explicitly configured Unix-domain socket. */
 export class UnixSocketClientTransport {
-    socketPath;
     socket;
     readBuffer = new ReadBuffer();
     onclose;
     onerror;
     onmessage;
+    socketPath;
     constructor(socketPath) {
         this.socketPath = socketPath;
     }

package/dist/utils.d.ts

@@ -1,5 +1,6 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import type { McpConfig, ServerEntry } from "./types.ts";
+export declare const ADAPTER_VERSION: string;
 export declare function normalizeRequestTimeoutMs(timeoutMs: number | undefined): number | undefined;
 export declare function openUrl(pi: ExtensionAPI, url: string, browser?: string, signal?: AbortSignal): Promise<void>;
 export declare function openPath(pi: ExtensionAPI, targetPath: string): Promise<void>;

package/dist/utils.js

@@ -1,6 +1,20 @@
 import { spawnSync } from "node:child_process";
+import { readFileSync } from "node:fs";
 import { homedir, platform } from "node:os";
 import { join } from "node:path";
+function readAdapterVersion() {
+    // Source modules sit beside package.json; compiled modules sit one level down in dist/.
+    for (const path of ["./package.json", "../package.json"]) {
+        try {
+            const manifest = JSON.parse(readFileSync(new URL(path, import.meta.url), "utf8"));
+            if (manifest.name === "@fitchmultz/pi-mcp-adapter" && typeof manifest.version === "string")
+                return manifest.version;
+        }
+        catch { }
+    }
+    return "0.0.0";
+}
+export const ADAPTER_VERSION = readAdapterVersion();
 export function normalizeRequestTimeoutMs(timeoutMs) {
     return typeof timeoutMs === "number" && Number.isFinite(timeoutMs) && timeoutMs > 0
         ? timeoutMs