dsh-tap 0.20.0

package/providers/qoder/oauth.js

@@ -0,0 +1,364 @@
+/**
+ * providers/qoder/oauth.js — Qoder CN 浏览器设备流（OAuth 订阅额度跟账号走）。
+ *
+ * 流程（证据：@qodercn-ai/qoderclicn 1.1.57 bundle 反混淆 + 2026-09-19 无凭据探测，
+ * 见 docs/reverse/qoder-cn.md）：
+ *   1. 本地生成 PKCE：verifier = 43–128 字符（charset A-Za-z0-9-._~），
+ *      challenge = base64url(SHA256(verifier))；nonce = UUID；machine_id 自持持久化。
+ *   2. 授权页 = <loginHost>/device/selectAccounts?challenge=&challenge_method=S256
+ *      &nonce=&machine_id=&client_id=<prod uuid>
+ *      （实测无 cookie → 302 <loginHost>/users/sign-in?oauth_callback=…；
+ *        qoder.cn 与 qoder.com.cn 双域同构）
+ *   3. 轮询 GET <openapi>/api/v1/deviceToken/poll?nonce=&verifier=&challenge_method=S256
+ *      - **404 = 未完成**（bundle 契约 `markErrorStatus: s=>404!==s.status`；实测
+ *        未登录/未注册 challenge 同为 404 {"errorCode":"NotFound"}）
+ *      - 缺参 = 400 精确业务码（DeviceTokenNonceRequired / DeviceTokenVerifierRequired）
+ *      - 间隔 1s、上限 5 分钟（bundle 常量 _Ai=1e3 / G$a=3e5）
+ *      - 完成 = 200 {token, refresh_token, expires_at, refresh_token_expires_at}
+ *   4. 刷新 POST <openapi>/api/v1/deviceToken/refresh {refresh_token, machine_id}
+ *      → {device_token, refresh_token, expires_at, refresh_token_expires_at}
+ *      **refresh_token 前缀强制 drt-**（实测 bogus → DeviceRefreshTokenPrefixInvalid）
+ *   5. 出站认证 = `Authorization: Bearer <token>`（无自研签名；签名只存在于
+ *      /algo COSY 面，本通道不走那一面）
+ *
+ * 与 codebuddy/trae 两路的形态差异：
+ *   - 没有本地回环回调服务（不像 Trae 的 /authorize）——授权在服务端完成，
+ *     我们只轮询，故无回调页 XSS 面；
+ *   - 没有多 Key 轮换，单账号；
+ *   - poll 的"未完成"是 404 而非业务码，因此**不能**把 404 当失败。
+ *
+ * 实例状态（refresh 单飞锁、poll 代际、pending 视图、relogin 粘性信号）全在
+ * 本工厂闭包内（踩坑 #20）。
+ */
+
+import { createHash, randomBytes, randomUUID } from 'node:crypto'
+
+const LOGIN_TIMEOUT_MS = 5 * 60 * 1000
+const LOGIN_POLL_INTERVAL_MS = 1000
+const REFRESH_LEAD_MS = 60_000
+
+/** bundle 常量：prod 与 dev 两个 client_id，本通道用 prod 形态。 */
+export const QODER_CLIENT_ID = 'e883ade2-e6e3-4d6d-adf7-f92ceff5fdcb'
+
+/** 授权页允许的站点族：Qoder CN 官方域 + 回环（离线 mock 上游用）。 */
+const LOGIN_SITE_SUFFIXES = ['qoder.cn', 'qoder.com.cn']
+const isLoopbackHost = (h) => h === '127.0.0.1' || h === 'localhost' || h === '[::1]'
+
+const VERIFIER_CHARSET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~'
+
+/** PKCE 参数形态对齐官方 CLI：长度 43–128 随机，S256 挑战。 */
+export function createPkce() {
+  const len = 43 + Math.floor(Math.random() * 86)
+  const bytes = randomBytes(len)
+  let verifier = ''
+  for (let i = 0; i < len; i++) verifier += VERIFIER_CHARSET[bytes[i] % VERIFIER_CHARSET.length]
+  const challenge = createHash('sha256').update(verifier).digest().toString('base64url')
+  return { verifier, challenge }
+}
+
+/** 机器标识：48 位 hex（与官方长 hex 形态同类，随机自持，跨登录稳定）。 */
+export function createMachineId() {
+  return randomBytes(24).toString('hex')
+}
+
+/**
+ * 有效期归一。2026-09-19 真实响应实证：poll 同时给 `expires_at`（**ISO 字符串**
+ * 或数字秒）与 `expires_in`（相对秒），refresh 给 `expires_at`/`expires_in`。
+ * 规则对齐 bundle 的 L4()??tIe()：纯数字串按 epoch（秒/毫秒分档）否则按 ISO 解析，
+ * 再否则视为相对秒。无法判定返回 null。
+ */
+export function normalizeExpiry(value, now = Date.now()) {
+  if (value == null || value === '') return null
+  if (typeof value === 'number' || (typeof value === 'string' && /^\d+$/.test(value.trim()))) {
+    const n = Number(value)
+    if (!Number.isFinite(n) || n <= 0) return null
+    if (n > 1e12) return n // 绝对毫秒
+    if (n > 1e9) return n * 1000 // 绝对秒
+    return now + n * 1000 // 相对秒
+  }
+  const parsed = Date.parse(String(value))
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : null
+}
+
+/**
+ * 授权 URL 出宿主前的门禁。
+ *
+ * 与 codebuddy 的 assertSafeAuthUrl 的**关键差异**：那边 authUrl 来自上游响应，
+ * 故"与 baseURL 同域"是一条有效判据；这里 URL 的 host 直接来自用户设置
+ * （qoderLoginHost），同域判据等于不设防（任何 https 域都能自证通过——
+ * verify [5] 实测抓到这一点）。因此本门禁**不认同域**，只认：
+ *   - scheme = https（回环对回环例外，供离线 mock 上游）；
+ *   - host ∈ Qoder 官方站点族（qoder.cn / qoder.com.cn）或回环。
+ */
+function assertSafeAuthUrl(authUrl) {
+  let parsed
+  try { parsed = new URL(String(authUrl)) } catch { throw new Error('authUrl 不是合法 URL') }
+  if (parsed.protocol !== 'https:' && !isLoopbackHost(parsed.hostname)) {
+    throw new Error(`authUrl 必须使用 https（收到 ${parsed.protocol}//）`)
+  }
+  const hostOk = isLoopbackHost(parsed.hostname)
+    || LOGIN_SITE_SUFFIXES.some((s) => parsed.hostname === s || parsed.hostname.endsWith(`.${s}`))
+  if (!hostOk) {
+    throw new Error(`authUrl 域名 ${parsed.hostname} 不在 Qoder 官方登录站点族（${LOGIN_SITE_SUFFIXES.join(' / ')}）`)
+  }
+}
+
+/** 基址前置校验：手改的设置文件可能是 javascript: / 非法 URL，必须响亮拒绝。 */
+function assertLoginBase(loginHost) {
+  let parsed
+  try { parsed = new URL(String(loginHost)) } catch { throw new Error('qoderLoginHost 不是合法 URL') }
+  if (parsed.protocol !== 'https:' && !isLoopbackHost(parsed.hostname)) {
+    throw new Error(`qoderLoginHost 必须使用 https（收到 ${parsed.protocol}//）`)
+  }
+  return parsed
+}
+
+/** poll/refresh 两形态的令牌体归一（poll 给 token，refresh 给 device_token）。 */
+function tokenFrom(body, now = Date.now()) {
+  const access = body?.token ?? body?.device_token ?? body?.access_token
+  if (typeof access !== 'string' || !access) return null
+  const refresh = body.refresh_token ?? body.refreshToken
+  return {
+    accessToken: access,
+    // 缺字段返回 undefined（不是 null）：refresh 响应常只换 access 不带
+    // refresh_token，调用方据此沿用旧值——写 null 会断掉后续续期。
+    ...(refresh != null ? { refreshToken: refresh } : {}),
+    expiresAt: normalizeExpiry(body.expires_at ?? body.expire_time ?? body.expires_in ?? body.expiresIn, now) ?? (now + 3600_000),
+    refreshExpiresAt: normalizeExpiry(body.refresh_token_expires_at ?? body.refresh_token_expire_time ?? body.refresh_token_expires_in, now),
+  }
+}
+
+/**
+ * @param {{ readAuth: () => object, writeAuth: (v: object) => void }} deps
+ *   令牌存储 IO（组合根绑定 ~/.dsh/qoder-plugin-auth.json；令牌与 machine_id
+ *   永不回传浏览器——oauthStatus() 只出视图字段）。
+ */
+export function createQoderOAuth({ readAuth, writeAuth }) {
+  let refreshInFlight = null
+  let pollGeneration = 0
+  // 令牌存储代际号：logout 令其失效。refresh 落盘是读-改-写（writeAuth
+  // ({...readAuth(), auth: {...}})）——与 logout 的整体覆写竞态时，在飞刷新
+  // 会把已登出的令牌写回（登出失效）。落盘前比对代际，过期即丢弃结果。
+  let storeGeneration = 0
+  let reloginNeeded = false
+  const pending = { active: false, authUrl: '', error: '' }
+
+  /** 机器标识幂等自持：首次使用生成并落盘，之后所有登录/刷新复用一个。 */
+  function ensureMachineId() {
+    const store = readAuth()
+    if (typeof store.machine?.machineId === 'string' && store.machine.machineId) return store.machine.machineId
+    const machineId = createMachineId()
+    writeAuth({ ...store, machine: { machineId } })
+    return machineId
+  }
+
+  /** 出站 URL 拼装（openapi 面）。 */
+  const api = (s, path) => `${String(s.qoderOpenapiBaseURL).replace(/\/+$/, '')}${path}`
+
+  /** 刷新（单飞；失败返回 undefined 不抛，并置 reloginNeeded）。 */
+  async function refreshOAuth(s) {
+    if (refreshInFlight) return refreshInFlight
+    const generation = storeGeneration
+    refreshInFlight = (async () => {
+      try {
+        const store = readAuth()
+        const auth = store.auth
+        if (!auth?.refreshToken) { reloginNeeded = true; return undefined }
+        const res = await fetch(api(s, '/api/v1/deviceToken/refresh'), {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json', Accept: 'application/json' },
+          body: JSON.stringify({ refresh_token: auth.refreshToken, machine_id: store.machine?.machineId ?? '' }),
+        })
+        if (!res.ok) { reloginNeeded = true; return undefined }
+        const body = await res.json().catch(() => null)
+        const next = tokenFrom(body)
+        if (!next) { reloginNeeded = true; return undefined }
+        // logout 竞态守卫：代际在飞期间已变（用户点了退出）→ 丢弃刷新结果
+        if (generation !== storeGeneration) return undefined
+        // 缺字段一律沿用旧值（refresh 响应常只轮换 access token）。
+        const merged = {
+          ...readAuth(),
+          auth: {
+            accessToken: next.accessToken,
+            refreshToken: next.refreshToken ?? auth.refreshToken ?? null,
+            expiresAt: next.expiresAt,
+            refreshExpiresAt: next.refreshExpiresAt ?? auth.refreshExpiresAt ?? null,
+            loginMethod: auth.loginMethod ?? 'browser',
+          },
+        }
+        writeAuth(merged)
+        reloginNeeded = false
+        return merged.auth
+      } catch {
+        reloginNeeded = true
+        return undefined
+      } finally {
+        refreshInFlight = null
+      }
+    })()
+    return refreshInFlight
+  }
+
+  /** 每次出站共用：临期自动刷新；返回 {authorization, machineId, uid} 或 null。
+   *  expiresAt 缺失视为临期而非永不过期——拿着未知新鲜度的凭据出门，上游 401
+   *  远不如本地一次清晰刷新（有 refreshToken 时）。 */
+  async function resolveQoderCredential(s) {
+    const store = readAuth()
+    const auth = store.auth
+    if (!auth?.accessToken) return null
+    let current = auth
+    const stale = !auth.expiresAt || auth.expiresAt - Date.now() < REFRESH_LEAD_MS
+    if (auth.refreshToken && stale) {
+      const refreshed = await refreshOAuth(s)
+      if (!refreshed) return null
+      current = refreshed
+    }
+    return {
+      authorization: `Bearer ${current.accessToken}`,
+      machineId: store.machine?.machineId ?? null,
+      uid: store.account?.uid ?? null,
+    }
+  }
+
+  /** 组装授权页 URL（不发请求——设备流的 challenge 在客户端生成）。 */
+  function buildAuthUrl(s, machineId) {
+    const { verifier, challenge } = createPkce()
+    const nonce = randomUUID()
+    const params = new URLSearchParams({
+      challenge,
+      challenge_method: 'S256',
+      nonce,
+      machine_id: machineId,
+      client_id: s.qoderClientId || QODER_CLIENT_ID,
+    })
+    // URL 解析构造：基址带尾斜杠/尾路径时仍以 /device/selectAccounts 为准。
+    const authUrl = new URL(`/device/selectAccounts?${params.toString()}`, s.qoderLoginHost).toString()
+    return { authUrl, verifier, nonce }
+  }
+
+  /**
+   * 启动登录：置 pending → 返回授权页 URL → 后台轮询直到出令牌/超时。
+   * @returns {Promise<{started:true, authUrl:string}>}
+   */
+  async function startOAuth(s) {
+    if (pending.active) return { started: true, authUrl: pending.authUrl }
+
+    // 基址校验置于 machine_id 生成之前：非法设置不产生任何写入、不激活 pending。
+    assertLoginBase(s.qoderLoginHost)
+    const machineId = ensureMachineId()
+    const { authUrl, verifier, nonce } = buildAuthUrl(s, machineId)
+    // 门禁置于置位之前：拒绝时 pending 不激活，不外泄未过检的 URL。
+    assertSafeAuthUrl(authUrl)
+
+    pending.active = true
+    pending.authUrl = authUrl
+    pending.error = ''
+
+    const poll = async () => {
+      const gen = pollGeneration
+      const alive = () => gen === pollGeneration && pending.active
+      const deadline = Date.now() + LOGIN_TIMEOUT_MS
+      try {
+        while (alive() && Date.now() < deadline) {
+          await new Promise((r) => setTimeout(r, LOGIN_POLL_INTERVAL_MS))
+          if (!alive()) return
+          let res
+          try {
+            const q = new URLSearchParams({ nonce, verifier, challenge_method: 'S256' })
+            res = await fetch(`${api(s, '/api/v1/deviceToken/poll')}?${q}`, { headers: { Accept: 'application/json' } })
+          } catch {
+            continue // 网络抖动：继续等，不当失败
+          }
+          // 404 = 未完成（bundle 契约）。绝不与"失败"混同。
+          if (res.status === 404) continue
+          const body = await res.json().catch(() => null)
+          if (!res.ok) {
+            const code = body?.errorCode ?? `HTTP ${res.status}`
+            pending.error = `登录失败：${code} ${body?.errorMessage ?? ''}`.trim()
+            return
+          }
+          const auth = tokenFrom(body)
+          if (!auth) continue // 200 但无令牌：形态异常，继续观察到超时
+          if (!alive()) return // 令牌在飞期间已 logout
+          const account = await fetchAccount(s, auth.accessToken)
+          if (!alive()) return
+          writeAuth({
+            ...readAuth(),
+            auth: { ...auth, loginMethod: 'browser' },
+            ...(account ? { account } : {}),
+          })
+          reloginNeeded = false
+          return
+        }
+        if (alive()) pending.error = '登录超时（5 分钟未完成授权）'
+      } finally {
+        if (gen === pollGeneration) pending.active = false
+      }
+    }
+    // fire-and-forget 必须 .catch 落地（踩坑 #33：unhandledRejection 崩宿主）。
+    poll().catch((err) => { pending.error = String(err?.message ?? err) })
+    return { started: true, authUrl }
+  }
+
+  /** 账号信息尽力而为（失败不影响登录成立）。 */
+  async function fetchAccount(s, accessToken) {
+    try {
+      const res = await fetch(api(s, '/api/v1/userinfo'), {
+        headers: { Accept: 'application/json', Authorization: `Bearer ${accessToken}` },
+      })
+      const body = await res.json().catch(() => null)
+      if (!body || typeof body !== 'object') return null
+      const uid = body.uid ?? body.user_id ?? body.id ?? null
+      const nickname = body.name ?? body.username ?? body.user_name ?? null
+      if (!uid && !nickname) return null
+      return {
+        uid: uid != null ? String(uid) : null,
+        nickname,
+        email: body.email ?? null,
+        organizationId: body.organization_id ?? body.orgId ?? null,
+      }
+    } catch {
+      return null
+    }
+  }
+
+  /** 视图（令牌/machine_id 永不出宿主）。 */
+  function oauthStatus() {
+    const store = readAuth()
+    const auth = store.auth
+    const refreshExpired = typeof auth?.refreshExpiresAt === 'number' && auth.refreshExpiresAt > 0
+      && auth.refreshExpiresAt <= Date.now()
+    return {
+      pending: pending.active,
+      authUrl: pending.active ? pending.authUrl : '',
+      error: pending.error,
+      signedIn: Boolean(auth?.accessToken),
+      needsRelogin: Boolean(auth?.accessToken) && (refreshExpired || reloginNeeded),
+      account: store.account?.nickname || store.account?.uid
+        ? { nickname: store.account.nickname, uid: store.account.uid }
+        : null,
+      accessTokenExpiresAt: auth?.expiresAt ?? null,
+      refreshExpiresAt: auth?.refreshExpiresAt ?? null,
+      hasMachineId: Boolean(store.machine?.machineId),
+    }
+  }
+
+  function logout() {
+    pollGeneration++ // 令在飞 poll 失效：logout 后才完成的授权不落盘
+    storeGeneration++ // 令在飞 refresh 失效：其落盘前的代际校验必然失败
+    pending.active = false
+    pending.error = ''
+    reloginNeeded = false
+    const store = readAuth()
+    writeAuth({ machine: store.machine }) // 机器标识保留，令牌与账号清除
+  }
+
+  return {
+    startOAuth,
+    resolveQoderCredential,
+    refreshOAuth,
+    oauthStatus,
+    logout,
+    ensureMachineId,
+  }
+}

