sintbot 1.4.14 → 1.4.16

package/src/groupbrain.js

@@ -0,0 +1,135 @@
+'use strict'
+// The single change logic for a group's backend · model · thinking depth.
+// The console group card, the chat /model command and the Feishu model card
+// all call applyBrainChange, so "did the backend change / only the model /
+// only the depth / nothing" is decided in one place.
+//
+// Pure: mutates the given raw configuration object; the caller writes it
+// through the configuration writer (which validates, resets sessions when the
+// backend changes, replaces the file atomically and applies it).
+
+const brainMod = require('./core/brain')
+const { DEFAULTS } = require('./config')
+
+/**
+ * @param raw     configuration object (mutated)
+ * @param chatId
+ * @param change  { provider?, model?, effort? }
+ *   provider: switch backend (omitted = keep); model / effort: string choice
+ *   ('' = clear), omitted = keep. Choices go to the target backend's entry.
+ * @returns { error } | { before, after, switching, target, home, modelChanged, effortChanged, changed }
+ *   error ∈ 'no-group' | 'unknown-provider' | 'bad-model' | 'bad-effort'
+ */
+function applyBrainChange(raw, chatId, change = {}) {
+  const { provider, model, effort } = change
+  const g = raw && raw.groups && raw.groups[chatId]
+  if (!g) return { error: 'no-group' }
+  if (provider !== undefined && !(raw.providers || {})[provider]) return { error: 'unknown-provider' }
+  if (model !== undefined && model !== '' && !brainMod.isModel(model)) return { error: 'bad-model' }
+  if (effort !== undefined && effort !== '' && !brainMod.isEffort(effort)) return { error: 'bad-effort' }
+  const defName = raw.defaultProvider || DEFAULTS.defaultProvider
+  const provAll = { ...DEFAULTS.providers, ...(raw.providers || {}) }
+  const home = g.provider || defName
+  const before = brainMod.groupBrain(g, home, provAll[home], { defaultProvider: defName })
+  // Legacy group.model first moves under its own backend, then the backend may change.
+  brainMod.migrateLegacyModel(g, defName)
+  const switching = provider !== undefined && provider !== home
+  const target = provider || home
+  if (model !== undefined || effort !== undefined) {
+    const prefs = (g.providerPrefs && typeof g.providerPrefs === 'object' && !Array.isArray(g.providerPrefs)) ? g.providerPrefs : {}
+    const cur = { ...(brainMod.cleanPref(prefs[target]) || {}) }
+    if (model !== undefined) { if (model) cur.model = model; else delete cur.model }
+    if (effort !== undefined) { if (effort) cur.effort = effort; else delete cur.effort }
+    if (Object.keys(cur).length) prefs[target] = cur; else delete prefs[target]
+    g.providerPrefs = prefs
+  }
+  const np = brainMod.normalizePrefs(g.providerPrefs)
+  if (np) g.providerPrefs = np; else delete g.providerPrefs
+  if (switching) g.provider = provider
+  const after = brainMod.groupBrain(g, target, provAll[target], { defaultProvider: defName })
+  const modelChanged = !switching && before.model !== after.model
+  const effortChanged = !switching && before.effort !== after.effort
+  return { before, after, switching, target, home, modelChanged, effortChanged,
+    changed: switching || modelChanged || effortChanged }
+}
+
+// One audit row (console, chat command and card share the shape; source tells which).
+function auditRow(chatId, r, { source, by }) {
+  const pick = (b) => ({ model: b.model || '', effort: b.effort || '' })
+  return { kind: 'group-model', chatId, source, by: by || '', from: { provider: r.home, ...pick(r.before) },
+    to: { provider: r.target, ...pick(r.after) }, switching: r.switching, modelChanged: r.modelChanged,
+    effortChanged: r.effortChanged, ts: Date.now() }
+}
+
+// Card-level values that move into groups: subscription cards give up model
+// and depth; a third-party endpoint keeps its model (connection setting) and
+// gives up depth only.
+function movable(p) {
+  return { model: p && !p.baseUrl ? brainMod.defaultModel(p) : '', effort: p ? brainMod.defaultEffort(p) : '' }
+}
+
+/**
+ * Migration step one (additive, before the service starts): every group gets,
+ * on every visible card (and its current card even when hidden), the card's
+ * current default for any item it has not chosen. Card values stay in place,
+ * so an older version that ignores providerPrefs behaves exactly as before.
+ * Idempotent. Mutates raw. @returns {{ changed, groups: string[] }}
+ */
+function fillGroupPicks(raw) {
+  const out = { changed: false, groups: [] }
+  if (!raw || typeof raw !== 'object') return out
+  const provs = (raw.providers && typeof raw.providers === 'object') ? raw.providers : {}
+  const defName = raw.defaultProvider || DEFAULTS.defaultProvider
+  const provAll = { ...DEFAULTS.providers, ...provs }
+  const withDefaults = Object.keys(provs).filter((n) => { const d = movable(provs[n]); return !!(d.model || d.effort) })
+  for (const [id, g] of Object.entries(raw.groups || {})) {
+    if (!g || typeof g !== 'object' || Array.isArray(g) || id === 'oc_example_chat_id') continue
+    let touched = brainMod.migrateLegacyModel(g, defName)
+    if (withDefaults.length) {
+      const home = g.provider || defName
+      const prefs = (g.providerPrefs && typeof g.providerPrefs === 'object' && !Array.isArray(g.providerPrefs)) ? g.providerPrefs : {}
+      const names = new Set([home, ...Object.keys(prefs)])
+      for (const n of Object.keys(provAll)) if (provAll[n] && !provAll[n].hidden) names.add(n)
+      for (const n of names) {
+        if (!withDefaults.includes(n)) continue
+        const d = movable(provs[n])
+        const cur = { ...(brainMod.cleanPref(prefs[n]) || {}) }
+        if (!cur.model && d.model) { cur.model = d.model; touched = true }
+        if (!cur.effort && d.effort) { cur.effort = d.effort; touched = true }
+        if (Object.keys(cur).length) prefs[n] = cur
+      }
+      const np = brainMod.normalizePrefs(prefs)
+      if (np) g.providerPrefs = np; else delete g.providerPrefs
+    }
+    if (touched) out.groups.push(id)
+  }
+  out.changed = out.groups.length > 0
+  return out
+}
+
+/**
+ * Migration step two (after every group connected): remove the card-level
+ * values that step one copied into the groups. Effective values do not change
+ * for any group whose picks were filled. Idempotent. Mutates raw.
+ * @returns {{ changed, providers: string[] }}
+ */
+function stripCardDefaults(raw) {
+  const out = { changed: false, providers: [] }
+  const provs = raw && raw.providers && typeof raw.providers === 'object' ? raw.providers : {}
+  for (const [n, p] of Object.entries(provs)) {
+    if (!p || typeof p !== 'object') continue
+    const d = movable(p)
+    if (!d.model && !d.effort) continue
+    if (!p.baseUrl) {
+      delete p.model
+      if (p.runner !== 'codex' && p.env) delete p.env.ANTHROPIC_MODEL
+    }
+    delete p.reasoningEffort
+    if (p.env) { delete p.env.CLAUDE_CODE_EFFORT_LEVEL; if (!Object.keys(p.env).length) delete p.env }
+    out.providers.push(n)
+  }
+  out.changed = out.providers.length > 0
+  return out
+}
+
+module.exports = { applyBrainChange, auditRow, fillGroupPicks, stripCardDefaults }

