thincoder 0.12.61 → 0.12.63

package/src/log.mjs

@@ -1,195 +0,0 @@
-/**
- * log.mjs — 诊断事件日志（docs/design/LOGGING.md 权威规格）。
- * 双端同构：thincoder/src/log.mjs 与 thincoder-vscode/src/log.mjs 同一实现语义
- * （共享 ~/.thincoder/logs/、同格式、同事件面——F-L6）。
- *
- * 常驻骨架日志：回合/LLM/工具/子代理/挂起的关键事件——每行一个 JSON 事件，按天轮转
- * （agent-YYYY-MM-DD.log），保留 1 天——用户零手动维护（F-L3/NF-L4）。问题发生时
- * 直接 tail/grep 定位断点（根治"临时插桩再删"循环）。
- *
- * 纪律（实现侧逐条落实）：
- * - fire-and-forget：logEvent 失败静默降级（NF-L1）——主流程零影响。进程内首次写失败
- *   即置死（_dead），当日不再尝试（磁盘满/权限错不逐事件空转）。
- * - 单事件行 <512 字符（NF-L2）：head（LLM ≤300 / 工具 ≤200）、err ≤200 由调用方截断，
- *   本模块对任意字符串字段做上限兜底（head 300 / err 200 / 其余 120）+ 超长时丢可选字段。
- * - 敏感字段零落盘（NF-L3/§2.4，2026-09-03 评审 refinement #7 匹配语义定稿）：
- *   ① 字段名精确匹配黑名单（apiKey/designToken/password/secret/token，大小写不敏感；
- *      另加防御性名称 authorization/proxy/proxyUri——防凭据型 URL/头字段泄漏——§2.5）
- *      → 整个字段丢弃；
- *   ② 内容只扫密钥形态（sk-xxx / Bearer xxx / key=… 等）→ 截断到形态之前
- *      ——宁可丢信息不漏密钥。
- *   工具事件不记 args；URL 不入事件（llm/tool 事件从不携带 URL；err 文本经形态扫描）。
- * - 摘要截断（B 方案，2026-09-03 用户裁定）：截断处带 "…" 标记（截后仍 ≤上限）。
- * - 测试隔离：node --test 进程（NODE_TEST_CONTEXT）默认不写盘——防测试事件污染真实
- *   诊断日志（两端测试套件都会跑真实 agent 管线）；显式设置 THINCODER_LOG_DIR 强制
- *   写入该目录（log.test.mjs 用它隔离临时目录——refinement #6）。
- * - 轮转清理（refinement #3——长驻进程覆盖）：非仅启动时——每进程每日**首次写事件**
- *   时顺带清理 >1 天的 agent-*.log（extension host 可长驻数月，启动清理覆盖不到）。
- * - seq：每进程单调计数器。双端同写一个文件时 seq 会各自重复——定位同文件时序以
- *   ts 为准，seq 仅进程内参照（refinement #8）。
- */
-
-import { appendFileSync, mkdirSync, readdirSync, rmSync, existsSync, statSync } from "node:fs"
-import { homedir } from "node:os"
-import { join } from "node:path"
-
-/** 单行长度硬上限（NF-L2） */
-export const MAX_LINE = 512
-/** 字段名精确黑名单（NF-L3/§2.4——2026-09-03 评审 refinement #7：与 §2.4 词表一致含 token） */
-const BLACKLIST_FIELDS = new Set(["apikey", "designtoken", "password", "secret", "token", "authorization", "proxyuri", "proxy"])
-/** 内容密钥形态扫描（大小写不敏感）——命中即截断到形态前 */
-const SECRET_FORM = /(\bsk-[A-Za-z0-9_-]{6,}|\bBearer\s+[A-Za-z0-9._~+/=-]{6,}|\b(?:api[_-]?key|key|token|secret|password|pwd|passwd)\s*[=:]\s*['"]?[A-Za-z0-9._~+/=-]{6,})/i
-/** 字符串字段长度兜底：head ≤300 / err ≤200 / 其余 ≤120 */
-const FIELD_CAPS = { head: 300, err: 200 }
-
-let _seq = 0
-let _dead = false // 进程内写失败即死（NF-L1 静默降级——不逐事件重复空转）
-let _cleanupDate = null // 本进程已执行过清理的日期（每日首次写时清一次）
-
-/** 日志目录：THINCODER_LOG_DIR（测试隔离/override）> ~/.thincoder/logs（与 sessions/ 同域） */
-export function logsDir() {
-  return process.env.THINCODER_LOG_DIR ?? join(homedir(), ".thincoder", "logs")
-}
-
-/** 今日日志文件路径（agent-YYYY-MM-DD.log） */
-export function todayLogPath(now = new Date()) {
-  const ymd = now.toISOString().slice(0, 10)
-  return join(logsDir(), `agent-${ymd}.log`)
-}
-
-/** 写门（测试隔离）：test runner 进程（NODE_TEST_CONTEXT）默认跳过——除显式
- *  THINCODER_LOG_DIR override（log.test.mjs 隔离临时目录——refinement #6）。 */
-function writeEnabled() {
-  if (_dead) return false
-  if (process.env.NODE_TEST_CONTEXT && !process.env.THINCODER_LOG_DIR) return false
-  return true
-}
-
-/** 清理 >1 天的 agent-*.log（NF-L4——refinement #3：机会式，非仅启动时）。
- *  保留窗口（2026-09-03 code review #1 修正）：以文件名日期的**当日结束**为龄基准——
- *  今天+昨天的文件保留（任何事件至少留存 24h、最多 48h），早于昨天的删除。
- *  无法按名解析日期的 agent-*.log 按 mtime 兜底（>1 天未写的删除）。
- *  导出供测试直呼（T-L7/T-L7b）。静默：任何失败都不影响主流程。 */
-export const LOG_RETENTION_MS = 24 * 60 * 60 * 1000
-export function cleanupOldLogs(now = new Date()) {
-  const dir = logsDir()
-  if (!existsSync(dir)) return
-  let names
-  try {
-    names = readdirSync(dir)
-  } catch {
-    return
-  }
-  for (const name of names) {
-    if (!name.startsWith("agent-") || !name.endsWith(".log")) continue
-    const m = name.match(/^agent-(\d{4}-\d{2}-\d{2})\.log$/)
-    const ts = m ? Date.parse(m[1] + "T00:00:00Z") : NaN
-    // 文件名日期 → 龄以该日结束（ts+24h）计：事件在删除时至少已留存 24h
-    const ageMs = Number.isFinite(ts) ? now - (ts + LOG_RETENTION_MS) : (tryStatAge(dir, name, now) ?? Infinity)
-    if (ageMs > LOG_RETENTION_MS) {
-      try { rmSync(join(dir, name), { force: true }) } catch { /* 静默 */ }
-    }
-  }
-}
-
-function tryStatAge(dir, name, now) {
-  try {
-    return now - statSync(join(dir, name)).mtimeMs
-  } catch {
-    return null
-  }
-}
-
-/**
- * 写入一条事件（fire-and-forget）。fields 内所有字符串都经黑名单/截断处理。
- * 事件行结构：{"ts":ISO,"ev":kind,"seq":N,...fields}——单行 JSON <512 字符。
- */
-export function logEvent(kind, fields = {}) {
-  if (!writeEnabled()) return
-  const now = new Date()
-  // 机会式轮转清理：每进程每日首次写事件时执行一次（refinement #3——长驻进程覆盖）
-  const ymd = now.toISOString().slice(0, 10)
-  if (_cleanupDate !== ymd) {
-    _cleanupDate = ymd
-    cleanupOldLogs(now)
-  }
-  const entry = { ts: now.toISOString(), ev: kind, seq: ++_seq }
-  for (const [k, v] of Object.entries(fields ?? {})) {
-    if (v === undefined || v === null) continue
-    // ① 字段名精确黑名单 → 丢弃（token 族永不落盘）
-    if (BLACKLIST_FIELDS.has(String(k).toLowerCase())) continue
-    if (typeof v === "string") entry[k] = sanitizeString(k, v)
-    else if (typeof v === "number" || typeof v === "boolean") entry[k] = v
-  }
-  let line = JSON.stringify(entry)
-  // ② 防御性收尾（NF-L2）：字段上限后仍超长 → 丢可选字段（保留 ts/ev/seq）直至 <512
-  while (line.length > MAX_LINE && Object.keys(entry).length > 3) {
-    for (const k of Object.keys(entry)) {
-      if (k !== "ts" && k !== "ev" && k !== "seq") { delete entry[k]; break }
-    }
-    line = JSON.stringify(entry)
-  }
-  try {
-    const dir = logsDir()
-    mkdirSync(dir, { recursive: true })
-    appendFileSync(join(dir, `agent-${ymd}.log`), line + "\n", "utf8")
-  } catch {
-    _dead = true // NF-L1：写失败静默降级——主流程零影响
-  }
-}
-
-/** 共享脱敏（§18.6 D-TR2——trace-store 复用；logEvent 自身保持"丢弃字段"语义，
- *  本函数提供"遮蔽标记"语义——同一字段名黑名单 + 同一 SECRET_FORM 形态扫描，
- *  不发明新遮蔽模式）。字段名命中黑名单 → "[REDACTED]（整个字段遮蔽）；内容命中
- *  密钥形态 → 截断到形态前 + "[redacted]" 标记（宁可丢信息不漏密钥——§2.4）。 */
-export function redactSecret(fieldKey, value) {
-  const s = String(value)
-  if (BLACKLIST_FIELDS.has(String(fieldKey).toLowerCase())) return "[REDACTED]"
-  const hit = s.match(SECRET_FORM)
-  return hit ? s.slice(0, hit.index) + "[redacted]" : s
-}
-
-/** 内容级净化：密钥形态截断到形态前（②）；超长截断 + "…" 标记。 */
-export function sanitizeString(key, value) {
-  let s = String(value)
-  // 密钥形态 → 截断到形态前（宁可丢信息不漏密钥——§2.4）
-  const hit = s.match(SECRET_FORM)
-  if (hit) s = s.slice(0, hit.index)
-  const cap = FIELD_CAPS[key] ?? 120
-  if (s.length > cap) s = s.slice(0, cap - 1) + "…"
-  return s
-}
-
-/** 错误文本提取：message + cause 链首条、压成单行、≤max（默认 200——NF-L2/§2.2） */
-export function errText(err, max = 200) {
-  let msg = err?.message ?? String(err ?? "")
-  if (!msg && err?.cause) msg = String(err.cause)
-  if (err?.cause?.message && !/^LLM API error/.test(msg)) msg += ` (${err.cause.message})`
-  msg = msg.replace(/\s*\n\s*/g, " ").trim()
-  if (msg.length > max) msg = msg.slice(0, max - 1) + "…"
-  return msg
-}
-
-/** 错误 kind 分类（llm:error 字段）：timeout（网关超时/超时信号）/ abort（用户中止）/
- *  error（其余——API/网络/未分类）。signal 为请求中止信号（chat 调用点直传）。 */
-export function classifyErr(err, signal) {
-  const msg = String(err?.message ?? "").toLowerCase() + " " + String(err?.cause?.message ?? "").toLowerCase()
-  if (/timeout|timed ?out|etimedout|time limit exceeded/i.test(msg)) return "timeout"
-  if (err?.name === "AbortError" || signal?.aborted) {
-    return signal?.reason?.name === "TimeoutError" ? "timeout" : "abort"
-  }
-  return "error"
-}
-
-/** 文本头截取：前 max 字符、单行化（JSON 单行约束）、截断带 "…" 标记。
- *  paragraph=true（llm:done 响应头）：取首段（首个空行前）——B 方案"首段文本"语义。 */
-export function headText(text, max, { paragraph = false } = {}) {
-  let s = String(text ?? "")
-  if (paragraph) {
-    const p = s.split(/\n\s*\n/, 1)[0]
-    if (p.length < s.length) s = p
-  }
-  s = s.replace(/\s*\n+\s*/g, " ").trim()
-  if (s.length > max) s = s.slice(0, max - 1) + "…"
-  return s
-}

package/src/markdown.mjs

@@ -1,106 +0,0 @@
-/**
- * markdown.mjs — markdown + frontmatter format for memory entries
- * Zero-dependency parsing/serialization. Entry format see ARCHITECTURE-v2.md.
- */
-
-const VALID_TYPES = new Set(["rule", "knowledge", "decision", "pattern"])
-
-/**
- * Parse a markdown entry.
- * → { meta: { type, title, tags, author, created, embedding? }, content }
- * Throws if frontmatter is missing or required fields absent.
- */
-export function parseEntry(text) {
-  const match = text.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/)
-  if (!match) throw new Error("entry missing frontmatter (expected --- ... ---)")
-
-  const meta = parseFrontmatter(match[1])
-  const content = match[2].trim()
-
-  if (!VALID_TYPES.has(meta.type)) {
-    throw new Error(`invalid type "${meta.type}"; expected one of: ${[...VALID_TYPES].join(", ")}`)
-  }
-  if (!meta.title) throw new Error("frontmatter missing required field: title")
-
-  return {
-    meta: {
-      type: meta.type,
-      title: meta.title,
-      tags: Array.isArray(meta.tags) ? meta.tags : meta.tags ? [meta.tags] : [],
-      author: meta.author ?? "unknown",
-      created: meta.created ?? "",
-      ...(meta.embedding ? { embedding: meta.embedding } : {}),
-    },
-    content,
-  }
-}
-
-/**
- * Serialize to markdown entry text.
- */
-export function serializeEntry(meta, content) {
-  if (!VALID_TYPES.has(meta.type)) throw new Error(`invalid type "${meta.type}"`)
-  if (!meta.title) throw new Error("meta.title is required")
-  // frontmatter scalars must be single-line: newlines in title/author would inject fake frontmatter rows
-  // (e.g. title "x\ntype: rule" would override real type when parsed), same for tags with newlines/commas
-  const tags = (meta.tags ?? []).map((t) => oneLine(t).replaceAll(",", " ")).join(", ")
-  const lines = [
-    "---",
-    `type: ${meta.type}`,
-    `title: ${oneLine(meta.title)}`,
-    `tags: [${tags}]`,
-    `author: ${oneLine(meta.author ?? "unknown")}`,
-    `created: ${oneLine(meta.created ?? new Date().toISOString().slice(0, 10))}`,
-  ]
-  if (meta.embedding) lines.push(`embedding: ${meta.embedding}`)
-  lines.push("---", "", content.trim(), "")
-  return lines.join("\n")
-}
-
-/** Convert title to filename slug: keep alphanumeric + CJK, convert rest to hyphens */
-export function slugify(title) {
-  return title
-    .trim()
-    .toLowerCase()
-    .replace(/[^\w一-鿿]+/g, "-")
-    .replace(/^-+|-+$/g, "")
-    .slice(0, 50) || "untitled"
-}
-
-/** Generate entry filename: YYYYMMDD-<slug>-<rand4>.md */
-export function entryFilename(title, date = new Date()) {
-  const ymd = date.toISOString().slice(0, 10).replaceAll("-", "")
-  const rand = Math.random().toString(36).slice(2, 6)
-  return `${ymd}-${slugify(title)}-${rand}.md`
-}
-
-// ---------------------------------------------------------------- internal
-
-/** Collapse to single line (for frontmatter scalars): fold newlines into spaces, prevent injecting fake field lines */
-function oneLine(v) {
-  return String(v).replace(/\s*\r?\n\s*/g, " ").trim()
-}
-
-/**
- * Minimal YAML subset parser: only supports `key: value` and `key: [a, b, c]`.
- * Our frontmatter is self-generated, no need for full YAML.
- */
-export function parseFrontmatter(text) {
-  const meta = {}
-  for (const line of text.split(/\r?\n/)) {
-    const m = line.match(/^(\w[\w-]*)\s*:\s*(.*)$/)
-    if (!m) continue
-    const [, key, raw] = m
-    const value = raw.trim()
-    if (value.startsWith("[") && value.endsWith("]")) {
-      meta[key] = value
-        .slice(1, -1)
-        .split(",")
-        .map((s) => s.trim())
-        .filter(Boolean)
-    } else {
-      meta[key] = value
-    }
-  }
-  return meta
-}

package/src/mcp/helpers.mjs

@@ -1,51 +0,0 @@
-/**
- * mcp/helpers.mjs — MCP shared utility functions and constants
- */
-
-export const INIT_TIMEOUT_MS = 30_000
-export const CALL_TIMEOUT_MS = 120_000
-export const ENDPOINT_WAIT_MS = 5_000
-
-let nextRpcId = 0
-/** Generate a unique incrementing RPC ID string */
-export function rpcId() {
-  return String(++nextRpcId)
-}
-
-/** Race a promise against a timeout, rejecting after ms milliseconds */
-export function withTimeout(promise, ms) {
-  let timer
-  const timeout = new Promise((_, reject) => {
-    timer = setTimeout(() => reject(new Error(`timeout after ${ms}ms`)), ms)
-    timer.unref?.()
-  })
-  return Promise.race([promise.finally(() => clearTimeout(timer)), timeout])
-}
-
-/** Quote a shell argument: wrap in double-quotes if it contains whitespace or quotes */
-export function quoteArg(s) {
-  return /[\s"]/.test(s) ? `"${s.replace(/"/g, '""')}"` : s
-}
-
-/** Convert an Authorization Bearer token into a WebSocket subprotocol.
- *  2026-08-31 MCP 会诊 #10：原实现把 token 塞进 URL query——代理/网关日志会泄露凭证，
- *  且无标准依据。Node 内置 WebSocket（undici）无法自定义请求头，MCP 生态的标准替代
- *  通道是 subprotocol（`bearer.<token>`）。用户 URL 自带的 query token 不动（兼容）。
- *  @returns {{ url: string, protocols: string[] }} — protocols 为空数组表示无认证。 */
-export function withAuthToken(wsUrl, authorization) {
-  if (!authorization) return { url: wsUrl, protocols: [] }
-  const token = authorization.replace(/^Bearer\s+/i, "")
-  let u
-  try {
-    u = new URL(wsUrl)
-  } catch {
-    throw new Error(`Invalid WebSocket URL: ${String(wsUrl).slice(0, 120)}`)
-  }
-  // subprotocol 不进入 URL/日志，token 不再注入 query
-  return { url: u.href, protocols: [`bearer.${token}`] }
-}
-
-/** Sanitize a tool name: replace non-alphanumeric chars with underscores, cap at 64 chars */
-export function sanitizeToolName(name) {
-  return name.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64)
-}

package/src/mcp/transport-http.mjs

@@ -1,248 +0,0 @@
-/**
- * mcp/transport-http.mjs — MCP HTTP + SSE transport (Streamable HTTP)
- */
-import { rpcId, CALL_TIMEOUT_MS, ENDPOINT_WAIT_MS, INIT_TIMEOUT_MS, withTimeout } from "./helpers.mjs"
-
-/** Create an MCP HTTP+SSE transport for Streamable HTTP servers */
-export function httpTransport(baseURL, extraHeaders = {}) {
-  const url = baseURL.replace(/\/+$/, "")
-  let sessionId = null
-  let closed = false
-  let eventSource = null
-  // 2026-09-01 MCP.md §4 D-1：GET SSE 不可用（405/不支持）降级后的纯 POST 模式标记。
-  // POST-only server（如 glm-websearch）无流可断：isAlive 不得因 eventSource == null 判死。
-  let postOnly = false
-  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 }
-    if (sessionId) h["Mcp-Session-Id"] = sessionId
-    return h
-  }
-
-  const pending = new Map()
-
-  async function* parseSSE(response) {
-    const reader = response.body.getReader()
-    const decoder = new TextDecoder()
-    let buf = ""
-    let current = { data: "", event: "message" }
-    try {
-      while (true) {
-        const { done, value } = await reader.read()
-        if (done) break
-        buf += decoder.decode(value, { stream: true })
-        const lines = buf.split("\n")
-        buf = lines.pop() ?? ""
-        for (const raw of lines) {
-          const line = raw.endsWith("\r") ? raw.slice(0, -1) : raw
-          if (line === "") {
-            if (current.data) {
-              yield { event: current.event, data: current.data.trimEnd() }
-              current = { data: "", event: "message" }
-            }
-          } else if (line.startsWith("data:")) {
-            current.data += (current.data ? "\n" : "") + line.slice(5).replace(/^ /, "")
-          } else if (line.startsWith("event:")) {
-            current.event = line.slice(6).trim()
-          }
-        }
-      }
-    } finally {
-      reader.releaseLock()
-    }
-  }
-
-  async function openSSE() {
-    if (closed) return
-    abortController?.abort()
-    abortController = new AbortController()
-    const signal = AbortSignal.any([abortController.signal, AbortSignal.timeout(INIT_TIMEOUT_MS)])
-    const resp = await fetch(url, {
-      method: "GET",
-      headers: { Accept: "text/event-stream", ...extraHeaders },
-      signal,
-    })
-    if (!resp.ok) throw new Error(`SSE connect failed: HTTP ${resp.status}`)
-    eventSource = parseSSE(resp)
-    let endpointReady
-    const gotEndpoint = new Promise((resolve) => { endpointReady = resolve })
-
-    ;(async () => {
-      try {
-        for await (const { event, data } of eventSource) {
-          if (closed) break
-          if (event === "endpoint") {
-            postUrl = new URL(data.trim(), url).href
-            legacySSE = true
-            endpointReady()
-            continue
-          }
-          try {
-            const msg = JSON.parse(data)
-            const resolver = pending.get(msg.id)
-            if (resolver) {
-              pending.delete(msg.id)
-              resolver(msg)
-            }
-          } catch { /* not JSON, ignore */ }
-        }
-        // 正常走完 = server 关闭了流（网络/对端退出）→ 非主动关闭视为死亡
-        if (!closed) fireDead("SSE stream ended")
-      } catch (error) {
-        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}`)
-        }
-      }
-    })()
-
-    const wait = new Promise((resolve) => {
-      const t = setTimeout(resolve, ENDPOINT_WAIT_MS)
-      t.unref?.()
-    })
-    await Promise.race([gotEndpoint, wait])
-  }
-
-  async function postRequest(method, params) {
-    const id = rpcId()
-    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(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)
-            resolve({ id, error: { code: -32000, message: `POST failed: ${e.message}` } })
-          })
-      }).finally(() => pending.delete(id))
-    }
-
-    // 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)
-
-  const notify = (method, params) => {
-    fetch(postUrl, {
-      method: "POST",
-      headers: headers(),
-      body: JSON.stringify({ jsonrpc: "2.0", method, params }),
-      signal: AbortSignal.timeout(10_000),
-    }).catch((e) => {
-      // notify is fire-and-forget by design, but log network errors for debugging
-      if (e.name !== "AbortError") console.error(`[mcp] notify failed: ${e.message}`)
-    })
-  }
-
-  const close = () => {
-    closed = true
-    abortController?.abort()
-    if (sessionId) {
-      fetch(postUrl, {
-        method: "DELETE",
-        headers: { "Mcp-Session-Id": sessionId, ...extraHeaders },
-        signal: AbortSignal.timeout(5_000),
-      }).catch((e) => {
-        // close is best-effort cleanup; log but don't throw
-        if (e.name !== "AbortError") console.error(`[mcp] close DELETE failed: ${e.message}`)
-      })
-      sessionId = null
-    }
-    for (const [, resolve] of pending) resolve({ id: null, error: { code: -32000, message: "Connection closed" } })
-    pending.clear()
-  }
-
-  /** D-1：openSSE 降级（GET 405/不支持）后由 connect 链调用——标记纯 Streamable POST 模式 */
-  const markPostOnly = () => { postOnly = true }
-
-  return {
-    send, notify, close, openSSE, url, headers: extraHeaders,
-    // F1：POST-only 降级（postOnly）与 legacy SSE 流（eventSource）都算活连接——
-    // 不得因 eventSource == null 误判死（glm-websearch "reconnect failed" 根因）。
-    isAlive: () => !closed && (eventSource != null || postOnly),
-    onDead, markPostOnly,
-  }
-}