@fitchmultz/pi-mcp-adapter 5.0.0 → 7.0.0

package/dist/mcp-output-guard.js

@@ -1,7 +1,7 @@
 import { randomBytes } from "node:crypto";
-import { mkdir, mkdtemp, writeFile } from "node:fs/promises";
+import { mkdir, mkdtemp, readFile, realpath, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { join, resolve } from "node:path";
+import { basename, dirname, join, resolve } from "node:path";
 export const DEFAULT_MCP_OUTPUT_MAX_BYTES = 50 * 1024;
 export const DEFAULT_MCP_OUTPUT_MAX_LINES = 2000;
 export const DEFAULT_MCP_DETAILS_MAX_BYTES = 16 * 1024;
@@ -24,6 +24,9 @@ export function guardedMcpDetails(guarded) {
     return {
         ...(guarded.mcpResult !== undefined ? { mcpResult: guarded.mcpResult } : {}),
         ...(guarded.outputGuard ? { outputGuard: guarded.outputGuard } : {}),
+        ...(guarded.resultRef ? { resultRef: guarded.resultRef } : {}),
+        ...(guarded.resultWriteError ? { resultWriteError: guarded.resultWriteError } : {}),
+        ...(guarded.payloadFiles?.length ? { payloadFiles: guarded.payloadFiles } : {}),
     };
 }
 /**
@@ -34,18 +37,17 @@ export function guardedMcpDetails(guarded) {
 export async function guardMcpOutput(content, options = {}) {
     const maxBytes = options.maxBytes ?? DEFAULT_MCP_OUTPUT_MAX_BYTES;
     const maxLines = options.maxLines ?? DEFAULT_MCP_OUTPUT_MAX_LINES;
-    const detailsMaxBytes = options.detailsMaxBytes ?? DEFAULT_MCP_DETAILS_MAX_BYTES;
     const prefix = options.prefix ?? "";
     const suffix = options.suffix ?? "";
     const normalizedContent = withEmptyTextFallback(content.length > 0
         ? sanitizeContent(content)
         : [{ type: "text", text: options.emptyTextFallback ?? "(empty result)" }], options.emptyTextFallback);
-    if (options.enabled === false) {
-        return {
-            content: addAffixes(normalizedContent, prefix, suffix),
-            ...(options.rawMcpResult !== undefined ? { mcpResult: options.rawMcpResult } : {}),
-        };
-    }
+    const retained = options.retainedMcpResult ?? (options.rawMcpResult === undefined ? {} : await retainMcpResult(options.rawMcpResult, options));
+    const reference = retained.resultRef ? formatMcpResultReference(retained.resultRef)
+        : retained.resultWriteError ? `[MCP result could not be saved: ${retained.resultWriteError}]` : undefined;
+    const withReference = (blocks) => reference ? [...blocks, { type: "text", text: reference }] : blocks;
+    if (options.enabled === false)
+        return { content: withReference(addAffixes(normalizedContent, prefix, suffix)), ...retained };
     const imageBlocks = normalizedContent.filter((block) => block.type === "image");
     const textOutput = normalizedContent
         .filter((block) => block.type === "text")
@@ -53,15 +55,17 @@ export async function guardMcpOutput(content, options = {}) {
         .join("\n");
     const composedOutput = `${prefix}${textOutput}${suffix}`;
     const stats = textStats(composedOutput);
+    const referenceSuffix = reference ? `\n${reference}` : "";
+    const totalStats = textStats(composedOutput ? composedOutput + referenceSuffix : reference ?? "");
     let guardedContent = addAffixes(normalizedContent, prefix, suffix);
     let outputGuard;
-    if (stats.bytes > maxBytes || stats.lines > maxLines) {
+    if (totalStats.bytes > maxBytes || totalStats.lines > maxLines) {
         const { path: fullOutputPath, error: writeError } = await saveArtifact("output", composedOutput, options.outputDirectory);
         const notice = formatTruncationNotice(stats, fullOutputPath, writeError);
-        const previewBudget = reserveBudget(maxBytes, maxLines, notice);
+        const previewBudget = reserveBudget(maxBytes, maxLines, notice + referenceSuffix);
         const preview = truncateHead(composedOutput, previewBudget.maxBytes, previewBudget.maxLines);
         const finalText = `${preview.content}\n\n${notice}`;
-        const finalStats = textStats(finalText);
+        const finalStats = textStats(finalText + referenceSuffix);
         guardedContent = [{ type: "text", text: finalText }, ...imageBlocks];
         outputGuard = {
             truncated: true,
@@ -74,13 +78,10 @@ export async function guardMcpOutput(content, options = {}) {
             ...(writeError !== undefined ? { writeError } : {}),
         };
     }
-    const mcpResult = options.rawMcpResult === undefined
-        ? undefined
-        : await boundMcpResult(options.rawMcpResult, detailsMaxBytes, options.outputDirectory);
     return {
-        content: guardedContent,
+        content: withReference(guardedContent),
         ...(outputGuard ? { outputGuard } : {}),
-        ...(mcpResult !== undefined ? { mcpResult } : {}),
+        ...retained,
     };
 }
 function sanitizeContent(content) {
@@ -187,15 +188,45 @@ function formatTruncationNotice(stats, fullOutputPath, writeError) {
  * detailsMaxBytes; otherwise replace it with a compact summary and spill the
  * raw JSON to a temp file.
  */
-async function boundMcpResult(result, detailsMaxBytes, outputDirectory) {
+export async function retainMcpResult(result, options = {}, rawResult = false) {
     const raw = safeStringify(result);
     const rawBytes = byteLength(raw);
-    if (rawBytes <= detailsMaxBytes)
-        return result;
-    return summarizeMcpResult(result, raw, rawBytes, outputDirectory);
+    const record = asRecord(result);
+    const content = Array.isArray(record?.content) ? record.content
+        : Array.isArray(record?.contents) ? record.contents.map(resource => ({ type: "resource", resource })) : [];
+    const payloadFiles = (await Promise.all(content.map(async (block, index) => {
+        const item = asRecord(block);
+        const resource = asRecord(item?.resource);
+        const data = item?.type === "audio" ? item.data : item?.type === "resource" ? resource?.blob : undefined;
+        if (typeof data !== "string")
+            return undefined;
+        const mimeType = item?.mimeType ?? resource?.mimeType;
+        return { index, kind: item.type, ...(typeof resource?.uri === "string" ? { uri: resource.uri } : {}), ...(typeof mimeType === "string" ? { mimeType } : {}), ...await saveArtifact("payload", Buffer.from(data, "base64"), options.outputDirectory) };
+    }))).filter((file) => file !== undefined);
+    const oversized = options.enabled !== false && rawBytes > (options.detailsMaxBytes ?? DEFAULT_MCP_DETAILS_MAX_BYTES);
+    const shouldSave = oversized || !record || Object.keys(record).some(key => key !== "content" && key !== "isError")
+        || content.some(block => {
+            const item = asRecord(block);
+            return item?.type !== "text" || Object.keys(item).some(key => key !== "type" && key !== "text");
+        });
+    if (!shouldSave)
+        return { mcpResult: result };
+    const artifact = await saveArtifact("mcp-result", raw, options.outputDirectory);
+    return {
+        mcpResult: oversized && !rawResult ? summarizeMcpResult(result, rawBytes, artifact) : result,
+        ...(artifact.path ? { resultRef: artifact.path } : {}),
+        ...(artifact.error ? { resultWriteError: artifact.error } : {}),
+        ...(payloadFiles.length ? { payloadFiles } : {}),
+    };
 }
-async function summarizeMcpResult(result, raw, rawBytes, outputDirectory) {
-    const { path: fullResultPath, error: resultWriteError } = await saveArtifact("mcp-result", raw, outputDirectory);
+export function formatMcpPayloadFile(file) {
+    return `[MCP ${file.kind === "audio" ? "audio" : "binary resource"}${file.uri ? ` (${file.uri})` : ""}: ${file.mimeType ?? "unknown MIME type"}; not rendered. ${file.path ? `Saved file: ${file.path}` : `Could not save: ${file.error}`}]`;
+}
+export function formatMcpResultReference(ref) {
+    return `[MCP result saved: ${JSON.stringify(ref)}. Inspect without repeating the call using mcp action "read-result" or tools.readResult with this ref. Optionally select a JSON Pointer with path.]`;
+}
+function summarizeMcpResult(result, rawBytes, artifact) {
+    const { path: fullResultPath, error: resultWriteError } = artifact;
     const record = asRecord(result);
     const content = Array.isArray(record?.content) ? record.content : [];
     const summary = {
@@ -281,7 +312,7 @@ async function saveArtifact(kind, text, outputDirectory) {
         if (outputDirectory !== undefined)
             await mkdir(parent, { recursive: true, mode: 0o700 });
         const dir = await mkdtemp(join(parent, "pi-mcp-output-"));
-        const path = join(dir, `${kind}-${randomBytes(4).toString("hex")}.txt`);
+        const path = join(dir, `${kind}-${randomBytes(4).toString("hex")}.${typeof text === "string" ? "txt" : "bin"}`);
         await writeFile(path, text, { encoding: "utf8", mode: 0o600 });
         return { path };
     }
@@ -289,6 +320,80 @@ async function saveArtifact(kind, text, outputDirectory) {
         return { error: error instanceof Error ? error.message : String(error) };
     }
 }
+export async function readMcpResult(input, options = {}) {
+    try {
+        if (!input || typeof input.ref !== "string")
+            throw new Error("ref must be a retained MCP result path");
+        // Script-only hosts deliberately have no general filesystem capability.
+        const root = await realpath(options.outputDirectory === undefined ? tmpdir() : resolve(options.outputDirectory));
+        const ref = await realpath(resolve(input.ref));
+        if (dirname(dirname(ref)) !== root || !/^pi-mcp-output-/.test(basename(dirname(ref)))
+            || !/^(mcp-result|output)-[a-f0-9]+\.txt$/.test(basename(ref)))
+            throw new Error("ref is not an MCP output artifact in this host's output directory");
+        let rendered = await readFile(ref, "utf8");
+        if (input.path !== undefined || input.fields !== undefined || basename(ref).startsWith("mcp-result-")) {
+            let value = JSON.parse(rendered);
+            if (input.path !== undefined && input.path !== "") {
+                if (typeof input.path !== "string" || !input.path.startsWith("/") || /~(?:[^01]|$)/.test(input.path))
+                    throw new Error("path must be an RFC 6901 JSON Pointer");
+                for (const token of input.path.slice(1).split("/")) {
+                    const key = token.replace(/~1/g, "/").replace(/~0/g, "~");
+                    if (value === null || typeof value !== "object" || (Array.isArray(value) && !/^(0|[1-9]\d*)$/.test(key)) || !Object.hasOwn(value, key))
+                        throw new Error(`JSON Pointer does not exist: ${input.path}`);
+                    value = value[key];
+                }
+            }
+            if (input.fields !== undefined) {
+                if (!Array.isArray(input.fields) || input.fields.some(field => typeof field !== "string"))
+                    throw new Error("fields must be an array of keys");
+                const select = (item) => {
+                    if (!item || typeof item !== "object" || Array.isArray(item))
+                        throw new Error("fields requires an object or array of objects");
+                    return Object.fromEntries(input.fields.filter(key => Object.hasOwn(item, key)).map(key => [key, item[key]]));
+                };
+                value = Array.isArray(value) ? value.map(select) : select(value);
+            }
+            rendered = JSON.stringify(value, null, 2);
+        }
+        const offset = input.offset ?? 0;
+        const limit = input.limit ?? 12_000;
+        if (!Number.isSafeInteger(offset) || offset < 0 || !Number.isSafeInteger(limit) || limit < 1)
+            throw new Error("offset must be a non-negative integer and limit a positive integer");
+        if (offset > 0 && rendered.codePointAt(offset - 1) > 0xffff)
+            throw new Error("offset must not split a Unicode surrogate pair");
+        const maxBytes = options.maxBytes ?? DEFAULT_MCP_OUTPUT_MAX_BYTES;
+        const maxLines = options.maxLines ?? DEFAULT_MCP_OUTPUT_MAX_LINES;
+        const notice = (end) => `[MCP result page: ${offset}–${end} of ${rendered.length} characters. Continue with offset: ${end}.]`;
+        const pageEnd = (byteCap, lineCap) => {
+            let end = offset;
+            let bytes = 0;
+            let lines = 1;
+            while (end < rendered.length && end - offset < limit) {
+                const width = rendered.codePointAt(end) > 0xffff ? 2 : 1;
+                const char = rendered.slice(end, end + width);
+                bytes += byteLength(char);
+                if (char === "\n")
+                    lines++;
+                // Tiny caps still return one complete character plus recovery guidance.
+                if (end > offset && (bytes > byteCap || lines > lineCap || end + width - offset > limit))
+                    break;
+                end += width;
+            }
+            return end;
+        };
+        let end = pageEnd(maxBytes, maxLines);
+        if (end < rendered.length) {
+            // The final offset cannot need more digits than the total length. Include the block separator.
+            end = pageEnd(maxBytes - byteLength(notice(rendered.length)) - 1, maxLines - 1);
+        }
+        const nextOffset = end < rendered.length ? end : null;
+        return { content: [{ type: "text", text: rendered.slice(offset, end) }, ...(nextOffset !== null ? [{ type: "text", text: notice(end) }] : [])], details: { ref, offset, nextOffset, totalCharacters: rendered.length, ...(input.path !== undefined ? { path: input.path } : {}) } };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { content: [{ type: "text", text: message }], details: { error: "result_read_failed", message } };
+    }
+}
 function asRecord(value) {
     return typeof value === "object" && value !== null ? value : undefined;
 }

package/dist/mcp-panel.d.ts

@@ -1,9 +1,7 @@
 import { type PanelKeybindings } from "./panel-keys.ts";
 import type { McpConfig, McpPanelCallbacks, McpPanelResult, ServerProvenance } from "./types.ts";
-import type { MetadataCache } from "./metadata-cache.ts";
+import { type MetadataCache } from "./metadata-cache.ts";
 declare class McpPanel {
-    private callbacks;
-    private done;
     private noticeLines;
     private prefix;
     private servers;
@@ -25,6 +23,8 @@ declare class McpPanel {
     private keys;
     private static readonly MAX_VISIBLE;
     private static readonly INACTIVITY_MS;
+    private callbacks;
+    private done;
     constructor(config: McpConfig, cache: MetadataCache | null, provenance: Map<string, ServerProvenance>, callbacks: McpPanelCallbacks, tui: {
         requestRender(): void;
     }, done: (result: McpPanelResult) => void, options?: {

package/dist/mcp-panel.js

@@ -1,9 +1,8 @@
 import { matchesKey, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 import { copyToClipboard } from "@earendil-works/pi-coding-agent";
 import { createPanelKeys } from "./panel-keys.js";
-import { isServerDisabled, isToolAllowed } from "./types.js";
-import { resourceNameToToolName } from "./resource-tools.js";
 import { sanitizeTerminalText, stripOscSequences } from "./utils.js";
+import { reconstructToolMetadata } from "./metadata-cache.js";
 const DEFAULT_THEME = {
     border: "2",
     title: "2",
@@ -94,8 +93,6 @@ function estimateTokens(tool) {
     return Math.ceil((tool.name.length + descLen + schemaLen) / 4) + 10;
 }
 class McpPanel {
-    callbacks;
-    done;
     noticeLines;
     prefix;
     servers = [];
@@ -117,6 +114,8 @@ class McpPanel {
     keys;
     static MAX_VISIBLE = 12;
     static INACTIVITY_MS = 60_000;
+    callbacks;
+    done;
     constructor(config, cache, provenance, callbacks, tui, done, options = {}) {
         this.callbacks = callbacks;
         this.done = done;
@@ -138,57 +137,24 @@ class McpPanel {
             else if (globalDirect) {
                 toolFilter = globalDirect;
             }
-            const tools = [];
-            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 = {
-                            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 = {
                 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();
         this.resetInactivityTimeout();
@@ -503,7 +469,6 @@ class McpPanel {
                 if (entry) {
                     this.rebuildServerTools(server, entry);
                 }
-                server.hasCachedData = true;
             }
             if (options.afterAuth) {
                 this.authNotice = connected && server.connectionStatus === "connected"
@@ -578,46 +543,22 @@ class McpPanel {
         this.cursorIndex = Math.max(0, Math.min(this.visibleItems.length - 1, this.cursorIndex + delta));
     }
     rebuildServerTools(server, entry) {
-        const existingState = new Map();
-        for (const t of server.tools)
-            existingState.set(t.name, t.isDirect);
-        const newTools = [];
-        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 = {
-                    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();
     }
@@ -677,6 +618,9 @@ class McpPanel {
                     continue;
                 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)}`));
@@ -722,8 +666,9 @@ class McpPanel {
             else {
                 const directCount = this.servers.reduce((sum, s) => sum + s.tools.filter((t) => t.isDirect).length, 0);
                 const totalTokens = this.servers.reduce((sum, s) => sum + s.tools.filter((t) => t.isDirect).reduce((ts, t) => ts + t.estimatedTokens, 0), 0);
-                const stats = directCount > 0 ? `${directCount} direct  ~${totalTokens.toLocaleString()} tokens` : "no direct tools";
+                const stats = 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.")));
             }
         }
         lines.push(emptyRow());
@@ -737,7 +682,7 @@ class McpPanel {
             ]
             : [
                 italic("↑↓") + " navigate",
-                italic("space") + " toggle",
+                italic("space") + " pin/unpin",
                 italic("⏎") + " expand/auth",
                 italic("ctrl+a") + " auth",
                 italic("ctrl+r") + " reconnect",
@@ -781,7 +726,7 @@ class McpPanel {
         const importLabel = server.source === "import" ? fg(t.description, ` (${importKind})`) : "";
         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;
         const totalCount = server.tools.length;
@@ -792,16 +737,8 @@ class McpPanel {
         else if (directCount > 0) {
             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);
-        }
-        return `${prefix} ${toggleIcon} ${nameStr}${importLabel}  ${toolInfo}${statusLabel}`;
+        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}${statusLabel}  ${toolInfo}`;
     }
     selectedServerHasFailureMessage() {
         const item = this.visibleItems[this.cursorIndex];

package/dist/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/dist/mcp-setup-panel.d.ts

@@ -31,10 +31,6 @@ export interface SetupPanelOptions {
     keybindings?: PanelKeybindings;
 }
 export declare class McpSetupPanel {
-    private discovery;
-    private callbacks;
-    private options;
-    private done;
     private screen;
     private actionCursor;
     private importCursor;
@@ -47,6 +43,10 @@ export declare class McpSetupPanel {
     private keys;
     private inactivityTimeout;
     private static readonly INACTIVITY_MS;
+    private discovery;
+    private callbacks;
+    private options;
+    private done;
     constructor(discovery: McpDiscoverySummary, callbacks: SetupPanelCallbacks, options: SetupPanelOptions, tui: {
         requestRender(): void;
     }, done: () => void);
@@ -72,6 +72,7 @@ export declare class McpSetupPanel {
     private previewWidth;
     private getActionPreview;
     private formatPreview;
+    private previewOrError;
     private formatWritePreview;
     private padLine;
     invalidate(): void;

package/dist/mcp-setup-panel.js

@@ -38,10 +38,6 @@ function wrapText(text, width) {
     return lines.length > 0 ? lines : [""];
 }
 export class McpSetupPanel {
-    discovery;
-    callbacks;
-    options;
-    done;
     screen;
     actionCursor = 0;
     importCursor = 0;
@@ -54,6 +50,10 @@ export class McpSetupPanel {
     keys;
     inactivityTimeout = null;
     static INACTIVITY_MS = 60_000;
+    discovery;
+    callbacks;
+    options;
+    done;
     constructor(discovery, callbacks, options, tui, done) {
         this.discovery = discovery;
         this.callbacks = callbacks;
@@ -361,7 +361,7 @@ export class McpSetupPanel {
             lines.push(this.padLine(fg(this.t.muted, `… ${actions.length - end} more below`), innerW));
         }
         lines.push(this.padLine("", innerW));
-        const preview = this.getActionPreview(this.getSelectedAction(), this.previewWidth(innerW));
+        const preview = this.previewOrError(width => this.getActionPreview(this.getSelectedAction(), width), innerW);
         for (const line of preview) {
             lines.push(this.padLine(line, innerW));
         }
@@ -384,8 +384,7 @@ export class McpSetupPanel {
         }
         lines.push(this.padLine("", innerW));
         const selected = this.discovery.imports.filter((entry) => this.selectedImports.has(entry.kind)).map((entry) => entry.kind);
-        const preview = this.callbacks.previewImports(selected);
-        for (const line of this.formatWritePreview("Compatibility import write preview", preview, [], this.previewWidth(innerW))) {
+        for (const line of this.previewOrError(width => this.formatWritePreview("Compatibility import write preview", this.callbacks.previewImports(selected), [], width), innerW)) {
             lines.push(this.padLine(line, innerW));
         }
         return lines;
@@ -522,6 +521,15 @@ export class McpSetupPanel {
         }
         return preview;
     }
+    previewOrError(preview, innerW) {
+        const width = this.previewWidth(innerW);
+        try {
+            return preview(width);
+        }
+        catch (error) {
+            return this.formatPreview([`Cannot preview write: ${error instanceof Error ? error.message : String(error)}`], width);
+        }
+    }
     formatWritePreview(title, preview, intro = [], width = DESKTOP_PREVIEW_WIDTH) {
         const lines = [];
         for (const line of intro) {

package/dist/mcp-status.js

@@ -21,7 +21,7 @@ export function createMcpStatusSnapshot(state) {
         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);
@@ -51,6 +51,7 @@ export function createMcpStatusSnapshot(state) {
             name,
             status,
             toolCount,
+            catalogKnown: metadata !== undefined || connection?.status === "connected",
             ...(resourceCount !== undefined ? { resourceCount } : {}),
             ...(status === "failed" && failedAgoSeconds !== undefined ? { failedAgoSeconds } : {}),
             disabled,

package/dist/mcp-trace.d.ts

@@ -52,7 +52,6 @@ export declare function createMcpTraceEvent(direction: McpTraceDirection, server
     durationMs?: number;
 }): McpTraceEvent;
 export declare class McpTraceWriter {
-    private readonly options;
     private readonly maxBytes;
     private readonly maxEvents;
     private readonly append;
@@ -65,6 +64,7 @@ export declare class McpTraceWriter {
     private initializationFailed;
     private persistenceError;
     private readonly fileReady;
+    private readonly options;
     constructor(options: McpTraceWriterOptions);
     get filePath(): string;
     get isDisabled(): boolean;

package/dist/mcp-trace.js

@@ -73,7 +73,6 @@ export function createMcpTraceEvent(direction, server, transport, message, statu
     return event;
 }
 export class McpTraceWriter {
-    options;
     maxBytes;
     maxEvents;
     append;
@@ -86,6 +85,7 @@ export class McpTraceWriter {
     initializationFailed = false;
     persistenceError;
     fileReady;
+    options;
     constructor(options) {
         this.options = options;
         this.maxBytes = boundedPositiveInteger(options.maxBytes, DEFAULT_MCP_TRACE_MAX_BYTES);

package/dist/metadata-cache.d.ts

@@ -11,7 +11,7 @@ export declare function parseDirectToolSelectors(selectors: string[]): {
     tools: Map<string, Set<string>>;
 };
 export declare function getMissingConfiguredDirectToolServers(config: McpConfig, cache: MetadataCache | null, envOverride?: string[]): string[];
-export declare function reconstructToolMetadata(serverName: string, entry: ServerCacheEntry, prefix: ToolPrefix, definition: Pick<ServerEntry, "exposeResources" | "includeTools" | "excludeTools" | "toolPrefix">): ToolMetadata[];
+export declare function reconstructToolMetadata(serverName: string, entry: ServerCacheEntry, prefix: ToolPrefix, definition: Pick<ServerEntry, "exposeResources" | "includeTools" | "excludeTools" | "toolPrefix" | "disabled">): ToolMetadata[];
 export declare function serializeTools(tools: McpTool[]): CachedTool[];
 export declare function serializeResources(resources: McpResource[]): CachedResource[];
 export declare function serializePrompts(prompts: McpPrompt[]): CachedPrompt[];