@fitchmultz/pi-mcp-adapter 5.0.0

package/dist/tool-registrar.js

@@ -0,0 +1,64 @@
+// 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).
+/**
+ * Transform MCP content types to Pi content blocks.
+ */
+export function transformMcpContent(content) {
+    return content.map(c => {
+        if (c.type === "text") {
+            return { type: "text", text: c.text ?? "" };
+        }
+        if (c.type === "image") {
+            return {
+                type: "image",
+                data: c.data ?? "",
+                mimeType: c.mimeType ?? "image/png",
+            };
+        }
+        if (c.type === "resource") {
+            const resourceUri = c.resource?.uri ?? "(no URI)";
+            const resourceContent = c.resource?.text ?? (c.resource ? JSON.stringify(c.resource) : "(no content)");
+            return {
+                type: "text",
+                text: `[Resource: ${resourceUri}]\n${resourceContent}`,
+            };
+        }
+        if (c.type === "resource_link") {
+            const linkName = c.name ?? c.uri ?? "unknown";
+            const linkUri = c.uri ?? "(no URI)";
+            return {
+                type: "text",
+                text: `[Resource Link: ${linkName}]\nURI: ${linkUri}`,
+            };
+        }
+        if (c.type === "audio") {
+            return {
+                type: "text",
+                text: `[Audio content: ${c.mimeType ?? "audio/*"}]`,
+            };
+        }
+        return { type: "text", text: JSON.stringify(c) };
+    });
+}
+/**
+ * Resolve a tool result's content blocks, falling back to structuredContent
+ * when content is empty.
+ */
+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) }];
+    }
+    return [];
+}
+function stringifyStructuredContent(value) {
+    try {
+        return JSON.stringify(value, null, 2) ?? String(value);
+    }
+    catch {
+        return String(value);
+    }
+}

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

@@ -0,0 +1,45 @@
+import { type AgentToolResult, type Theme, type ToolRenderResultOptions } from "@earendil-works/pi-coding-agent";
+import { type Component, Text } from "@earendil-works/pi-tui";
+type McpToolResultDetails = Record<string, unknown> & {
+    error?: unknown;
+};
+type RenderTheme = Pick<Theme, "fg" | "bold">;
+export interface McpProxyToolCallInput {
+    tool?: string;
+    args?: string | object;
+    connect?: string;
+    describe?: string;
+    search?: string;
+    includeSchemas?: boolean;
+    server?: string;
+    action?: string;
+}
+interface McpToolRenderContext {
+    isError: boolean;
+}
+export interface McpToolResultDisplay {
+    lines: string[];
+    truncated: boolean;
+}
+declare class CollapsibleText implements Component {
+    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;
+}
+export declare function formatMcpProxyToolCallLines(args: McpProxyToolCallInput, maxInputChars?: number): string[];
+export declare function formatMcpDirectToolCallLines(displayName: string, args: Record<string, unknown>, maxInputChars?: number): string[];
+export declare function renderMcpProxyToolCall(args: McpProxyToolCallInput, theme?: RenderTheme): Text;
+export declare function createMcpDirectToolCallRenderer(displayName: string): (args: Record<string, unknown>, theme?: RenderTheme) => Text;
+export declare function formatMcpToolResultIdentity(details: McpToolResultDetails | undefined): string | null;
+export declare function formatMcpToolResultLines(result: Pick<AgentToolResult<McpToolResultDetails>, "content">, expanded: boolean, maxCollapsedLines?: number, maxCollapsedChars?: number): McpToolResultDisplay;
+export declare function renderMcpToolResult(result: AgentToolResult<unknown>, options: ToolRenderResultOptions, theme?: RenderTheme, context?: McpToolRenderContext): CollapsibleText | Text;
+export {};

package/dist/tool-result-renderer.js