package/src/modelcatalog.js

@@ -0,0 +1,122 @@
+'use strict'
+// 「这张模型卡能选什么」(;两家都改成实时清单)。bin 注入给 engine.modelCatalog,控制台同一份;core 只认返回形状:
+//   { ok, models: [{ id, name?, efforts?, defEffort? }] | null, aliases: [], aliasOf?: { 别名: 具体型号 }, efforts: [],
+//     recommended: { model, effort }, source: 'live' | 'saved' | 'builtin' }
+//   models === null ⇒ 这家没有可选清单(第三方端点):群里只能调深度,型号到后台改 —— 打错一个字下一轮就报错,
+//   比让人在群里瞎试更稳。ok === false ⇒ 有清单但这会儿取不到(codex 探测失败、也没存过):型号这一项整条拒绝,不猜。
+//
+// 清单与名称一律取两家 CLI 的**实时数据**:
+//   Codex = app-server model/list(官方显示名 GPT-6.1-Sol、★ 默认型号、各型号支持与默认的深度);
+//   Claude 订阅 = Claude Code 初始化握手报的 /model 选单(claudemodels.probeModels:官方显示名、各型号支持的深度、
+//     default 指向的推荐型号;别名 opus / sonnet … 打进来存成它此刻指向的具体型号)。
+//   都是 10 分钟缓存、过期先给旧的后台再刷(模型卡按钮回调要 3 秒内回包,现场探测要好几秒);每次拿到就存盘(cacheFile),
+//   重启后 / 探测失败时先用存盘的(source 'saved')—— 不再退回写死在代码里、早已过时的候选。Claude 从没拿到过才用内置候选。
+//   拿到的显示名登记进 core/modelname.js(群里回执、卡片、控制台都按官方名称显示)。
+// recommended(没有「模型卡默认」):新绑的群、换到没选过的后端、模型卡「测试」预填 / 兜底用的推荐项 ——
+//   Codex = ★ 型号 + 它自带的默认深度;Claude 订阅 = 握手里 default 指向的型号 + xhigh(Claude Code 自己的默认档);
+//   第三方 = 型号由模型卡定(空)+ xhigh。只用于预填与迁移,运行时不拿它悄悄兜底。
+
+const fs = require('node:fs')
+const path = require('node:path')
+const { recommendEffort } = require('./core/modelcmd') // 推荐深度的口径只此一份(engine 的 /model 与模型卡同用)
+const { setModelNames } = require('./core/modelname')
+
+const CLAUDE_EFFORTS = ['low', 'medium', 'high', 'xhigh', 'max'] // Claude Code 的五档(code.claude.com model-config)
+// Codex 服务端真正接受的档(与控制台 RE_LEGAL 同一份口径):model/list 会过报(把 ultra 列进去),先过一道
+const CODEX_LEGAL = ['none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max']
+const CLAUDE_ALIASES = ['opus', 'sonnet', 'haiku'] // 只在拿不到实时清单、退回内置候选时用(原样交给 CLI)
+const CLAUDE_EFFORT = 'xhigh'
+const TTL = 600_000
+
+function createModelCatalog({ codexstatus, claudemodels, claudeBin = 'claude', cacheFile = null, now = () => Date.now(), log = () => {} } = {}) {
+  const live = { codex: null, claude: null } // { at, data }
+  const inflight = { codex: null, claude: null }
+  const fetchers = {
+    codex: async () => { const l = await codexstatus.listModels('codex'); return Array.isArray(l) && l.length ? l : null },
+    claude: async () => (claudemodels && typeof claudemodels.probeModels === 'function' ? claudemodels.probeModels(claudeBin) : null),
+  }
+  const register = (kind, data) => {
+    try {
+      if (kind === 'codex') setModelNames(data.map((m) => ({ id: m.model, name: m.name })))
+      else setModelNames(data.models)
+    } catch { /* 名称登记失败只影响显示 */ }
+  }
+  // 存盘的上次结果:at 记 0 ⇒ 第一次用到就后台再刷一次
+  if (cacheFile) {
+    try {
+      const saved = JSON.parse(fs.readFileSync(cacheFile, 'utf8'))
+      for (const k of ['codex', 'claude']) if (saved && saved[k] && saved[k].data) { live[k] = { at: 0, data: saved[k].data, saved: true }; register(k, saved[k].data) }
+    } catch { /* 没有 / 坏了就当没有 */ }
+  }
+  const persist = () => {
+    if (!cacheFile) return
+    try {
+      const out = {}
+      for (const k of ['codex', 'claude']) if (live[k]) out[k] = { at: live[k].at || now(), data: live[k].data }
+      fs.mkdirSync(path.dirname(cacheFile), { recursive: true })
+      const tmp = cacheFile + '.tmp'
+      fs.writeFileSync(tmp, JSON.stringify(out))
+      fs.renameSync(tmp, cacheFile)
+    } catch (e) { log('可选型号存盘失败: ' + (e && e.message)) }
+  }
+  const refresh = (kind) => {
+    if (!inflight[kind]) {
+      inflight[kind] = Promise.resolve().then(() => fetchers[kind]()).catch(() => null)
+        .then((data) => {
+          if (data) { live[kind] = { at: now(), data }; register(kind, data); persist() }
+          else log(`${kind === 'codex' ? 'codex' : 'Claude'} 可选型号探测失败 —— 沿用上次结果(如有)`)
+        })
+        .finally(() => { inflight[kind] = null })
+    }
+    return inflight[kind]
+  }
+  // 有结果就先用、过期了后台再刷;从没取到过(也没存盘)才等这一次
+  async function get(kind) {
+    const c = live[kind]
+    if (c) { if (now() - c.at >= TTL) refresh(kind); return c.data }
+    await refresh(kind)
+    return live[kind] ? live[kind].data : null
+  }
+  const sourceOf = (kind) => (live[kind] && live[kind].saved && !live[kind].at ? 'saved' : 'live')
+
+  async function catalog(name, provider) {
+    const p = provider || {}
+    if (p.runner === 'codex') {
+      const list = await get('codex')
+      if (!list) return { ok: false, models: [], aliases: [], efforts: CODEX_LEGAL.slice(1), recommended: { model: '', effort: '' } }
+      const models = list.map((m) => ({
+        id: m.model,
+        ...(m.name ? { name: m.name } : {}),
+        efforts: (m.efforts || []).filter((e) => CODEX_LEGAL.includes(e)),
+        ...(m.defEffort && CODEX_LEGAL.includes(m.defEffort) ? { defEffort: m.defEffort } : {}),
+      }))
+      const star = list.find((m) => m.isDefault) || list[0]
+      const cat = { ok: true, models, aliases: [], efforts: CODEX_LEGAL.slice(1), source: sourceOf('codex') }
+      cat.recommended = { model: star.model, effort: '' }
+      cat.recommended.effort = recommendEffort(cat, star.model)
+      return cat
+    }
+    if (!p.baseUrl) {
+      const d = await get('claude')
+      if (d && Array.isArray(d.models) && d.models.length) {
+        const models = d.models.map((m) => ({ id: m.id, name: m.name, ...(m.effort !== false && m.efforts && m.efforts.length ? { efforts: m.efforts.slice() } : {}) }))
+        const cat = { ok: true, models, aliases: [], aliasOf: { ...(d.aliasOf || {}) }, efforts: CLAUDE_EFFORTS.slice(), source: sourceOf('claude') }
+        cat.recommended = { model: d.recommended || models[0].id, effort: CLAUDE_EFFORT }
+        cat.recommended.effort = recommendEffort(cat, cat.recommended.model) // xhigh 不在这型号的档里才换
+        return cat
+      }
+      // 从没拿到过实时清单(没登录 / CLI 太老 / 超时)⇒ 内置候选 + 本机账号额外项 + 官方别名
+      let ids = []
+      try { ids = claudemodels.mergeModels(claudemodels.readExtraModels()).map((m) => m.id).filter(Boolean) } catch { ids = claudemodels.BUILTIN.map((m) => m.id).filter(Boolean) }
+      return { ok: true, models: ids.map((id) => ({ id })), aliases: CLAUDE_ALIASES.slice(), efforts: CLAUDE_EFFORTS.slice(), recommended: { model: ids[0] || '', effort: CLAUDE_EFFORT }, source: 'builtin' }
+    }
+    return { ok: true, models: null, aliases: [], efforts: CLAUDE_EFFORTS.slice(), recommended: { model: '', effort: CLAUDE_EFFORT } }
+  }
+  // 守护进程启动时预热(有哪家的卡才探哪家):第一张模型卡 / 第一次打开群卡就不用等探测
+  catalog.warm = (kinds = ['codex']) => Promise.all(kinds.filter((k) => fetchers[k]).map((k) => refresh(k)))
+  // 原始清单(控制台 /api/codex/models · /api/claude/models 用:要 isDefault / 说明这些字段)+ 它是不是实时的
+  catalog.raw = async (kind) => ({ data: fetchers[kind] ? await get(kind) : null, source: live[kind] ? sourceOf(kind) : 'none' })
+  return catalog
+}
+
+module.exports = { createModelCatalog, CLAUDE_EFFORTS, CODEX_LEGAL, CLAUDE_ALIASES }