package/providers/qoder/quota.js

@@ -0,0 +1,56 @@
+/**
+ * providers/qoder/quota.js — Qoder CN 账户配额只读快照（设置卡用）。
+ *
+ * 端点：GET {qoderOpenapiBaseURL}/api/v2/quota/usage，裸 Bearer（openapi 明文面，
+ * 不走 COSY 签名——签名是 infer 面与 /algo 目录面的事）。响应形态实测见
+ * scripts/probe-qoder-quota.mjs 落盘（docs/probes/qoder-quota-*.json）：
+ *   { userQuota:{total,used,remaining,percentage,unit},
+ *     addOnQuota:{total,used,remaining,percentage,unit,detailUrl}, … }
+ * addOnQuota.used 是实时配额计数器（配额扣减即时入账，臂 9 定论）。
+ * 成本纪律：60s memoize（与 codebuddy quotaSnapshot 同口径）；永不 throw——
+ * 失败回 { error }，调用方（设置卡）据此显示「—」，绝不编造数值。
+ */
+
+export function createQoderQuota({ settings, oauth }) {
+  let cache = { at: 0, value: null }
+
+  async function fetchSnapshot() {
+    const s = settings()
+    const cred = await oauth.resolveQoderCredential(s)
+    if (!cred) return { error: '未登录', fetchedAt: Date.now() }
+    const res = await fetch(`${s.qoderOpenapiBaseURL}/api/v2/quota/usage`, {
+      headers: { Authorization: cred.authorization, Accept: 'application/json' },
+      signal: AbortSignal.timeout(15_000),
+    })
+    const body = await res.json().catch(() => null)
+    if (!res.ok || !body || typeof body !== 'object') {
+      return { error: `http ${res.status}`, fetchedAt: Date.now() }
+    }
+    const pick = (q) => (q && typeof q === 'object')
+      ? {
+          total: typeof q.total === 'number' ? q.total : null,
+          used: typeof q.used === 'number' ? q.used : null,
+          remaining: typeof q.remaining === 'number' ? q.remaining : null,
+          unit: typeof q.unit === 'string' ? q.unit : null,
+        }
+      : null
+    return {
+      userQuota: pick(body.userQuota),
+      addOnQuota: pick(body.addOnQuota),
+      isQuotaExceeded: body.isQuotaExceeded === true,
+      fetchedAt: Date.now(),
+    }
+  }
+
+  function snapshot() {
+    if (cache.value && Date.now() - cache.at < 60_000) return Promise.resolve(cache.value)
+    return fetchSnapshot()
+      .catch((err) => ({ error: err?.message ?? String(err), fetchedAt: Date.now() }))
+      .then((value) => {
+        cache = { at: Date.now(), value }
+        return value
+      })
+  }
+
+  return { snapshot }
+}

