@nexrall/code-core 1.4.66 → 1.4.67

package/dist/mcp/manager.js

@@ -41,17 +41,40 @@ const client_1 = require("./client");
 const httpClient_1 = require("./httpClient");
 const sseClient_1 = require("./sseClient");
 const index_1 = require("../plugins/index");
+const stats_1 = require("./stats");
 // ─── McpManager ───────────────────────────────────────────────────────────────
 class McpManager {
     constructor() {
         this._clients = new Map();
         // Map: prefixed tool name → server name
         this._toolMap = new Map();
+        // Prompt metadata per server, fetched on first use (the `/` menu, `/mcp prompts`
+        // and positional→named argument mapping all read it). Cleared whenever the
+        // client is dropped, so a reconnect never serves a dead session's list.
+        this._promptCache = new Map();
         // Config + last connection error per server (for status UI, incl. failures)
         this._configs = new Map();
         this._errors = new Map();
         // Servers that returned 401 → need OAuth. Value = WWW-Authenticate challenge header.
         this._needsAuth = new Map();
+        // Names the user has switched off. Kept per-manager (not just in the file) so a
+        // toggle takes effect in THIS session, not at the next start.
+        this._disabled = new Set();
+        /** Per-tool call counts and timings — the "is it slow or broken?" answer (spec §42). */
+        this.stats = new stats_1.ToolStats();
+        // The human-facing elicitation handler (set by the host that owns a UI). Null means
+        // "nobody can be asked" — transports then auto-decline, so a server never hangs.
+        this._elicitationHandler = null;
+    }
+    /**
+     * Route every server's elicitation (`elicitation/create`) through this handler —
+     * including servers that connect later, which is why it is also re-applied in
+     * connectAll/enable. Pass null to restore auto-decline.
+     */
+    setElicitationHandler(handler) {
+        this._elicitationHandler = handler;
+        for (const client of this._clients.values())
+            client.setElicitationHandler(handler);
     }
     /** Pick the transport for a server config: stdio (command), Streamable HTTP, or legacy SSE. */
     static makeClient(name, cfg) {
@@ -73,24 +96,38 @@ class McpManager {
             path.join(os.homedir(), '.nexrall', 'mcp.json'),
             path.join(workDir, '.nexrall', 'mcp.json'),
         ];
+        // A list, so the two scopes UNION rather than override: switching a server off in
+        // the project must add to whatever the user file already silences.
+        const disabled = new Set();
         for (const loc of locations) {
             try {
                 const raw = fs.readFileSync(loc, 'utf-8');
                 const cfg = JSON.parse(raw);
                 Object.assign(merged.mcpServers, cfg.mcpServers ?? {});
+                for (const name of cfg.disabledServers ?? [])
+                    disabled.add(name);
             }
             catch {
                 // File doesn't exist or invalid JSON — skip
             }
         }
+        if (disabled.size)
+            merged.disabledServers = [...disabled].sort();
         return merged;
     }
     /** Connect to all configured servers. Errors per-server are logged, not thrown. */
     async connectAll(config) {
+        this._disabled = new Set(config.disabledServers ?? []);
         const entries = Object.entries(config.mcpServers);
         await Promise.all(entries.map(async ([name, serverCfg]) => {
             this._configs.set(name, serverCfg);
+            // Switched off by the user: remember it (so /mcp can list it) and do not spawn.
+            if (this._disabled.has(name)) {
+                this._errors.delete(name);
+                return;
+            }
             const client = McpManager.makeClient(name, serverCfg);
+            client.setElicitationHandler(this._elicitationHandler);
             try {
                 await client.connect();
                 this._clients.set(name, client);
@@ -161,7 +198,14 @@ class McpManager {
         // Enforce a timeout — a hung MCP server would otherwise block the agent loop forever.
         const MCP_TOOL_TIMEOUT_MS = 60000;
         const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error(`MCP tool "${prefixedName}" timed out after ${MCP_TOOL_TIMEOUT_MS / 1000}s`)), MCP_TOOL_TIMEOUT_MS));
-        const racers = [client.callTool(toolName, input), timeoutPromise];
+        // Timing covers the whole path the user waits on (server round-trip AND the
+        // race against the 60s timeout / abort), which is what "how long did that take"
+        // means from the outside. The tool name recorded is the PREFIXED one, so the
+        // stats of two servers with a same-named tool never merge.
+        const startedAt = Date.now();
+        this.stats.begin();
+        const timed = (p) => p.then((v) => { this.stats.ok(prefixedName, Date.now() - startedAt); return v; }, (e) => { this.stats.fail(prefixedName, Date.now() - startedAt, e.message || String(e)); throw e; });
+        const racers = [timed(client.callTool(toolName, input)), timed(timeoutPromise)];
         if (abortSignal) {
             let pollId;
             const abortPromise = new Promise((_, reject) => {
@@ -172,7 +216,7 @@ class McpManager {
                     }
                 }, 100);
             });
-            racers.push(abortPromise);
+            racers.push(timed(abortPromise));
             // Clearing the poll on whichever branch wins avoids leaving a live interval
             // (and the closure it holds) running for the rest of the process lifetime —
             // the same leak-prevention pattern client.ts uses for its own abort poll.
@@ -180,6 +224,97 @@ class McpManager {
         }
         return Promise.race(racers);
     }
+    /** Resources across connected, enabled servers. One server failing never hides the others. */
+    async listResources(server) {
+        const out = [];
+        for (const [name, client] of this._clients) {
+            if (server && name !== server)
+                continue;
+            for (const r of await client.listResources())
+                out.push({ ...r, server: name });
+        }
+        return out;
+    }
+    /** Read one resource. Throws a clear error for an unknown server; bounded by the tool timeout. */
+    async readResource(server, uri) {
+        const client = this._clients.get(server);
+        if (!client)
+            throw new Error(`No connected MCP server named "${server}". Connected: ${[...this._clients.keys()].join(', ') || '(none)'}`);
+        let timer;
+        const timeout = new Promise((_, rej) => { timer = setTimeout(() => rej(new Error(`Reading ${uri} timed out after 60s`)), 60000); });
+        try {
+            return await Promise.race([client.readResource(uri), timeout]);
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+        }
+    }
+    /**
+     * Prompt metadata for one connected server. Fetched once per connection and
+     * cached — including an empty list (server has no prompts capability), so the
+     * `/` menu does not re-ask a server on every keystroke; reconnecting clears
+     * the entry. Returns [] for a server that is not connected.
+     */
+    async promptsFor(server) {
+        const cached = this._promptCache.get(server);
+        if (cached)
+            return cached;
+        const client = this._clients.get(server);
+        if (!client)
+            return [];
+        const list = await client.listPrompts();
+        this._promptCache.set(server, list);
+        return list;
+    }
+    /** Prompts across connected, enabled servers, tagged with the server they came from. */
+    async listPrompts(server) {
+        const out = [];
+        for (const name of this._clients.keys()) {
+            if (server && name !== server)
+                continue;
+            for (const p of await this.promptsFor(name))
+                out.push({ ...p, server: name });
+        }
+        return out;
+    }
+    /**
+     * Expand one prompt to text. Positional values map, in order, onto the
+     * arguments the server declared in prompts/list — the same positional form
+     * Claude Code accepts (`/mcp__server__prompt first second`). Validation runs
+     * here, before the request, so mistakes read as sentences instead of raw
+     * JSON-RPC errors; the request itself is bounded by the same 60s timeout the
+     * resource reader uses.
+     */
+    async getPrompt(server, name, values = []) {
+        const client = this._clients.get(server);
+        if (!client)
+            throw new Error(`No connected MCP server named "${server}". Connected: ${[...this._clients.keys()].join(', ') || '(none)'}`);
+        const list = await this.promptsFor(server);
+        const meta = list.find((p) => p.name === name);
+        if (!meta) {
+            throw new Error(`No MCP prompt named "${name}" on server "${server}"${list.length ? ` (it offers: ${list.map((p) => p.name).join(', ')})` : ''}.`);
+        }
+        const declared = meta.arguments ?? [];
+        if (values.length > declared.length) {
+            throw new Error(`MCP prompt "${server}:${name}" takes ${declared.length} argument(s)${declared.length ? ` (${declared.map((a) => a.name).join(', ')})` : ''} — got ${values.length}.`);
+        }
+        const args = {};
+        declared.forEach((a, i) => { const v = values[i]; if (v !== undefined && v !== '')
+            args[a.name] = v; });
+        const missing = declared.filter((a) => a.required && args[a.name] === undefined);
+        if (missing.length)
+            throw new Error(`MCP prompt "${server}:${name}" is missing required argument(s): ${missing.map((a) => a.name).join(', ')}.`);
+        let timer;
+        const timeout = new Promise((_, rej) => { timer = setTimeout(() => rej(new Error(`MCP prompt ${server}:${name} timed out after 60s`)), 60000); });
+        try {
+            return await Promise.race([client.getPrompt(name, args), timeout]);
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+        }
+    }
     /** True if this tool name belongs to an MCP server. */
     isMcpTool(name) {
         return this._toolMap.has(name);
@@ -195,23 +330,103 @@ class McpManager {
             return cfg.type;
         return cfg?.url && !cfg?.command ? 'http' : 'stdio';
     }
-    /** Returns per-server status for UI display, including failed / auth-required connections. */
+    /** Returns per-server status for UI display, including failed / auth-required / disabled. */
     getStatus() {
         const out = [];
         for (const [name, client] of this._clients) {
-            out.push({ name, transport: McpManager.transportOf(this._configs.get(name)), tools: client.tools, connected: true });
+            out.push({ name, transport: McpManager.transportOf(this._configs.get(name)), tools: client.tools, connected: true, disabled: false });
         }
-        for (const [name, error] of this._errors) {
+        for (const name of this._configs.keys()) {
             if (this._clients.has(name))
                 continue;
-            out.push({ name, transport: McpManager.transportOf(this._configs.get(name)), tools: [], connected: false, error, needsAuth: this._needsAuth.has(name) });
+            const disabled = this._disabled.has(name);
+            const error = this._errors.get(name);
+            // A disabled server that never connected has no error to report — say nothing
+            // rather than repeat "disconnected" as if it were a failure.
+            if (disabled && !error) {
+                out.push({ name, transport: McpManager.transportOf(this._configs.get(name)), tools: [], connected: false, disabled: true });
+                continue;
+            }
+            out.push({
+                name, transport: McpManager.transportOf(this._configs.get(name)), tools: [],
+                connected: false, disabled, error, needsAuth: this._needsAuth.has(name),
+            });
         }
-        return out;
+        return out.sort((a, b) => a.name.localeCompare(b.name));
     }
     /** The WWW-Authenticate challenge a server returned on 401 (empty if none/unknown). */
     authChallenge(name) {
         return this._needsAuth.get(name) ?? '';
     }
+    /** True when the user has switched this server off for the session. */
+    isDisabled(name) {
+        return this._disabled.has(name);
+    }
+    /**
+     * Switch a server off in THIS session: drop its client and forget its tool map, so
+     * the next turn's tool list no longer offers it. The caller persists the choice
+     * (McpManager.setServerDisabled) — this method deliberately does not touch disk.
+     */
+    disable(name) {
+        const existed = this._configs.has(name);
+        this._disabled.add(name);
+        this._dropClient(name);
+        return existed;
+    }
+    /**
+     * Switch a server back on and connect it, without a restart. Resolves to an error
+     * message when the connection fails, so the caller can print it and leave the
+     * server listed as broken instead of silently reporting success.
+     */
+    async enable(name) {
+        this._disabled.delete(name);
+        const cfg = this._configs.get(name);
+        if (!cfg)
+            return `no server named "${name}" is configured`;
+        this._dropClient(name);
+        const client = McpManager.makeClient(name, cfg);
+        client.setElicitationHandler(this._elicitationHandler);
+        try {
+            await client.connect();
+        }
+        catch (err) {
+            const msg = err.message;
+            if (err instanceof httpClient_1.McpOAuthRequiredError)
+                this._needsAuth.set(name, err.wwwAuthenticate);
+            this._errors.set(name, msg);
+            return msg;
+        }
+        this._clients.set(name, client);
+        this._errors.delete(name);
+        this._needsAuth.delete(name);
+        for (const tool of client.tools)
+            this._toolMap.set(`${name}__${tool.name}`, name);
+        return null;
+    }
+    /** Disconnect one server for the session (its config stays; `enable` brings it back). */
+    disconnect(name) {
+        const had = this._clients.has(name) || this._errors.has(name);
+        this._dropClient(name);
+        this._errors.set(name, 'disconnected');
+        return had;
+    }
+    /** Forgets one server's client and tools, leaving its config and status alone. */
+    _dropClient(name) {
+        const client = this._clients.get(name);
+        if (client) {
+            try {
+                client.disconnect();
+            }
+            catch { /* best effort */ }
+        }
+        this._clients.delete(name);
+        for (const key of [...this._toolMap.keys()]) {
+            if (this._toolMap.get(key) === name)
+                this._toolMap.delete(key);
+        }
+        this._promptCache.delete(name);
+        this.stats.reset();
+    }
     // ─── Config file persistence (for the management UI) ──────────────────────────
     /** Path to an mcp.json for the given scope. */
     static configPath(workDir, scope) {
@@ -222,7 +437,11 @@ class McpManager {
     static readConfigFile(p) {
         try {
             const cfg = JSON.parse(fs.readFileSync(p, 'utf-8'));
-            return { mcpServers: cfg.mcpServers ?? {} };
+            // `disabledServers` has to survive the read: this is the object that gets written
+            // BACK by addServer/setServerDisabled/removeServer, and dropping the list here
+            // silently un-disabled every server but the one being toggled (found by a test
+            // that switched two off and watched the first reconnect).
+            return { mcpServers: cfg.mcpServers ?? {}, disabledServers: cfg.disabledServers };
         }
         catch {
             return { mcpServers: {} };
@@ -239,17 +458,62 @@ class McpManager {
         cfg.mcpServers[name] = server;
         McpManager.writeConfigFile(p, cfg);
     }
+    /**
+     * Switch a server off/on in the config FILE, so the choice survives a restart.
+     * Written to the project scope even when the server came from elsewhere (a plugin
+     * or the user file), because the project is the only scope this session is sure it
+     * may edit — and `disabledServers` is a name list, so it works for all three.
+     * Returns the file that was written.
+     */
+    static setServerDisabled(workDir, name, disabled, scope = 'project') {
+        const p = McpManager.configPath(workDir, scope);
+        const cfg = McpManager.readConfigFile(p);
+        const current = new Set(cfg.disabledServers ?? []);
+        if (disabled)
+            current.add(name);
+        else
+            current.delete(name);
+        cfg.disabledServers = [...current].sort();
+        if (cfg.disabledServers.length === 0)
+            delete cfg.disabledServers;
+        McpManager.writeConfigFile(p, cfg);
+        return p;
+    }
+    /** Where a server's definition comes from, for messages that have to be honest about it. */
+    static serverScope(workDir, name) {
+        const project = McpManager.readConfigFile(McpManager.configPath(workDir, 'project'));
+        if (project.mcpServers[name])
+            return 'project';
+        const user = McpManager.readConfigFile(McpManager.configPath(workDir, 'user'));
+        if (user.mcpServers[name])
+            return 'user';
+        try {
+            if ((0, index_1.pluginMcpServers)(workDir)[name])
+                return 'plugin';
+        }
+        catch { /* plugin scan is best-effort */ }
+        return 'none';
+    }
     /** Remove a server from whichever scope(s) define it. Returns true if anything was removed. */
     static removeServer(workDir, name) {
         let removed = false;
         for (const scope of ['project', 'user']) {
             const p = McpManager.configPath(workDir, scope);
             const cfg = McpManager.readConfigFile(p);
+            let touched = false;
             if (cfg.mcpServers[name]) {
                 delete cfg.mcpServers[name];
-                McpManager.writeConfigFile(p, cfg);
+                touched = true;
                 removed = true;
             }
+            if (cfg.disabledServers?.includes(name)) {
+                cfg.disabledServers = cfg.disabledServers.filter((n) => n !== name);
+                if (cfg.disabledServers.length === 0)
+                    delete cfg.disabledServers;
+                touched = true;
+            }
+            if (touched)
+                McpManager.writeConfigFile(p, cfg);
         }
         return removed;
     }
@@ -261,6 +525,8 @@ class McpManager {
         this._configs.clear();
         this._errors.clear();
         this._needsAuth.clear();
+        this._disabled.clear();
+        this.stats.reset();
     }
 }
 exports.McpManager = McpManager;

package/dist/mcp/sseClient.d.ts

@@ -1,4 +1,4 @@
-import type { McpServerConfig, McpToolDefinition, McpTransport } from './client';
+import type { McpServerConfig, McpToolDefinition, McpTransport, McpResource, McpPrompt, McpElicitationHandler } from './client';
 export declare class McpSseClient implements McpTransport {
     private readonly config;
     private _nextId;
@@ -9,10 +9,16 @@ export declare class McpSseClient implements McpTransport {
     private _closed;
     private readonly _pending;
     private _endpointWaiter;
+    private _elicitationHandler;
     readonly name: string;
     constructor(name: string, config: McpServerConfig);
     get tools(): McpToolDefinition[];
+    setElicitationHandler(handler: McpElicitationHandler | null): void;
     connect(): Promise<void>;
+    listResources(): Promise<McpResource[]>;
+    readResource(uri: string): Promise<string>;
+    listPrompts(): Promise<McpPrompt[]>;
+    getPrompt(name: string, args: Record<string, string>): Promise<string>;
     callTool(name: string, args: Record<string, unknown>): Promise<string>;
     disconnect(): void;
     /** Open the GET event stream and wait for the server's `endpoint` event. */

package/dist/mcp/sseClient.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sseClient.d.ts","sourceRoot":"","sources":["../../src/mcp/sseClient.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AA6BjF,qBAAa,YAAa,YAAW,YAAY;IAWrB,OAAO,CAAC,QAAQ,CAAC,MAAM;IAVjD,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,MAAM,CAA2B;IACzC,OAAO,CAAC,YAAY,CAAuB;IAC3C,OAAO,CAAC,MAAM,CAAgC;IAC9C,OAAO,CAAC,OAAO,CAAM;IACrB,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA0H;IACnJ,OAAO,CAAC,eAAe,CAAoE;IAC3F,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;gBAEV,IAAI,EAAE,MAAM,EAAmB,MAAM,EAAE,eAAe;IAIlE,IAAI,KAAK,IAAI,iBAAiB,EAAE,CAE/B;IAEK,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAaxB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;IAc5E,UAAU,IAAI,IAAI;IAalB,4EAA4E;YAC9D,WAAW;IAoCzB,OAAO,CAAC,eAAe;IAYvB,oFAAoF;IACpF,OAAO,CAAC,KAAK;IAWb,OAAO,CAAC,mBAAmB;IAQ3B,OAAO,CAAC,cAAc;IAuCtB,OAAO,CAAC,IAAI;YAgBE,OAAO;IAIrB,6EAA6E;YAC/D,YAAY;CAwB3B"}
+{"version":3,"file":"sseClient.d.ts","sourceRoot":"","sources":["../../src/mcp/sseClient.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,iBAAiB,EAAE,YAAY,EAAE,WAAW,EAAE,SAAS,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAC;AA6BhI,qBAAa,YAAa,YAAW,YAAY;IAYrB,OAAO,CAAC,QAAQ,CAAC,MAAM;IAXjD,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,MAAM,CAA2B;IACzC,OAAO,CAAC,YAAY,CAAuB;IAC3C,OAAO,CAAC,MAAM,CAAgC;IAC9C,OAAO,CAAC,OAAO,CAAM;IACrB,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA0H;IACnJ,OAAO,CAAC,eAAe,CAAoE;IAC3F,OAAO,CAAC,mBAAmB,CAAsC;IACjE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;gBAEV,IAAI,EAAE,MAAM,EAAmB,MAAM,EAAE,eAAe;IAIlE,IAAI,KAAK,IAAI,iBAAiB,EAAE,CAE/B;IAED,qBAAqB,CAAC,OAAO,EAAE,qBAAqB,GAAG,IAAI,GAAG,IAAI;IAE5D,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAaxB,aAAa,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC;IAOvC,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAI1C,WAAW,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC;IAOnC,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;IAMtE,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;IAc5E,UAAU,IAAI,IAAI;IAalB,4EAA4E;YAC9D,WAAW;IAoCzB,OAAO,CAAC,eAAe;IAYvB,oFAAoF;IACpF,OAAO,CAAC,KAAK;IAWb,OAAO,CAAC,mBAAmB;IAQ3B,OAAO,CAAC,cAAc;IAqDtB,OAAO,CAAC,IAAI;YAgBE,OAAO;IAIrB,6EAA6E;YAC/D,YAAY;CAwB3B"}

package/dist/mcp/sseClient.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.McpSseClient = void 0;
 const node_fetch_1 = __importDefault(require("node-fetch"));
+const client_1 = require("./client");
 const httpClient_1 = require("./httpClient");
 const REQUEST_TIMEOUT_MS = 30000;
 const ENDPOINT_TIMEOUT_MS = 15000;
@@ -19,24 +20,53 @@ class McpSseClient {
         this._closed = false;
         this._pending = new Map();
         this._endpointWaiter = null;
+        this._elicitationHandler = null;
         this.name = name;
     }
     get tools() {
         return this._tools;
     }
+    setElicitationHandler(handler) { this._elicitationHandler = handler; }
     async connect() {
         if (!this.config.url)
             throw new Error(`MCP server "${this.name}" has no url (sse transport requires one).`);
         await this._openStream();
         await this._rpc('initialize', {
             protocolVersion: '2024-11-05',
-            capabilities: {},
+            capabilities: (0, client_1.elicitationCapability)(this.config.bareElicitationCapability),
             clientInfo: { name: 'nexrall-code', version: '1.0' },
         });
         await this._notify('notifications/initialized');
         const res = (await this._rpc('tools/list', {}));
         this._tools = res?.tools ?? [];
     }
+    async listResources() {
+        try {
+            const res = (await this._rpc('resources/list', {}));
+            return Array.isArray(res?.resources) ? res.resources : [];
+        }
+        catch {
+            return []; /* server has no resources capability */
+        }
+    }
+    async readResource(uri) {
+        return (0, client_1.flattenResourceContents)(await this._rpc('resources/read', { uri }));
+    }
+    async listPrompts() {
+        try {
+            const res = (await this._rpc('prompts/list', {}));
+            return Array.isArray(res?.prompts) ? res.prompts : [];
+        }
+        catch {
+            return []; /* server has no prompts capability */
+        }
+    }
+    async getPrompt(name, args) {
+        const params = { name };
+        if (Object.keys(args).length)
+            params.arguments = args;
+        return (0, client_1.flattenPromptMessages)(await this._rpc('prompts/get', params));
+    }
     async callTool(name, args) {
         const result = (await this._rpc('tools/call', { name, arguments: args }));
         if (!result)
@@ -159,6 +189,19 @@ class McpSseClient {
         catch {
             return; // non-JSON frame
         }
+        // A server→client REQUEST (elicitation) — answer it over the POST channel.
+        // Checked first: server request ids are their own namespace and could collide
+        // with one of ours.
+        if (typeof msg.method === 'string' && msg.id != null) {
+            const method = msg.method;
+            const params = msg.params;
+            const reqId = msg.id;
+            void (async () => {
+                const reply = await (0, client_1.serverRequestReply)(this.name, this._elicitationHandler, method, params);
+                await this._postMessage({ jsonrpc: '2.0', id: reqId, ...reply });
+            })().catch(() => { });
+            return;
+        }
         if (typeof msg.id === 'number' && this._pending.has(msg.id)) {
             const { resolve, reject, timer } = this._pending.get(msg.id);
             clearTimeout(timer);
@@ -167,6 +210,7 @@ class McpSseClient {
                 reject(new Error(`MCP error ${msg.error.code}: ${msg.error.message}`));
             else
                 resolve(msg.result ?? null);
+            return;
         }
         // Server-initiated notifications (no matching id) are ignored.
     }

package/dist/mcp/stats.d.ts

@@ -0,0 +1,41 @@
+export interface ToolStat {
+    calls: number;
+    failures: number;
+    /** Total wall time across every call, for an average that ignores the outlier size. */
+    totalMs: number;
+    /** The most recent call's duration — what a user means by "how long does it take". */
+    lastMs: number;
+    lastError?: string;
+    /** Epoch ms of the last call, so a stale number can be recognised as stale. */
+    lastAt: number;
+}
+export interface ServerTotals {
+    calls: number;
+    failures: number;
+    /** Calls that neither succeeded nor failed — still in flight or abandoned. */
+    pending: number;
+}
+export declare class ToolStats {
+    private readonly _byTool;
+    private _pending;
+    /** A call has started. Pair with exactly one ok()/fail(). */
+    begin(): void;
+    ok(name: string, ms: number, now?: number): void;
+    fail(name: string, ms: number, error: string, now?: number): void;
+    /** Everything recorded for one tool, or undefined if it was never called. */
+    get(name: string): ToolStat | undefined;
+    /** Stats for every tool whose name starts with `<server>__`, keyed by the bare tool name. */
+    forServer(server: string, prefix?: string): Array<{
+        tool: string;
+        stat: ToolStat;
+    }>;
+    forServerTotals(server: string, prefix?: string): ServerTotals;
+    /** Forgets one tool's history — so a fixed server stops showing old failures. */
+    reset(name?: string): void;
+    private _entry;
+}
+/** "240ms" / "1.2s" — a latency reading, not a stopwatch. */
+export declare function formatMs(ms: number): string;
+/** One line per tool, or '' when the server was never called (nothing to say yet). */
+export declare function describeStats(stat: ToolStat | undefined, avg?: boolean): string;
+//# sourceMappingURL=stats.d.ts.map

package/dist/mcp/stats.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stats.d.ts","sourceRoot":"","sources":["../../src/mcp/stats.ts"],"names":[],"mappings":"AAYA,MAAM,WAAW,QAAQ;IACvB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,uFAAuF;IACvF,OAAO,EAAE,MAAM,CAAC;IAChB,sFAAsF;IACtF,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,+EAA+E;IAC/E,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,8EAA8E;IAC9E,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,qBAAa,SAAS;IACpB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA+B;IACvD,OAAO,CAAC,QAAQ,CAAK;IAErB,6DAA6D;IAC7D,KAAK,IAAI,IAAI;IAIb,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,GAAG,SAAa,GAAG,IAAI;IAUpD,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,SAAa,GAAG,IAAI;IAWrE,6EAA6E;IAC7E,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS;IAIvC,6FAA6F;IAC7F,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,SAAO,GAAG,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,QAAQ,CAAA;KAAE,CAAC;IAYjF,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,SAAO,GAAG,YAAY;IAS5D,iFAAiF;IACjF,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI;IAK1B,OAAO,CAAC,MAAM;CAKf;AAED,6DAA6D;AAC7D,wBAAgB,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAI3C;AAED,sFAAsF;AACtF,wBAAgB,aAAa,CAAC,IAAI,EAAE,QAAQ,GAAG,SAAS,EAAE,GAAG,UAAO,GAAG,MAAM,CAO5E"}

package/dist/mcp/stats.js

@@ -0,0 +1,108 @@
+"use strict";
+// Per-tool call statistics for MCP servers (spec §42 "Tool latency / failures").
+//
+// WHY: when an MCP tool call returns nothing useful, the user's only question is
+// "is this server slow, or broken?" — and the answer existed nowhere. The manager
+// saw every call (it is the only path a tool call can take) but kept no record, so
+// a flaky server looked exactly like a healthy one until it failed outright.
+//
+// Kept in its own file, and kept PURE (the caller measures the elapsed time), so the
+// bookkeeping is unit-testable without spawning an MCP server. Nothing here is a
+// promise about the future: the numbers are "since this session started", which is
+// exactly the window a user is reasoning about.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolStats = void 0;
+exports.formatMs = formatMs;
+exports.describeStats = describeStats;
+class ToolStats {
+    constructor() {
+        this._byTool = new Map();
+        this._pending = 0;
+    }
+    /** A call has started. Pair with exactly one ok()/fail(). */
+    begin() {
+        this._pending++;
+    }
+    ok(name, ms, now = Date.now()) {
+        this._pending = Math.max(0, this._pending - 1);
+        const s = this._entry(name);
+        s.calls++;
+        s.totalMs += Math.max(0, ms);
+        s.lastMs = Math.max(0, ms);
+        s.lastAt = now;
+        delete s.lastError;
+    }
+    fail(name, ms, error, now = Date.now()) {
+        this._pending = Math.max(0, this._pending - 1);
+        const s = this._entry(name);
+        s.calls++;
+        s.failures++;
+        s.totalMs += Math.max(0, ms);
+        s.lastMs = Math.max(0, ms);
+        s.lastError = error;
+        s.lastAt = now;
+    }
+    /** Everything recorded for one tool, or undefined if it was never called. */
+    get(name) {
+        return this._byTool.get(name);
+    }
+    /** Stats for every tool whose name starts with `<server>__`, keyed by the bare tool name. */
+    forServer(server, prefix = '__') {
+        const head = server + prefix;
+        const out = [];
+        for (const [name, stat] of this._byTool) {
+            if (!name.startsWith(head))
+                continue;
+            out.push({ tool: name.slice(head.length), stat });
+        }
+        // Slowest / most used first: that is the row a user is looking for.
+        out.sort((a, b) => b.stat.calls - a.stat.calls || a.tool.localeCompare(b.tool));
+        return out;
+    }
+    forServerTotals(server, prefix = '__') {
+        const rows = this.forServer(server, prefix);
+        return {
+            calls: rows.reduce((n, r) => n + r.stat.calls, 0),
+            failures: rows.reduce((n, r) => n + r.stat.failures, 0),
+            pending: this._pending,
+        };
+    }
+    /** Forgets one tool's history — so a fixed server stops showing old failures. */
+    reset(name) {
+        if (name === undefined) {
+            this._byTool.clear();
+            return;
+        }
+        this._byTool.delete(name);
+    }
+    _entry(name) {
+        let s = this._byTool.get(name);
+        if (!s) {
+            s = { calls: 0, failures: 0, totalMs: 0, lastMs: 0, lastAt: 0 };
+            this._byTool.set(name, s);
+        }
+        return s;
+    }
+}
+exports.ToolStats = ToolStats;
+/** "240ms" / "1.2s" — a latency reading, not a stopwatch. */
+function formatMs(ms) {
+    if (!Number.isFinite(ms) || ms < 0)
+        return '—';
+    if (ms < 1000)
+        return `${Math.round(ms)}ms`;
+    return `${(ms / 1000).toFixed(ms < 10000 ? 1 : 0)}s`;
+}
+/** One line per tool, or '' when the server was never called (nothing to say yet). */
+function describeStats(stat, avg = true) {
+    if (!stat || stat.calls === 0)
+        return '';
+    const parts = [`${stat.calls} call${stat.calls === 1 ? '' : 's'}`];
+    if (stat.failures)
+        parts.push(`${stat.failures} failed`);
+    parts.push(`${avg && stat.calls > 1 ? 'avg' : 'last'} ${formatMs(avg && stat.calls > 1 ? stat.totalMs / stat.calls : stat.lastMs)}`);
+    if (stat.lastError)
+        parts.push(stat.lastError.split('\n')[0].slice(0, 80));
+    return parts.join(' · ');
+}
+//# sourceMappingURL=stats.js.map