package/src/platform/feishu.js

@@ -848,6 +848,23 @@ function createFeishuPlatform({ appId, appSecret, botOpenId = null, onlyWhenMent
       return sendText(chatId, content)
     },
 
+    // One interactive reply under a group command (the /model card). Like
+    // replyOnce it is best-effort and never retried; the caller falls back
+    // to the text reply when this does not confirm.
+    async replyCardOnce(replyCtx, card) {
+      const mid = replyCtx && replyCtx.messageId
+      if (typeof mid !== 'string' || !/^om_[A-Za-z0-9_-]{1,124}$/.test(mid) ||
+          !card || typeof card !== 'object') {
+        throw new TypeError('Feishu card reply needs exact message target and a card')
+      }
+      return client.im.message.reply({ path: { message_id: mid },
+        data: { msg_type: 'interactive', content: JSON.stringify(card) } })
+    },
+
+    // open_id → display name (cached; null when unknown). The model card's
+    // receipt says who changed it; a card callback only carries the open_id.
+    nameOf: (openId) => senderNameOf(openId),
+
     // 发一张静态富卡,返回 { msgId, cardId }(msgId=按钮/表情命中锚点;cardId=实体更新回填用)。
     // 文本已由调用方在构卡时逐字段 redact(卡是 JSON 不能整体脱敏),故这里不再包 redact。
     async sendCard(chatId, cardJson) {

package/src/platform/modelcard.js

@@ -0,0 +1,103 @@
+'use strict'
+// 群里 /model 的「模型卡」。发 /model 不带参数 ⇒ 一张能点的卡:
+//   后端一排按钮 · 型号一个下拉 · 思考深度一排按钮 + 「确认更新」「关闭」;确认后卡片收成一行回执(卡片本身就是回执,不另发消息);
+//   10 分钟后过期翻只读(防止往上翻聊天记录时误点到几天前的老卡)。
+// 纯函数、零依赖:飞书卡片 schema 2.0 的 JSON 形状只在此一处;样式与通知卡同一套(撑满宽 · 标题栏底色说类别 ·
+//   注意事项与右下角小字用 notation 灰字;⚠ 2.0 不认 note 组件)。没有这种卡的平台(企微)由调用方退回文本回执。
+// ⚠ 脱敏:型号 / 后端名来自配置与清单,没有用户输入;结果行里的人名来自平台,同样经 opts.redact。
+
+const esc = (s) => String(s == null ? '' : s).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')
+const DEFAULT_VALUE = '__default__' // 下拉里「跟随默认」那一项的值(选项值不能是空串)
+
+const grey = (s, size = 'notation') => ({ tag: 'markdown', text_size: size, content: `<font color='grey'>${esc(s)}</font>` })
+
+function button(label, { selected = false, value, disabled = false } = {}) {
+  const b = { tag: 'button', text: { tag: 'plain_text', content: label }, type: selected ? 'primary_filled' : 'default', size: 'small', width: 'default' }
+  if (disabled) b.disabled = true
+  if (value) b.behaviors = [{ type: 'callback', value }]
+  return b
+}
+
+// 一排按钮:flow 布局,窄屏自动折行
+function buttonRow(buttons) {
+  return { tag: 'column_set', flex_mode: 'flow', horizontal_spacing: '6px', horizontal_align: 'left', columns: buttons.map((b) => ({ tag: 'column', width: 'auto', elements: [b] })) }
+}
+
+/**
+ * 「先选、再确认」(点一下就生效容易点错):
+ *   点后端 / 选型号 / 点深度只改**卡上的草稿**(卡片重画选中状态,什么都没生效);草稿与当前不同时出一行「将改为 … —— 会不会开新对话」,
+ *   「确认更新」一次生效(只写一次、最多开一次新对话、审计一条),卡片收成一行回执;「关闭」什么都不改,卡片原地变成灰色「已关闭」。
+ *   草稿随每个回调值带回去(无状态,守护进程重启也不丢):{ a:'mc', f:'p'|'m'|'e'|'ok'|'x', v?, d:{p,m,e}, t }
+ *   —— p 后端 · m 型号 · e 深度('' = 跟随默认);下拉的选中值在回调的 action.option 里。
+ * @param s {
+ *   mode: 'edit' | 'receipt' | 'closed' | 'expired',  current: 'claude · claude-opus-5 · xhigh'(当前生效的)
+ *   failover: '', quota: '',                          —— 额度临时切换那一句 / 缓存额度(有才给)
+ *   draft: { p, m, e },                               —— edit:卡上正在选的
+ *   backends: [{ name, selected }], model: { options: [{ value, label }], selected } | null(null = 这家型号到后台改),
+ *   efforts: [{ value, label, selected }],            —— label 里由调用方标「(默认)」
+ *   preview: { to, note } | null,                     —— 草稿与当前不同才有;null ⇒「确认更新」灰着
+ *   receipt: { line, before },                        —— receipt:谁改成了什么 · 之前是什么
+ *   issuedAt: 发卡 / 上次操作的时刻(写进回调值,10 分钟过期)
+ * }
+ */
+function buildModelCard(s, { redact } = {}) {
+  const r = typeof redact === 'function' ? (x) => String(redact(String(x))) : (x) => String(x)
+  const mode = s.mode || (s.expired ? 'expired' : 'edit')
+  const t = s.issuedAt || 0
+  const d = { p: '', m: '', e: '', ...(s.draft || {}) }
+  const cb = (f, v) => ({ a: 'mc', f, ...(v !== undefined ? { v } : {}), d, t })
+  const els = []
+  const head = (title, template, tag, tagColor) => ({
+    title: { tag: 'plain_text', content: title },
+    subtitle: { tag: 'plain_text', content: r(s.current || '') },
+    template, text_tag_list: [{ tag: 'text_tag', text: { tag: 'plain_text', content: tag }, color: tagColor }],
+    padding: '12px 12px 12px 12px',
+  })
+  let header
+  if (mode === 'receipt') {
+    // 确认之后:收成一行回执 —— 控件全收起(卡片就此「关闭」),群里留一条谁改成了什么
+    header = head('模型已更新', 'green', '已更新', 'green')
+    const rc = s.receipt || {}
+    els.push({ tag: 'markdown', text_size: 'normal', content: esc(r(rc.line || '')) })
+    if (rc.before) els.push(grey(r(rc.before)))
+  } else if (mode === 'closed') {
+    header = head('本群模型', 'grey', '已关闭', 'neutral')
+    els.push(grey('已关闭 · 模型没变', 'normal'))
+  } else if (mode === 'expired') {
+    header = head('本群模型', 'grey', '已过期', 'neutral')
+    els.push(grey('这张卡已过期,没有改任何东西 —— 发 /model 重新打开', 'normal'))
+  } else {
+    header = head('本群模型', 'indigo', '模型', 'indigo')
+    const info = []
+    if (s.failover) info.push(`**额度切换** ${esc(s.failover)}`)
+    if (s.quota) info.push(`**额度** ${esc(s.quota)}`)
+    if (info.length) els.push({ tag: 'markdown', text_size: 'normal', content: info.join('\n') })
+    const backendBtns = buttonRow((s.backends || []).map((b) => button(b.name, { selected: b.selected, value: b.selected ? null : cb('p', b.name) })))
+    let modelCtl
+    if (s.model) {
+      modelCtl = {
+        tag: 'select_static', width: 'fill', type: 'default',
+        placeholder: { tag: 'plain_text', content: '选一个型号' },
+        initial_option: s.model.selected || DEFAULT_VALUE,
+        options: s.model.options.map((o) => ({ text: { tag: 'plain_text', content: o.label }, value: o.value || DEFAULT_VALUE })),
+        behaviors: [{ type: 'callback', value: cb('m') }],
+      }
+    } else modelCtl = grey('这个后端的型号在控制台改', 'normal')
+    const effortBtns = buttonRow((s.efforts || []).map((e) => button(e.label || e.value, { selected: e.selected, value: e.selected ? null : cb('e', e.value || DEFAULT_VALUE) })))
+    // 标签在上、控件在下(手机上五个深度按钮一排放得下)
+    for (const [label, ctl] of [['后端', backendBtns], ['型号', modelCtl], ['思考深度', effortBtns]]) els.push(grey(label), ctl)
+    els.push({ tag: 'hr' })
+    if (s.preview) {
+      els.push({ tag: 'markdown', text_size: 'normal', content: `**将改为** ${esc(s.preview.to)}` })
+      if (s.preview.note) els.push(grey(s.preview.note))
+    }
+    els.push(buttonRow([
+      button('确认更新', { selected: !!s.preview, value: s.preview ? cb('ok') : null, disabled: !s.preview }),
+      button('关闭', { value: { a: 'mc', f: 'x', t } }),
+    ]))
+    els.push(grey('选好后点「确认更新」才生效 · 换后端会开新对话，换型号或调深度接着当前对话 · 要等手头任务结束 · 10 分钟内有效 · 点不动时可直接发 /model high 这类文字'))
+  }
+  return { schema: '2.0', config: { width_mode: 'fill', update_multi: true }, header, body: { padding: '12px 12px 12px 12px', vertical_spacing: '8px', elements: els } }
+}
+
+module.exports = { buildModelCard, DEFAULT_VALUE }