package/providers/qwen/index.js

@@ -0,0 +1,15 @@
+import { createOpenAICompatProvider } from '../openai-compat.js'
+
+/**
+ * Qwen Code（portal.qwen.ai）preset。2026-08-19 实测：GET /models 不存在
+ * （404），/chat/completions 认证方言 = 标准 401 invalid_api_key。
+ * 注意：Qwen OAuth 免费额度已于 2026-04-15 停服（官方文档），本机
+ * oauth_creds.json 里的存量 token 大概率已失效——导入时探针会如实拒绝，
+ * 不留半成品。Coding Plan（sk-sp- key）是另一端点 coding.dashscope.aliyuncs.com。
+ */
+export default createOpenAICompatProvider({
+  id: 'qwen',
+  displayName: 'Qwen Code',
+  baseURL: 'https://portal.qwen.ai/v1',
+  fallbackModels: ['qwen3-coder-plus', 'qwen3-coder-flash'],
+})

package/providers/tool-pairing.js

@@ -0,0 +1,129 @@
+/**
+ * providers/tool-pairing.js — 出站 messages 的 tool 配对/可见性不变量修复（两个翻译网关共用）。
+ *
+ * 为什么需要它（2026-09-22 实测根因，踩坑 #39 + #41）：
+ *
+ * A. 孤儿 tool（#39）：宿主 `@earendil-works/pi-ai` 的 `transform-messages.js` 会把
+ *    `stopReason` 为 `error`/`aborted` 的 assistant 消息**整条丢弃**（理由：中断轮次含
+ *    半截推理/工具调用，重放会触发 API 错误），但它产出的 `toolResult` 消息照旧保留——
+ *    于是出站序列里出现孤儿 `role:"tool"`（无前置 `assistant.tool_calls`）。
+ *
+ * B. 不可见 content（#41，真主因）：严格上游（Qoder 的 dmodel/kmodel/mmodel 家族）的
+ *    配对校验器**把 `content` 为 `null`/缺键的消息整条当不存在**——`content:null` 的
+ *    assistant.tool_calls 声明不再算"preceding message with tool_calls"，`content:null`
+ *    的 tool 结果也不再算"responding to tool_call_id"。而 pi-ai 在
+ *    `compat.requiresAssistantAfterToolResult === false`（provider 非 deepseek/moonshot/
+ *    nvidia… 时的探测默认）下，**每个纯工具轮的 assistant 都是 `content: null`**
+ *    （openai-completions.js:961），于是每一个正常工具轮都必 400。修复 A 补的桩若也用
+ *    `content: null`，同样被判孤儿（实测同一条 400 文案）。
+ *
+ * 症状（两因同果）：`provider_error` + details 内层
+ *   `Messages with role 'tool' must be a response to a preceding message with 'tool_calls'`
+ *   （dmodel）/ `Invalid request: tool_call_id is not found`（kmodel）/
+ *   `invalid params, tool result's tool id(…) not found (2013)`（mmodel）。
+ * 触发一次即永久：失败那轮写进历史后，此后每次请求都带同一坏体（"怎么重试都是同一个错"）。
+ *
+ * 修复纪律：只补**结构**与**内容可见性**（null↔'' 在 OpenAI 方言里语义等价），
+ * 不碰任何字段取值语义——合法非空历史逐字节不变。
+ */
+
+/** tool 配对修复时给"不可用"结果用的替代正文（留给模型读）。 */
+export const INTERRUPTED_TOOL_RESULT = '(tool result unavailable: previous attempt was interrupted)'
+
+/** assistant / tool 消息 content 为 null/缺失时的替代正文（语义等价，且严格上游认它）。 */
+export const EMPTY_CONTENT = ''
+
+/**
+ * 修复 OpenAI messages 的 tool 配对 + 内容可见性不变量。
+ *
+ * - `content` 为 `null`/缺键的 assistant / tool 消息 → 补成 `''`（规则 B）；
+ * - 孤儿 `role:"tool"`（前置 assistant 里没有这条 tool_call）→ 补一条仅含该
+ *   tool_call 的 assistant 桩（id 取原 tool_call_id，name 取 tool 消息的 name 或
+ *   `'tool'`，content 用 `''`），结果原样保留——比丢弃结果更保上下文；
+ * - 同 id 的重复结果 → 丢弃（上游会把第二条当孤儿）；
+ * - assistant 声明了却没结果的 tool_call（会话收尾 / user 插在结果前）→ 补
+ *   {@link INTERRUPTED_TOOL_RESULT} 结果，保住配对。
+ *
+ * @param {Array} messages OpenAI 方言 messages
+ * @returns {{messages: Array, repaired: {orphans: number, synthesized: number, duplicates: number, invisible: number}}}
+ */
+export function sanitizeToolPairing(messages) {
+  const out = []
+  const repaired = { orphans: 0, synthesized: 0, duplicates: 0, invisible: 0 }
+  let pending = null // 最近一条 assistant 声明、尚未配齐结果的 tool_call id 集合
+  let resolved = new Set() // 本 assistant 段内已收到结果的 id（挡同 id 重复结果）
+
+  /** 可见性归一：null/缺失 content → ''（严格上游的配对校验器不认 null 载体）。 */
+  const visible = (msg) => {
+    if (msg.content !== null && msg.content !== undefined) return msg
+    repaired.invisible++
+    return { ...msg, content: EMPTY_CONTENT }
+  }
+
+  /** 给所有未回结果的 tool_call 补"不可用"结果。 */
+  const flushPending = () => {
+    if (!pending || !pending.size) return
+    for (const id of pending) {
+      out.push({ role: 'tool', tool_call_id: id, content: INTERRUPTED_TOOL_RESULT })
+      repaired.synthesized++
+    }
+    pending = null
+  }
+
+  for (const msg of Array.isArray(messages) ? messages : []) {
+    if (!msg || typeof msg !== 'object') continue
+    if (msg.role === 'assistant') {
+      flushPending()
+      resolved = new Set()
+      const calls = Array.isArray(msg.tool_calls) ? msg.tool_calls : []
+      const ids = calls.map((tc) => (typeof tc?.id === 'string' && tc.id ? tc.id : null)).filter(Boolean)
+      pending = ids.length ? new Set(ids) : null
+      out.push(visible(msg))
+      continue
+    }
+    if (msg.role === 'tool') {
+      const id = typeof msg.tool_call_id === 'string' ? msg.tool_call_id : ''
+      if (id && resolved.has(id)) {
+        repaired.duplicates++
+        continue
+      }
+      if (pending && id && pending.has(id)) {
+        pending.delete(id)
+        resolved.add(id)
+        out.push(visible(msg))
+        continue
+      }
+      repaired.orphans++
+      const callId = id || `call_orphan_${repaired.orphans}`
+      out.push(visible({
+        role: 'assistant',
+        content: EMPTY_CONTENT,
+        tool_calls: [{
+          id: callId,
+          type: 'function',
+          function: {
+            name: typeof msg.name === 'string' && msg.name ? msg.name : 'tool',
+            arguments: '{}',
+          },
+        }],
+      }))
+      out.push(visible(id ? msg : { ...msg, tool_call_id: callId }))
+      if (id) resolved.add(id)
+      continue
+    }
+    // user / system 插在结果之前：补齐未回结果的 tool_call
+    flushPending()
+    out.push(msg)
+  }
+  // 会话以未回结果的 tool_call 收尾：同样补齐
+  flushPending()
+  return { messages: out, repaired }
+}
+
+/** 取证日志用的单行摘要（无修复时返回 null）。 */
+export function describeRepair(repaired) {
+  if (!repaired) return null
+  const { orphans = 0, synthesized = 0, duplicates = 0, invisible = 0 } = repaired
+  if (!orphans && !synthesized && !duplicates && !invisible) return null
+  return `orphans=${orphans} synthesized=${synthesized} duplicates=${duplicates} invisible=${invisible}`
+}

