lark-relay 0.4.5 → 0.4.7

package/lib/claude.js

@@ -1,231 +0,0 @@
-'use strict'
-
-// 唤起 headless claude。session 确定性派生,不落配置、不需人填。
-const crypto = require('crypto')
-const fs = require('fs')
-const os = require('os')
-const path = require('path')
-const { spawn } = require('child_process')
-
-// 模型分发交给一个 shell 函数 `claude()` —— 由它做白名单校验与后端路由,
-// 是模型名的单一事实源。包不自己维护模型清单(那样新增后端要改两处)。
-//
-// LR_CC_RC 指向定义了 `claude()` 的 rc 文件。默认值只是个约定俗成的位置,
-// 部署时按实际环境设置:Environment=LR_CC_RC=%h/path/to/claude.sh
-const CC_RC = process.env.LR_CC_RC || path.join(os.homedir(), '.claude-route.sh')
-
-// sha1(task|scope) 前 32 位切成 8-4-4-4-12
-function deriveUuid(task, scope) {
-  const h = crypto.createHash('sha1').update(`${task}|${scope}`).digest('hex')
-  return `${h.slice(0, 8)}-${h.slice(8, 12)}-${h.slice(12, 16)}-${h.slice(16, 20)}-${h.slice(20, 32)}`
-}
-
-// Claude Code 按 cwd 分目录存 session:/ 和 . 都换成 -
-function encCwd(cwd) {
-  return String(cwd).replace(/[/.]/g, '-')
-}
-
-function sessionFile(cwd, uuid) {
-  return path.join(os.homedir(), '.claude', 'projects', encCwd(cwd), `${uuid}.jsonl`)
-}
-
-// 会话世代号:超过 idleGap 没动静就开新会话。thread 模式不调用(话题即边界,恒 0)。
-function sessionEpoch(stateDir, task, chatId, idleGap) {
-  const dir = path.join(stateDir, 'state')
-  fs.mkdirSync(dir, { recursive: true })
-  const file = path.join(dir, `${task}__${chatId}.tsv`)
-  const now = Math.floor(Date.now() / 1000)
-  let epoch = 0
-  try {
-    const [lastStr, epStr] = fs.readFileSync(file, 'utf8').trim().split('\t')
-    const last = Number(lastStr) || 0
-    epoch = Number(epStr) || 0
-    if (idleGap > 0 && now - last > idleGap) epoch += 1
-  } catch {}
-  fs.writeFileSync(file, `${now}\t${epoch}\n`)
-  return epoch
-}
-
-// 提示词按 mode 分流 —— 两类场景对模型的要求根本不同。
-// work/chat:模型产出一段结论,由 dispatch 发回群(模型不碰发送)。
-// agent:模型自己决定发不发、发给谁、用谁的身份、发文字还是表情 ——
-//   引擎不做回复决策,和「引擎不做权限管控」是同一条思路:边界靠 instructions 到达模型侧。
-const PROMPTS = {
-  task: (batch) =>
-    `下面是飞书群里最新一批消息。请把它们当作针对本仓库(当前工作目录)的任务来处理:定位/分析/修复/测试。处理完后,你的最终回复会被原样发回该群,请直接面向群里的人简洁说明你做了什么、发现了什么、需要什么确认。
-
-===== 群消息 =====
-${batch}
-===== 结束 =====`,
-
-  agent: (batch) =>
-    `下面是飞书群里最新一批消息。
-
-**本轮的发送完全由你负责** —— 没有任何东西会被自动发回群。按你的职责文档判断:
-该不该回应、回应哪一条、用哪个身份、发文字还是表情回应、要不要执行既定任务。
-需要发送时自己用 lark-cli 完成。
-
-**多数情况下正确的选择是什么都不做** —— 不要为了有所动作而发言。
-
-处理完请用一句话说明你做了什么(如「用可莉回复了接梗」「无 @ 我方,沉默」),
-这句话只进台账供事后回溯,不会发到群里。
-
-===== 群消息 =====
-${batch}
-===== 结束 =====`,
-}
-
-/**
- * 起一轮 headless claude。
- * @returns {Promise<{rc:number, final:string, err:string}>}
- */
-function runClaude(opts) {
-  const {
-    cwd,
-    prompt,
-    uuid,
-    instructions,
-    addDirs = [],
-    allowedTools = 'Read Edit Write Bash',
-    model,
-    timeoutSec = 1800,
-    stream = false,
-    onEvent,
-  } = opts
-
-  const resume = fs.existsSync(sessionFile(cwd, uuid))
-  const args = ['-p', prompt]
-  // 首次用 --session-id 建、之后用 --resume 续,判据就是 jsonl 是否存在
-  args.push(resume ? '--resume' : '--session-id', uuid)
-  args.push('--add-dir', cwd) // 主工作目录自己也加一次
-  args.push('--setting-sources', 'user,project,local') // 含 project 才加载主目录 CLAUDE.md
-  args.push('--permission-mode', 'acceptEdits')
-  args.push('--allowedTools', allowedTools)
-  for (const d of addDirs) args.push('--add-dir', d)
-  // 职责/边界必须走这里:CLAUDE.md 只自动加载主工作目录+父链,
-  // --add-dir 的目录启动不加载,AGENTS.md 也不被当 memory
-  if (instructions && fs.existsSync(instructions)) {
-    args.push('--append-system-prompt-file', instructions)
-  }
-  args.push('--output-format', stream ? 'stream-json' : 'json')
-  if (stream) args.push('--verbose')
-
-  // 经 bash -lc source <rc> 后调 claude() —— 模型分发与白名单校验都在那里。
-  // rc 不存在时**不当致命错误**:降级到 PATH 里的 claude,只在指定了 --model 时才必须有 rc
-  // (否则 --model 传给原生 claude 会是另一套语义)。
-  // ⚠️ CC_RC 必须 shellQuote:曾直接内插进双引号里的 echo,
-  // LR_CC_RC='/x$(命令)' 会被执行(实测)。所有插进 script 的值一律走 shellQuote
-  const quoted = args.map(shellQuote).join(' ')
-  const rcQ = shellQuote(CC_RC)
-  const script = model
-    ? `set -o pipefail\n` +
-      `if ! source ${rcQ} 2>/dev/null; then\n` +
-      `  printf '%s\\n' "cc: 指定了 --model 但 source 失败,设 LR_CC_RC 指向定义 claude() 的文件" >&2\n` +
-      `  exit 3\n` +
-      `fi\n` +
-      `claude --model ${shellQuote(model)} ${quoted}\n`
-    : `set -o pipefail\n` +
-      `source ${rcQ} 2>/dev/null || true\n` +
-      `claude ${quoted}\n`
-
-  return new Promise((resolve) => {
-    const child = spawn('bash', ['-lc', script], {
-      cwd,
-      env: {
-        ...process.env,
-        LANG: 'C.UTF-8',
-        LC_ALL: 'C.UTF-8',
-        // headless 里 Bash 工具层单命令超时 10min(非整体超时)
-        BASH_MAX_TIMEOUT_MS: process.env.BASH_MAX_TIMEOUT_MS || '600000',
-      },
-      stdio: ['ignore', 'pipe', 'pipe'],
-    })
-
-    let out = ''
-    let err = ''
-    let done = false
-    // 挂钟超时兜底:包住整轮
-    const timer = setTimeout(() => {
-      if (!done) {
-        err += `\n[timeout ${timeoutSec}s]`
-        child.kill('SIGTERM')
-        setTimeout(() => child.kill('SIGKILL'), 5000)
-      }
-    }, timeoutSec * 1000)
-
-    if (stream) {
-      let buf = ''
-      child.stdout.on('data', (d) => {
-        buf += d.toString()
-        const lines = buf.split('\n')
-        buf = lines.pop()
-        for (const line of lines) handleStreamLine(line, onEvent, (t) => (out = t))
-      })
-      child.stdout.on('end', () => {
-        if (buf.trim()) handleStreamLine(buf, onEvent, (t) => (out = t))
-      })
-    } else {
-      child.stdout.on('data', (d) => (out += d.toString()))
-    }
-    child.stderr.on('data', (d) => (err += d.toString()))
-
-    child.on('close', (code) => {
-      done = true
-      clearTimeout(timer)
-      let final = ''
-      if (stream) {
-        final = out
-      } else {
-        try {
-          final = JSON.parse(stripToJson(out))?.result || ''
-        } catch {
-          final = out.trim()
-        }
-      }
-      resolve({ rc: code === null ? 124 : code, final, err })
-    })
-    child.on('error', (e) => {
-      done = true
-      clearTimeout(timer)
-      resolve({ rc: 1, final: '', err: String(e.message) })
-    })
-  })
-}
-
-// stream-json 事件 → say / tool / final
-function handleStreamLine(line, onEvent, setFinal) {
-  const s = line.trim()
-  if (!s || s[0] !== '{') return
-  let j
-  try {
-    j = JSON.parse(s)
-  } catch {
-    return
-  }
-  if (j.type === 'assistant') {
-    for (const c of j.message?.content || []) {
-      if (c.type === 'text' && c.text) onEvent?.('say', c.text)
-      else if (c.type === 'tool_use') {
-        const detail =
-          c.input?.command ?? c.input?.file_path ?? c.input?.pattern ?? c.input?.description ?? ''
-        const str = String(detail)
-        onEvent?.('tool', `${c.name}: ${str.length > 300 ? `${str.slice(0, 300)}…` : str}`)
-      }
-    }
-  } else if (j.type === 'result') {
-    const r = j.result || ''
-    setFinal(r)
-    onEvent?.('final', r)
-  }
-}
-
-function stripToJson(s) {
-  const i = String(s).indexOf('{')
-  return i === -1 ? '{}' : String(s).slice(i)
-}
-
-function shellQuote(s) {
-  return `'${String(s).replace(/'/g, `'\\''`)}'`
-}
-
-module.exports = { runClaude, deriveUuid, sessionEpoch, PROMPTS }

package/lib/cot.js

@@ -1,377 +0,0 @@
-'use strict'
-
-// cot display:消息上挂载「思考过程」,事件流对齐 AG-UI 协议。
-// 三步流:POST 建 COT 消息 → PUT 攒批写事件(可反复)→ RUN_FINISHED 自动完结。
-// 接口细节与实测边界见 docs/cot-message-api.md
-//
-// **COT 只承载过程,结论必须单独发一条普通消息** —— 接口的设计前提,不是我们的选择。
-// 故本类没有 card.finalize(result) 那种「把结论写进载体」的能力。
-//
-// ⚠️ content 是**字符串化的 JSON**(双层编码),_encode 统一处理
-// ⚠️ RUN_FINISHED / RUN_ERROR 后再写事件被硬拒("COT already in terminal state"),
-//   故 finalize 之后必须闭嘴 —— 用 this.done 守
-const larkcli = require('./larkcli')
-const { stripToJson, errText, tail } = larkcli
-
-const BATCH_MS = Number(process.env.LR_COT_BATCH_MS || 1000)
-const MAX_EVENTS = 50 // 接口硬上限:events[] 每次 1~50 条
-// 单条 content 上限是**序列化后 4096 字节**,不是字符(文档写「字符」)。
-// 中文每字 3 字节 → 按字符截会稳定超限,且一条超长会让同批全部事件被拒
-const MAX_CONTENT_BYTES = 4096
-
-// say 映射到哪类事件。**实测两者渲染完全一致**,故按事件量取舍:
-// text 每段 3 个事件,reasoning 每段 5 个(多一对外包裹)。
-// 留开关是因为渲染一致不保证永远一致
-const SAY_AS = process.env.LR_COT_SAY_AS === 'reasoning' ? 'reasoning' : 'text'
-
-// claude 工具名 → COT 内置 icon 枚举。
-// 实测 9 个枚举全部有专属图标(search 🔍 / bash </> / read 📖 / write ✏️ / doc 📄 /
-// calendar 📅 / task ☑️ / meeting 📹 / default ●)。文档外的值多数回落成 default 的圆点,
-// 少数(shell/edit/web)生效但只是已有图标的别名 —— 没有新增表达力且无兼容承诺,不用
-const ICONS = {
-  Bash: 'bash',
-  BashOutput: 'bash',
-  Read: 'read',
-  NotebookRead: 'read',
-  Edit: 'write',
-  Write: 'write',
-  NotebookEdit: 'write',
-  Grep: 'search',
-  Glob: 'search',
-  WebSearch: 'search',
-  WebFetch: 'search',
-  Task: 'task',
-  TodoWrite: 'task',
-}
-
-// MCP 工具名(mcp__<server>__<action>)按名字猜 —— 它们在 dispatch 场景很常见,
-// 一律给 default 的圆点等于没信息。命名约定不保证,故只在猜中时用。
-// **顺序即优先级**:域名词(doc/task/calendar)比动词更能说明工具属于哪个域,故排在前
-const MCP_HINTS = [
-  [/meeting|minutes|\bvc\b/, 'meeting'],
-  [/calendar|schedule/, 'calendar'],
-  [/task|todo/, 'task'],
-  [/doc|sheet|base|wiki|file/, 'doc'],
-  [/write|create|update|edit|send|post|delete/, 'write'],
-  [/read|get|fetch|view/, 'read'],
-  [/search|find|query|list/, 'search'],
-]
-
-function iconFor(tool) {
-  if (ICONS[tool]) return ICONS[tool]
-  const s = String(tool).toLowerCase()
-  if (s.startsWith('mcp__')) {
-    for (const [re, icon] of MCP_HINTS) if (re.test(s)) return icon
-  }
-  return 'default'
-}
-
-// 按 UTF-8 字节截断,且不切坏字符(码点边界对齐)。
-// 不能按码点数截 —— 上限是字节,中文每字 3 字节(见 MAX_CONTENT_BYTES)
-function clipBytes(s, maxBytes) {
-  const str = String(s)
-  if (Buffer.byteLength(str, 'utf8') <= maxBytes) return str
-  const ell = '…'
-  const ellBytes = Buffer.byteLength(ell, 'utf8')
-  // 连省略号都装不下 → 返回空串。否则 '' + '…' 会**超过** maxBytes,
-  // 破坏「返回值 ≤ maxBytes」这个契约(本函数是导出的)
-  if (maxBytes < ellBytes) return ''
-  const budget = maxBytes - ellBytes
-  // Buffer 直切会把多字节字符切成半个 → 用码点逐个累加,天然对齐边界。
-  // 逐码点而非逐 UTF-16 单元:emoji 等代理对不能拆
-  let bytes = 0
-  let out = ''
-  for (const ch of str) {
-    const b = Buffer.byteLength(ch, 'utf8')
-    if (bytes + b > budget) break
-    out += ch
-    bytes += b
-  }
-  return out + ell
-}
-
-class CotSession {
-  constructor({ profile, chatId, lastMsg, replyInThread }) {
-    this.profile = profile
-    this.chatId = chatId
-    this.lastMsg = lastMsg
-    this.replyInThread = replyInThread
-    this.cotId = null
-    this.messageId = null
-    this.done = false // 已写 RUN_FINISHED/RUN_ERROR;之后写入必被拒
-    this.seq = 0 // 只用来生成本地唯一的 messageId/toolCallId,**从不发给服务端**
-    this.pending = [] // 待发事件队列
-    this.lastStamp = 0 // 事件 timestamp 的单调下界(见 _stamp)
-    this.pendingSay = null // 延迟一段的 say(见 onSay);结论不能进过程区
-    this.timer = null
-    // 串行队列:PUT 必须按写入顺序到达,晚发先到会让 delta 乱序拼接成错乱文本
-    this.q = Promise.resolve()
-  }
-
-  _enqueue(fn) {
-    this.q = this.q.then(fn, fn)
-    return this.q
-  }
-
-  // 步骤 ①:建 COT 消息 → {cot_id, message_id}。两者后续都要带。
-  // origin_message_id 让 COT 挂在触发它的那条用户消息上。
-  async create() {
-    const data = { receive_id: this.chatId }
-    if (this.lastMsg && this.lastMsg !== '-') data.origin_message_id = this.lastMsg
-    if (this.replyInThread) data.reply_in_thread = true
-    const { stdout } = await larkcli.run([
-      '--profile', this.profile, 'api', 'POST', '/open-apis/im/v1/message_cot',
-      '--params', JSON.stringify({ receive_id_type: 'chat_id' }),
-      '--as', 'bot', '--data', JSON.stringify(data),
-    ])
-    const j = JSON.parse(stripToJson(stdout))
-    this.cotId = j?.data?.cot_id || null
-    this.messageId = j?.data?.message_id || null
-    if (!this.cotId || !this.messageId) return null
-    // RUN_STARTED 立刻发,让消息一出现就是「在跑」而不是空壳
-    this._push(['RUN_STARTED', { runId: this.cotId, threadId: this.cotId }])
-    await this.flush()
-    return this.cotId
-  }
-
-  // 编码单条事件:content 序列化 + 超 4096 字节时截断自由文本字段。
-  // 返回事件对象,null = 截不下来只能丢弃(整批被服务端拒比丢一条更糟)
-  _encode(eventType, content) {
-    let s = JSON.stringify(content)
-    if (Buffer.byteLength(s, 'utf8') > MAX_CONTENT_BYTES) {
-      // 超长只可能来自 delta/title/message 这类自由文本
-      const key = ['delta', 'title', 'message'].find((k) => typeof content[k] === 'string')
-      if (!key) return null // 没有可截的字段 → 丢这条,过程事件不值得冒整批失败
-      // JSON 转义会膨胀(换行 2 字节、控制字符 6 字节),故截完再验、按实测比例收敛。
-      // 别用固定系数退让 —— 0.8 退 8 次才到 0.17,覆盖不了 6 倍膨胀(ANSI 日志会撞上)
-      const overhead = Buffer.byteLength(JSON.stringify({ ...content, [key]: '' }), 'utf8')
-      let budget = MAX_CONTENT_BYTES - overhead
-      for (let i = 0; i < 8 && budget > 0; i++) {
-        const clipped = { ...content, [key]: clipBytes(content[key], budget) }
-        s = JSON.stringify(clipped)
-        const actual = Buffer.byteLength(s, 'utf8')
-        if (actual <= MAX_CONTENT_BYTES) break
-        // 按本轮实测膨胀率反推能装多少,留 2% 余量
-        const ratio = (MAX_CONTENT_BYTES - overhead) / (actual - overhead)
-        const next = Math.floor(budget * ratio * 0.98)
-        budget = next < budget ? next : budget - 1 // 保证严格递减,不会死循环
-      }
-      // 截不下来就丢;配对的 START/END 由 _push 的成组语义一起丢,不留空气泡
-      if (Buffer.byteLength(s, 'utf8') > MAX_CONTENT_BYTES) return null
-    }
-    return { event_type: eventType, content: s, timestamp: String(this._stamp()) }
-  }
-
-  // 事件 timestamp 必须**严格单调递增**。
-  // 实测(2026-08-20):同一批 8 个 delta 用相同 timestamp 时,客户端渲染成
-  // 「3 2 6 8 7 5 4 1」—— 不是反转而是完全打乱,说明它按 timestamp 排序且排序不稳定。
-  // 而一段 say 的 START/CONTENT/END 是同步生成的,Date.now() 必然相同 → 文字错乱。
-  // 墙上时间只作下界,计数器保证单调(同 paths.js 的 stamp,时钟回拨也不倒退)
-  _stamp() {
-    const now = Date.now()
-    this.lastStamp = now > this.lastStamp ? now : this.lastStamp + 1
-    return this.lastStamp
-  }
-
-  // 成组入队:**同一组事件保证同批发出**。
-  // 一段 say 是 3 件套(reasoning 档 5 件)、一次工具调用是 2 件套 —— 若被切批拆散,
-  // 前半批失败就会让客户端收到没有 START 的孤立 CONTENT/END(渲染行为未验证)。
-  // 组内任一条因超长被丢 → 整组丢,不留「有气泡无内容」
-  _push(...events) {
-    if (this.done) return
-    const encoded = []
-    for (const [type, content] of events) {
-      const e = this._encode(type, content)
-      if (!e) return // 组内有一条编码不出来 → 整组不发
-      encoded.push(e)
-    }
-    // 装不下整组就先把已攒的发走,让这一组完整落进下一批 —— 这是「不跨批」的实现
-    if (this.pending.length && this.pending.length + encoded.length > MAX_EVENTS) this.flush()
-    this.pending.push(...encoded)
-    if (this.pending.length >= MAX_EVENTS) {
-      this.flush()
-    } else if (!this.timer) {
-      this.timer = setTimeout(() => this.flush(), BATCH_MS)
-      if (this.timer.unref) this.timer.unref() // 别让攒批定时器吊住进程退出
-    }
-  }
-
-  // 等队列排空后返回 v,且**吞掉 rejection** —— flush/update 返回的就是 this.q,
-  // 而它们被 fire-and-forget 调用,裸传 rejected 的 q 会终结常驻进程
-  _settled(v) {
-    return this.q.then(
-      () => v,
-      () => v,
-    )
-  }
-
-  // 步骤 ②:PUT 写事件。返回 bool —— **调用方靠它判断是否要兜底**
-  // (RUN_FINISHED 写失败则 COT 永久卡在「在跑」)。
-  // 整个 fn 体裹 try:flush() 绝不能抛(理由同 _settled);连日志的 EPIPE 也要吞
-  flush() {
-    if (this.timer) {
-      clearTimeout(this.timer)
-      this.timer = null
-    }
-    // 已封口:pending 里的事件注定被拒,清掉省下每批一次的失败请求 + 日志
-    if (this.done) {
-      this.pending = []
-      return this._settled(false)
-    }
-    // cotId 为 null 时**不清空 pending** —— create 还没成功,事件要活到它成功
-    if (!this.pending.length || !this.cotId) return this._settled(true)
-    const batch = this.pending
-    this.pending = []
-    return this._enqueue(async () => {
-      let ok = true
-      try {
-        // 切片非冗余:create 之前攒的事件可远超 50 条(那时 flush 提前返回且不清空)。
-        // 切点不会落在一段 say 中间 —— _push 的成组语义保证
-        for (let i = 0; i < batch.length; i += MAX_EVENTS) {
-          const events = batch.slice(i, i + MAX_EVENTS)
-          try {
-            await larkcli.run([
-              '--profile', this.profile, 'api', 'PUT', '/open-apis/im/v1/message_cot',
-              '--as', 'bot',
-              '--data', JSON.stringify({
-                events, message_id: this.messageId, cot_id: this.cotId,
-              }),
-            ])
-          } catch (err) {
-            ok = false
-            const t = tail(errText(err), 200)
-            process.stderr.write(`cot: 写事件失败(${events.length} 条)→ ${t}\n`)
-            // terminal state 之后的写入全是徒劳,直接封口
-            if (/terminal state/.test(t)) this.done = true
-            break // 一片失败,后续片多半同因,别刷屏
-          }
-        }
-      } catch {
-        ok = false // 含 stderr.write 抛 EPIPE 这类极端情况
-      }
-      return ok
-    })
-  }
-
-  // 中间文本。每段一个独立 messageId —— 同 id 的多条 CONTENT 会被客户端拼成一段,
-  // 而两次 say 之间通常隔着工具调用,拼起来读不通。
-  //
-  // **延迟一段**:最后一段 say 就是结论,它会作为独立消息再发一次 ——
-  // 也写进过程区群里就看到两遍。故压着最新一段,onFinal 时丢弃。
-  // 用「延迟一段」而非内容比较 —— 最稳
-  onSay(text) {
-    this._flushPending()
-    this.pendingSay = text
-  }
-
-  _flushPending() {
-    if (this.pendingSay === null) return
-    const text = this.pendingSay
-    this.pendingSay = null
-    const id = `say-${++this.seq}`
-    if (SAY_AS === 'text') {
-      this._push(
-        ['TEXT_MESSAGE_START', { messageId: id, role: 'assistant' }],
-        ['TEXT_MESSAGE_CONTENT', { messageId: id, delta: String(text) }],
-        ['TEXT_MESSAGE_END', { messageId: id }],
-      )
-    } else {
-      this._push(
-        ['REASONING_START', { messageId: id }],
-        ['REASONING_MESSAGE_START', { messageId: id }],
-        ['REASONING_MESSAGE_CONTENT', { messageId: id, delta: String(text) }],
-        ['REASONING_MESSAGE_END', { messageId: id }],
-        ['REASONING_END', { messageId: id }],
-      )
-    }
-  }
-
-  // 工具调用。**不写 TOOL_CALL_RESULT**:输出动辄几千字符且可能含不宜进群的仓库内容,
-  // 与 card 档只显示工具名+参数摘要一致。text 形如 "Bash: ls -la"(claude.js 拼的)
-  onTool(text) {
-    // 工具调用到来 = 前面那段 say 不是结论,可以放行了
-    this._flushPending()
-    const s = String(text)
-    const tool = s.split(':', 1)[0].trim()
-    const id = `tool-${++this.seq}`
-    this._push(
-      [
-        'TOOL_CALL_START',
-        {
-          toolCallId: id,
-          icon: iconFor(tool),
-          title: s,
-          toolCallName: tool || 'tool',
-        },
-      ],
-      ['TOOL_CALL_END', { toolCallId: id }],
-    )
-  }
-
-  // 手里那段 pending(= 结论)直接丢弃,不放行 —— 它会作为独立消息发出,
-  // 写进过程区就成了群里的第二遍
-  onFinal() {
-    this.pendingSay = null
-  }
-
-  // 步骤 ③:RUN_FINISHED 自动完结 —— **但只在写入成功时**。写失败(500/频控/抖动)
-  // 那条终结事件就没到服务端,COT 永久卡在「在跑」→ 靠 complete 兜底(幂等,不守 done)。
-  // rc != 0 走 RUN_ERROR + 无条件 complete:RUN_ERROR 是否自动流转未验证,补一刀不亏
-  async finalize({ rc = 0, error = '' } = {}) {
-    if (!this.cotId || this.done) return false
-    if (rc === 0) {
-      this._push(['RUN_FINISHED', { runId: this.cotId, threadId: this.cotId }])
-      const ok = await this.flush()
-      this.done = true
-      if (!ok) await this.complete('done') // 它和最多 49 条事件同批,该批被拒就一起没了
-      return true
-    }
-    // rc != 0:没有「结论」这回事,压着的那段 say 是仅有的线索,放行
-    this._flushPending()
-    this._push([
-      'RUN_ERROR',
-      {
-        runId: this.cotId,
-        threadId: this.cotId,
-        message: clipBytes(error || `rc=${rc}`, 500),
-        code: String(rc),
-      },
-    ])
-    await this.flush()
-    this.done = true
-    await this.complete('error')
-    return true
-  }
-
-  // 手动关写入态。正常路径不需要(RUN_FINISHED 已流转),
-  // 留给异常中断 —— 不调的话 COT 会一直显示「在跑」
-  async complete(reason = 'done') {
-    if (!this.cotId) return false
-    return this._enqueue(async () => {
-      try {
-        await larkcli.run([
-          '--profile', this.profile, 'api', 'POST',
-          `/open-apis/im/v1/message_cot/complete/${this.cotId}`,
-          '--params', JSON.stringify({ message_id: this.messageId, reason }),
-          '--as', 'bot',
-        ])
-        return true
-      } catch {
-        return false
-      }
-    })
-  }
-
-  // 兜「从没 finalize 成功」的情况:超时被 SIGTERM、异常中断 ——
-  // 不调 complete 的话 COT 会一直显示「在跑」
-  async stop() {
-    if (this.done || !this.cotId) return
-    // 从没 finalize 就走到这里 = 异常中断,压着的那段不是结论 → 放行
-    this._flushPending()
-    await this.flush()
-    await this.complete('timeout')
-    this.done = true
-  }
-}
-
-module.exports = { CotSession, iconFor, clipBytes, SAY_AS, MAX_EVENTS, MAX_CONTENT_BYTES }