@@ -0,0 +1,224 @@
+import { keyHint } from "@earendil-works/pi-coding-agent";
+import { Text } from "@earendil-works/pi-tui";
+const plainTheme = {
+    fg: (_name, text) => text,
+    bold: (text) => text,
+};
+const DEFAULT_MAX_CALL_INPUT_CHARS = 1500;
+const DEFAULT_MAX_COLLAPSED_LINES = 3;
+const DEFAULT_MAX_COLLAPSED_CHARS = 8000;
+const COLLAPSED_RENDER_CHAR_SLACK = 8;
+class CollapsibleText {
+    text;
+    expanded;
+    maxCollapsedLines;
+    ellipsis;
+    expandHint;
+    preTruncated;
+    fullText;
+    footerText;
+    collapsedText = null;
+    constructor(text, expanded, maxCollapsedLines, ellipsis, expandHint, preTruncated = false) {
+        this.text = text;
+        this.expanded = expanded;
+        this.maxCollapsedLines = maxCollapsedLines;
+        this.ellipsis = ellipsis;
+        this.expandHint = expandHint;
+        this.preTruncated = preTruncated;
+        this.fullText = new Text(text, 0, 0);
+        this.footerText = new Text(`${ellipsis}\n${expandHint}`, 0, 0);
+    }
+    render(width) {
+        if (this.expanded) {
+            return this.fullText.render(width);
+        }
+        const safeWidth = Math.max(1, Math.floor(width));
+        const charBudget = safeWidth * (this.maxCollapsedLines + 1) * COLLAPSED_RENDER_CHAR_SLACK;
+        if (!this.collapsedText || this.collapsedText.charBudget !== charBudget) {
+            const prefix = this.text.length > charBudget
+                ? this.text.slice(0, charBudget)
+                : this.text;
+            this.collapsedText = {
+                charBudget,
+                fullyIncluded: prefix === this.text,
+                text: new Text(prefix, 0, 0),
+            };
+        }
+        const lines = this.collapsedText.text.render(width);
+        if (!this.preTruncated && this.collapsedText.fullyIncluded && lines.length <= this.maxCollapsedLines)
+            return lines;
+        return [
+            ...lines.slice(0, this.maxCollapsedLines),
+            ...this.footerText.render(width),
+        ];
+    }
+    invalidate() { }
+}
+function truncateText(value, maxChars) {
+    if (value.length <= maxChars)
+        return value;
+    return `${value.slice(0, Math.max(0, maxChars - 1))}…`;
+}
+function formatJsonish(value, maxChars) {
+    if (typeof value === "string") {
+        try {
+            return truncateText(JSON.stringify(JSON.parse(value), null, 2), maxChars);
+        }
+        catch {
+            return truncateText(value, maxChars);
+        }
+    }
+    try {
+        return truncateText(JSON.stringify(value, null, 2), maxChars);
+    }
+    catch {
+        return truncateText(String(value), maxChars);
+    }
+}
+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")
+        return [`mcp ${args.action}`];
+    if (args.tool) {
+        const target = args.server ? `${args.tool} @ ${args.server}` : args.tool;
+        const lines = [`mcp call ${target}`];
+        if (args.args)
+            lines.push(formatJsonish(args.args, maxInputChars));
+        return lines;
+    }
+    if (args.connect)
+        return [`mcp connect ${args.connect}`];
+    if (args.describe)
+        return [`mcp describe ${args.describe}`];
+    if (args.search) {
+        let line = `mcp search ${args.search}`;
+        if (args.server)
+            line += ` @ ${args.server}`;
+        if (args.includeSchemas === false)
+            line += " (schemas hidden)";
+        return [line];
+    }
+    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) {
+    if (!hasUsefulObjectContent(args))
+        return [displayName];
+    return [displayName, formatJsonish(args, maxInputChars)];
+}
+function renderToolCallLines(lines, theme) {
+    const activeTheme = theme ?? plainTheme;
+    const [title = "mcp", ...rest] = lines;
+    const styledTitle = activeTheme.fg("toolTitle", activeTheme.bold(title));
+    const styledRest = rest.map(line => activeTheme.fg("muted", line));
+    return new Text([styledTitle, ...styledRest].join("\n"), 0, 0);
+}
+export function renderMcpProxyToolCall(args, theme) {
+    return renderToolCallLines(formatMcpProxyToolCallLines(args), theme);
+}
+export function createMcpDirectToolCallRenderer(displayName) {
+    return (args, theme) => {
+        return renderToolCallLines(formatMcpDirectToolCallLines(displayName, args), theme);
+    };
+}
+function blockToLines(block) {
+    if (block.type === "text") {
+        return block.text.split("\n");
+    }
+    return [`[image: ${block.mimeType}]`];
+}
+function collectCollapsedResultLines(content, maxLines, maxChars) {
+    if (content.length === 0)
+        return { lines: ["(empty result)"], truncated: false };
+    const lines = [];
+    let remainingChars = maxChars;
+    let truncated = false;
+    const appendLine = (line) => {
+        if (lines.length >= maxLines || remainingChars <= 0) {
+            truncated = true;
+            return false;
+        }
+        if (line.length > remainingChars) {
+            lines.push(line.slice(0, remainingChars));
+            truncated = true;
+            remainingChars = 0;
+            return false;
+        }
+        lines.push(line);
+        remainingChars -= line.length + 1;
+        return true;
+    };
+    for (const block of content) {
+        if (block.type !== "text") {
+            if (!appendLine(`[image: ${block.mimeType}]`))
+                break;
+            continue;
+        }
+        let start = 0;
+        while (start <= block.text.length) {
+            const newline = block.text.indexOf("\n", start);
+            const line = newline === -1 ? block.text.slice(start) : block.text.slice(start, newline);
+            if (!appendLine(line))
+                break;
+            if (newline === -1)
+                break;
+            start = newline + 1;
+        }
+        if (truncated)
+            break;
+    }
+    if (lines.length === 0)
+        lines.push("");
+    if (truncated && lines.length >= maxLines)
+        lines.push("…");
+    return { lines, truncated };
+}
+export function formatMcpToolResultIdentity(details) {
+    if (details?.mode !== "call")
+        return null;
+    const server = typeof details.server === "string"
+        ? details.server
+        : typeof details.hintServer === "string"
+            ? details.hintServer
+            : null;
+    if (!server)
+        return null;
+    if (typeof details.tool === "string")
+        return `MCP ${server}/${details.tool}`;
+    if (typeof details.resourceUri === "string")
+        return `MCP ${server} resource ${details.resourceUri}`;
+    if (typeof details.requestedTool === "string")
+        return `MCP ${server}/${details.requestedTool}`;
+    return null;
+}
+export function formatMcpToolResultLines(result, expanded, maxCollapsedLines = 3, maxCollapsedChars = DEFAULT_MAX_COLLAPSED_CHARS) {
+    if (!expanded) {
+        return collectCollapsedResultLines(result.content, maxCollapsedLines, maxCollapsedChars);
+    }
+    const allLines = result.content.flatMap(blockToLines);
+    const lines = allLines.length > 0 ? allLines : ["(empty result)"];
+    return { lines, truncated: false };
+}
+export function renderMcpToolResult(result, options, theme, context) {
+    const activeTheme = theme ?? plainTheme;
+    if (options.isPartial) {
+        return new Text(activeTheme.fg("warning", "Running MCP tool..."), 0, 0);
+    }
+    const details = typeof result.details === "object" && result.details !== null
+        ? result.details
+        : {};
+    const hasErrorDetails = Boolean(details.error);
+    const expanded = options.expanded || context?.isError === true || hasErrorDetails;
+    const display = formatMcpToolResultLines(result, expanded);
+    const identity = formatMcpToolResultIdentity(details);
+    const output = [
+        ...(identity ? [activeTheme.fg("muted", identity)] : []),
+        ...display.lines.map((line) => activeTheme.fg("toolOutput", line)),
+    ].join("\n");
+    return new CollapsibleText(output, expanded, DEFAULT_MAX_COLLAPSED_LINES + (identity ? 1 : 0), activeTheme.fg("muted", "…"), activeTheme.fg("muted", `(${keyHint("app.tools.expand", "to expand")})`), display.truncated);
+}