package/providers/trae/catalog.js

@@ -0,0 +1,103 @@
+/**
+ * providers/trae/catalog.js — Trae 本地模型目录接入。
+ *
+ * 数据源是本机 TRAE SOLO CN 的 VS Code 全局状态库（state.vscdb 的
+ * AI.agent.model.model_list_map），由 scripts/trae-model-catalog.mjs 的纯函数
+ * 负责（发现/复制/解析/归一化/scrub——该脚本的 CLI 入口带 import.meta 守卫，
+ * 作为库导入不会执行 main）。这里只做"目录 → dsh 模型 profile"的映射与镜像。
+ *
+ * 映射规则（docs/reverse/trae-model-catalog.md 的字段说明为裁判）：
+ *   - 只收 preset 型条目（provider 为空）——deepseek//… 等 BYOK 条目路由到
+ *     用户自己的 provider，经 Trae 通道会失败；
+ *   - id 用目录原 id（dsh 里模型 id 按 provider 命名空间隔离，与 codebuddy
+ *     重名不冲突）；
+ *   - contextWindow 取 contextWindowDefault，缺失回落 max（数组取最大档）；
+ *   - maxTokens 取 maxOutputTokens；multimodal → input [text,image]；
+ *   - reasoning_effort_config.options → reasoningEfforts（键 = 宿主枚举映射
+ *     TRAE_EFFORT_TO_HOST_KEY/枚举内恒等，值 = 声明拼写；support_thinking
+ *     非 true 或空 options 不出档）。
+ */
+
+import { mkdtempSync, rmSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+import {
+  discoverStateDbs, copySqliteForRead, readModelListCandidates,
+  selectDefaultCandidate, normalizeCatalog,
+} from '../../scripts/trae-model-catalog.mjs'
+
+// Trae 声明拼写 → 宿主枚举键（保序映射：light<high<extra_high ↔ low<high<xhigh）。
+// 宿主 llm-pi-ai 对 models[].reasoningEfforts 的键有固定枚举
+//（off|minimal|low|medium|high|xhigh|max）——声明拼写原样做键会被宿主 schema
+// 整块拒收（2026-10-04 实测 host-config lastError），值则恒为目录声明拼写
+//（remote 通道 custom_model.reasoning_effort 线值，不臆造，踩坑 #42）。
+const TRAE_EFFORT_TO_HOST_KEY = { light: 'low', high: 'high', extra_high: 'xhigh' }
+// 宿主枚举全集：声明拼写本就在枚举内时恒等透传（如未来上游声明 low/max）。
+const HOST_EFFORT_ENUM = new Set(['off', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'])
+
+/** 目录条目 → dsh 模型 profile（可路由集合 = preset 且未禁用）。 */
+export function catalogToProfiles(catalog) {
+  const list = []
+  for (const m of catalog?.models ?? []) {
+    if (m.provider) continue // BYOK/托管条目不经 Trae 通道
+    if (m.selectable === false || m.status === false) continue
+    const p = { id: m.id, name: m.displayName ?? m.id }
+    const ctx = m.contextWindowDefault
+      ?? (Array.isArray(m.contextWindowMax) ? Math.max(...m.contextWindowMax) : m.contextWindowMax)
+      ?? null
+    if (ctx != null) p.contextWindow = ctx
+    if (m.maxOutputTokens != null) p.maxTokens = m.maxOutputTokens
+    if (m.multimodal === true) p.input = ['text', 'image']
+    // 档位投影（goal: trae-work-cn-repair G3）：目录 reasoning_effort_config
+    // 声明 {support_thinking, options, default_level} → reasoningEfforts。
+    // supportThinking 非 true 或空 options 不出档（不摆假档位）；未映射拼写
+    // 不进宿主表（仍可由设置卡档位控件按声明拼写使用）。
+    const eff = m.reasoningEffortConfig
+    if (eff && eff.supportThinking === true && Array.isArray(eff.options) && eff.options.length) {
+      const table = {}
+      for (const opt of eff.options) {
+        const hostKey = TRAE_EFFORT_TO_HOST_KEY[opt] ?? (HOST_EFFORT_ENUM.has(opt) ? opt : undefined)
+        if (hostKey) table[hostKey] = opt
+      }
+      // max 档：目录不声明但上游实测接受且产生比 extra_high 更多的推理内容
+      //（2026-10-05 探针 docs/probes/trae-max-effort-1791203547000.json：
+      // glm-5.3 high 2788 < extra_high 3209 < max 4139 推理字符，方向一致）。
+      // 只给声明了 extra_high 的模型追加（extra_high 是目录最高声明档位，
+      // max 作为其上位档；无 extra_high 的模型不加——不臆造未测路径）。
+      if (eff.options.includes('extra_high') && !table.max) table.max = 'max'
+      if (Object.keys(table).length) p.reasoningEfforts = table
+    }
+    list.push(p)
+  }
+  return list
+}
+
+/**
+ * 从本机 state.vscdb 拉一次目录（发现 → 副本 → 解析 → 归一化）。
+ * 返回 { profiles, catalog, fetchedAt, source }；任何一步失败抛错（调用方
+ * 决定保底策略——沿用旧镜像或清空）。
+ */
+export function fetchLocalCatalog({ dbPath } = {}) {
+  const target = dbPath ?? discoverStateDbs()[0]?.dbPath
+  if (!target) throw new Error('未发现 TRAE SOLO CN 的 state.vscdb（需要 --db 或本机安装）')
+  const tmp = mkdtempSync(join(tmpdir(), 'trae-catalog-'))
+  try {
+    const copy = copySqliteForRead(target, tmp)
+    const candidates = readModelListCandidates(copy)
+    for (const c of candidates) c.dbPath = target // 指纹指向原始路径
+    const best = selectDefaultCandidate(candidates)
+    if (!best) throw new Error('state.vscdb 中没有可解析的 model_list_map 候选')
+    const catalog = normalizeCatalog(best)
+    const profiles = catalogToProfiles(catalog)
+    if (!profiles.length) throw new Error('目录归一化后无可路由模型（全为 BYOK 或禁用？）')
+    return {
+      profiles,
+      catalog,
+      fetchedAt: catalog.source.generatedAt,
+      source: { candidateCount: candidates.length, chosen: catalog.source.itemKeyFingerprint },
+    }
+  } finally {
+    rmSync(tmp, { recursive: true, force: true })
+  }
+}