s-app-scoder-agent 0.8.20 → 0.9.2

package/dist/mcp.js

@@ -7,15 +7,30 @@
  * lại → stdio. Exposes discovered tools as `mcp__<server>__<tool>` prefixed
  * names in the agent's tool registry.
  */
-import { spawn } from "node:child_process";
+import { spawn, spawnSync } from "node:child_process";
 import { CLIENT_NAME, getVersion } from "./version.js";
 import { redactSecrets } from "./llm.js";
 export const MCP_TOOL_PREFIX = "mcp__";
 export function mcpToolKey(serverName, toolName) {
     return `${MCP_TOOL_PREFIX}${serverName}__${toolName}`;
 }
+/** Phase 4: generic MCP resource/prompt tools (advertised only when available). */
+export const MCP_RESOURCE_TOOL_NAMES = new Set([
+    "mcp_list_resources",
+    "mcp_read_resource",
+    "mcp_list_prompts",
+    "mcp_get_prompt",
+]);
+const schemaObj = (properties, required) => ({
+    type: "object",
+    properties,
+    required,
+    additionalProperties: false,
+});
+const strProp = (description) => ({ type: "string", description });
+const boolProp = (description) => ({ type: "boolean", description });
 /** Expand {env:VAR} references in config env values. */
-function expandEnv(env) {
+export function expandEnv(env) {
     const out = {};
     for (const [k, v] of Object.entries(env ?? {})) {
         out[k] = v.replace(/\{env:([A-Za-z_][A-Za-z0-9_]*)\}/g, (_, n) => process.env[n] ?? "");
@@ -74,12 +89,33 @@ export class StdioTransport {
         return Promise.resolve();
     }
     close() {
-        if (this.proc) {
-            try {
-                this.proc.kill();
-            }
-            catch { /* already dead */ }
-            this.proc = null;
+        const p = this.proc;
+        this.proc = null;
+        if (!p)
+            return;
+        // Release pipe handles so the parent process can exit immediately.
+        // On Windows shell:true (cmd.exe wrapper), p.kill() only kills cmd.exe —
+        // the real node child is orphaned and keeps stdout open. Use taskkill /T
+        // to kill the whole process tree; this also works for the plain node case.
+        try {
+            p.stdin?.end();
+        }
+        catch { /* ignore */ }
+        try {
+            p.stdout?.destroy();
+        }
+        catch { /* ignore */ }
+        try {
+            p.stderr?.destroy();
+        }
+        catch { /* ignore */ }
+        try {
+            p.kill();
+        }
+        catch { /* ignore */ }
+        if (process.platform === "win32" && p.pid) {
+            // Fire-and-forget; ignore errors — process may already be gone.
+            spawnSync("taskkill", ["/pid", String(p.pid), "/T", "/F"], { stdio: "ignore", windowsHide: true });
         }
     }
     onChunk(chunk) {
@@ -128,11 +164,11 @@ export class HttpTransport {
     async send(msg) {
         if (this.closed)
             throw new Error(`MCP HTTP transport "${this.cfg.url}" closed`);
-        const res = await this.post(msg, this.sessionId);
+        const res = await this.post(msg, this.sessionId, undefined);
         // Session expired (server restart) → thử lại một lần không session.
         if ((res.status === 404 || res.status === 400) && this.sessionId) {
             this.sessionId = null;
-            const retry = await this.post(msg, null);
+            const retry = await this.post(msg, null, undefined);
             return this.consume(retry);
         }
         return this.consume(res);
@@ -141,11 +177,13 @@ export class HttpTransport {
         this.closed = true;
         this.sessionId = null;
     }
-    async post(msg, sessionId) {
+    defaultTimeout() {
+        return this.cfg.timeoutMs ?? 120_000;
+    }
+    async post(msg, sessionId, signal) {
         const url = this.cfg.url;
         if (!url)
             throw new Error("MCP HTTP transport requires \"url\" in the server config");
-        // M3: headers hỗ trợ {env:VAR} substitution như env — không hardcode secrets.
         const headers = {
             "content-type": "application/json",
             accept: "application/json, text/event-stream",
@@ -154,11 +192,17 @@ export class HttpTransport {
         if (sessionId)
             headers["mcp-session-id"] = sessionId;
         try {
+            // Combine the caller's abort signal (MCP A cancellation) with an idle
+            // timeout into one AbortSignal. AbortSignal.any needs ≥1 real signal.
+            const signals = [AbortSignal.timeout(this.defaultTimeout())];
+            if (signal)
+                signals.push(signal);
+            const combined = signals.length > 1 ? AbortSignal.any(signals) : signals[0];
             return await fetch(url, {
                 method: "POST",
                 headers,
                 body: JSON.stringify(msg),
-                signal: AbortSignal.timeout(120_000),
+                signal: combined,
             });
         }
         catch (e) {
@@ -174,12 +218,7 @@ export class HttpTransport {
             throw new Error(`MCP HTTP ${res.status} ${res.statusText}`);
         }
         const ct = res.headers.get("content-type") ?? "";
-        if (ct.includes("text/event-stream")) {
-            const text = await res.text();
-            for (const m of parseSseMessages(text))
-                this.msgCb?.(m);
-        }
-        else if (ct.includes("application/json")) {
+        if (ct.includes("application/json")) {
             const body = (await res.text()).trim();
             if (body) {
                 try {
@@ -187,24 +226,76 @@ export class HttpTransport {
                 }
                 catch { /* skip malformed */ }
             }
-        } // 202/no-content (notifications) — nothing to parse
+            return;
+        }
+        if (ct.includes("text/event-stream")) {
+            // MCP A: incremental SSE — stream body, emit each JSON-RPC message as
+            // its `data:` event completes, instead of buffering the entire response.
+            await this.consumeSseStream(res.body);
+            return;
+        }
+        // 202/no-content (notifications) — nothing to parse
+    }
+    /** Incremental SSE: read the body as a stream and emit each JSON-RPC message
+     *  as its SSE block (blank-line-separated) completes — no full-body buffer. */
+    async consumeSseStream(body) {
+        if (!body)
+            return;
+        const reader = body.getReader();
+        const decoder = new TextDecoder();
+        let buf = "";
+        try {
+            for (;;) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buf += decoder.decode(value, { stream: true }).replace(/\r\n/g, "\n");
+                let sep;
+                while ((sep = buf.indexOf("\n\n")) !== -1) {
+                    const block = buf.slice(0, sep);
+                    buf = buf.slice(sep + 2);
+                    const msg = parseSseEvent(block);
+                    if (msg)
+                        this.msgCb?.(msg);
+                }
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+        // Flush any trailing partial SSE block at EOF (no trailing \n\n).
+        if (buf.trim()) {
+            const msg = parseSseEvent(buf);
+            if (msg)
+                this.msgCb?.(msg);
+        }
+    }
+}
+/** Parse a single SSE block (blank-line-separated events) into one JSON-RPC message.
+ *  Normalizes CRLF → LF before splitting on the event separator. */
+export function parseSseEvent(block) {
+    const data = block
+        .replace(/\r\n/g, "\n")
+        .split(/\n/)
+        .filter((l) => l.startsWith("data:"))
+        .map((l) => l.slice(5).trim())
+        .join("\n");
+    if (!data)
+        return null;
+    try {
+        return JSON.parse(data);
+    }
+    catch {
+        return null;
     }
 }
-/** Parse SSE text thành JSON-RPC messages (concat các dòng `data:` liên tiếp). */
+/** Parse SSE text (legacy buffer-based) thành JSON-RPC messages. */
 export function parseSseMessages(text) {
     const out = [];
     for (const block of text.split(/\r?\n\r?\n/)) {
-        const data = block
-            .split(/\r?\n/)
-            .filter((l) => l.startsWith("data:"))
-            .map((l) => l.slice(5).trim())
-            .join("\n");
-        if (!data)
-            continue;
-        try {
-            out.push(JSON.parse(data));
-        }
-        catch { /* skip malformed */ }
+        const m = parseSseEvent(block);
+        if (m)
+            out.push(m);
     }
     return out;
 }
@@ -220,6 +311,14 @@ export class McpConnection {
     state = "connecting";
     /** M1: status/state sink (AgentEvent mcp_status). */
     onState = null;
+    /** MCP A: inbound server notifications (tools/list_changed, progress…). */
+    onNotification = null;
+    /** Server-reported metadata from `initialize` (surfaced on /mcp). */
+    serverInfo = {};
+    capabilities = {};
+    instructions = null;
+    /** Protocol version negotiated with the server. */
+    protocolVersion = "2024-11-05";
     manuallyClosed = false;
     reconnectAttempt = 0;
     constructor(name, cfg) {
@@ -254,12 +353,17 @@ export class McpConnection {
     async startAndHandshake(timeoutMs) {
         await this.transport.start();
         this.wireTransport();
-        // MCP handshake: initialize + notifications/initialized
-        await this.rpc("initialize", {
+        // MCP handshake: initialize + notifications/initialized. Negotiate the
+        // highest protocol version we support that the server accepts.
+        const initRes = await this.rpc("initialize", {
             protocolVersion: "2024-11-05",
             capabilities: {},
             clientInfo: { name: CLIENT_NAME, version: getVersion() },
         }, timeoutMs);
+        this.protocolVersion = initRes.protocolVersion ?? "2024-11-05";
+        this.capabilities = initRes.capabilities ?? {};
+        this.serverInfo = initRes.serverInfo ?? {};
+        this.instructions = initRes.instructions ?? null;
         void this.transport.send({ jsonrpc: "2.0", method: "notifications/initialized" }).catch(() => {
             // notification — không có pending để reject; lỗi sẽ lộ ở call sau.
         });
@@ -268,8 +372,12 @@ export class McpConnection {
     /** Wire inbound messages + channel-death → reconnect (stdio only). */
     wireTransport() {
         this.transport.onMessage((msg) => {
-            if (msg.id === undefined)
-                return; // notification — nothing pending
+            if (msg.id === undefined) {
+                // Server notifications (tools/list_changed, progress, message) —
+                // route them to the manager so it can react (re-register tools etc.).
+                this.onNotification?.(msg);
+                return;
+            }
             const pending = this.pending.get(msg.id);
             if (!pending)
                 return;
@@ -313,30 +421,70 @@ export class McpConnection {
             await this.scheduleReconnect();
         }
     }
-    /** M1: health check — ping không có response trong MCP spec stdio → dùng
-     *  tools/list với timeout ngắn làm liveness probe. */
+    /** MCP A: liveness probe — prefer ping (official MCP spec), fallback tools/list. */
     async healthy(timeoutMs = 5_000) {
         if (!this.alive)
             return false;
         try {
-            await this.rpc("tools/list", {}, timeoutMs);
+            // ping was added in MCP 2025-03; fall back to tools/list for older servers.
+            if (this.capabilities.ping === true) {
+                await this.rpc("ping", {}, timeoutMs);
+            }
+            else {
+                await this.rpc("tools/list", {}, timeoutMs);
+            }
             return true;
         }
         catch {
             return false;
         }
     }
+    /** MCP A: explicit ping. */
+    async ping(timeoutMs = 5_000) {
+        await this.rpc("ping", {}, timeoutMs);
+    }
     async listTools(timeoutMs = 120_000) {
         const res = await this.rpc("tools/list", {}, timeoutMs);
         return (res.tools ?? []).filter((t) => typeof t.name === "string");
     }
+    // ── Phase 4: resources ────────────────────────────────────────────────────
+    async listResources(timeoutMs = 30_000) {
+        const res = await this.rpc("resources/list", {}, timeoutMs);
+        return (res.resources ?? []).filter((r) => typeof r.uri === "string");
+    }
+    async listResourceTemplates(timeoutMs = 30_000) {
+        const res = await this.rpc("resources/templates/list", {}, timeoutMs);
+        return (res.resourceTemplates ?? []).filter((r) => typeof r.uriTemplate === "string");
+    }
+    async readResource(uri, timeoutMs = 30_000) {
+        const res = await this.rpc("resources/read", { uri }, timeoutMs);
+        return { contents: res.contents ?? [] };
+    }
+    async subscribeResource(uri, timeoutMs = 30_000) {
+        await this.rpc("resources/subscribe", { uri }, timeoutMs);
+    }
+    async unsubscribeResource(uri, timeoutMs = 30_000) {
+        await this.rpc("resources/unsubscribe", { uri }, timeoutMs);
+    }
+    // ── Phase 4: prompts ──────────────────────────────────────────────────────
+    async listPrompts(timeoutMs = 30_000) {
+        const res = await this.rpc("prompts/list", {}, timeoutMs);
+        return (res.prompts ?? []).filter((p) => typeof p.name === "string");
+    }
+    async getPrompt(name, args, timeoutMs = 30_000) {
+        const res = await this.rpc("prompts/get", { name, arguments: args ?? {} }, timeoutMs);
+        return { description: res.description, messages: res.messages ?? [] };
+    }
     async callTool(name, args, timeoutMs = 120_000) {
         const res = await this.rpc("tools/call", { name, arguments: args }, timeoutMs);
         const isErr = res.isError === true;
         const parts = (res.content ?? []).map((c) => c.text ?? "").filter(Boolean);
         // H-13: MCP servers are third-party — redact secret shapes from output
         // before it enters the conversation or logs.
-        return { ok: !isErr, output: redactSecrets(parts.join("\n")) || "(empty result)", structured: res.structuredContent };
+        const structured = res.structuredContent
+            ? JSON.parse(redactSecrets(JSON.stringify(res.structuredContent)))
+            : undefined;
+        return { ok: !isErr, output: redactSecrets(parts.join("\n")) || "(empty result)", structured };
     }
     kill() {
         this.manuallyClosed = true;
@@ -381,21 +529,47 @@ export class McpManager {
     onStatus = null;
     /** Sidebar TUI: máy trạng thái per-server (connecting/ready/reconnecting/dead). */
     onServerState = null;
+    /** Phase 4: server-pushed resource updates (after resources/subscribe). */
+    onResourceUpdated = null;
+    /** Phase 4: progress notifications from long-running MCP tool calls. */
+    onProgress = null;
+    /** Phase 4: per-server resource/template cache (refreshed on list_changed). */
+    resources = new Map();
+    /** Phase 4: per-server prompt cache. */
+    prompts = new Map();
+    /** Phase 4: URIs subscribed per server. */
+    subscriptions = new Map();
     constructor(configs) {
         this.configs = configs;
     }
     /** Connect all servers; skip failures with a warning. Returns discovered tool count. */
     async connectAll() {
+        const report = this.onStatus ?? ((line) => console.error(line));
         await Promise.allSettled(Object.entries(this.configs).map(async ([name, cfg]) => {
+            // MCP B: `enabled:false` and `trust:"readonly"` servers are NOT spawned —
+            // readonly mode must never start an external process. Report them as
+            // skipped so /mcp can still list them.
+            if (cfg.enabled === false || cfg.trust === "readonly") {
+                if (cfg.enabled === false)
+                    report(`· MCP "${name}" skipped (enabled: false)`);
+                else
+                    report(`· MCP "${name}" skipped (trust: readonly — not spawned)`);
+                this.onServerState?.(name, "disabled", cfg.enabled === false ? "enabled:false" : "trust:readonly");
+                return;
+            }
             const conn = new McpConnection(name, cfg);
             this.wireReconnect(name, conn);
             await conn.connect();
             await this.registerTools(name, conn);
+            await this.refreshResources(name, conn);
+            await this.refreshPrompts(name, conn);
             this.conns.set(name, conn);
         })).then((results) => {
-            const report = this.onStatus ?? ((line) => console.error(line));
             results.forEach((r, i) => {
                 const name = Object.keys(this.configs)[i];
+                const cfg = this.configs[name];
+                if (cfg?.enabled === false || cfg?.trust === "readonly")
+                    return; // already reported as skipped
                 if (r.status === "rejected") {
                     this.onServerState?.(name, "dead", "connect failed");
                     report(`⚠  MCP server "${name}" unavailable: ${String(r.reason?.message).slice(0, 160)}`);
@@ -408,7 +582,7 @@ export class McpManager {
         });
         return this.tools.size;
     }
-    /** M1: surface connection state machine + refresh tools sau reconnect. */
+    /** M1: surface connection state machine + refresh tools sau reconnect + wire notifications. */
     wireReconnect(name, conn) {
         conn.onState = (state, detail) => {
             // Sidebar TUI: structured state trước — mọi transition đều thú vị với
@@ -421,11 +595,59 @@ export class McpManager {
                 report(`✘ MCP "${name}" dead: ${detail}`);
             if (state === "ready" && detail === "reconnected") {
                 report(`✓ MCP "${name}" reconnected`);
-                // Refresh tool list — server có thể đăng ký bộ tool mới.
+                // Refresh tool + resource + prompt lists — the server may have changed.
                 conn
                     .listTools()
                     .then((defs) => this.reregisterTools(name, conn, defs))
                     .catch(() => { });
+                void this.refreshResources(name, conn);
+                void this.refreshPrompts(name, conn);
+                for (const uri of this.subscriptions.get(name) ?? []) {
+                    void conn.subscribeResource(uri).catch(() => { });
+                }
+            }
+        };
+        // MCP A: react to server notifications — tools/list_changed re-registers
+        // the tool set (no full reconnect needed); progress/message are surfaced
+        // as status lines but don't disrupt anything.
+        conn.onNotification = (msg) => {
+            const method = String(msg.method ?? "");
+            const report = this.onStatus ?? ((line) => console.error(line));
+            const params = (msg.params ?? {});
+            if (method === "notifications/tools/list_changed" || method === "tools/list_changed") {
+                conn
+                    .listTools()
+                    .then((defs) => {
+                    this.reregisterTools(name, conn, defs);
+                    report(`↻ MCP "${name}" tools changed — re-registered ${defs.length}`);
+                })
+                    .catch(() => { });
+            }
+            else if (method === "notifications/resources/list_changed" || method === "resources/list_changed") {
+                void this.refreshResources(name, conn).then(() => {
+                    const n = this.resources.get(name)?.resources.length ?? 0;
+                    report(`↻ MCP "${name}" resources changed — ${n} resource${n === 1 ? "" : "s"}`);
+                });
+            }
+            else if (method === "notifications/prompts/list_changed" || method === "prompts/list_changed") {
+                void this.refreshPrompts(name, conn).then(() => {
+                    const n = this.prompts.get(name)?.length ?? 0;
+                    report(`↻ MCP "${name}" prompts changed — ${n} prompt${n === 1 ? "" : "s"}`);
+                });
+            }
+            else if (method === "notifications/resources/updated" || method === "resources/updated") {
+                const uri = typeof params.uri === "string" ? params.uri : "";
+                if (uri) {
+                    this.onResourceUpdated?.(name, uri);
+                    report(`↻ MCP "${name}" resource updated: ${uri}`);
+                }
+            }
+            else if (method === "notifications/progress" || method === "progress") {
+                // Long-running tool progress — forwarded to the UI hook (no chat spam).
+                this.onProgress?.(name, params);
+            }
+            else if (method === "notifications/message" || method === "message") {
+                report(`ℹ MCP "${name}": ${String(params.message ?? "message")}`);
             }
         };
     }
@@ -433,13 +655,64 @@ export class McpManager {
         const defs = await conn.listTools();
         this.reregisterTools(name, conn, defs);
     }
-    /** Replace một server's tool registrations (reconnect refresh). */
+    /** Phase 4: cache resources + templates when the server advertises them. */
+    async refreshResources(name, conn) {
+        if (conn.capabilities.resources == null) {
+            this.resources.delete(name);
+            return;
+        }
+        let resources = [];
+        let templates = [];
+        try {
+            resources = await conn.listResources();
+        }
+        catch { /* optional method */ }
+        try {
+            templates = await conn.listResourceTemplates();
+        }
+        catch { /* optional method */ }
+        this.resources.set(name, { resources, templates });
+    }
+    /** Phase 4: cache prompts when the server advertises them. */
+    async refreshPrompts(name, conn) {
+        if (conn.capabilities.prompts == null) {
+            this.prompts.delete(name);
+            return;
+        }
+        try {
+            this.prompts.set(name, await conn.listPrompts());
+        }
+        catch { /* optional method */ }
+    }
+    /** MCP A: apply per-server tool include/exclude filters to a tool list. */
+    filterToolDefs(name, defs) {
+        const filter = this.configs[name]?.tools;
+        if (!filter)
+            return defs;
+        const include = filter.include?.filter(Boolean) ?? [];
+        const exclude = new Set((filter.exclude ?? []).map((s) => s.toLowerCase()));
+        const match = (pat, n) => {
+            if (!pat.includes("*"))
+                return n === pat.toLowerCase();
+            const rx = new RegExp("^" + pat.split("*").map((s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join(".*") + "$", "i");
+            return rx.test(n);
+        };
+        return defs.filter((t) => {
+            const n = t.name.toLowerCase();
+            if (include.length > 0 && !include.some((pat) => match(pat, n)))
+                return false;
+            if ([...exclude].some((e) => match(e, n)))
+                return false;
+            return true;
+        });
+    }
+    /** Replace một server's tool registrations (reconnect refresh) — honor config filters. */
     reregisterTools(name, conn, defs) {
         for (const [key, t] of [...this.tools]) {
             if (t.serverName === name)
                 this.tools.delete(key);
         }
-        for (const def of defs) {
+        for (const def of this.filterToolDefs(name, defs)) {
             const key = mcpToolKey(name, def.name);
             this.tools.set(key, { conn, serverName: name, toolName: def.name, def });
         }
@@ -460,6 +733,211 @@ export class McpManager {
     getTool(name) {
         return this.tools.get(name);
     }
+    /** MCP A: connection state + metadata for /mcp status display.
+     *  connected is based on McpConnection.state, not tool count. */
+    serverStates() {
+        return [...this.conns.entries()].map(([name, conn]) => ({
+            name,
+            state: conn.state,
+            serverInfo: conn.serverInfo,
+            capabilities: conn.capabilities,
+            instructions: conn.instructions,
+            toolCount: [...this.tools.values()].filter((t) => t.serverName === name).length,
+            resourceCount: this.resources.get(name)?.resources.length ?? 0,
+            promptCount: this.prompts.get(name)?.length ?? 0,
+        }));
+    }
+    /** Phase 4: cached resources + templates per server. */
+    listResourcesByServer() {
+        return [...this.resources.entries()].map(([server, r]) => ({ server, ...r }));
+    }
+    /** Phase 4: cached prompts per server. */
+    listPromptsByServer() {
+        return [...this.prompts.entries()].map(([server, prompts]) => ({ server, prompts }));
+    }
+    hasResources() {
+        return this.resources.size > 0;
+    }
+    hasPrompts() {
+        return this.prompts.size > 0;
+    }
+    /** Phase 4: read a resource; optionally subscribe to its update notifications. */
+    async readResource(server, uri, opts = {}) {
+        const conn = this.conns.get(server);
+        if (!conn)
+            return { ok: false, output: `ERROR: MCP server "${server}" is not connected.` };
+        try {
+            const res = await conn.readResource(uri);
+            if (opts.subscribe) {
+                try {
+                    await conn.subscribeResource(uri);
+                    const set = this.subscriptions.get(server) ?? new Set();
+                    set.add(uri);
+                    this.subscriptions.set(server, set);
+                }
+                catch {
+                    // Subscription is best-effort; the read itself already succeeded.
+                }
+            }
+            const parts = res.contents.map((c) => {
+                if (typeof c.text === "string")
+                    return c.text;
+                if (typeof c.blob === "string") {
+                    return `[binary ${c.mimeType ?? "application/octet-stream"} — ${c.blob.length} base64 chars]`;
+                }
+                return "";
+            }).filter(Boolean);
+            return { ok: true, output: redactSecrets(parts.join("\n")) || "(empty resource)" };
+        }
+        catch (err) {
+            return { ok: false, output: `ERROR: resources/read failed: ${err.message}` };
+        }
+    }
+    /** Phase 4: render a server prompt template into text messages. */
+    async getPrompt(server, name, args) {
+        const conn = this.conns.get(server);
+        if (!conn)
+            return { ok: false, output: `ERROR: MCP server "${server}" is not connected.` };
+        try {
+            const res = await conn.getPrompt(name, args);
+            const msgs = res.messages.map((m) => {
+                const content = m.content;
+                const text = content && content.type === "text" && typeof content.text === "string"
+                    ? content.text
+                    : JSON.stringify(m.content);
+                return `[${m.role ?? "user"}] ${text}`;
+            });
+            const header = res.description ? `${res.description}\n\n` : "";
+            return { ok: true, output: redactSecrets(header + (msgs.join("\n\n") || "(empty prompt)")) };
+        }
+        catch (err) {
+            return { ok: false, output: `ERROR: prompts/get failed: ${err.message}` };
+        }
+    }
+    /** Phase 4: true when `name` is a generic resource/prompt tool. */
+    isResourceTool(name) {
+        return MCP_RESOURCE_TOOL_NAMES.has(name);
+    }
+    /** Phase 4: specs for resource/prompt tools — advertised only when available. */
+    resourceToolSpecs() {
+        const specs = [];
+        if (this.hasResources()) {
+            specs.push({
+                type: "function",
+                function: {
+                    name: "mcp_list_resources",
+                    description: "List MCP resources and resource templates exposed by connected servers. " +
+                        "Use before mcp_read_resource when you don't know the URI.",
+                    parameters: schemaObj({ server: strProp("Optional server name — omit to list all servers") }, []),
+                },
+            });
+            specs.push({
+                type: "function",
+                function: {
+                    name: "mcp_read_resource",
+                    description: "Read one MCP resource by URI (resources/read). Pass subscribe=true to receive " +
+                        "resources/updated notifications for that URI.",
+                    parameters: schemaObj({
+                        server: strProp("Server name that owns the resource"),
+                        uri: strProp("Resource URI (from mcp_list_resources or a resource template)"),
+                        subscribe: boolProp("Subscribe to updates for this URI (default: false)"),
+                    }, ["server", "uri"]),
+                },
+            });
+        }
+        if (this.hasPrompts()) {
+            specs.push({
+                type: "function",
+                function: {
+                    name: "mcp_list_prompts",
+                    description: "List prompt templates exposed by connected MCP servers.",
+                    parameters: schemaObj({ server: strProp("Optional server name — omit to list all servers") }, []),
+                },
+            });
+            specs.push({
+                type: "function",
+                function: {
+                    name: "mcp_get_prompt",
+                    description: "Render one MCP prompt template (prompts/get) into text messages.",
+                    parameters: schemaObj({
+                        server: strProp("Server name that owns the prompt"),
+                        name: strProp("Prompt name (from mcp_list_prompts)"),
+                        arguments: {
+                            type: "object",
+                            description: "Prompt arguments (string values)",
+                            additionalProperties: { type: "string" },
+                        },
+                    }, ["server", "name"]),
+                },
+            });
+        }
+        return specs;
+    }
+    /** Phase 4: dispatch a generic resource/prompt tool call. */
+    async invokeResourceTool(name, args) {
+        switch (name) {
+            case "mcp_list_resources": {
+                const server = typeof args.server === "string" ? args.server : undefined;
+                const rows = this.listResourcesByServer().filter((r) => !server || r.server === server);
+                if (rows.length === 0)
+                    return { ok: true, output: "(no MCP resources)" };
+                return {
+                    ok: true,
+                    output: rows.map(({ server: s, resources, templates }) => {
+                        const lines = [`## ${s}`];
+                        for (const r of resources) {
+                            lines.push(`- ${r.uri}${r.name ? ` — ${r.name}` : ""}${r.mimeType ? ` (${r.mimeType})` : ""}`);
+                        }
+                        for (const t of templates) {
+                            lines.push(`- template: ${t.uriTemplate}${t.name ? ` — ${t.name}` : ""}`);
+                        }
+                        return lines.join("\n");
+                    }).join("\n\n"),
+                };
+            }
+            case "mcp_read_resource": {
+                const server = typeof args.server === "string" ? args.server : "";
+                const uri = typeof args.uri === "string" ? args.uri : "";
+                if (!server || !uri)
+                    return { ok: false, output: "ERROR: mcp_read_resource requires server and uri." };
+                return this.readResource(server, uri, { subscribe: args.subscribe === true });
+            }
+            case "mcp_list_prompts": {
+                const server = typeof args.server === "string" ? args.server : undefined;
+                const rows = this.listPromptsByServer().filter((r) => !server || r.server === server);
+                if (rows.length === 0)
+                    return { ok: true, output: "(no MCP prompts)" };
+                return {
+                    ok: true,
+                    output: rows.map(({ server: s, prompts }) => {
+                        const lines = [`## ${s}`];
+                        for (const p of prompts) {
+                            const params = (p.arguments ?? []).map((a) => `${a.name}${a.required ? "" : "?"}`).join(", ");
+                            lines.push(`- ${p.name}${params ? ` (${params})` : ""}${p.description ? ` — ${p.description}` : ""}`);
+                        }
+                        return lines.join("\n");
+                    }).join("\n\n"),
+                };
+            }
+            case "mcp_get_prompt": {
+                const server = typeof args.server === "string" ? args.server : "";
+                const promptName = typeof args.name === "string" ? args.name : "";
+                if (!server || !promptName)
+                    return { ok: false, output: "ERROR: mcp_get_prompt requires server and name." };
+                const rawArgs = args.arguments;
+                const promptArgs = {};
+                if (rawArgs && typeof rawArgs === "object" && !Array.isArray(rawArgs)) {
+                    for (const [k, v] of Object.entries(rawArgs)) {
+                        if (typeof v === "string")
+                            promptArgs[k] = v;
+                    }
+                }
+                return this.getPrompt(server, promptName, promptArgs);
+            }
+            default:
+                return { ok: false, output: `ERROR: unknown MCP resource tool "${name}".` };
+        }
+    }
     /** Convert all discovered MCP tools to OpenAI function-calling specs. */
     toToolSpecs() {
         return [...this.tools.values()].map(({ conn: _, serverName, toolName, def }) => ({
@@ -476,39 +954,60 @@ export class McpManager {
             c.kill();
         this.conns.clear();
         this.tools.clear();
+        this.resources.clear();
+        this.prompts.clear();
+        this.subscriptions.clear();
     }
-    /** M4: config hot-reload — connect server mới, kill server đã bị xóa khỏi config. */
+    /** M4: config hot-reload — connect server mới, kill server đã bị xóa/changed khỏi config. */
     async applyConfig(configs) {
-        this.configs = configs;
-        // Server bị xóa → kill + unregister.
+        const report = this.onStatus ?? ((line) => console.error(line));
+        // A server's transport-effective config changed → restart it (kill + reconnect).
+        const configChanged = (prev, next) => {
+            const pick = (c) => JSON.stringify([c.command, c.url, c.type, c.args, c.env ?? {}, c.headers ?? {}, c.timeoutMs ?? null, c.tools ?? {}, c.enabled ?? true, c.trust ?? "auto"]);
+            return pick(prev) !== pick(next);
+        };
+        // Server bị xóa hoặc đổi config → kill + unregister.
         for (const [name, conn] of [...this.conns]) {
-            if (!configs[name]) {
+            if (!configs[name] || configChanged(this.configs[name], configs[name])) {
                 conn.kill();
                 this.conns.delete(name);
                 for (const [key, t] of [...this.tools]) {
                     if (t.serverName === name)
                         this.tools.delete(key);
                 }
-                const report = this.onStatus ?? ((line) => console.error(line));
-                report(`✘ MCP "${name}" removed (config changed)`);
+                this.resources.delete(name);
+                this.prompts.delete(name);
+                this.subscriptions.delete(name);
+                if (configs[name] && configChanged(this.configs[name], configs[name])) {
+                    report(`↻ MCP "${name}" config changed — restarting`);
+                }
+                else {
+                    report(`✘ MCP "${name}" removed (config changed)`);
+                }
             }
         }
-        // Server mới → connect.
+        this.configs = configs;
+        // Server mới → connect (except enabled:false / trust:readonly — never spawn).
         for (const [name, cfg] of Object.entries(configs)) {
             if (this.conns.has(name))
                 continue;
+            if (cfg.enabled === false || cfg.trust === "readonly") {
+                this.onServerState?.(name, "disabled", cfg.enabled === false ? "enabled:false" : "trust:readonly");
+                report(`· MCP "${name}" skipped (${cfg.enabled === false ? "enabled: false" : "trust: readonly — not spawned"})`);
+                continue;
+            }
             const conn = new McpConnection(name, cfg);
             this.wireReconnect(name, conn);
             try {
                 await conn.connect();
                 await this.registerTools(name, conn);
+                await this.refreshResources(name, conn);
+                await this.refreshPrompts(name, conn);
                 this.conns.set(name, conn);
-                const report = this.onStatus ?? ((line) => console.error(line));
                 const n = [...this.tools.values()].filter((t) => t.serverName === name).length;
                 report(`✓ MCP "${name}" connected — ${n} tool${n === 1 ? "" : "s"} (hot-reload)`);
             }
             catch (e) {
-                const report = this.onStatus ?? ((line) => console.error(line));
                 report(`⚠  MCP server "${name}" unavailable: ${String(e.message).slice(0, 160)}`);
             }
         }