@fitchmultz/pi-mcp-adapter 5.0.0 → 7.0.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/state.d.ts

@@ -33,7 +33,7 @@ export interface McpExtensionState {
     manager: McpServerManager;
     lifecycle: McpLifecycleManager;
     toolMetadata: Map<string, ToolMetadata[]>;
-    /** Resource counts retained separately because tool metadata includes resource tools. */
+    /** Native resource counts, separate from callable tools. */
     resourceCounts: Map<string, number>;
     promptMetadata: Map<string, PromptMetadata[]>;
     /** Servers whose prompt inventory came from successful live discovery. */

package/dist/tool-loader.d.ts

@@ -0,0 +1,32 @@
+import type { AgentToolResult, ExtensionAPI, ExtensionContext, ToolDefinition } from "@earendil-works/pi-coding-agent";
+import { type TSchema } from "typebox";
+import { type MetadataCache } from "./metadata-cache.ts";
+import type { McpExtensionState } from "./state.ts";
+import { type DirectToolSpec, type McpAdapterOptions, type McpConfig, type ToolMetadata } from "./types.ts";
+type Reference = {
+    name: string;
+    namespace?: string;
+};
+type SearchDefinition<TParams extends TSchema, TDetails> = Omit<ToolDefinition<TParams, TDetails>, "execute"> & {
+    execute: (...args: Parameters<ToolDefinition<TParams, TDetails>["execute"]>) => Promise<AgentToolResult<TDetails> & {
+        tools: Reference[];
+    }>;
+};
+export type SearchAPI = ExtensionAPI & {
+    registerToolSearch?: <TParams extends TSchema, TDetails>(definition: SearchDefinition<TParams, TDetails>) => void;
+    getActiveToolReferences?: () => Reference[];
+    setActiveToolReferences?: (tools: Reference[]) => void;
+};
+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;
+    restore: (ctx: ExtensionContext) => void;
+    sync: (config: McpConfig, cache: MetadataCache | null, env?: string[] | null, asyncSupported?: boolean, registerGateways?: (pins: DirectToolSpec[]) => void) => DirectToolSpec[];
+    activate: (matches: Array<{
+        server: string;
+        tool: ToolMetadata;
+    }>) => Reference[];
+    persist: () => void;
+    selectedServers: () => string[];
+};
+export {};

package/dist/tool-loader.js

