thincoder 0.12.52 → 0.12.54

package/src/mcp/transport-http.mjs

@@ -12,6 +12,16 @@ export function httpTransport(baseURL, extraHeaders = {}) {
   let abortController = null
   let postUrl = url
   let legacySSE = false
+  let deadFired = false
+  let deadListeners = new Set()
+
+  /** 2026-08-31 MCP 会诊 P5：意外死亡通知（SSE 流断/error，非主动 close）。 */
+  const fireDead = (msg) => {
+    if (deadFired) return
+    deadFired = true
+    for (const cb of deadListeners) { try { cb(msg) } catch { /* listener error */ } }
+  }
+  const onDead = (cb) => { deadListeners.add(cb); return () => deadListeners.delete(cb) }
 
   const headers = () => {
     const h = { "Content-Type": "application/json", Accept: "text/event-stream, application/json", ...extraHeaders }
@@ -86,10 +96,14 @@ export function httpTransport(baseURL, extraHeaders = {}) {
             }
           } catch { /* not JSON, ignore */ }
         }
+        // 正常走完 = server 关闭了流（网络/对端退出）→ 非主动关闭视为死亡
+        if (!closed) fireDead("SSE stream ended")
       } catch (error) {
-        if (!closed) {
+        const wasClosed = closed
+        if (!wasClosed) {
           for (const [, resolve] of pending) resolve({ id: null, error: { code: -32000, message: `SSE error: ${error.message}` } })
           pending.clear()
+          fireDead(`SSE error: ${error.message}`)
         }
       }
     })()
