@fitchmultz/pi-mcp-adapter 5.0.0 → 7.0.0

package/dist/metadata-cache.js

@@ -3,12 +3,11 @@ import { existsSync, readFileSync, writeFileSync, renameSync, mkdirSync } from "
 import { dirname } from "node:path";
 import { getAdapterPath } from "./agent-dir.js";
 import { createHash } from "node:crypto";
-import { getToolUiResourceUri } from "@modelcontextprotocol/ext-apps/app-bridge";
-import { formatPromptCommandName, formatToolName, isServerDisabled, isToolAllowed, resolveToolPrefix } from "./types.js";
-import { resourceNameToToolName } from "./resource-tools.js";
-import { extractToolUiStreamMode, interpolateEnvRecord, resolveBearerToken, resolveConfigPath, resolveServerUrl, } from "./utils.js";
-import { extractUiToolVisibility, isUiToolVisibleToModel } from "./ui-tool-visibility.js";
-const CACHE_VERSION = 1;
+import { formatPromptCommandName, isServerDisabled, resolveToolPrefix } from "./types.js";
+import { buildToolMetadata } from "./tool-metadata.js";
+import { interpolateEnvRecord, resolveBearerToken, resolveConfigPath, resolveServerUrl, } from "./utils.js";
+// Version 2 stores raw descriptors; version 1 readers cannot enforce raw UI visibility.
+const CACHE_VERSION = 2;
 const CACHE_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
 export function getMetadataCachePath() {
     return getAdapterPath("mcp-cache.json");
@@ -23,7 +22,7 @@ export function loadMetadataCache(enabled = true) {
         const raw = JSON.parse(readFileSync(cachePath, "utf-8"));
         if (!raw || typeof raw !== "object")
             return null;
-        if (raw.version !== CACHE_VERSION)
+        if (raw.version !== 1 && raw.version !== CACHE_VERSION)
             return null;
         if (!raw.servers || typeof raw.servers !== "object")
             return null;
@@ -43,7 +42,7 @@ export function saveMetadataCache(cache, enabled = true) {
     try {
         if (existsSync(cachePath)) {
             const existing = JSON.parse(readFileSync(cachePath, "utf-8"));
-            if (existing && existing.version === CACHE_VERSION && existing.servers) {
+            if (existing && (existing.version === 1 || existing.version === CACHE_VERSION) && existing.servers) {
                 merged.servers = { ...existing.servers };
             }
         }
@@ -139,83 +138,29 @@ export function getMissingConfiguredDirectToolServers(config, cache, envOverride
     return missing;
 }
 export function reconstructToolMetadata(serverName, entry, prefix, definition) {
-    const metadata = [];
-    const seenNames = new Set();
-    const effectivePrefix = resolveToolPrefix(definition, prefix);
-    for (const tool of entry.tools ?? []) {
-        if (!tool?.name)
-            continue;
-        if (!isUiToolVisibleToModel(tool.uiVisibility)) {
-            continue;
-        }
-        if (!isToolAllowed(tool.name, serverName, effectivePrefix, definition.includeTools, definition.excludeTools)) {
-            continue;
-        }
-        const name = formatToolName(tool.name, serverName, effectivePrefix);
-        if (seenNames.has(name)) {
-            continue;
-        }
-        seenNames.add(name);
-        metadata.push({
-            name,
-            originalName: tool.name,
-            description: tool.description ?? "",
-            ...(tool.inputSchema !== undefined ? { inputSchema: tool.inputSchema } : {}),
-            ...(tool.annotations !== undefined ? { annotations: tool.annotations } : {}),
-            ...(tool.uiResourceUri !== undefined ? { uiResourceUri: tool.uiResourceUri } : {}),
-            ...(tool.uiVisibility !== undefined ? { uiVisibility: tool.uiVisibility } : {}),
-            ...(tool.uiStreamMode !== undefined ? { uiStreamMode: tool.uiStreamMode } : {}),
-        });
-    }
-    if (definition.exposeResources !== false) {
-        for (const resource of entry.resources ?? []) {
-            if (!resource?.name || !resource?.uri)
-                continue;
-            const baseName = `read_${resourceNameToToolName(resource.name)}`;
-            if (!isToolAllowed(baseName, serverName, effectivePrefix, definition.includeTools, definition.excludeTools)) {
-                continue;
-            }
-            const name = formatToolName(baseName, serverName, effectivePrefix);
-            if (seenNames.has(name)) {
-                continue;
-            }
-            seenNames.add(name);
-            metadata.push({
-                name,
-                originalName: baseName,
-                description: resource.description ?? `Read resource: ${resource.uri}`,
-                resourceUri: resource.uri,
-            });
-        }
+    return buildToolMetadata((entry.tools ?? []).filter(tool => tool?.name).map(restoreCachedTool), entry.resources ?? [], definition, serverName, prefix).metadata;
+}
+function restoreCachedTool(tool) {
+    const { uiResourceUri, uiVisibility, uiStreamMode, ...descriptor } = tool;
+    if (descriptor._meta !== undefined || (uiResourceUri === undefined && uiVisibility === undefined && uiStreamMode === undefined)) {
+        return descriptor;
     }
-    return metadata;
+    return {
+        ...descriptor,
+        _meta: {
+            ui: {
+                ...(uiResourceUri !== undefined ? { resourceUri: uiResourceUri } : {}),
+                ...(uiVisibility !== undefined ? { visibility: uiVisibility } : {}),
+                ...(uiStreamMode !== undefined ? { "pi-mcp-adapter.streamMode": uiStreamMode } : {}),
+            },
+        },
+    };
 }
 export function serializeTools(tools) {
-    return tools
-        .filter(t => t?.name)
-        .map(t => {
-        const uiResourceUri = tryGetToolUiResourceUri(t);
-        const uiVisibility = extractUiToolVisibility(t._meta);
-        const uiStreamMode = extractToolUiStreamMode(t._meta);
-        return {
-            name: t.name,
-            ...(t.description !== undefined ? { description: t.description } : {}),
-            ...(t.inputSchema !== undefined ? { inputSchema: t.inputSchema } : {}),
-            ...(t.annotations !== undefined ? { annotations: t.annotations } : {}),
-            ...(uiResourceUri !== undefined ? { uiResourceUri } : {}),
-            ...(uiVisibility !== undefined ? { uiVisibility } : {}),
-            ...(uiStreamMode !== undefined ? { uiStreamMode } : {}),
-        };
-    });
+    return tools.filter(tool => tool?.name);
 }
 export function serializeResources(resources) {
-    return resources
-        .filter(r => r?.name && r?.uri)
-        .map(r => ({
-        uri: r.uri,
-        name: r.name,
-        ...(r.description !== undefined ? { description: r.description } : {}),
-    }));
+    return resources.filter(resource => resource?.name && resource?.uri);
 }
 export function serializePrompts(prompts) {
     return (prompts ?? [])
@@ -267,11 +212,3 @@ function stableStringify(value) {
     const keys = Object.keys(obj).sort();
     return `{${keys.map(k => `${JSON.stringify(k)}:${stableStringify(obj[k])}`).join(",")}}`;
 }
-function tryGetToolUiResourceUri(tool) {
-    try {
-        return getToolUiResourceUri({ _meta: tool._meta });
-    }
-    catch {
-        return undefined;
-    }
-}

package/dist/npx-resolver.js

@@ -17,13 +17,15 @@ export async function resolveNpxBinary(command, args, signal) {
     if (!parsed)
         return null;
     const packageSpec = parsePackageSpec(parsed.packageSpec);
+    if (!packageSpec)
+        return null;
     const cacheKey = JSON.stringify([command, ...args]);
     const cache = loadCache();
     const cached = cache?.entries?.[cacheKey];
     if (cached
         && Date.now() - cached.resolvedAt < CACHE_TTL_MS
         && existsSync(cached.resolvedBin)
-        && (!packageSpec?.exactVersion || cached.packageVersion === packageSpec.exactVersion)) {
+        && (!packageSpec.exactVersion || cached.packageVersion === packageSpec.exactVersion)) {
         return { binPath: cached.resolvedBin, extraArgs: parsed.extraArgs, isJs: cached.isJs };
     }
     const resolved = resolveFromNpmCache(parsed.packageSpec, parsed.binName);
@@ -289,11 +291,13 @@ function parsePackageSpec(spec) {
     if (!packageName)
         return null;
     const normalizedVersion = requestedVersion?.replace(/^=/, "").replace(/^v/i, "");
+    // Let npm resolve ranges and tags rather than choosing an arbitrary cached version.
+    if (requestedVersion !== undefined && (!normalizedVersion || !EXACT_PACKAGE_VERSION_RE.test(normalizedVersion))) {
+        return null;
+    }
     return {
         packageName,
-        ...(normalizedVersion && EXACT_PACKAGE_VERSION_RE.test(normalizedVersion)
-            ? { exactVersion: normalizedVersion }
-            : {}),
+        ...(normalizedVersion ? { exactVersion: normalizedVersion } : {}),
     };
 }
 function defaultBinName(packageName) {

package/dist/prompts.d.ts

@@ -4,7 +4,7 @@ import type { McpExtensionState } from "./state.ts";
 import { type McpConfig, type PromptMetadata } from "./types.ts";
 /**
  * Resolve prompt metadata for slash-command registration at extension load
- * time. Mirrors `resolveDirectTools`: reads the persistent metadata cache so
+ * time. Like typed tool registration, reads the persistent metadata cache so
  * commands are available before any server connects.
  */
 export declare function resolveCachedPrompts(config: McpConfig, cacheEnabled?: boolean): PromptMetadata[];

package/dist/prompts.js

@@ -5,7 +5,7 @@ import { logger } from "./logger.js";
 import { truncateAtWord } from "./utils.js";
 /**
  * Resolve prompt metadata for slash-command registration at extension load
- * time. Mirrors `resolveDirectTools`: reads the persistent metadata cache so
+ * time. Like typed tool registration, reads the persistent metadata cache so
  * commands are available before any server connects.
  */
 export function resolveCachedPrompts(config, cacheEnabled = true) {

package/dist/proxy-modes.d.ts

@@ -1,5 +1,6 @@
 import type { AgentToolResult, ToolInfo } from "@earendil-works/pi-coding-agent";
 import type { McpExtensionState } from "./state.ts";
+import type { ServerConnection } from "./server-manager.ts";
 import type { ToolMetadata, McpOperationContext, McpToolCallIdentity } from "./types.ts";
 import { type SessionRecoveryDeps } from "./session-recovery.ts";
 type ProxyToolResult = AgentToolResult<Record<string, unknown>>;
@@ -7,8 +8,8 @@ export declare function executeUiMessages(state: McpExtensionState): ProxyToolRe
 export declare function executeStatus(state: McpExtensionState): ProxyToolResult;
 export declare function executeAuthStart(state: McpExtensionState, serverName: string, signal?: AbortSignal): Promise<ProxyToolResult>;
 export declare function executeAuthComplete(state: McpExtensionState, serverName: string, input?: string, signal?: AbortSignal): Promise<ProxyToolResult>;
-export declare function executeDescribe(state: McpExtensionState, toolName: string): ProxyToolResult;
-export declare function executeSearch(state: McpExtensionState, query: string, server?: string, includeSchemas?: boolean, limit?: number, offset?: number): ProxyToolResult;
+export declare function executeDescribe(state: McpExtensionState, toolName: string, serverFilter?: string): ProxyToolResult;
+export declare function executeSearch(state: McpExtensionState, query: string, server?: string, includeSchemas?: boolean, limit?: number, offset?: number, caller?: "mcp" | "mcp_search"): ProxyToolResult;
 export declare function executeList(state: McpExtensionState, server: string, limit?: number, offset?: number): ProxyToolResult;
 export declare function executeInstructions(state: McpExtensionState, server: string): ProxyToolResult;
 export declare function executeConnect(state: McpExtensionState, serverName: string, signal?: AbortSignal, limit?: number, offset?: number): Promise<ProxyToolResult>;
@@ -24,15 +25,48 @@ interface ToolCallOptions extends McpToolCallIdentity {
     recoverAuthConnection: NonNullable<SessionRecoveryDeps["onNeedsAuth"]>;
     authRequiredMessage: () => string;
     autoAuthAttempted: () => boolean;
-    onRawResult?: (result: unknown) => void;
+    raw?: boolean;
 }
 /**
  * Executes an already-approved tool call against a connected server.
  *
- * Both the `mcp` proxy and direct tools reach this with a resolved target and a
- * live connection; everything before this point (name resolution, connect and
- * auth strategy, approval) differs between them and stays with the caller.
+ * Direct, gateway, resource and script calls share executeCall preparation.
+ * Raw scripts skip content rendering but retain protocol results and artifacts.
  */
 export declare function runToolCall(state: McpExtensionState, serverName: string, target: ToolCallTarget, args: Record<string, unknown> | undefined, options: ToolCallOptions): Promise<ProxyToolResult>;
-export declare function executeCall(state: McpExtensionState, toolName: string, args?: Record<string, unknown>, serverOverride?: string, getPiTools?: () => ToolInfo[], signal?: AbortSignal, onRawResult?: (result: unknown) => void, identity?: McpToolCallIdentity, beforeDispatch?: (signal: AbortSignal | undefined, operation: McpOperationContext) => Promise<void>): Promise<ProxyToolResult>;
+export interface ExecuteCallOptions {
+    exactOriginalName?: boolean;
+    resourceUri?: string;
+    /** Scripts receive the raw protocol result without model-facing content transformation. */
+    raw?: boolean;
+}
+/** Connect/auth once for calls and resource discovery. Recovery stays bounded by withSessionRecovery. */
+export declare function prepareMcpConnection(state: McpExtensionState, serverName: string, signal?: AbortSignal): Promise<{
+    error: {
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        details: {
+            mode: string;
+            error: string;
+            server: string;
+            message: string;
+        };
+    };
+    connection?: never;
+    recoverAuthConnection?: never;
+    autoAuthAttempted?: never;
+} | {
+    error: ProxyToolResult;
+    connection?: never;
+    recoverAuthConnection?: never;
+    autoAuthAttempted?: never;
+} | {
+    error?: never;
+    connection: ServerConnection;
+    recoverAuthConnection: (serverName: string, signal?: AbortSignal, challenge?: import("./session-recovery.ts").AuthChallengeContext) => Promise<ServerConnection | undefined>;
+    autoAuthAttempted: () => boolean;
+}>;
+export declare function executeCall(state: McpExtensionState, toolName: string, args?: Record<string, unknown>, serverOverride?: string, getPiTools?: () => ToolInfo[], signal?: AbortSignal, identity?: McpToolCallIdentity, beforeDispatch?: (signal: AbortSignal | undefined, operation: McpOperationContext) => Promise<void>, options?: ExecuteCallOptions): Promise<ProxyToolResult>;
 export {};