@fitchmultz/pi-mcp-adapter 5.0.0 → 6.0.0

package/mcp-panel.ts

@@ -1,11 +1,9 @@
 import { matchesKey, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 import { copyToClipboard } from "@earendil-works/pi-coding-agent";
 import { createPanelKeys, type PanelKeybindings, type PanelKeys } from "./panel-keys.ts";
-import { isServerDisabled, isToolAllowed } from "./types.ts";
-import type { McpConfig, McpPanelCallbacks, McpPanelResult, ServerProvenance, ToolPrefix } from "./types.ts";
-import { resourceNameToToolName } from "./resource-tools.ts";
+import type { McpConfig, McpPanelCallbacks, McpPanelResult, ServerEntry, ServerProvenance, ToolPrefix } from "./types.ts";
 import { sanitizeTerminalText, stripOscSequences } from "./utils.ts";
-import type { MetadataCache, ServerCacheEntry, CachedTool } from "./metadata-cache.ts";
+import { reconstructToolMetadata, type MetadataCache, type ServerCacheEntry, type CachedTool } from "./metadata-cache.ts";
 
 interface PanelTheme {
   border: string;
@@ -130,9 +128,9 @@ interface ServerState {
   expanded: boolean;
   source: "user" | "project" | "import";
   importKind?: string;
-  includeTools?: string[];
-  excludeTools?: string[];
-  exposeResources: boolean;
+  definition: ServerEntry;
+  toolFilter: true | string[] | false;
+  resourceCount: number;
   connectionStatus: ConnectionStatus;
   failureMessage?: string | null;
   tools: ToolState[];
@@ -197,61 +195,24 @@ class McpPanel {
         toolFilter = globalDirect;
       }
 
-      const tools: ToolState[] = [];
-      if (serverCache && !this.authOnly && !isServerDisabled(definition)) {
-        for (const tool of serverCache.tools ?? []) {
-          if (!isToolAllowed(tool.name, serverName, this.prefix, definition.includeTools, definition.excludeTools)) {
-            continue;
-          }
-
-          const isDirect = toolFilter === true || (Array.isArray(toolFilter) && toolFilter.includes(tool.name));
-          tools.push({
-            name: tool.name,
-            description: tool.description ?? "",
-            isDirect,
-            wasDirect: isDirect,
-            estimatedTokens: estimateTokens(tool),
-          });
-        }
-        if (definition.exposeResources !== false) {
-          for (const resource of serverCache.resources ?? []) {
-            const baseName = `read_${resourceNameToToolName(resource.name)}`;
-            if (!isToolAllowed(baseName, serverName, this.prefix, definition.includeTools, definition.excludeTools)) {
-              continue;
-            }
-
-            const isDirect = toolFilter === true || (Array.isArray(toolFilter) && toolFilter.includes(baseName));
-            const ct: CachedTool = {
-              name: baseName,
-              ...(resource.description !== undefined ? { description: resource.description } : {}),
-            };
-            tools.push({
-              name: baseName,
-              description: resource.description ?? `Read resource: ${resource.uri}`,
-              isDirect,
-              wasDirect: isDirect,
-              estimatedTokens: estimateTokens(ct),
-            });
-          }
-        }
-      }
-
       const status = callbacks.getConnectionStatus(serverName);
       const failureMessage = callbacks.getFailureMessage?.(serverName) ?? null;
 
-      this.servers.push({
+      const server: ServerState = {
         name: serverName,
         expanded: false,
         source: prov?.kind ?? "user",
         ...(prov?.importKind !== undefined ? { importKind: prov.importKind } : {}),
-        ...(definition.includeTools !== undefined ? { includeTools: definition.includeTools } : {}),
-        ...(definition.excludeTools !== undefined ? { excludeTools: definition.excludeTools } : {}),
-        exposeResources: definition.exposeResources !== false,
+        definition,
+        toolFilter,
+        resourceCount: 0,
         connectionStatus: status,
         failureMessage,
-        tools,
+        tools: [],
         hasCachedData: !!serverCache,
-      });
+      };
+      this.servers.push(server);
+      if (serverCache && !this.authOnly) this.rebuildServerTools(server, serverCache);
     }
 
     this.rebuildVisibleItems();
@@ -565,7 +526,6 @@ class McpPanel {
         if (entry) {
           this.rebuildServerTools(server, entry);
         }
-        server.hasCachedData = true;
       }
       if (options.afterAuth) {
         this.authNotice = connected && server.connectionStatus === "connected"
@@ -637,50 +597,22 @@ class McpPanel {
   }
 
   private rebuildServerTools(server: ServerState, entry: ServerCacheEntry): void {
-    const existingState = new Map<string, boolean>();
-    for (const t of server.tools) existingState.set(t.name, t.isDirect);
-
-    const newTools: ToolState[] = [];
-    for (const tool of entry.tools ?? []) {
-      if (!isToolAllowed(tool.name, server.name, this.prefix, server.includeTools, server.excludeTools)) {
-        continue;
-      }
-
-      const prev = existingState.get(tool.name);
-      const isDirect = prev !== undefined ? prev : false;
-      newTools.push({
-        name: tool.name,
-        description: tool.description ?? "",
-        isDirect,
-        wasDirect: prev !== undefined ? server.tools.find((t) => t.name === tool.name)?.wasDirect ?? false : false,
+    const existingState = new Map(server.tools.map(tool => [tool.name, tool]));
+    const metadata = reconstructToolMetadata(server.name, entry, this.prefix, server.definition);
+    server.resourceCount = metadata.filter(tool => tool.resourceUri !== undefined).length;
+    server.tools = metadata.filter(tool => tool.resourceUri === undefined).map(tool => {
+      const previous = existingState.get(tool.originalName);
+      const pinned = server.toolFilter === true
+        || (Array.isArray(server.toolFilter) && server.toolFilter.includes(tool.originalName));
+      return {
+        name: tool.originalName,
+        description: tool.description,
+        isDirect: previous?.isDirect ?? pinned,
+        wasDirect: previous?.wasDirect ?? pinned,
         estimatedTokens: estimateTokens(tool),
-      });
-    }
-
-    if (server.exposeResources) {
-      for (const resource of entry.resources ?? []) {
-        const baseName = `read_${resourceNameToToolName(resource.name)}`;
-        if (!isToolAllowed(baseName, server.name, this.prefix, server.includeTools, server.excludeTools)) {
-          continue;
-        }
-
-        const prev = existingState.get(baseName);
-        const isDirect = prev !== undefined ? prev : false;
-        const ct: CachedTool = {
-          name: baseName,
-          ...(resource.description !== undefined ? { description: resource.description } : {}),
-        };
-        newTools.push({
-          name: baseName,
-          description: resource.description ?? `Read resource: ${resource.uri}`,
-          isDirect,
-          wasDirect: prev !== undefined ? server.tools.find((t) => t.name === baseName)?.wasDirect ?? false : false,
-          estimatedTokens: estimateTokens(ct),
-        });
-      }
-    }
-
-    server.tools = newTools;
+      };
+    });
+    server.hasCachedData = true;
     this.rebuildVisibleItems();
     this.updateDirty();
   }
@@ -746,6 +678,9 @@ class McpPanel {
 
         if (item.type === "server") {
           lines.push(row(this.renderServerRow(server, isCursor)));
+          if (isCursor && !this.authOnly && server.resourceCount > 0) {
+            lines.push(row(fg(t.hint, "    Resources: mcp actions resources / read-resource")));
+          }
           if (isCursor && server.connectionStatus === "failed" && server.failureMessage) {
             for (const line of this.wrapText(sanitizeDisplayText(server.failureMessage), innerW - 6)) {
               lines.push(row(`    ${fg(t.cancel, line)}`));
@@ -796,8 +731,9 @@ class McpPanel {
           0,
         );
         const stats =
-          directCount > 0 ? `${directCount} direct  ~${totalTokens.toLocaleString()} tokens` : "no direct tools";
+          directCount > 0 ? `${directCount} pinned  ~${totalTokens.toLocaleString()} tokens` : "no pinned tools";
         lines.push(row(fg(t.description, stats + (this.dirty ? fg(t.needsAuth, "  (unsaved)") : ""))));
+        lines.push(row(fg(t.hint, "Pins load at startup; discover more with mcp_search.")));
       }
     }
 
@@ -812,7 +748,7 @@ class McpPanel {
         ]
       : [
           italic("↑↓") + " navigate",
-          italic("space") + " toggle",
+          italic("space") + " pin/unpin",
           italic("⏎") + " expand/auth",
           italic("ctrl+a") + " auth",
           italic("ctrl+r") + " reconnect",
@@ -860,7 +796,7 @@ class McpPanel {
     const statusLabel = this.renderConnectionStatus(server);
 
     if (!server.hasCachedData && !this.authOnly) {
-      return `${prefix}   ${nameStr}${importLabel}  ${fg(t.description, "(not cached)")}${statusLabel}`;
+      return `${prefix}   ${nameStr}${importLabel}${statusLabel}  ${fg(t.description, "(undiscovered)")}`;
     }
 
     const directCount = server.tools.filter((t) => t.isDirect).length;
@@ -872,17 +808,10 @@ class McpPanel {
       toggleIcon = fg(t.needsAuth, "◐");
     }
 
-    let toolInfo = "";
-    if (totalCount > 0) {
-      toolInfo = `${directCount}/${totalCount}`;
-      if (directCount > 0) {
-        const tokens = server.tools.filter((t) => t.isDirect).reduce((s, t) => s + t.estimatedTokens, 0);
-        toolInfo += `  ~${tokens.toLocaleString()}`;
-      }
-      toolInfo = fg(t.description, toolInfo);
-    }
+    const toolInfo = this.authOnly ? "" : fg(t.description,
+      `${totalCount} tool${totalCount === 1 ? "" : "s"}, ${directCount} pinned${server.resourceCount > 0 ? `, ${server.resourceCount} resource${server.resourceCount === 1 ? "" : "s"}` : ""}`);
 
-    return `${prefix} ${toggleIcon} ${nameStr}${importLabel}  ${toolInfo}${statusLabel}`;
+    return `${prefix} ${toggleIcon} ${nameStr}${importLabel}${statusLabel}  ${toolInfo}`;
   }
 
   private selectedServerHasFailureMessage(): boolean {

package/mcp-script-worker.mjs

@@ -69,7 +69,7 @@ const tools = new Proxy(Object.create(null), {
       return async (input) => request("search", { input });
     }
     if (property === "call") {
-      return async (path, args) => {
+      return async (path, args, server) => {
         // Invalid paths never reach dispatch and therefore never appear in the call trace.
         if (typeof path !== "string" || path.trim() === "") {
           return {
@@ -80,9 +80,12 @@ const tools = new Proxy(Object.create(null), {
             },
           };
         }
-        return request("call", { path, args });
+        if (server !== undefined && (typeof server !== "string" || !server)) return { ok: false, error: { code: "invalid_arguments", message: "server must be a non-empty string" } };
+        return request("call", { path, args, server });
       };
     }
+    if (property === "resources" || property === "listResources") return async (input) => request("resources", { input });
+    if (property === "readResource" || property === "readResult") return async (input) => request(property, { input });
     if (property === "describe") {
       return async (input) => request("describe", { input });
     }

package/mcp-status.ts

@@ -33,7 +33,7 @@ export function createMcpStatusSnapshot(state: McpExtensionState): McpStatusSnap
     const disabled = definition?.disabled === true;
     const connection = disabled ? undefined : state.manager.getConnection(name);
     const metadata = disabled ? undefined : state.toolMetadata.get(name);
-    const toolCount = metadata?.length ?? (connection?.status === "connected" ? connection.tools.length : 0);
+    const toolCount = metadata?.filter(tool => !tool.resourceUri).length ?? (connection?.status === "connected" ? connection.tools.length : 0);
     const resourceCount = disabled
       ? undefined
       : state.resourceCounts?.get(name) ?? (connection?.status === "connected" ? connection.resources.length : undefined);
@@ -60,6 +60,7 @@ export function createMcpStatusSnapshot(state: McpExtensionState): McpStatusSnap
       name,
       status,
       toolCount,
+      catalogKnown: metadata !== undefined || connection?.status === "connected",
       ...(resourceCount !== undefined ? { resourceCount } : {}),
       ...(status === "failed" && failedAgoSeconds !== undefined ? { failedAgoSeconds } : {}),
       disabled,

package/metadata-cache.ts

@@ -3,7 +3,6 @@ import { existsSync, readFileSync, writeFileSync, renameSync, mkdirSync } from "
 import { dirname } from "node:path";
 import { getAdapterPath } from "./agent-dir.ts";
 import { createHash } from "node:crypto";
-import { getToolUiResourceUri } from "@modelcontextprotocol/ext-apps/app-bridge";
 import type {
   CachedPrompt,
   CachedResource,
@@ -19,18 +18,17 @@ import type {
   ToolMetadata,
   PromptMetadata,
 } from "./types.ts";
-import { formatPromptCommandName, formatToolName, isServerDisabled, isToolAllowed, resolveToolPrefix, type ToolPrefix } from "./types.ts";
-import { resourceNameToToolName } from "./resource-tools.ts";
+import { formatPromptCommandName, isServerDisabled, resolveToolPrefix, type ToolPrefix } from "./types.ts";
+import { buildToolMetadata } from "./tool-metadata.ts";
 import {
-  extractToolUiStreamMode,
   interpolateEnvRecord,
   resolveBearerToken,
   resolveConfigPath,
   resolveServerUrl,
 } from "./utils.ts";
-import { extractUiToolVisibility, isUiToolVisibleToModel } from "./ui-tool-visibility.ts";
 
-const CACHE_VERSION = 1;
+// 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 type { CachedPrompt, CachedResource, CachedTool, MetadataCache, ServerCacheEntry } from "./types.ts";
@@ -46,7 +44,7 @@ export function loadMetadataCache(enabled = true): MetadataCache | null {
   try {
     const raw = JSON.parse(readFileSync(cachePath, "utf-8"));
     if (!raw || typeof raw !== "object") return null;
-    if (raw.version !== CACHE_VERSION) return null;
+    if (raw.version !== 1 && raw.version !== CACHE_VERSION) return null;
     if (!raw.servers || typeof raw.servers !== "object") return null;
     return raw as MetadataCache;
   } catch {
@@ -64,7 +62,7 @@ export function saveMetadataCache(cache: MetadataCache, enabled = true): void {
   try {
     if (existsSync(cachePath)) {
       const existing = JSON.parse(readFileSync(cachePath, "utf-8")) as MetadataCache;
-      if (existing && existing.version === CACHE_VERSION && existing.servers) {
+      if (existing && (existing.version === 1 || existing.version === CACHE_VERSION) && existing.servers) {
         merged.servers = { ...existing.servers };
       }
     }
@@ -178,92 +176,40 @@ export function reconstructToolMetadata(
   serverName: string,
   entry: ServerCacheEntry,
   prefix: ToolPrefix,
-  definition: Pick<ServerEntry, "exposeResources" | "includeTools" | "excludeTools" | "toolPrefix">
+  definition: Pick<ServerEntry, "exposeResources" | "includeTools" | "excludeTools" | "toolPrefix" | "disabled">
 ): ToolMetadata[] {
-  const metadata: ToolMetadata[] = [];
-  const seenNames = new Set<string>();
-  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);
+  return buildToolMetadata(
+    (entry.tools ?? []).filter(tool => tool?.name).map(restoreCachedTool),
+    entry.resources ?? [],
+    definition,
+    serverName,
+    prefix,
+  ).metadata;
+}
 
-      metadata.push({
-        name,
-        originalName: baseName,
-        description: resource.description ?? `Read resource: ${resource.uri}`,
-        resourceUri: resource.uri,
-      });
-    }
+function restoreCachedTool(tool: CachedTool): McpTool {
+  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: McpTool[]): CachedTool[] {
-  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: McpResource[]): CachedResource[] {
-  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: McpPrompt[]): CachedPrompt[] {
@@ -323,11 +269,3 @@ function stableStringify(value: unknown): string {
   const keys = Object.keys(obj).sort();
   return `{${keys.map(k => `${JSON.stringify(k)}:${stableStringify(obj[k])}`).join(",")}}`;
 }
-
-function tryGetToolUiResourceUri(tool: McpTool): string | undefined {
-  try {
-    return getToolUiResourceUri({ _meta: tool._meta });
-  } catch {
-    return undefined;
-  }
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fitchmultz/pi-mcp-adapter",
-  "version": "5.0.0",
+  "version": "6.0.0",
   "description": "Fitch's independently maintained MCP adapter for Pi coding agent",
   "type": "module",
   "types": "./dist/index.d.ts",
@@ -30,7 +30,9 @@
   },
   "scripts": {
     "build": "node ./scripts/build.mjs",
+    "build:bridge": "node ./scripts/build-app-bridge.mjs",
     "prepare": "node ./scripts/prepare.mjs",
+    "check:compat": "node scripts/compat-host.mjs && npm run build && npm run typecheck && vitest run --exclude __tests__/interactive-visualizer-server.test.ts && npm run test:oauth && node scripts/compat-package-smoke.mjs",
     "typecheck": "tsc --noEmit",
     "test": "vitest run",
     "test:watch": "vitest",
@@ -67,6 +69,7 @@
     "dist",
     "docs/client-metadata.json",
     "scripts/build.mjs",
+    "scripts/build-app-bridge.mjs",
     "scripts/prepare.mjs",
     "tsconfig.build.json",
     "tsconfig.json",
@@ -74,6 +77,8 @@
     "agent-dir.ts",
     "legacy-migration.ts",
     "index.ts",
+    "tool-loader.ts",
+    "gateway-arguments.ts",
     "error-signal.ts",
     "state.ts",
     "utils.ts",
@@ -81,7 +86,6 @@
     "runtime-owner.ts",
     "checkpoint.ts",
     "tool-metadata.ts",
-    "ts-shape.ts",
     "search-ranking.ts",
     "tool-approval.ts",
     "init.ts",
@@ -136,21 +140,21 @@
   "dependencies": {
     "@modelcontextprotocol/client": "2.0.0",
     "@modelcontextprotocol/core": "2.0.0",
-    "@modelcontextprotocol/ext-apps": "^1.7.5",
-    "@modelcontextprotocol/sdk": "^1.30.0",
+    "@modelcontextprotocol/ext-apps": "2.0.0",
     "@napi-rs/keyring": "^1.3.0",
     "cross-spawn": "^7.0.6",
+    "minisearch": "^7.2.0",
     "open": "^10.2.0",
     "smol-toml": "^1.8.0",
     "strip-json-comments": "^5.0.3",
-    "zod": "^3.25.0 || ^4.0.0"
+    "zod": "^4.6.5"
   },
   "peerDependencies": {
     "@earendil-works/pi-ai": "*",
     "@earendil-works/pi-coding-agent": "*",
     "@earendil-works/pi-tui": "*",
     "typebox": "*",
-    "zod": "^3.25.0 || ^4.0.0"
+    "zod": "^4.6.5"
   },
   "peerDependenciesMeta": {
     "@earendil-works/pi-ai": {
@@ -167,13 +171,14 @@
     }
   },
   "devDependencies": {
-    "@earendil-works/pi-ai": "0.84.0",
-    "@earendil-works/pi-coding-agent": "0.84.0",
-    "@earendil-works/pi-tui": "0.84.0",
+    "@earendil-works/pi-ai": "0.87.0",
+    "@earendil-works/pi-coding-agent": "0.87.0",
+    "@earendil-works/pi-tui": "0.87.0",
     "@modelcontextprotocol/conformance": "0.1.16",
     "@modelcontextprotocol/server": "2.0.0",
     "@types/cross-spawn": "6.0.6",
     "@types/node": "20.19.43",
+    "esbuild": "^0.28.2",
     "tsx": "^4.21.0",
     "typebox": "1.3.7",
     "typescript": "5.9.3",

package/prompts.ts

@@ -12,7 +12,7 @@ import { truncateAtWord } from "./utils.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 function resolveCachedPrompts(config: McpConfig, cacheEnabled = true): PromptMetadata[] {