@@ -0,0 +1,152 @@
+import { Type } from "typebox";
+import { createDirectToolExecutor, directToolSelection } from "./direct-tools.js";
+import { isServerCacheValid, reconstructToolMetadata } from "./metadata-cache.js";
+import { createMcpDirectToolCallRenderer, renderMcpToolResult } from "./tool-result-renderer.js";
+import { isServerDisabled } from "./types.js";
+import { normalizeDirectToolInputSchema } from "./utils.js";
+import { isToolCallApprovalRequired } from "./tool-approval.js";
+const ENTRY = "mcp-tool-selection";
+const key = (value) => JSON.stringify([value.server, value.tool]);
+const refKey = (value) => JSON.stringify([value.namespace ?? null, value.name]);
+const reserved = new Set(["read", "bash", "powershell", "edit", "write", "grep", "find", "ls", "mcp", "mcp_search", "mcp_script"]);
+export function supportsNativeAsync(ctx) {
+    const compat = ctx.model?.compat;
+    return "getPendingToolCalls" in ctx && typeof ctx.getPendingToolCalls === "function"
+        && !!compat && "supportsAsyncTools" in compat && compat.supportsAsyncTools === true;
+}
+export function createToolLoader(pi, getState, getInitPromise, beforeExecute) {
+    const native = typeof pi.registerToolSearch === "function"
+        && typeof pi.getActiveToolReferences === "function"
+        && typeof pi.setActiveToolReferences === "function";
+    pi.registerEntryRenderer(ENTRY, () => undefined);
+    const registered = new Map();
+    let available = new Set();
+    let selected = new Map();
+    let inactive = new Map();
+    let restoring = true;
+    const active = () => native ? pi.getActiveToolReferences() : pi.getActiveTools().map(name => ({ name }));
+    const setActive = (refs) => {
+        const unique = [...new Map(refs.map(ref => [refKey(ref), ref])).values()];
+        if (JSON.stringify(active()) === JSON.stringify(unique))
+            return;
+        if (native)
+            pi.setActiveToolReferences(unique);
+        else
+            pi.setActiveTools(unique.map(ref => ref.name));
+    };
+    function capture() {
+        const current = new Set(active().map(refKey));
+        for (const [id, { selection, ref, pinned }] of registered) {
+            if (!available.has(id))
+                continue;
+            if (current.has(refKey(ref))) {
+                if (!pinned)
+                    selected.set(id, selection);
+                inactive.delete(id);
+            }
+            else {
+                selected.delete(id);
+                if (pinned)
+                    inactive.set(id, selection);
+            }
+        }
+    }
+    function persist() {
+        capture();
+        pi.appendEntry(ENTRY, { selected: [...selected.values()], inactive: [...inactive.values()] });
+    }
+    function restore(ctx) {
+        selected = new Map();
+        inactive = new Map();
+        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;
+            for (const [field, target] of [[data.selected, selected], [data.inactive, inactive]]) {
+                target.clear();
+                for (const selection of Array.isArray(field) ? field : []) {
+                    if (typeof selection?.server === "string" && typeof selection.tool === "string")
+                        target.set(key(selection), selection);
+                }
+            }
+        }
+        restoring = true;
+    }
+    function sync(config, cache, env, asyncSupported = false, registerGateways) {
+        if (!restoring)
+            capture();
+        const previousRefs = new Set([...registered.values()].map(item => refKey(item.ref)));
+        const existing = new Set(pi.getAllTools().map(tool => refKey(tool)));
+        const specs = [];
+        for (const [server, definition] of Object.entries(env === null ? {} : config.mcpServers)) {
+            if (isServerDisabled(definition))
+                continue;
+            const entry = cache?.servers[server];
+            const metadata = getState()?.toolMetadata.get(server) ?? (entry && isServerCacheValid(entry, definition)
+                ? reconstructToolMetadata(server, entry, config.settings?.toolPrefix ?? "server", definition) : []);
+            const selection = directToolSelection(config, server, env ?? undefined);
+            for (const { name: prefixedName, ...tool } of metadata) {
+                if (tool.resourceUri)
+                    continue;
+                const pinned = selection === true || (Array.isArray(selection) && selection.includes(tool.originalName));
+                const ref = native && !pinned ? { namespace: `mcp_${server}`, name: tool.originalName } : { name: prefixedName };
+                specs.push({ spec: { ...tool, prefixedName, serverName: server }, selection: { server, tool: tool.originalName }, ref, pinned });
+            }
+        }
+        const counts = new Map();
+        for (const { ref } of specs)
+            counts.set(refKey(ref), (counts.get(refKey(ref)) ?? 0) + 1);
+        available = new Set();
+        const enabled = [];
+        for (const { spec, selection, ref, pinned } of specs) {
+            const id = key(selection);
+            const refId = refKey(ref);
+            if ((!ref.namespace && reserved.has(ref.name)) || counts.get(refId) > 1 || (existing.has(refId) && !previousRefs.has(refId)))
+                continue;
+            available.add(id);
+            const asyncTool = asyncSupported && !beforeExecute && !spec.uiResourceUri && !isToolCallApprovalRequired(config, spec.serverName, spec);
+            const fingerprint = JSON.stringify({ spec, ref, asyncTool });
+            if (registered.get(id)?.fingerprint !== fingerprint) {
+                pi.registerTool({
+                    ...ref,
+                    ...(asyncTool ? { async: true } : {}),
+                    ...(beforeExecute ? { executionMode: "sequential" } : {}),
+                    label: spec.title ?? `MCP: ${spec.originalName}`,
+                    description: spec.description || "(no description)",
+                    parameters: Type.Unsafe(normalizeDirectToolInputSchema(spec.inputSchema)),
+                    execute: createDirectToolExecutor(getState, getInitPromise, spec, beforeExecute),
+                    renderCall: createMcpDirectToolCallRenderer(spec.prefixedName),
+                    renderResult: renderMcpToolResult,
+                });
+            }
+            registered.set(id, { selection, ref, fingerprint, pinned });
+            if (selected.has(id) || (pinned && !inactive.has(id)))
+                enabled.push(ref);
+        }
+        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);
+        // Official 0.87 reactivates allowlisted definitions on registration. Apply our loadout last.
+        const ownedRefs = new Set([...previousRefs, ...[...registered.values()].map(item => refKey(item.ref))]);
+        setActive([...active().filter(ref => !ownedRefs.has(refKey(ref))), ...enabled]);
+        restoring = false;
+        return pins;
+    }
+    function activate(matches) {
+        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 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;
+        });
+        persist();
+        return tools;
+    }
+    return { native, restore, sync, activate, persist, selectedServers: () => [...new Set([...selected.values()].map(item => item.server))] };
+}