@@ -106,14 +120,26 @@ export function httpTransport(baseURL, extraHeaders = {}) {
     const body = JSON.stringify({ jsonrpc: "2.0", id, method, params })
 
     if (legacySSE) {
+      // 2026-08-31 MCP 会诊 #10：legacy 模式下 POST 若直接带回 JSON-RPC body（违规 server，
+      // 规范是响应经 GET SSE 流回）——原实现对 resp.ok 什么都不做 → pending 挂满 120s。
+      // 空 body = 规范行为（等待 SSE 流）；非空 JSON = 违规 server，直接解析 resolve。
       return new Promise((resolve) => {
         pending.set(id, resolve)
         fetch(postUrl, { method: "POST", headers: headers(), body, signal: AbortSignal.timeout(CALL_TIMEOUT_MS) })
-          .then((resp) => {
+          .then(async (resp) => {
             if (!resp.ok) {
               pending.delete(id)
               resolve({ id, error: { code: -32000, message: `POST failed: HTTP ${resp.status}` } })
+              return
+            }
+            const raw = await resp.text().catch(() => "")
+            if (raw.trim()) {
+              try {
+                const msg = JSON.parse(raw)
+                if (msg.id === id) { pending.delete(id); resolve(msg); return }
+              } catch { /* ignore — pending 交给 SSE 流 */ }
             }
+            // 空体或非本次 id 的 JSON：保持 pending 等 GET SSE 流回包
           })
           .catch((e) => {
             pending.delete(id)
@@ -122,30 +148,56 @@ export function httpTransport(baseURL, extraHeaders = {}) {
       }).finally(() => pending.delete(id))
     }
 
-    const resp = await fetch(postUrl, {
-      method: "POST",
-      headers: headers(),
-      body,
-      signal: AbortSignal.timeout(CALL_TIMEOUT_MS),
-    })
-    if (!resp.ok) throw new Error(`HTTP ${resp.status}`)
-
-    const ct = resp.headers.get("content-type") ?? ""
-    const newSessionId = resp.headers.get("Mcp-Session-Id")
-    if (newSessionId) sessionId = newSessionId
-
-    if (ct.includes("text/event-stream")) {
-      const sse = parseSSE(resp)
-      for await (const { data } of sse) {
-        try {
-          const msg = JSON.parse(data)
-          if (msg.id === id) return msg
-        } catch { /* skip */ }
-      }
-      return { id, error: { code: -32000, message: "No JSON-RPC response in SSE stream" } }
-    }
-
-    return resp.json()
+    // 2026-08-31 MCP 会诊 P4：Streamable HTTP 规范路径（POST→202→GET SSE 回包）。
+    // 原实现非 legacy 分支从不注册 pending：202 空 body → resp.json() 抛 SyntaxError，
+    // 而 SSE 流里 pending.get(id) 永远 miss——每次调用挂满 120s。
+    // 现在两类通道统一：先注册 pending，POST 得到的结果（直接 body / SSE / 202 等待）
+    // 都经 pending resolve；SSE 流由 openSSE() 转发。200+JSON 直接 body 解析。
+    return new Promise((resolve) => {
+      pending.set(id, resolve)
+      fetch(postUrl, { method: "POST", headers: headers(), body, signal: AbortSignal.timeout(CALL_TIMEOUT_MS) })
+        .then(async (resp) => {
+          const ct = resp.headers.get("content-type") ?? ""
+          const newSessionId = resp.headers.get("Mcp-Session-Id")
+          if (newSessionId) sessionId = newSessionId
+          // 202: 已接受，响应将经 GET SSE 流回——pending 保持，由 openSSE 转发 resolve
+          if (resp.status === 202) return
+          if (!resp.ok) {
+            pending.delete(id)
+            resolve({ id, error: { code: -32000, message: `HTTP ${resp.status}` } })
+            return
+          }
+          if (ct.includes("text/event-stream")) {
+            // 响应体本身就是一条 SSE（一次性流）：解析匹配该 id
+            try {
+              for await (const { data } of parseSSE(resp)) {
+                try {
+                  const msg = JSON.parse(data)
+                  if (msg.id === id) { pending.delete(id); resolve(msg); return }
+                } catch { /* skip */ }
+              }
+              pending.delete(id)
+              resolve({ id, error: { code: -32000, message: "No JSON-RPC response in SSE stream" } })
+            } catch (e) {
+              pending.delete(id)
+              resolve({ id, error: { code: -32000, message: `SSE response failed: ${e.message}` } })
+            }
+            return
+          }
+          // 直接 JSON body：拿掉 pending 立即解析
+          pending.delete(id)
+          try {
+            resolve(await resp.json())
+          } catch (e) {
+            resolve({ id, error: { code: -32000, message: `invalid JSON body: ${e.message}` } })
+          }
+        })
+        .catch((e) => {
+          if (pending.delete(id)) {
+            resolve({ id, error: { code: -32000, message: `POST failed: ${e.message}` } })
+          }
+        })
+    }).finally(() => pending.delete(id))
   }
 
   const send = async (method, params) => withTimeout(postRequest(method, params), CALL_TIMEOUT_MS)
@@ -180,5 +232,5 @@ export function httpTransport(baseURL, extraHeaders = {}) {
     pending.clear()
   }
 
-  return { send, notify, close, openSSE, url, headers: extraHeaders }
+  return { send, notify, close, openSSE, url, headers: extraHeaders, isAlive: () => !closed && eventSource != null, onDead }
 }

package/src/mcp/transport-stdio.mjs

@@ -4,6 +4,23 @@
 import { spawn } from "node:child_process"
 import { rpcId, CALL_TIMEOUT_MS, withTimeout, quoteArg } from "./helpers.mjs"
 
+/** Kill the child AND its whole process tree.
+ *  win32: cmd.exe 包装 spawn 的孙进程（npx/node）必须 taskkill /T /F 才能杀净
+ *  （2026-08-31 MCP 会诊 P2：此前只 child.kill() 杀 cmd.exe 壳，真 server 成僵尸
+ *  并在 Windows 团队每人每次断开/重连泄漏一批）；
+ *  POSIX: SIGTERM 后 2s 未退 SIGKILL 兜底。 */
+function killTree(child) {
+  if (!child.pid) return
+  if (process.platform === "win32") {
+    try { spawn("taskkill", ["/pid", String(child.pid), "/T", "/F"], { stdio: "ignore", windowsHide: true }) } catch { /* best effort */ }
+    return
+  }
+  try {
+    child.kill("SIGTERM")
+    setTimeout(() => { try { child.kill("SIGKILL") } catch { /* already gone */ } }, 2000).unref?.()
+  } catch { /* best effort */ }
+}
+
 /** Create an MCP stdio transport over a spawned child process.
  *  @param {Object} [env] — extra environment variables merged on top of process.env */
 export function stdioTransport(command, args, env) {
@@ -22,6 +39,17 @@ export function stdioTransport(command, args, env) {
   let stderrTail = ""
   let spawnError = null
   let closed = false
+  let deadFired = false
+  let deadListeners = new Set()
+
+  /** 2026-08-31 MCP 会诊 P5：意外死亡通知（进程自杀/崩溃，非主动 close）。
+   *  主动 close() 先置 closed → 后续 close 事件不触发。 */
+  const fireDead = (msg) => {
+    if (deadFired) return
+    deadFired = true
+    for (const cb of deadListeners) { try { cb(msg) } catch { /* listener error */ } }
+  }
+  const onDead = (cb) => { deadListeners.add(cb); return () => deadListeners.delete(cb) }
 
   const failAll = (message) => {
     for (const [, resolve] of pending) resolve({ id: null, error: { code: -32000, message } })
@@ -56,16 +84,31 @@ export function stdioTransport(command, args, env) {
     failAll(`spawn failed: ${error.message}`)
   })
   child.on("close", () => {
+    const wasClosed = closed // 主动 close() 先置 closed → 意外事件不重复
     closed = true
     const lastLine = stderrTail.trim().split("\n").pop()
     failAll(`Connection closed${lastLine ? ` | stderr: ${lastLine}` : ""}`)
+    if (!wasClosed) fireDead(`MCP server process exited${lastLine ? ` | stderr: ${lastLine}` : ""}`)
   })
 
-  const send = (method, params) => {
+  const send = (method, params, signal) => {
     if (spawnError) return Promise.resolve({ id: null, error: { code: -32000, message: `spawn failed: ${spawnError.message}` } })
     if (closed) return Promise.reject(new Error("MCP connection closed"))
     const id = rpcId()
-    const promise = new Promise((resolve) => pending.set(id, resolve))
+    let resolveFn
+    const promise = new Promise((resolve) => { resolveFn = resolve; pending.set(id, resolve) })
+    // 2026-08-31 MCP 会诊 P7：上层 signal 中断时即刻作废 pending（原实现等满
+    // CALL_TIMEOUT_MS 才清）并向 server 发 cancelled 通知。
+    const onAbort = () => {
+      pending.delete(id)
+      try { notify("notifications/cancelled", { requestId: id }) } catch { /* ignore */ }
+      resolveFn({ id, error: { code: -32000, message: "Request cancelled by user" } })
+    }
+    if (signal) {
+      if (signal.aborted) return Promise.reject((signal.reason instanceof Error) ? signal.reason : new DOMException("Aborted", "AbortError"))
+      signal.addEventListener("abort", onAbort, { once: true })
+      promise.finally(() => signal.removeEventListener("abort", onAbort)).catch?.(() => {})
+    }
     try {
       child.stdin.write(JSON.stringify({ jsonrpc: "2.0", id, method, params }) + "\n")
     } catch (error) {
@@ -82,5 +125,16 @@ export function stdioTransport(command, args, env) {
     } catch { /* ignore */ }
   }
 
-  return { send, notify, close: () => { if (!closed) child.kill() } }
+  return {
+    send, notify,
+    close: () => {
+      // 2026-08-31 MCP 会诊 P2：close ≠ 只杀进程——先置 closed + failAll（在途请求
+      // 立即得到 "Connection closed" 而非挂满 120s），再杀整个进程树。
+      closed = true
+      failAll("Connection closed")
+      if (child.exitCode === null) killTree(child)
+    },
+    isAlive: () => !closed && !spawnError && child.exitCode === null,
+    onDead,
+  }
 }

package/src/mcp/transport-ws.mjs

@@ -8,6 +8,16 @@ export function wsTransport(wsUrl, extraHeaders = {}) {
   const pending = new Map()
   let closed = false
   let ws = null
+  let deadFired = false
+  let deadListeners = new Set()
+
+  /** 2026-08-31 MCP 会诊 P5：意外死亡通知（非主动 close 的连接断开）。 */
+  const fireDead = (msg) => {
+    if (deadFired) return
+    deadFired = true
+    for (const cb of deadListeners) { try { cb(msg) } catch { /* listener error */ } }
+  }
+  const onDead = (cb) => { deadListeners.add(cb); return () => deadListeners.delete(cb) }
 
   const failAll = (message) => {
     for (const [, resolve] of pending) resolve({ id: null, error: { code: -32000, message } })
@@ -16,15 +26,22 @@ export function wsTransport(wsUrl, extraHeaders = {}) {
 
   const connect = () => {
     if (closed) throw new Error("MCP WebSocket connection closed")
-    ws = new WebSocket(withAuthToken(wsUrl, extraHeaders.Authorization))
+    // 2026-08-31 MCP 会诊 #10：Authorization 经 subprotocol（bearer.<token>）传递，
+    // 不注入 URL query（防代理/网关日志泄露）；无认证时 protocols 为空数组。
+    const { url: wsUrlResolved, protocols } = withAuthToken(wsUrl, extraHeaders.Authorization)
+    ws = new WebSocket(wsUrlResolved, protocols.length ? protocols : undefined)
 
     return new Promise((resolve, reject) => {
+      let settled = false
+      const settleErr = (err) => { if (!settled) { settled = true; reject(err) } }
       const timeout = setTimeout(() => {
-        ws.close()
-        reject(new Error(`WebSocket connect timeout: ${wsUrl}`))
+        settleErr(new Error(`WebSocket connect timeout: ${wsUrl}`))
+        try { ws.close() } catch { /* ignore */ }
       }, INIT_TIMEOUT_MS)
 
       ws.addEventListener("open", () => {
+        if (settled) return
+        settled = true
         clearTimeout(timeout)
         resolve()
       })
@@ -41,28 +58,45 @@ export function wsTransport(wsUrl, extraHeaders = {}) {
       })
 
       ws.addEventListener("error", (event) => {
+        const wasClosed = closed
         clearTimeout(timeout)
         closed = true
-        const errMsg = event.message || "WebSocket error"
-        if (pending.size > 0) {
-          failAll(errMsg)
-        } else {
-          reject(new Error(errMsg))
-        }
+        const errMsg = event.message || event.error?.message || "WebSocket error"
+        settleErr(new Error(errMsg))
+        failAll(errMsg)
+        if (!wasClosed) fireDead(errMsg)
       })
 
       ws.addEventListener("close", () => {
+        const wasClosed = closed
         clearTimeout(timeout)
         closed = true
+        // 2026-08-31 MCP 会诊 P1：握手期间 disconnect（close 先于 open 且无 error）——
+        // 原实现 close 只 clearTimeout + failAll，connect promise 永不 settle（启动挂死）。
+        // settled 标志保证 close 未开成必 reject。
+        settleErr(new Error("WebSocket closed before connection established"))
         failAll("WebSocket closed")
+        if (!wasClosed) fireDead("WebSocket closed")
       })
     })
   }
 
-  const send = (method, params) => {
+  const send = (method, params, signal) => {
     if (closed) return Promise.reject(new Error("MCP WebSocket connection closed"))
     const id = rpcId()
-    const promise = new Promise((resolve) => pending.set(id, resolve))
+    let resolveFn
+    const promise = new Promise((resolve) => { resolveFn = resolve; pending.set(id, resolve) })
+    // 2026-08-31 MCP 会诊 P7：abort 即刻作废 pending + 发 cancelled（原等满 120s）
+    if (signal) {
+      if (signal.aborted) return Promise.reject(new DOMException("Aborted", "AbortError"))
+      const onAbort = () => {
+        pending.delete(id)
+        try { notify("notifications/cancelled", { requestId: id }) } catch { /* ignore */ }
+        resolveFn({ id, error: { code: -32000, message: "Request cancelled by user" } })
+      }
+      signal.addEventListener("abort", onAbort, { once: true })
+      promise.finally(() => signal.removeEventListener("abort", onAbort)).catch?.(() => {})
+    }
     try {
       ws.send(JSON.stringify({ jsonrpc: "2.0", id, method, params }))
     } catch (error) {
@@ -84,5 +118,5 @@ export function wsTransport(wsUrl, extraHeaders = {}) {
     try { ws?.close() } catch { /* ignore */ }
   }
 
-  return { send, notify, close, connect }
+  return { send, notify, close, connect, isAlive: () => !closed && ws?.readyState === WebSocket.OPEN, onDead }
 }

package/src/mcp.mjs

@@ -7,29 +7,159 @@ import { stdioTransport } from "./mcp/transport-stdio.mjs"
 import { httpTransport } from "./mcp/transport-http.mjs"
 import { wsTransport } from "./mcp/transport-ws.mjs"
 
+
+/** Race a pending MCP request against an abort signal — a hung MCP server must not
+ *  hold the turn hostage. signal absent → passthrough. */
+async function sendWithSignal(promise, signal) {
+  if (!signal) return promise
+  return new Promise((resolve, reject) => {
+    const onAbort = () => {
+      const e = new DOMException("The operation was aborted", "AbortError")
+      e.reason = signal.reason
+      reject(e)
+    }
+    if (signal.aborted) return onAbort()
+    signal.addEventListener("abort", onAbort, { once: true })
+    promise.then(
+      (v) => { signal.removeEventListener("abort", onAbort); resolve(v) },
+      (e) => { signal.removeEventListener("abort", onAbort); reject(e) },
+    )
+  })
+}
+
 // ---- MCP lifecycle ----
 
-function buildTools(mcpTools, transport, config) {
+/** 2026-08-31 MCP 会诊 P5：CLI session 注册表（serverName → session）。
+ *  session.state.transport 可变（重连替换）；buildTools 的 execute 动态取
+ *  session.state.transport——server 崩溃后无需重建 agent.tools 即自愈。 */
+const _sessions = new Map()
+/** 退避重连进行中（serverName → promise）——与 vscode 语义对齐；延迟表见 _mcpHooks。 */
+const _reconnecting = new Map()
+
+/** 2026-08-31 MCP 会诊 P5：测试钩子（退避延迟可替换，惯例同 rate.mjs _rateHooks）。
+ *  scheduleReconnect 与 ensureAlive 读这里的 delay/reconnectDelays——测试可注入微秒级延迟。 */
+export const _mcpHooks = {
+  delay: (ms) => new Promise((r) => setTimeout(r, ms)),
+  reconnectDelays: [1000, 2000, 4000, 8000],
+}
+
+/** 按 config 创建并完成握手的 transport（findTransportConfig 与 vscode 对齐）。 */
+async function createConnectedTransport(config, serverName) {
+  let transport
+  if (config.wsUrl) {
+    transport = wsTransport(config.wsUrl, config.headers ?? {})
+    await transport.connect()
+  } else if (config.url) {
+    transport = httpTransport(config.url, config.headers ?? {})
+    try {
+      await transport.openSSE()
+    } catch {
+      // Server doesn't support GET SSE — degrade to pure Streamable HTTP POST mode
+    }
+  } else {
+    transport = stdioTransport(config.command, config.args ?? [], config.env)
+  }
+  const mcpTools = await doInitialize(transport, serverName)
+  return { transport, mcpTools }
+}
+
+/** onDead → 后台退避重连；成功替换 session.state.transport（tools 闭包动态引用，
+ *  agent.tools 无需重建）；失败静默（下次 execute 前置检查再试）。 */
+function scheduleReconnect(name, config) {
+  if (_reconnecting.has(name)) return _reconnecting.get(name)
+  const p = (async () => {
+    let lastErr
+    for (const delayMs of _mcpHooks.reconnectDelays) {
+      await _mcpHooks.delay(delayMs)
+      try {
+        const { transport } = await createConnectedTransport(config, name)
+        const session = _sessions.get(name)
+        if (!session || session.closed) { transport.close(); return false }
+        attachSession(session, transport)
+        return true
+      } catch (error) {
+        lastErr = error
+      }
+    }
+    console.error(`[mcp] ${name} reconnect failed after ${_mcpHooks.reconnectDelays.length} attempts: ${lastErr?.message ?? lastErr}`)
+    return false
+  })().finally(() => _reconnecting.delete(name))
+  _reconnecting.set(name, p)
+  return p
+}
+
+/** 给 session 绑定一个新 transport（建连 onDead 钩子 → 自愈链）。 */
+function attachSession(session, transport) {
+  session.state.transport = transport
+  transport.onDead?.(() => {
+    if (session.state.transport !== transport) return // 已再替换，旧钩子作废
+    scheduleReconnect(session.config.name ?? session.config.command ?? session.config.url ?? session.config.wsUrl, session.config)
+  })
+}
+
+function buildTools(mcpTools, session, config) {
   const prefix = config.name ? `${config.name}_` : "mcp_"
-  return mcpTools.map((t) => ({
-    name: sanitizeToolName(prefix + t.name),
-    description: t.description ?? `MCP tool: ${t.name}`,
-    parameters: t.inputSchema ?? { type: "object", properties: {} },
-    readonly: false,
-    async execute(args) {
-      const resp = await transport.send("tools/call", { name: t.name, arguments: args })
-      if (resp.error) throw new Error(`MCP tool "${t.name}": ${resp.error.message}`)
-      const content = resp.result?.content ?? []
-      return content
-        .map((c) => (c.type === "text" ? c.text : c.type === "resource" ? `[resource: ${c.resource?.uri}]` : JSON.stringify(c)))
-        .join("\n") || "(no output)"
-    },
-    _mcpTransport: transport,
-    _mcpName: config.name,
-  }))
+  // 2026-08-31 MCP 会诊 P6：sanitize 碰撞/空名防御 + schema/description 类型守卫 + 输出防御
+  const seen = new Set()
+  const out = []
+  for (const t of mcpTools) {
+    const rawName = sanitizeToolName(prefix + t.name)
+    if (!rawName || rawName === "mcp_") continue
+    let name = rawName
+    for (let n = 2; seen.has(name); n++) name = `${rawName}_${n}`
+    seen.add(name)
+    out.push({
+      name,
+      description: typeof t.description === "string" ? t.description : `MCP tool: ${t.name}`,
+      parameters: (t.inputSchema && typeof t.inputSchema === "object") ? t.inputSchema : { type: "object", properties: {} },
+      readonly: false,
+      async execute(args, ctx) {
+        // 2026-08-31 会诊 #11：上层 signal 中断 + send 第 3 参底层取消（pending 即刻作废）
+        // P5：执行前动态取 session.transport——死亡时等重连 promise/触发一次重连再试
+        const transport = await ensureAlive(session)
+        const send = transport.send("tools/call", { name: t.name, arguments: args }, ctx?.signal)
+        const resp = await sendWithSignal(send, ctx?.signal)
+        if (resp.error) throw new Error(`MCP tool "${t.name}": ${resp.error.message}`)
+        if (resp.result?.isError) throw new Error(`MCP tool "${t.name}": ${extractMcpText(resp.result.content) || "(server reported an error)"}`)
+        return truncateMcpOutput(extractMcpText(resp.result?.content ?? [])) || "(no output)"
+      },
+      _mcpTransport: session.state.transport,
+      _mcpName: config.name,
+    })
+  }
+  return out
 }
 
-async function doInitialize(transport, name) {
+/** P5：拿到活的 transport——死连接等待/触发重连；耗尽后抛错（工具错误透给模型）。 */
+async function ensureAlive(session) {
+  const t = session.state.transport
+  if (t?.isAlive?.()) return t
+  const name = session.config.name ?? session.config.command ?? session.config.url ?? session.config.wsUrl
+  let reconnect = _reconnecting.get(name)
+  if (!reconnect) reconnect = scheduleReconnect(name, session.config)
+  const ok = await reconnect
+  if (!ok || !session.state.transport?.isAlive?.()) {
+    throw new Error(`MCP server "${name}" is unavailable (reconnect failed)`)
+  }
+  return session.state.transport
+}
+
+/** MCP content 数组 → 文本（非数组/元素非对象防御）。 */
+function extractMcpText(content) {
+  if (!Array.isArray(content)) return typeof content === "string" ? content : JSON.stringify(content)
+  return content
+    .filter((c) => c && typeof c === "object")
+    .map((c) => (c.type === "text" ? c.text : c.type === "resource" ? `[resource: ${c.resource?.uri}]` : JSON.stringify(c)))
+    .join("\n")
+}
+
+/** 输出截断（32KB 上限，防 server 回 10MB 撑爆上下文）。 */
+function truncateMcpOutput(text) {
+  if (text.length <= 32_000) return text
+  return text.slice(0, 32_000) + "\n[… truncated: " + (text.length - 32_000) + " chars omitted]"
+}
+
+async function doInitialize(transport, _name) {
   const initResp = await withTimeout(
     transport.send("initialize", {
       protocolVersion: "2024-11-05",
@@ -41,68 +171,77 @@ async function doInitialize(transport, name) {
   if (initResp.error) throw new Error(`initialize error: ${initResp.error.message}`)
   transport.notify?.("notifications/initialized", {})
 
-  const toolsResp = await transport.send("tools/list", {})
-  if (toolsResp.error) throw new Error(`tools/list failed: ${toolsResp.error.message}`)
-  return toolsResp.result?.tools ?? []
+  // 2026-08-31 MCP 会诊 P6：tools/list 分页被忽略（nextCursor 多页工具静默丢失）——
+  // 循环跟随 cursor 直到 server 不再返回（上限 20 页防死循环）。
+  const tools = []
+  let cursor
+  for (let page = 0; page < 20; page++) {
+    const toolsResp = await transport.send("tools/list", cursor ? { cursor } : {})
+    if (toolsResp.error) throw new Error(`tools/list failed: ${toolsResp.error.message}`)
+    tools.push(...(toolsResp.result?.tools ?? []))
+    cursor = toolsResp.result?.nextCursor
+    if (!cursor) break
+  }
+  return tools
 }
 
-/** Connect to an MCP server (stdio/http/ws), initialize, and return built tool wrappers */
+/** Connect to an MCP server (stdio/http/ws), initialize, and return built tool wrappers.
+ *  2026-08-31 MCP 会诊 P5：session 幂等——同 name 活连接复用（make-agent 每进程一次，
+ *  cmd-mcp 重复 add 同一 server 不会双实例），崩溃后下次调用/execute 自愈。 */
 export async function connectMcpServer(config) {
-  if (config.wsUrl) {
-    const transport = wsTransport(config.wsUrl, config.headers ?? {})
-    try {
-      await transport.connect()
-      const mcpTools = await doInitialize(transport, config.name ?? config.wsUrl)
-      return buildTools(mcpTools, transport, config)
-    } catch (error) {
-      transport.close()
-      throw error
-    }
-  }
+  if (!config || (!config.command && !config.url && !config.wsUrl))
+    throw new Error(`MCP server "${config?.name ?? ""}": needs either 'wsUrl' (websocket), 'command' (stdio), or 'url' (http)`)
+  const name = config.name ?? config.command ?? config.url ?? config.wsUrl
+  const configFingerprint = JSON.stringify([config.command ?? null, config.args ?? null, config.url ?? null, config.wsUrl ?? null, config.env ?? null, config.headers ?? null])
 
-  if (config.url) {
-    const transport = httpTransport(config.url, config.headers ?? {})
-    try {
-      await transport.openSSE()
-    } catch {
-      // Server doesn't support GET (pure Streamable HTTP POST): degrade to no-SSE mode
+  const existing = _sessions.get(name)
+  if (existing && !existing.closed) {
+    const sameConfig = existing.configFingerprint === configFingerprint
+    if (sameConfig && existing.state.transport?.isAlive?.()) {
+      return existing.state.tools
     }
-    try {
-      const mcpTools = await doInitialize(transport, config.name ?? config.url)
-      return buildTools(mcpTools, transport, config)
-    } catch (error) {
-      transport.close()
-      throw error
+    if (!sameConfig) {
+      // config 变更：主动关闭旧连接（不触发 onDead 重连）并丢弃 session
+      existing.closed = true
+      try { existing.state.transport?.close() } catch { /* ignore */ }
+      _sessions.delete(name)
     }
   }
 
-  if (config.command) {
-    const transport = stdioTransport(config.command, config.args ?? [], config.env)
-    try {
-      const mcpTools = await doInitialize(transport, config.name ?? config.command)
-      return buildTools(mcpTools, transport, config)
-    } catch (error) {
-      transport.close()
-      throw error
-    }
+  const { transport, mcpTools } = await createConnectedTransport(config, name)
+  const session = {
+    config, configFingerprint,
+    state: { transport, tools: null },
+    closed: false,
   }
-
-  throw new Error(`MCP server "${config.name}": needs either 'wsUrl' (websocket), 'command' (stdio), or 'url' (http)`)
+  session.state.tools = buildTools(mcpTools, session, config)
+  attachSession(session, transport)
+  _sessions.set(name, session)
+  return session.state.tools
 }
 
 /** Close all MCP transport connections on an agent's tools */
 export function closeAllMcp(agent) {
   for (const t of agent.tools) {
-    if (t._mcpTransport) t._mcpTransport.close()
+    if (t._mcpTransport) closeSession(t._mcpName)
   }
 }
 
+/** 主动关闭 session（不触发 onDead 重连）：transport close + 登记关闭标记 + 清注册表。 */
+function closeSession(name) {
+  const session = _sessions.get(name)
+  if (!session) return
+  session.closed = true
+  try { session.state.transport?.close() } catch { /* ignore */ }
+  _sessions.delete(name)
+}
+
 /** Remove MCP tools belonging to a specific server from the agent's tool list */
 export function removeMcpTools(agent, serverName) {
   const keep = []
   for (const t of agent.tools) {
     if (t._mcpName === serverName) {
-      if (t._mcpTransport) t._mcpTransport.close()
+      closeSession(serverName)
     } else {
       keep.push(t)
     }