min-agent 0.3.0 → 0.4.0

package/dist/markdown.js

@@ -52,7 +52,15 @@ export class MarkdownRenderer {
                 break;
             const line = this.buffer.slice(0, nlIdx);
             this.buffer = this.buffer.slice(nlIdx + 1);
-            // Table handling: collect rows, render when table ends
+            if (this.inCodeBlock || line.startsWith("```")) {
+                if (this.inTable) {
+                    output += this.renderTable(c);
+                    this.tableRows = [];
+                    this.inTable = false;
+                }
+                output += this.formatLine(line, c) + "\n";
+                continue;
+            }
             if (this.isTableRow(line)) {
                 if (this.isTableSeparator(line)) {
                     this.inTable = true;
@@ -127,29 +135,47 @@ export class MarkdownRenderer {
         return /^\s*\|[\s:]*-+[\s:|-]*\|\s*$/.test(line);
     }
     parseTableRow(line) {
-        return line.trim().slice(1, -1).split("|").map((cell) => cell.trim());
+        return line
+            .trim()
+            .slice(1, -1)
+            .split("|")
+            .map((cell) => cell.trim());
     }
     /** Pad string to target display width */
+    clipToWidth(str, targetWidth) {
+        let width = 0;
+        let out = "";
+        for (const ch of str) {
+            const w = displayWidth(ch);
+            if (width + w > targetWidth)
+                break;
+            out += ch;
+            width += w;
+        }
+        return out;
+    }
     padToWidth(str, targetWidth) {
-        const currentWidth = displayWidth(str);
-        const padding = targetWidth - currentWidth;
-        return padding > 0 ? str + " ".repeat(padding) : str;
+        const clipped = this.clipToWidth(str, targetWidth);
+        const padding = targetWidth - displayWidth(clipped);
+        return padding > 0 ? clipped + " ".repeat(padding) : clipped;
     }
     renderTable(c) {
         if (this.tableRows.length === 0)
             return "";
-        // Calculate column widths based on display width (CJK-aware)
-        const colCount = Math.max(...this.tableRows.map((r) => r.length));
+        const colCount = Math.max(0, ...this.tableRows.map((r) => r.length));
+        if (colCount === 0)
+            return "";
         const widths = Array(colCount).fill(0);
+        const maxCol = 64;
         for (const row of this.tableRows) {
             for (let i = 0; i < row.length; i++) {
-                widths[i] = Math.max(widths[i], displayWidth(row[i] ?? ""));
+                widths[i] = Math.min(maxCol, Math.max(widths[i], displayWidth(row[i] ?? "")));
             }
         }
         const lines = [];
-        const top = `${c.dim}┌${widths.map((w) => "─".repeat(w + 2)).join("┬")}┐${c.reset}`;
-        const mid = `${c.dim}├${widths.map((w) => "─".repeat(w + 2)).join("┼")}┤${c.reset}`;
-        const bot = `${c.dim}└${widths.map((w) => "─".repeat(w + 2)).join("┴")}┘${c.reset}`;
+        const top = `${c.dim}┌${widths.map((w) => "─".repeat(Math.max(0, w + 2))).join("┬")}┐${c.reset}`;
+        const mid = `${c.dim}├${widths.map((w) => "─".repeat(Math.max(0, w + 2))).join("┼")}┤${c.reset}`;
+        const bot = `${c.dim}└${widths.map((w) => "─".repeat(Math.max(0, w + 2))).join("┴")}┘${c.reset}`;
         lines.push(top);
         for (let r = 0; r < this.tableRows.length; r++) {
             const row = this.tableRows[r];

package/dist/mcp.js

@@ -32,6 +32,10 @@ function truncateStructured(value) {
     }
     return value;
 }
+const MAX_LISTED_RESOURCES = 200;
+const MAX_LISTED_TEMPLATES = 100;
+const MAX_LISTED_PROMPTS = 100;
+const MAX_RESOURCE_BLOB_CHARS = 2048;
 const DEFAULT_TIMEOUT = 30000;
 const STDERD_KEEP_LINES = 20;
 const OAUTH_BROWSER_TIMEOUT_MS = 5 * 60 * 1000;
@@ -48,6 +52,7 @@ let connectedServers = {};
 const mcpServerErrors = {};
 /** Cache of built tool wrappers; invalidated when MCP servers (re)connect. */
 let mcpToolsCache = null;
+let mcpReadOnlyToolIds = new Set();
 const configCaches = new Map();
 function loadJsonConfig(filePath) {
     const cache = configCaches.get(filePath);
@@ -151,13 +156,100 @@ async function listAllTools(client) {
     } while (cursor);
     return all;
 }
-async function openStdioMcpServer(name, config, onTransport) {
+async function pageAll(fetchPage, cap) {
+    const all = [];
+    let cursor;
+    do {
+        const page = await fetchPage(cursor);
+        all.push(...page.items);
+        cursor = page.nextCursor;
+        if (all.length >= cap)
+            return all.slice(0, cap);
+    } while (cursor);
+    return all;
+}
+export async function discoverMcpExtras(client) {
+    const caps = client.getServerCapabilities();
+    let resources = [];
+    let resourceTemplates = [];
+    let prompts = [];
+    if (caps?.resources) {
+        try {
+            resources = await pageAll(async (cursor) => {
+                const result = await client.listResources(cursor ? { cursor } : undefined);
+                return {
+                    items: result.resources.map((r) => ({
+                        uri: r.uri,
+                        name: r.name,
+                        ...(r.description ? { description: r.description } : {}),
+                        ...(r.mimeType ? { mimeType: r.mimeType } : {}),
+                    })),
+                    nextCursor: result.nextCursor,
+                };
+            }, MAX_LISTED_RESOURCES);
+        }
+        catch {
+            resources = [];
+        }
+        try {
+            resourceTemplates = await pageAll(async (cursor) => {
+                const result = await client.listResourceTemplates(cursor ? { cursor } : undefined);
+                return {
+                    items: result.resourceTemplates.map((t) => ({
+                        uriTemplate: t.uriTemplate,
+                        name: t.name,
+                        ...(t.description ? { description: t.description } : {}),
+                        ...(t.mimeType ? { mimeType: t.mimeType } : {}),
+                    })),
+                    nextCursor: result.nextCursor,
+                };
+            }, MAX_LISTED_TEMPLATES);
+        }
+        catch {
+            resourceTemplates = [];
+        }
+    }
+    if (caps?.prompts) {
+        try {
+            prompts = await pageAll(async (cursor) => {
+                const result = await client.listPrompts(cursor ? { cursor } : undefined);
+                return {
+                    items: result.prompts.map((p) => ({
+                        name: p.name,
+                        ...(p.description ? { description: p.description } : {}),
+                        ...(p.arguments && p.arguments.length > 0 ? { arguments: p.arguments } : {}),
+                    })),
+                    nextCursor: result.nextCursor,
+                };
+            }, MAX_LISTED_PROMPTS);
+        }
+        catch {
+            prompts = [];
+        }
+    }
+    return { resources, resourceTemplates, prompts };
+}
+async function connectedFromClient(client, transport, config, extra = {}) {
+    const tools = await listAllTools(client);
+    const extras = await discoverMcpExtras(client);
+    return {
+        client,
+        transport,
+        tools,
+        ...extras,
+        callTimeout: resolveMcpTimeouts(config).callTimeout,
+        signature: configSignature(config),
+        ...extra,
+    };
+}
+async function openStdioMcpServer(name, config, hooks) {
     // Support both formats:
     // { command: ["uvx", "mcp-server-time"] }           — min-agent native
     // { command: "uvx", args: ["mcp-server-time"] }     — opencode/claude style
     let cmd;
     let args;
     if (Array.isArray(config.command)) {
+        ;
         [cmd, ...args] = config.command;
     }
     else if (typeof config.command === "string") {
@@ -179,16 +271,17 @@ async function openStdioMcpServer(name, config, onTransport) {
     });
     // Drain the child's stderr so a chatty server can never block on a full pipe buffer.
     transport.stderr?.pipe(stderrSink.stream);
-    onTransport?.(transport);
+    hooks?.onTransport?.(transport);
     const client = new Client({ name: "min-agent", version: "0.1.0" });
     try {
         await client.connect(transport);
-        const tools = await listAllTools(client);
-        return { client, transport, tools, callTimeout: resolveMcpTimeouts(config).callTimeout, signature: configSignature(config), stderrSink };
+        return await connectedFromClient(client, transport, config, { stderrSink });
     }
     catch (err) {
         await transport.close().catch(() => { });
-        const tail = stderrSink.lines.length ? `\nServer stderr (last ${stderrSink.lines.length} lines):\n${stderrSink.lines.map((l) => `  ${l}`).join("\n")}` : "";
+        const tail = stderrSink.lines.length
+            ? `\nServer stderr (last ${stderrSink.lines.length} lines):\n${stderrSink.lines.map((l) => `  ${l}`).join("\n")}`
+            : "";
         throw new Error(`${err?.message ?? String(err)}${tail}`);
     }
 }
@@ -407,7 +500,7 @@ async function runOAuthFlow(name, config, baseUrl) {
         throw new Error(`MCP "${name}" OAuth failed: ${err?.message ?? String(err)}`);
     }
 }
-async function openRemoteMcpServer(name, config, onTransport) {
+async function openRemoteMcpServer(name, config, hooks) {
     const rawUrl = config.url?.trim();
     if (!rawUrl) {
         throw new Error(`MCP "${name}" has empty url`);
@@ -425,15 +518,17 @@ async function openRemoteMcpServer(name, config, onTransport) {
     const requestInit = buildRemoteRequestInit(config);
     const mode = config.remoteTransport ?? "auto";
     const oauthProvider = await runOAuthFlow(name, config, baseUrl);
-    const callTimeout = resolveMcpTimeouts(config).callTimeout;
+    // Expose the provider so an outer timeout can dispose it; on success the
+    // ConnectedServer takes ownership (closeConnectedServer closes it).
+    if (oauthProvider)
+        hooks?.onOAuthProvider?.(oauthProvider);
     const connectStreamable = async () => {
         const client = new Client({ name: "min-agent", version: "0.1.0" });
         const transport = new StreamableHTTPClientTransport(baseUrl, requestInit || oauthProvider ? { requestInit, authProvider: oauthProvider } : undefined);
-        onTransport?.(transport);
+        hooks?.onTransport?.(transport);
         try {
             await client.connect(transport);
-            const tools = await listAllTools(client);
-            return { client, transport, tools, callTimeout, signature: configSignature(config), oauthProvider };
+            return await connectedFromClient(client, transport, config, { oauthProvider });
         }
         catch (err) {
             await transport.close().catch(() => { });
@@ -443,11 +538,10 @@ async function openRemoteMcpServer(name, config, onTransport) {
     const connectSse = async () => {
         const client = new Client({ name: "min-agent", version: "0.1.0" });
         const transport = new SSEClientTransport(baseUrl, requestInit || oauthProvider ? { requestInit, authProvider: oauthProvider } : undefined);
-        onTransport?.(transport);
+        hooks?.onTransport?.(transport);
         try {
             await client.connect(transport);
-            const tools = await listAllTools(client);
-            return { client, transport, tools, callTimeout, signature: configSignature(config), oauthProvider };
+            return await connectedFromClient(client, transport, config, { oauthProvider });
         }
         catch (err) {
             await transport.close().catch(() => { });
@@ -473,6 +567,9 @@ async function openRemoteMcpServer(name, config, onTransport) {
         }
     }
     catch (err) {
+        // The connection failed, so nobody else owns the provider — close its
+        // callback server instead of leaking the port.
+        oauthProvider?.close();
         const message = err instanceof Error ? err.message : String(err);
         // Handle OAuth/Unauthorized errors
         if (err instanceof UnauthorizedError || message.includes("Unauthorized") || message.includes("401")) {
@@ -485,11 +582,11 @@ async function openRemoteMcpServer(name, config, onTransport) {
         throw new Error(`MCP "${name}" remote connection failed: ${message}`);
     }
 }
-async function openMcpServer(name, config, onTransport) {
+async function openMcpServer(name, config, hooks) {
     if (isRemoteMcpConfig(config)) {
-        return await openRemoteMcpServer(name, config, onTransport);
+        return await openRemoteMcpServer(name, config, hooks);
     }
-    return await openStdioMcpServer(name, config, onTransport);
+    return await openStdioMcpServer(name, config, hooks);
 }
 /** One-line summary for CLI / logs (no secrets). */
 export function formatMcpServerBinding(config) {
@@ -497,18 +594,26 @@ export function formatMcpServerBinding(config) {
         const mode = config.remoteTransport ?? "auto";
         return `${config.url} [remote:${mode}]`;
     }
-    const cmd = Array.isArray(config.command) ? config.command.join(" ") : `${config.command ?? ""} ${(config.args ?? []).join(" ")}`.trim();
+    const cmd = Array.isArray(config.command)
+        ? config.command.join(" ")
+        : `${config.command ?? ""} ${(config.args ?? []).join(" ")}`.trim();
     return cmd || "(no command)";
 }
 async function openMcpServerWithTimeout(name, config) {
     const timeout = resolveMcpTimeouts(config).connectTimeout;
     let timer;
     const transportHolder = { transport: null };
+    const oauthHolder = { provider: null };
     const timeoutPromise = new Promise((_, reject) => {
         timer = setTimeout(() => reject(new Error(`connection timed out after ${timeout}ms`)), timeout);
     });
-    const connectPromise = openMcpServer(name, config, (t) => {
-        transportHolder.transport = t;
+    const connectPromise = openMcpServer(name, config, {
+        onTransport: (t) => {
+            transportHolder.transport = t;
+        },
+        onOAuthProvider: (p) => {
+            oauthHolder.provider = p;
+        },
     });
     connectPromise.catch(() => { });
     try {
@@ -517,6 +622,12 @@ async function openMcpServerWithTimeout(name, config) {
     }
     catch (error) {
         await transportHolder.transport?.close().catch(() => { });
+        oauthHolder.provider?.close();
+        // The abandoned connect may still resolve later (e.g. a slow OAuth login);
+        // dispose the result immediately so neither the client nor the OAuth
+        // callback server leaks. The registry is untouched: this server was never
+        // registered, and a newer connection may own the name by now.
+        void connectPromise.then((server) => disposeServerResources(server)).catch(() => { });
         return { error };
     }
     finally {
@@ -530,8 +641,8 @@ export async function connectMcpServer(name, config) {
     const { server, error } = await openMcpServerWithTimeout(name, config);
     if (server) {
         delete mcpServerErrors[name];
-        console.log(`\x1b[90m  MCP "${name}" connected (${server.tools.length} tools)\x1b[0m`);
-        log("info", `mcp "${name}" connected (${server.tools.length} tools)`);
+        console.log(`\x1b[90m  MCP "${name}" connected (${server.tools.length} tools, ${server.resources.length} resources, ${server.prompts.length} prompts)\x1b[0m`);
+        log("info", `mcp "${name}" connected (${server.tools.length} tools, ${server.resources.length} resources, ${server.prompts.length} prompts)`);
         return server;
     }
     const message = error?.message ?? String(error);
@@ -559,19 +670,26 @@ export async function checkMcpServer(name, config) {
         await server.client.close();
     }
     catch { }
+    server.oauthProvider?.close();
     return { name, enabled: true, ok: true, toolCount };
 }
 export async function checkAllMcpServers() {
     const entries = loadMcpConfigEntries();
     const settled = await Promise.allSettled(entries.map(({ name, config }) => checkMcpServer(name, config)));
-    return settled.map((r, i) => r.status === "fulfilled" ? r.value : { name: entries[i]?.name ?? "unknown", enabled: true, ok: false, toolCount: 0, error: String(r.reason) });
+    return settled.map((r, i) => r.status === "fulfilled"
+        ? r.value
+        : { name: entries[i]?.name ?? "unknown", enabled: true, ok: false, toolCount: 0, error: String(r.reason) });
 }
-async function closeConnectedServer(name, server) {
+/** Close client + OAuth provider without touching the connection registry. */
+async function disposeServerResources(server) {
     try {
         await server.client.close();
     }
     catch { }
     server.oauthProvider?.close();
+}
+async function closeConnectedServer(name, server) {
+    await disposeServerResources(server);
     delete connectedServers[name];
     delete mcpServerErrors[name];
 }
@@ -648,15 +766,20 @@ export async function initMcp() {
 export function getMcpTools() {
     if (mcpToolsCache)
         return mcpToolsCache;
-    mcpToolsCache = buildMcpToolsMap(connectedServers);
+    mcpReadOnlyToolIds = new Set();
+    mcpToolsCache = buildMcpToolsMap(connectedServers, mcpReadOnlyToolIds);
     return mcpToolsCache;
 }
+export function getMcpReadOnlyToolIds() {
+    getMcpTools();
+    return mcpReadOnlyToolIds;
+}
 /**
  * Build AI SDK tool wrappers for a set of connected MCP servers.
  * Tool IDs are collision-safe (suffixed when sanitized names clash) and
  * descriptions are prefixed with the owning server name.
  */
-export function buildMcpToolsMap(servers) {
+export function buildMcpToolsMap(servers, readOnlyIds) {
     const tools = {};
     const used = new Set();
     for (const [serverName, server] of Object.entries(servers)) {
@@ -673,15 +796,14 @@ export function buildMcpToolsMap(servers) {
                 ...(baseSchema.properties ? {} : { properties: {} }),
             };
             const readOnly = mcpTool.annotations?.readOnlyHint === true;
-            const description = `[${serverName}] ${mcpTool.description ?? `MCP tool: ${mcpTool.name}`}` +
-                (readOnly ? " (read-only)" : "");
+            if (readOnly)
+                readOnlyIds?.add(toolId);
+            const description = `[${serverName}] ${mcpTool.description ?? `MCP tool: ${mcpTool.name}`}` + (readOnly ? " (read-only)" : "");
             const outputSchema = mcpTool.outputSchema;
             tools[toolId] = tool({
                 description,
                 inputSchema: jsonSchema(schema),
-                ...(outputSchema && outputSchema.type === "object"
-                    ? { outputSchema: jsonSchema(outputSchema) }
-                    : {}),
+                ...(outputSchema && outputSchema.type === "object" ? { outputSchema: jsonSchema(outputSchema) } : {}),
                 execute: async (args, options) => {
                     try {
                         const signals = [AbortSignal.timeout(server.callTimeout)];
@@ -722,11 +844,187 @@ export function getMcpStatus() {
             connected: !!server,
             enabled: config.enabled !== false,
             tools: server?.tools.map((t) => t.name) ?? [],
+            resource_count: server?.resources.length ?? 0,
+            prompt_count: server?.prompts.length ?? 0,
             ...(mcpServerErrors[name] ? { error: mcpServerErrors[name] } : {}),
         };
     }
     return status;
 }
+export function listMcpCatalog(serverName) {
+    const names = serverName ? [serverName] : Object.keys(connectedServers);
+    return {
+        servers: names.flatMap((name) => {
+            const server = connectedServers[name];
+            if (!server)
+                return [];
+            return [{ name, resources: server.resources, templates: server.resourceTemplates, prompts: server.prompts }];
+        }),
+    };
+}
+function connectedNames() {
+    return Object.keys(connectedServers);
+}
+function resolveCatalogServer(serverName, kind) {
+    if (serverName) {
+        const server = connectedServers[serverName];
+        if (!server)
+            return `MCP server "${serverName}" is not connected. Connected: ${connectedNames().join(", ") || "none"}`;
+        return server;
+    }
+    const names = connectedNames();
+    if (names.length === 0)
+        return "No MCP servers connected.";
+    if (names.length === 1)
+        return connectedServers[names[0]];
+    return `Multiple MCP servers are connected (${names.join(", ")}). Pass server to choose which ${kind} to use.`;
+}
+export async function readMcpResource(uri, serverName) {
+    const resolved = resolveCatalogServer(serverName, "resource");
+    if (typeof resolved === "string")
+        return resolved;
+    try {
+        const result = await resolved.client.readResource({ uri }, { timeout: resolved.callTimeout });
+        return formatResourceContents(result.contents);
+    }
+    catch (err) {
+        return `Failed to read resource: ${err instanceof Error ? err.message : String(err)}`;
+    }
+}
+export async function getMcpPrompt(name, args, serverName) {
+    const resolved = resolveCatalogServer(serverName, "prompt");
+    if (typeof resolved === "string")
+        return resolved;
+    try {
+        const result = await resolved.client.getPrompt({ name, ...(args && Object.keys(args).length > 0 ? { arguments: args } : {}) }, { timeout: resolved.callTimeout });
+        return formatPromptResult(result);
+    }
+    catch (err) {
+        return `Failed to get prompt: ${err instanceof Error ? err.message : String(err)}`;
+    }
+}
+export function formatResourceContents(contents) {
+    if (contents.length === 0)
+        return "(empty resource)";
+    return contents
+        .map((part) => {
+        if (typeof part.text === "string")
+            return part.text;
+        if (typeof part.blob === "string") {
+            if (part.blob.length <= MAX_RESOURCE_BLOB_CHARS)
+                return part.blob;
+            return `[binary ${part.mimeType ?? "application/octet-stream"} ${part.blob.length} chars, omitted]`;
+        }
+        return JSON.stringify(part);
+    })
+        .join("\n\n");
+}
+export function formatPromptResult(result) {
+    const header = result.description ? `${result.description}\n\n` : "";
+    const body = result.messages
+        .map((m) => {
+        const content = m.content;
+        if (content &&
+            typeof content === "object" &&
+            "type" in content &&
+            content.type === "text" &&
+            "text" in content) {
+            return `${m.role}: ${String(content.text)}`;
+        }
+        return `${m.role}: ${JSON.stringify(content)}`;
+    })
+        .join("\n");
+    return header + body;
+}
+export function getMcpCatalogTools() {
+    if (Object.keys(connectedServers).length === 0)
+        return {};
+    const listResources = tool({
+        description: "List MCP resources and resource URI templates from connected servers. Use this before mcp_read_resource. Optional server name limits the listing to one server.",
+        inputSchema: jsonSchema({
+            type: "object",
+            properties: {
+                server: { type: "string", description: "MCP server name. Omit to list every connected server." },
+            },
+        }),
+        execute: async ({ server }) => {
+            const catalog = listMcpCatalog(server);
+            if (catalog.servers.length === 0) {
+                return server ? `MCP server "${server}" is not connected.` : "No MCP servers connected.";
+            }
+            const lines = catalog.servers.flatMap((s) => {
+                const res = s.resources.map((r) => `  resource ${r.uri}  ${r.name}${r.description ? ` — ${r.description}` : ""}`);
+                const templates = s.templates.map((t) => `  template ${t.uriTemplate}  ${t.name}${t.description ? ` — ${t.description}` : ""}`);
+                if (res.length === 0 && templates.length === 0)
+                    return [`[${s.name}] (no resources)`];
+                return [`[${s.name}]`, ...res, ...templates];
+            });
+            return truncateToolOutput(lines.join("\n"), { direction: "head" }).content;
+        },
+    });
+    const readResource = tool({
+        description: "Read an MCP resource by URI. Use mcp_list_resources first. Pass server when more than one MCP server is connected.",
+        inputSchema: jsonSchema({
+            type: "object",
+            properties: {
+                uri: { type: "string", description: "Resource URI from mcp_list_resources" },
+                server: { type: "string", description: "MCP server name when multiple servers are connected" },
+            },
+            required: ["uri"],
+        }),
+        execute: async ({ uri, server }) => truncateToolOutput(await readMcpResource(uri, server), { direction: "head" }).content,
+    });
+    const listPrompts = tool({
+        description: "List MCP prompt templates from connected servers. Use this before mcp_get_prompt. Optional server name limits the listing to one server.",
+        inputSchema: jsonSchema({
+            type: "object",
+            properties: {
+                server: { type: "string", description: "MCP server name. Omit to list every connected server." },
+            },
+        }),
+        execute: async ({ server }) => {
+            const catalog = listMcpCatalog(server);
+            if (catalog.servers.length === 0) {
+                return server ? `MCP server "${server}" is not connected.` : "No MCP servers connected.";
+            }
+            const lines = catalog.servers.flatMap((s) => {
+                if (s.prompts.length === 0)
+                    return [`[${s.name}] (no prompts)`];
+                return [
+                    `[${s.name}]`,
+                    ...s.prompts.map((p) => {
+                        const args = p.arguments?.map((a) => `${a.name}${a.required ? "*" : ""}`).join(", ");
+                        return `  ${p.name}${args ? `(${args})` : ""}${p.description ? ` — ${p.description}` : ""}`;
+                    }),
+                ];
+            });
+            return truncateToolOutput(lines.join("\n"), { direction: "head" }).content;
+        },
+    });
+    const getPrompt = tool({
+        description: "Fill an MCP prompt template. Use mcp_list_prompts first. Pass server when more than one MCP server is connected.",
+        inputSchema: jsonSchema({
+            type: "object",
+            properties: {
+                name: { type: "string", description: "Prompt name from mcp_list_prompts" },
+                server: { type: "string", description: "MCP server name when multiple servers are connected" },
+                arguments: {
+                    type: "object",
+                    additionalProperties: { type: "string" },
+                    description: "Prompt arguments as string values",
+                },
+            },
+            required: ["name"],
+        }),
+        execute: async ({ name, server, arguments: promptArgs }) => truncateToolOutput(await getMcpPrompt(name, promptArgs, server), { direction: "head" }).content,
+    });
+    return {
+        mcp_list_resources: listResources,
+        mcp_read_resource: readResource,
+        mcp_list_prompts: listPrompts,
+        mcp_get_prompt: getPrompt,
+    };
+}
 function sanitize(s) {
     return s.replace(/[^a-zA-Z0-9_-]/g, "_");
 }