package/dist/tool-metadata.d.ts

@@ -5,5 +5,72 @@ export declare function buildToolMetadata(tools: McpTool[], resources: McpResour
     failedTools: string[];
 };
 export declare function totalToolCount(state: McpExtensionState): number;
+export declare function toToolDescriptor(server: string, tool: ToolMetadata): {
+    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;
+    icons?: {
+        src: string;
+        mimeType?: string | undefined;
+        sizes?: string[] | undefined;
+        theme?: "dark" | "light" | undefined;
+    }[] | undefined;
+    title?: string | undefined;
+    inputSchema?: {
+        [x: string]: unknown;
+        type: "object";
+        properties?: {
+            [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;
+            } | 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;
+    };
+    description: string;
+    server: string;
+    path: string;
+    name: string;
+};
+export declare function catalogCoverage(state: McpExtensionState, server?: string): {
+    complete: boolean;
+    knownServers: string[];
+    unknownServers: string[];
+};
 export declare function findToolByName(metadata: ToolMetadata[] | undefined, toolName: string): ToolMetadata | undefined;
 export declare function formatSchema(schema: unknown, indent?: string): string;

package/dist/tool-metadata.js

@@ -1,12 +1,13 @@
 import { getToolUiResourceUri } from "@modelcontextprotocol/ext-apps/app-bridge";
-import { formatToolName, isToolAllowed, resolveToolPrefix } from "./types.js";
+import { formatToolName, isServerDisabled, isToolAllowed, resolveToolPrefix } from "./types.js";
 import { resourceNameToToolName } from "./resource-tools.js";
 import { extractToolUiStreamMode } from "./utils.js";
 import { extractUiToolVisibility, isUiToolVisibleToModel } from "./ui-tool-visibility.js";
 export function buildToolMetadata(tools, resources, definition, serverName, prefix) {
     const metadata = [];
     const failedTools = [];
-    const seenNames = new Set();
+    if (isServerDisabled(definition))
+        return { metadata, failedTools };
     const effectivePrefix = resolveToolPrefix(definition, prefix);
     for (const tool of tools) {
         if (!tool?.name) {
@@ -17,14 +18,10 @@ export function buildToolMetadata(tools, resources, definition, serverName, pref
             continue;
         }
         const name = formatToolName(tool.name, serverName, effectivePrefix);
-        if (seenNames.has(name)) {
-            continue;
-        }
         const uiVisibility = extractUiToolVisibility(tool._meta);
         if (!isUiToolVisibleToModel(uiVisibility)) {
             continue;
         }
-        seenNames.add(name);
         let uiResourceUri;
         try {
             uiResourceUri = getToolUiResourceUri({ _meta: tool._meta });
@@ -34,11 +31,10 @@ export function buildToolMetadata(tools, resources, definition, serverName, pref
         }
         const uiStreamMode = extractToolUiStreamMode(tool._meta);
         metadata.push({
+            ...tool,
             name,
             originalName: tool.name,
             description: tool.description ?? "",
-            ...(tool.inputSchema !== undefined ? { inputSchema: tool.inputSchema } : {}),
-            ...(tool.annotations !== undefined ? { annotations: tool.annotations } : {}),
             ...(uiResourceUri !== undefined ? { uiResourceUri } : {}),
             ...(uiVisibility !== undefined ? { uiVisibility } : {}),
             ...(uiStreamMode !== undefined ? { uiStreamMode } : {}),
@@ -46,20 +42,19 @@ export function buildToolMetadata(tools, resources, definition, serverName, pref
     }
     if (definition.exposeResources !== false) {
         for (const resource of 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,
+                resourceDescriptor: resource,
             });
         }
     }
@@ -68,18 +63,29 @@ export function buildToolMetadata(tools, resources, definition, serverName, pref
 export function totalToolCount(state) {
     let count = 0;
     for (const metadata of state.toolMetadata.values()) {
-        count += metadata.length;
+        count += metadata.filter(tool => tool.resourceUri === undefined).length;
     }
     return count;
 }
+export function toToolDescriptor(server, tool) {
+    const { name: path, originalName: name, resourceUri: _resourceUri, resourceDescriptor: _resourceDescriptor, uiResourceUri: _uiResourceUri, uiVisibility: _uiVisibility, uiStreamMode: _uiStreamMode, ...descriptor } = tool;
+    return { ...descriptor, server, path, name };
+}
+export function catalogCoverage(state, server) {
+    const servers = Object.keys(state.config.mcpServers).filter(name => (!server || name === server) && !isServerDisabled(state.config.mcpServers[name]));
+    const knownServers = servers.filter(name => state.toolMetadata.has(name));
+    const unknownServers = servers.filter(name => !state.toolMetadata.has(name));
+    return { complete: unknownServers.length === 0, knownServers, unknownServers };
+}
 export function findToolByName(metadata, toolName) {
     if (!metadata)
         return undefined;
-    const exact = metadata.find(m => m.name === toolName);
-    if (exact)
-        return exact;
+    const exact = metadata.filter(m => m.name === toolName);
+    if (exact.length > 0)
+        return exact.length === 1 ? exact[0] : undefined;
     const normalized = toolName.replace(/-/g, "_");
-    return metadata.find(m => m.name.replace(/-/g, "_") === normalized);
+    const matches = metadata.filter(m => m.name.replace(/-/g, "_") === normalized);
+    return matches.length === 1 ? matches[0] : undefined;
 }
 export function formatSchema(schema, indent = "  ") {
     if (!schema || typeof schema !== "object" || Array.isArray(schema)) {

package/dist/tool-registrar.d.ts

@@ -1,10 +1,10 @@
 import type { McpContent, ContentBlock } from "./types.ts";
+import { type McpPayloadFile } from "./mcp-output-guard.ts";
 /**
  * Transform MCP content types to Pi content blocks.
  */
 export declare function transformMcpContent(content: McpContent[]): ContentBlock[];
-/**
- * Resolve a tool result's content blocks, falling back to structuredContent
- * when content is empty.
- */
+/** Human content and structured content are complementary protocol fields. */
 export declare function resolveMcpResultContent(result: Record<string, unknown>): ContentBlock[];
+/** Persist content the model cannot consume; never imply an audio/blob payload was rendered. */
+export declare function renderMcpResultContent(result: Record<string, unknown>, payloadFiles?: McpPayloadFile[]): ContentBlock[];

package/dist/tool-registrar.js

@@ -1,6 +1,5 @@
-// tool-registrar.ts - MCP content transformation
-// NOTE: Tools are NOT registered with Pi - only the unified `mcp` proxy tool is registered.
-// This keeps the LLM context small (1 tool instead of 100s).
+// MCP protocol content to model-visible content.
+import { formatMcpPayloadFile } from "./mcp-output-guard.js";
 /**
  * Transform MCP content types to Pi content blocks.
  */
@@ -18,7 +17,7 @@ export function transformMcpContent(content) {
         }
         if (c.type === "resource") {
             const resourceUri = c.resource?.uri ?? "(no URI)";
-            const resourceContent = c.resource?.text ?? (c.resource ? JSON.stringify(c.resource) : "(no content)");
+            const resourceContent = c.resource?.text ?? (c.resource?.blob !== undefined ? "[Binary content; not rendered]" : "(no content)");
             return {
                 type: "text",
                 text: `[Resource: ${resourceUri}]\n${resourceContent}`,
@@ -35,24 +34,30 @@ export function transformMcpContent(content) {
         if (c.type === "audio") {
             return {
                 type: "text",
-                text: `[Audio content: ${c.mimeType ?? "audio/*"}]`,
+                text: `[Audio content: ${c.mimeType ?? "audio/*"}; not rendered]`,
             };
         }
         return { type: "text", text: JSON.stringify(c) };
     });
 }
-/**
- * Resolve a tool result's content blocks, falling back to structuredContent
- * when content is empty.
- */
+/** Human content and structured content are complementary protocol fields. */
 export function resolveMcpResultContent(result) {
     const blocks = transformMcpContent((Array.isArray(result.content) ? result.content : []));
-    if (blocks.length > 0)
-        return blocks;
     if (result.structuredContent !== undefined) {
-        return [{ type: "text", text: stringifyStructuredContent(result.structuredContent) }];
+        blocks.push({ type: "text", text: stringifyStructuredContent(result.structuredContent) });
     }
-    return [];
+    return blocks;
+}
+/** Persist content the model cannot consume; never imply an audio/blob payload was rendered. */
+export function renderMcpResultContent(result, payloadFiles = []) {
+    const content = Array.isArray(result.contents)
+        ? result.contents.map(resource => typeof resource.text === "string" ? { type: "text", text: resource.text } : { type: "resource", resource })
+        : Array.isArray(result.content) ? result.content : [];
+    const rendered = content.map((block, index) => {
+        const file = payloadFiles.find(file => file.index === index);
+        return file ? { type: "text", text: formatMcpPayloadFile(file) } : block;
+    });
+    return resolveMcpResultContent({ ...result, content: rendered });
 }
 function stringifyStructuredContent(value) {
     try {

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

@@ -10,6 +10,9 @@ export interface McpProxyToolCallInput {
     connect?: string;
     describe?: string;
     search?: string;
+    query?: string;
+    uri?: string;
+    ref?: string;
     includeSchemas?: boolean;
     server?: string;
     action?: string;
@@ -22,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;
@@ -79,8 +79,15 @@ function hasUsefulObjectContent(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value) && Object.keys(value).length > 0;
 }
 export function formatMcpProxyToolCallLines(args, maxInputChars = DEFAULT_MAX_CALL_INPUT_CHARS) {
-    if (args.action === "ui-messages")
+    if (args.action === "ui-messages" || args.action === "status")
         return [`mcp ${args.action}`];
+    if (args.action) {
+        const target = args.tool ?? args.query ?? args.uri ?? args.ref;
+        let line = `mcp ${args.action}${target ? ` ${target}` : ""}${args.server ? `${target ? " @" : ""} ${args.server}` : ""}`;
+        if (args.action === "search" && args.includeSchemas === false)
+            line += " (schemas hidden)";
+        return args.action === "call" && args.args ? [line, formatJsonish(args.args, maxInputChars)] : [line];
+    }
     if (args.tool) {
         const target = args.server ? `${args.tool} @ ${args.server}` : args.tool;
         const lines = [`mcp call ${target}`];
@@ -102,8 +109,6 @@ export function formatMcpProxyToolCallLines(args, maxInputChars = DEFAULT_MAX_CA
     }
     if (args.server)
         return [`mcp list ${args.server}`];
-    if (args.action)
-        return [`mcp ${args.action}`];
     return ["mcp status"];
 }
 export function formatMcpDirectToolCallLines(displayName, args, maxInputChars = DEFAULT_MAX_CALL_INPUT_CHARS) {