package/dist/ts-shape.d.ts

@@ -0,0 +1,2 @@
+/** Renders the useful JSON Schema subset as TypeScript, or null for unsupported schemas. */
+export declare function renderTsShape(inputSchema: unknown): string | null;

package/dist/ts-shape.js

@@ -0,0 +1,147 @@
+const UNSUPPORTED_KEYWORDS = ["if", "then", "else", "allOf", "not", "patternProperties", "additionalProperties"];
+/** Renders the useful JSON Schema subset as TypeScript, or null for unsupported schemas. */
+export function renderTsShape(inputSchema) {
+    try {
+        if (!isSchema(inputSchema))
+            return null;
+        const definitions = new Map();
+        for (const key of ["$defs", "definitions"]) {
+            const rawDefinitions = inputSchema[key];
+            if (rawDefinitions === undefined)
+                continue;
+            if (!isSchema(rawDefinitions))
+                return null;
+            for (const [name, definition] of Object.entries(rawDefinitions)) {
+                if (!isSchema(definition))
+                    return null;
+                definitions.set(`${key}/${decodePointerToken(name)}`, definition);
+            }
+        }
+        const aliases = new Map();
+        const usedAliases = new Set();
+        let aliasIndex = 0;
+        const aliasFor = (definitionKey) => {
+            let alias = aliases.get(definitionKey);
+            if (alias)
+                return alias;
+            const name = definitionKey.slice(definitionKey.indexOf("/") + 1);
+            alias = /^[A-Za-z_$][\w$]*$/.test(name) && !usedAliases.has(name) ? name : `Definition${++aliasIndex}`;
+            while (usedAliases.has(alias))
+                alias = `Definition${++aliasIndex}`;
+            aliases.set(definitionKey, alias);
+            usedAliases.add(alias);
+            return alias;
+        };
+        const render = (schema) => {
+            if (!isSchema(schema) || hasUnsupportedKeyword(schema))
+                return null;
+            if ("$ref" in schema) {
+                if (typeof schema.$ref !== "string")
+                    return null;
+                const match = schema.$ref.match(/^#\/(\$defs|definitions)\/([^/]+)$/);
+                if (!match)
+                    return null;
+                const definitionGroup = match[1];
+                const definitionName = match[2];
+                if (definitionGroup === undefined || definitionName === undefined)
+                    return null;
+                const definitionKey = `${definitionGroup}/${decodePointerToken(definitionName)}`;
+                if (!definitions.has(definitionKey))
+                    return null;
+                return aliasFor(definitionKey);
+            }
+            if (Array.isArray(schema.enum)) {
+                const values = schema.enum.map(renderLiteral);
+                return values.every((value) => value !== null) ? values.join(" | ") : null;
+            }
+            if (Object.hasOwn(schema, "const"))
+                return renderLiteral(schema.const);
+            if (Array.isArray(schema.anyOf) || Array.isArray(schema.oneOf)) {
+                const variants = (schema.anyOf ?? schema.oneOf);
+                if (variants.length === 0)
+                    return null;
+                const rendered = variants.map(render);
+                return rendered.every((value) => value !== null) ? rendered.join(" | ") : null;
+            }
+            if (schema.type === "object" || schema.properties !== undefined) {
+                if (schema.properties === undefined)
+                    return "{}";
+                if (!isSchema(schema.properties))
+                    return null;
+                const required = new Set(Array.isArray(schema.required)
+                    ? schema.required.filter((name) => typeof name === "string")
+                    : []);
+                const properties = [];
+                for (const [name, property] of Object.entries(schema.properties)) {
+                    const rendered = render(property);
+                    if (rendered === null)
+                        return null;
+                    properties.push(`${formatPropertyName(name)}${required.has(name) ? "" : "?"}: ${rendered};`);
+                }
+                return properties.length === 0 ? "{}" : `{ ${properties.join(" ")} }`;
+            }
+            if (schema.type === "array") {
+                if (schema.items === undefined)
+                    return "unknown[]";
+                const item = render(schema.items);
+                return item === null ? null : `${needsParentheses(item) ? `(${item})` : item}[]`;
+            }
+            if (Array.isArray(schema.type)) {
+                const types = schema.type.map(renderType);
+                return types.every((type) => type !== null) ? types.join(" | ") : null;
+            }
+            if (typeof schema.type === "string")
+                return renderType(schema.type);
+            return "unknown";
+        };
+        const root = render(inputSchema);
+        if (root === null)
+            return null;
+        const definitionsText = [];
+        for (const [key, alias] of aliases) {
+            const definition = definitions.get(key);
+            if (!definition)
+                return null;
+            const rendered = render(definition);
+            if (rendered === null)
+                return null;
+            definitionsText.push(`type ${alias} = ${rendered};`);
+        }
+        return definitionsText.length > 0 ? `${definitionsText.join("\n")}\n\n${root}` : root;
+    }
+    catch {
+        return null;
+    }
+}
+function isSchema(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasUnsupportedKeyword(schema) {
+    return UNSUPPORTED_KEYWORDS.some(keyword => Object.hasOwn(schema, keyword));
+}
+function decodePointerToken(token) {
+    return token.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+function renderType(type) {
+    switch (type) {
+        case "string": return "string";
+        case "number":
+        case "integer": return "number";
+        case "boolean": return "boolean";
+        case "null": return "null";
+        case "object": return "{}";
+        case "array": return "unknown[]";
+        default: return null;
+    }
+}
+function renderLiteral(value) {
+    if (value === null || typeof value === "string" || typeof value === "boolean")
+        return JSON.stringify(value);
+    return typeof value === "number" && Number.isFinite(value) ? String(value) : null;
+}
+function formatPropertyName(name) {
+    return /^[A-Za-z_$][\w$]*$/.test(name) ? name : JSON.stringify(name);
+}
+function needsParentheses(type) {
+    return type.includes(" | ");
+}