opencode-lobster-auth 0.1.2 → 0.2.0

package/lib/checkin.mjs

@@ -0,0 +1,240 @@
+// 每日积分礼（签到）的领取逻辑。
+//
+// 上游接口（2026-11-02 实测）：
+//   GET  /api/client-activities/slot?placement=desktop_sidebar&clientVersion=…&…
+//        → { slotState: "available", activity: { activityCode, configRevision } }
+//   GET  /api/client-activities/<code>/context?configRevision=<rev>
+//        → { state: { claimedToday, claimedDays, rewardCredits, claimedCredits }, actions: [] }
+//   POST /api/client-activities/<code>/actions/check_in
+//        体 { configRevision, idempotencyKey, payload: {} }
+//        → code 0 领取成功；code 51104「活动奖励已领取」（幂等，重复发不重复给）
+//
+// 判据取 context 的 actions：已领时是 []，未领时才有 check_in。
+// 领完必须复核（再读一次 context），接口 200 不等于真的到账。
+//
+// 这里只搬活动那一半。原脚本（技术方案调研/lobsterai-checkin）里取 token、
+// 调 /api/auth/refresh、把 token 缓存到磁盘的部分**不搬** —— 那会把桌面端
+// 踢下线，是本插件明确不碰的（见 README「不做的事」）。
+
+const BASE = "https://lobsterai-server.youdao.com"
+const UPDATE_URL = "https://api-overmind.youdao.com/openapi/get/luna/hardware/lobsterai/prod/update"
+const PLACEMENT = "desktop_sidebar"
+// 实测 macOS 上也认 win32，别按本机平台改
+const PLATFORM = "win32"
+
+// magpie 只认这几个 outcome，其它值会被改写成 failed
+export const OUTCOMES = ["claimed", "done", "ineligible", "inactive", "captcha", "failed"]
+
+const timeout = (ms) => AbortSignal.timeout(ms)
+
+async function call(method, path, token, body, version) {
+  const headers = { authorization: `Bearer ${token}`, accept: "application/json" }
+  if (version) headers["User-Agent"] = `LobsterAI/${version}`
+  if (body !== undefined) headers["content-type"] = "application/json"
+  const res = await fetch(BASE + path, {
+    method, headers,
+    body: body === undefined ? undefined : JSON.stringify(body),
+    signal: timeout(20_000),
+  })
+  const text = await res.text()
+  let json = null
+  try { json = JSON.parse(text) } catch {}
+  return { status: res.status, json, text }
+}
+
+// 当前客户端版本。活动位是否投放跟版本号有关，版本过旧会拿不到活动。
+export async function clientVersion() {
+  try {
+    const res = await fetch(UPDATE_URL, { signal: timeout(8_000) })
+    if (!res.ok) throw new Error(`版本查询 HTTP ${res.status}`)
+    const j = await res.json()
+    const v = j?.data?.value?.version
+    if (typeof v === "string" && /^\d{4}\.\d/.test(v)) return { version: v, known: true }
+  } catch {}
+  // 兜底：拿不到版本时用一个已知能用的值。known=false 让上层能把「可能是版本问题」
+  // 如实报出来，而不是假装活动没投放。
+  return { version: "2026.10.30", known: false }
+}
+
+const isObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value)
+const isRevision = (value) => typeof value === "number" && Number.isSafeInteger(value) && value >= 0
+
+// 供应商的「一天」何时翻篇：下一个北京零点（活动 ctx 的 state.timezone 是
+// Asia/Shanghai）。magpie 靠这个字段决定下次什么时候再问：
+//   有 until -> 它知道今天确实过去了，下次按 until 来；
+//   没 until -> 它无法判断，只能把结果标成 `again`（稍后再问），
+//               界面上就显示成「暂不可签到」而不是「今日已签到」。
+// 实测 qoder 的签到记录就带着 until（它的积分 10:00 UTC+8 开门）。
+const BEIJING_MS = 8 * 3600 * 1000
+export function nextDayTurn(now = Date.now()) {
+  const shifted = now + BEIJING_MS
+  const nextMidnight = Math.floor(shifted / 86400000) * 86400000 + 86400000
+  return new Date(nextMidnight - BEIJING_MS).toISOString()
+}
+
+// 本日奖励：活动 state 里的 rewardCredits。实测 100。
+const rewardOf = (state) => {
+  const n = Number(state?.rewardCredits)
+  return Number.isFinite(n) && n > 0 ? n : 0
+}
+
+
+function envelope(r) {
+  const msg = typeof r.json?.message === "string" ? r.json.message : ""
+  if (r.status === 401 || r.status === 403) return { expired: true, message: msg || "登录已失效" }
+  if (r.status < 200 || r.status >= 300) {
+    return { bad: true, message: `HTTP ${r.status}${msg ? `：${msg}` : ""}` }
+  }
+  // HTTP 成功和合法业务信封都需要。缺少 code 绝不能被当成“没有错误”。
+  if (!isObject(r.json) || !Number.isSafeInteger(r.json.code)) {
+    return { bad: true, message: `签到响应缺少有效业务 code${msg ? `：${msg}` : ""}` }
+  }
+  if (r.json.code === 0) {
+    return isObject(r.json.data)
+      ? { data: r.json.data }
+      : { bad: true, message: "签到成功响应缺少有效 data" }
+  }
+  if (/未登录|登录已失效|token/i.test(msg)) return { expired: true, message: msg }
+  return { code: r.json.code, message: msg || `code ${r.json.code}` }
+}
+
+function validContext(data) {
+  return isObject(data?.state) && typeof data.state.claimedToday === "boolean" &&
+    Array.isArray(data.actions) && data.actions.every((action) => typeof action === "string") &&
+    (data.configRevision === undefined || isRevision(data.configRevision))
+}
+
+// 读活动位 + 上下文，返回领不领得动、以及要用的判据
+export async function readState(token, { version } = {}) {
+  const v = version ?? (await clientVersion())
+  const slotPath = `/api/client-activities/slot?${new URLSearchParams({
+    placement: PLACEMENT, clientVersion: v.version, containerApiVersion: "2", platform: PLATFORM,
+  })}`
+  const slot = envelope(await call("GET", slotPath, token, undefined, v.version))
+  if (slot.expired) return { outcome: "failed", reason: slot.message, version: v }
+  if (slot.bad) return { outcome: "failed", reason: slot.message, version: v }
+  if (slot.code !== undefined) return { outcome: "failed", reason: slot.message || `code ${slot.code}`, version: v }
+
+  const activity = slot.data.activity
+  const slotState = slot.data.slotState
+  if (typeof slotState !== "string" || !slotState.trim()) {
+    return { outcome: "failed", reason: "活动位响应缺少有效 slotState", version: v }
+  }
+  if (slotState !== "available") {
+    // 版本是现取的 → 上游就是没投放；版本是兜底值 → 可能是版本过旧，值得当天重试
+    return {
+      outcome: v.known ? "inactive" : "failed",
+      reason: v.known ? "" : "拿不到当前客户端版本，无法确认活动是否投放",
+      slotState, version: v,
+    }
+  }
+
+  if (!isObject(activity) || typeof activity.activityCode !== "string" || !activity.activityCode.trim() || !isRevision(activity.configRevision)) {
+    return { outcome: "failed", reason: "活动位响应缺少有效活动或 configRevision", version: v }
+  }
+  const code = activity.activityCode
+  const rev = activity.configRevision
+  const ctx = envelope(await call("GET", `/api/client-activities/${encodeURIComponent(code)}/context?configRevision=${rev}`, token, undefined, v.version))
+  if (ctx.expired || ctx.bad || ctx.code !== undefined) return { outcome: "failed", reason: ctx.message, version: v }
+  if (!validContext(ctx.data)) return { outcome: "failed", reason: "签到上下文缺少有效 state/actions", version: v }
+
+  const actions = ctx.data.actions.map((a) => a.toLowerCase().trim())
+  return {
+    outcome: null, code, rev: ctx.data.configRevision ?? rev, state: ctx.data.state, actions, version: v,
+  }
+}
+
+// 领一次并复核。返回 magpie 的 outcome 形状。
+export async function claim(token, state, { idempotencyKey } = {}) {
+  const { code, rev, actions } = state
+  // 今天已经领过：报 done，但要带上 credit 和 until ——
+  // 缺 until 时 magpie 会把它当成「今天可能还没过去」而标记 again，
+  // 界面上就变成「暂不可签到」；缺 credit 则看不到今天拿到多少。
+  if (state.state?.claimedToday === true) {
+    const out = { outcome: "done", until: nextDayTurn() }
+    const reward = rewardOf(state.state)
+    if (reward > 0) out.credit = reward
+    return out
+  }
+  if (!actions.includes("check_in")) return { outcome: "ineligible" }
+
+  const body = {
+    configRevision: rev,
+    idempotencyKey: idempotencyKey ?? crypto.randomUUID(),
+    payload: {},
+  }
+  const r = envelope(await call("POST", `/api/client-activities/${encodeURIComponent(code)}/actions/check_in`, token, body, state.version?.version))
+  // 51104 = 活动奖励已领取。并发的另一路已经领过，算 done
+  if (r.code === 51104) {
+    const out = { outcome: "done", until: nextDayTurn() }
+    const reward = rewardOf(state.state)
+    if (reward > 0) out.credit = reward
+    return out
+  }
+  if (r.expired || r.code !== undefined || r.bad) return { outcome: "failed", reason: r.message ?? "领取失败" }
+
+  const granted = Number(r.data?.creditsGranted ?? r.data?.rewardCredits ?? r.data?.result?.rewardCredits) || 0
+
+  // 复核：接口 200 不等于到账。
+  // 判据只能是**观察到的状态变化**：复核里 claimedToday 必须为真。
+  // 绝不能因为 POST 自己说 creditsGranted>0 就报 claimed —— 那是拿请求的回显当证据，
+  // 响应说发了、状态没落地时会假报成功。
+  let after
+  try {
+    const c = envelope(await call("GET", `/api/client-activities/${encodeURIComponent(code)}/context?configRevision=${rev}`, token, undefined, state.version?.version))
+    if (c.expired || c.bad || c.code !== undefined) {
+      return { outcome: "failed", reason: `领取后复核失败：${c.message}` }
+    }
+    if (!validContext(c.data)) return { outcome: "failed", reason: "领取后复核响应缺少有效 state/actions" }
+    after = c.data.state
+  } catch (e) {
+    return { outcome: "failed", reason: `领取后复核请求失败：${e?.message ?? String(e)}` }
+  }
+
+  if (!after.claimedToday) {
+    return { outcome: "failed", reason: "领取后复核未通过（服务端仍显示今日未领取）" }
+  }
+
+  const out = { outcome: "claimed", until: nextDayTurn() }
+  // 发放额优先用 POST 的回显；回显没有（或为 0）时用复核里的本日奖励
+  const grantedNow = granted > 0 ? granted : Number(after.rewardCredits) || 0
+  if (grantedNow > 0) out.credit = grantedNow
+  // 不填 streak：claimedDays 是活动开始以来的累计天数，不是连签天数，
+  // magpie 会把 streak 显示成「连续 N 天」。
+  return out
+}
+
+// auth.checkin 的实现：读状态 → 该领就领。
+// 任何失败都返回 outcome + message，**绝不抛** —— 抛异常 magpie 也记成 failed，
+// 但丢失原因；而且两次读都走网络，超时/断网是常态不是异常。
+export async function checkinWith(token, { version, idempotencyKey } = {}) {
+  if (!token) return { outcome: "failed", message: "尚未登录" }
+  let state
+  try {
+    state = await readState(token, { version })
+  } catch (e) {
+    return { outcome: "failed", message: e?.message ?? String(e) }
+  }
+  if (state.outcome) {
+    const out = { outcome: state.outcome }
+    // magpie 的 `message` 就是给人看的原因；内部统一用 reason，出口转一次
+    if (state.reason) out.message = state.reason
+    return out
+  }
+  let r
+  try {
+    r = await claim(token, state, { idempotencyKey })
+  } catch (e) {
+    return { outcome: "failed", message: e?.message ?? String(e) }
+  }
+  const out = { outcome: r.outcome }
+  if (r.credit) out.credit = r.credit
+  // until 必须带出去：magpie 靠它判断供应商的「一天」何时翻篇。
+  // 丢了它，「今天已签」会被当成「可能还没过去」而标记 again，
+  // 界面就从「今日已签到」退化成「暂不可签到」。
+  if (r.until) out.until = r.until
+  if (r.reason) out.message = r.reason
+  return out
+}
+
+export { PLACEMENT, PLATFORM, UPDATE_URL }

package/lib/constants.mjs

@@ -15,10 +15,36 @@ export const ICON = "https://lobsterai.youdao.com/portal/lobsterai-logo.png"
 export const CLIENT_VERSION = "2026.9.23"
 export const CAPABILITIES = "kimi-k3-agentic-v1,thinking-level-control-v1"
 
-// 接口不提供输出上限，取一个保守值（见设计文档 §8）
-export const DEFAULT_OUTPUT = 32000
+// 输出上限。接口的 maxTokens 字段恒为 null，所以靠实测：
+// 2026-11-02 逐模型打 max_tokens=131072，18 个可用模型全部通过；glm-5.3 自己
+// 报的上限就是 [1, 131072]。524288 才 HTTP 500。原来的 32000 会把长回答截掉，
+// 而 magpie 会把这个数当 max_output_tokens 广告给 agent。
+export const DEFAULT_OUTPUT = 131072
 export const DEFAULT_CONTEXT = 1000000
 
+// 没有 thinkingConfig 的模型：上游照样认 reasoning_effort，但**每个模型接受的
+// 档位不一样**，2026-11-02 逐模型实测（十模型 × 七档，见设计文档 §5 补测）：
+//   MiniMax-M3.1-Flash 拒收 none（"requires adaptive thinking"）
+//   qwen3.7-max        拒收 max（只到 xhigh）
+//   qwen3.7-plus       max 偶发 500
+//   MiniMax-M3         思考写在 content 的 <think> 里，reasoning_content 恒 0，
+//                      上游不分档，只有「关 / 开」
+// 只列**实测接受且确实有区别**的档位。没列进来的模型一律不声明（显示成
+// 「thinks, no levels」），宁少不多：声明了却选不动，用户以为能控，实际被忽略或 400。
+export const MEASURED_LEVELS = {
+  "kimi-k3.1-pro": ["none", "low", "medium", "high", "xhigh", "max"],
+  "kimi-k2.8-preview": ["none", "low", "medium", "high", "xhigh", "max"],
+  "qwen3.8-max": ["none", "low", "medium", "high", "xhigh", "max"],
+  "qwen3.8-flash": ["none", "low", "medium", "high", "xhigh", "max"],
+  "qwen3.8-omni-flash": ["none", "low", "medium", "high", "xhigh", "max"],
+  "doubao-seed-2-1-pro-260915": ["none", "low", "medium", "high", "xhigh", "max"],
+  "MiniMax-M3.1-Flash": ["medium", "high", "xhigh", "max"],
+  "qwen3.7-max": ["none", "low", "medium", "high", "xhigh"],
+  "qwen3.7-plus": ["none", "low", "medium", "high", "xhigh"],
+  // 只有「关」与「开」两种真实状态
+  "MiniMax-M3": ["none", "max"],
+}
+
 export function configModel({ name, context, output, reasoning, image }) {
   const input = ["text"]
   if (image) input.push("image")

package/lib/models.mjs

@@ -1,14 +1,18 @@
 // /api/models/available 的条目 → magpie 的运行时模型。
 // 运行时模型用嵌套的 capabilities；config 钩子用扁平字段（见 constants.configModel）。
 
-import { NPM, DEFAULT_OUTPUT, DEFAULT_CONTEXT, configModel } from "./constants.mjs"
-import { variantsOf } from "./thinking.mjs"
+import { NPM, DEFAULT_OUTPUT, DEFAULT_CONTEXT, configModel, MEASURED_LEVELS } from "./constants.mjs"
+import { variantsOf, variantsFromLevels } from "./thinking.mjs"
 
 export function runtimeModel(entry, base = {}) {
   const id = String(entry.modelId ?? "")
   const image = !!entry.supportsImage
   const profile = entry.thinkingConfig
-  const hasThinking = !!entry.supportsThinking && Array.isArray(profile?.options) && profile.options.length > 0
+  const hasProfile = Array.isArray(profile?.options) && profile.options.length > 0
+  // 上游自报「会思考」就认：10 个没有 thinkingConfig 的模型 supportsThinking 也是
+  // true，上游同样认 reasoning_effort。原来按「有没有档位表」判，把这 10 个
+  // 报成不思考，界面上连 reasoning 都不显示。
+  const reasoning = !!entry.supportsThinking
 
   return {
     ...base,
@@ -23,7 +27,7 @@ export function runtimeModel(entry, base = {}) {
     limit: { context: Number(entry.contextWindow) || DEFAULT_CONTEXT, output: DEFAULT_OUTPUT },
     capabilities: {
       temperature: true,
-      reasoning: hasThinking,
+      reasoning,
       attachment: image,
       toolcall: true,
       input: { text: true, image, audio: false, video: false, pdf: false },
@@ -31,7 +35,9 @@ export function runtimeModel(entry, base = {}) {
       interleaved: false,
     },
     release_date: "",
-    variants: hasThinking ? variantsOf(profile) : {},
+    // 当前 profile 决定 lobsterai_options 的合法值，不能与旧 reasoning_effort
+    // 通道的实测档位做并集。只有没有 profile 时才使用实测表。
+    variants: !reasoning ? {} : hasProfile ? variantsOf(profile) : variantsFromLevels(MEASURED_LEVELS[id]),
     // magpie 自己的字段：一次请求消耗的点数倍率
     rate: Number(entry.costMultiplier) || 0,
   }

package/lib/proxy.mjs

@@ -1,25 +1,18 @@
 // 请求管线。上游有两个必须处理的行为：
 //   1. 永远以 SSE 作答，即使请求写了 stream:false；
-//   2. 把错误塞进 SSE 的 event:error 且状态码仍是 200，原样透传会让 magpie
-//      永不故障切换。
+//   2. 把错误塞进 200 的 SSE 里，原样透传会让 magpie 永不故障切换。
+//      错误有两种帧形态，见下面 errorFrame —— 只认一种会把它吞成一个 200 空回复。
 // 另外思考档位要翻译成私有字段（见 lib/thinking.mjs）。
 
-import { sse, first } from "./sse.mjs"
+import { sse, chain } from "./sse.mjs"
 import { respond } from "./assemble.mjs"
-import { applyThinking, applyKimiK3, isKimiK3 } from "./thinking.mjs"
+import { errorFrame, StreamError } from "./stream-error.mjs"
+export { errorOf } from "./stream-error.mjs"
+import { applyThinking, applyKimi, isKimiK3 } from "./thinking.mjs"
 import { CLIENT_VERSION, CAPABILITIES } from "./constants.mjs"
 
 const LIMIT_WORDS = /限流|频率|过快|过于频繁|rate ?limit|too many/i
 
-export function errorOf(data) {
-  let v
-  try { v = JSON.parse(data) } catch { return { code: 0, message: "" } }
-  const e = v?.error && typeof v.error === "object" ? v.error : v
-  const code = Number(e?.code ?? v?.code ?? 0) || 0
-  const message = String(e?.message ?? v?.message ?? v?.msg ?? "")
-  return { code, message }
-}
-
 export function statusFor(code, message) {
   if (code === 40100) return 401
   if (code === 40300) return 403
@@ -38,6 +31,33 @@ function errorResponse(status, code, message) {
   )
 }
 
+// 窥探到第一条带 choices 的 chunk（包括 role 空帧）为止。
+// 后续错误由非流式重组处理，流式则保留错误事件，不能追改已发送的状态码。
+// DONE 是逻辑终止，不必等传输 EOF；提前报错/终止必须关闭上游。
+async function sniffError(records) {
+  const held = []
+  let handedOff = false
+  try {
+    for (;;) {
+      const n = await records.next()
+      if (n.done) return { bad: null, head: chain(held, records) }
+      const rec = n.value
+      held.push(rec)
+      const bad = errorFrame(rec)
+      if (bad) return { bad, head: null }
+      if (rec.data === "[DONE]") return { bad: null, head: chain(held, records) }
+      let v
+      try { v = JSON.parse(rec.data) } catch {}
+      if (v && typeof v === "object" && Object.prototype.hasOwnProperty.call(v, "choices")) {
+        handedOff = true
+        return { bad: null, head: chain(held, records) }
+      }
+    }
+  } finally {
+    if (!handedOff) await records.return?.()
+  }
+}
+
 // tokenOf 由调用方注入：桌面端导入的账号自己不存 token，得每次现读，
 // 因此这里不能写死「oauth 读 access、api 读 key」。
 export function makeFetch({ getAuth, tokenOf, profileOf, call }) {
@@ -61,7 +81,9 @@ export function makeFetch({ getAuth, tokenOf, profileOf, call }) {
     // 请求体改写
     const profile = profileOf(req.model)
     const k3 = isKimiK3(req.model)
-    if (k3) applyKimiK3(req)
+    // Kimi 家族：采样参数必须删（服务端固定）；仅 kimi-k3 本身强制 max。
+    // 拆成两个契约是因为 k3.1-pro 认完整档位，压成 max 会改掉用户选的档位。
+    applyKimi(req, req.model)
     const translated = applyThinking(req, profile)
     // 翻译成功才把 magpie 下发的档位名删掉：它下发的是它阶梯里的名字
     // （最低档叫 none），未必是上游的叫法。没翻译成功（模型没有档位表）
@@ -92,12 +114,22 @@ export function makeFetch({ getAuth, tokenOf, profileOf, call }) {
     // 上游理论上永远给 SSE；真给了 JSON 就直通，不做重组
     if (!ctype.includes("event-stream")) return res
 
-    const { head, rest } = await first(sse(res.body))
-    if (head && head.event === "error") {
-      const { code, message } = errorOf(head.data)
-      return errorResponse(statusFor(code, message), code, message || "LobsterAI 返回了一个错误")
+    // 错误不一定在第一帧：先窥探到第一条真正带 choices 的 chunk 为止
+    const { bad, head } = await sniffError(sse(res.body))
+    if (bad) {
+      const { code, message } = bad
+      return errorResponse(statusFor(code, message), code, message)
+    }
+    let out
+    try {
+      out = await respond(req, head)
+    } catch (e) {
+      // 非流式请求整条流都在手里，中途出现的错误帧也能还原成真正的状态码
+      if (e instanceof StreamError) {
+        return errorResponse(statusFor(e.payload.code, e.payload.message), e.payload.code, e.payload.message)
+      }
+      throw e
     }
-    const out = await respond(req, rest)
     // 成功也要带 kept：插件不自己续期，用的就是存下来的 token。
     // magpie 靠这个头把账号上的失效标记清掉。
     out.headers.set("X-Magpie-Sign-In", "kept")

package/lib/sse.mjs

@@ -48,20 +48,16 @@ export async function* sse(body) {
   if (last) yield last
 }
 
-async function* empty() {}
-
-// first 读一条但把它放回去：上游把错误藏在流里，必须先看一眼首条
-export async function first(it) {
-  const n = await it.next()
-  if (n.done) return { head: null, rest: empty() }
-  return { head: n.value, rest: chain([n.value], it) }
-}
-
 export async function* chain(held, it) {
-  yield* held
-  for (;;) {
-    const n = await it.next()
-    if (n.done) return
-    yield n.value
+  try {
+    yield* held
+    for (;;) {
+      const n = await it.next()
+      if (n.done) return
+      yield n.value
+    }
+  } finally {
+    // DONE、合并时抛错或下游取消，都必须继续关闭底层 SSE/HTTP 流。
+    await it.return?.()
   }
 }

package/lib/stream-error.mjs

@@ -0,0 +1,34 @@
+// SSE 的两种错误形态共用同一判据，避免首帧与非流式重组的处理分叉。
+// event:error 的 data 可以是纯文本；无 event 的错误必须是没有 choices 的 error 信封。
+
+export function errorOf(data) {
+  let v
+  try { v = JSON.parse(data) } catch { return { code: 0, message: String(data ?? "") } }
+  const raw = v?.error ?? v
+  const message = typeof raw === "string"
+    ? raw
+    : String(raw?.message ?? raw?.msg ?? v?.message ?? v?.msg ?? "")
+  const code = Number((raw && typeof raw === "object" ? raw.code : undefined) ?? v?.code ?? 0) || 0
+  return { code, message }
+}
+
+export function errorFrame(rec) {
+  if (!rec) return null
+  // 显式事件优先于 JSON 解析和 choices；标量/null/畸形的普通记录则不算错误。
+  if (rec.event !== "error") {
+    let v
+    try { v = JSON.parse(rec.data) } catch { return null }
+    if (!v || typeof v !== "object" || Array.isArray(v)) return null
+    if (Object.prototype.hasOwnProperty.call(v, "choices") || !v.error) return null
+  }
+  const payload = errorOf(rec.data)
+  return { ...payload, message: payload.message || "LobsterAI 返回了一个错误" }
+}
+
+export class StreamError extends Error {
+  constructor(payload) {
+    super(payload.message)
+    this.name = "StreamError"
+    this.payload = payload
+  }
+}

package/lib/thinking.mjs

@@ -33,6 +33,14 @@ export function variantsOf(profile) {
   return Object.fromEntries(opts.map((o) => [nameForMagpie(o.level), { [MARKER]: o.level }]))
 }
 
+// 没有 thinkingConfig 的模型：档位名就是上游要的 reasoning_effort 原名
+// （magpie 用「声明过的那个名字」下发，插件再原样透传），所以直接用实测到的
+// 档位名，不必翻译。值对象仍只是占位，magpie 只取键名。
+export function variantsFromLevels(levels) {
+  if (!Array.isArray(levels) || levels.length === 0) return {}
+  return Object.fromEntries(levels.map((lv) => [lv, { [MARKER]: lv }]))
+}
+
 // 档位可能以多种形式到达：插件自己的标记、reasoning_effort、reasoningEffort、
 // thinking.level。按 level 或 openclawLevel 查表，未命中用 defaultLevel。
 export function levelOf(req, profile) {
@@ -51,10 +59,11 @@ export function levelOf(req, profile) {
     const byOpenclaw =
       opts.find((o) => o.openclawLevel === wanted) ?? opts.find((o) => o.openclawLevel === level)
     if (byOpenclaw) return byOpenclaw.level
-    if (isLevel(level)) return level
   }
-  if (profile?.defaultLevel && isLevel(profile.defaultLevel)) return profile.defaultLevel
-  return "off"
+  if (profile?.defaultLevel && isLevel(profile.defaultLevel) && opts.some((o) => o.level === profile.defaultLevel)) {
+    return profile.defaultLevel
+  }
+  return opts[0]?.level && isLevel(opts[0].level) ? opts[0].level : "off"
 }
 
 // 上游只在模型自带 thinkingConfig 时才接受 lobsterai_options。对没有档位表的
@@ -75,24 +84,61 @@ export function applyThinking(req, profile) {
   return true
 }
 
-// Kimi K3 的额外契约（LobsterAI 的 kimiK3StreamWrapper.ts）：
-// 采样参数由服务端固定，必须删掉；reasoning_effort 固定为 max；
-// 历史里缺 reasoning_content 的 assistant tool_call 消息会被拒答。
-const K3_FIXED = ["temperature", "top_p", "n", "presence_penalty", "frequency_penalty"]
+// Kimi 家族有两个互不相干的契约，实测要分开（2026-11-02）：
+//
+// ① 采样参数由服务端固定 —— 覆盖**整个家族**。kimi-k3 / kimi-k3.1-pro /
+//    kimi-k2.8-preview 带 temperature=0.7 全部报
+//    50204 "invalid temperature: only 1 is allowed for this model"，
+//    带 top_p=0.5 报 "only 0.95 is allowed"，带 presence_penalty 报 "only 0 is allowed"。
+//    原正则只匹配 kimi-k3*，kimi-k2.8-preview 是 19 个可用模型之一，必然踩雷。
+//
+// ② 强制 reasoning_effort=max —— 只属于 kimi-k3 本身。
+//    工具历史补 reasoning_content 是独立的兼容修复，仍覆盖原来的 kimi-k3 前缀家族；
+//    kimi-k3.1-pro 实测认完整档位，不能因此把它压成 max。
+const SAMPLING_FIXED = ["temperature", "top_p", "n", "presence_penalty", "frequency_penalty"]
+
+// 上游按模型 id 前缀判定 Kimi 家族，这里跟着它走
+export function isKimi(modelId) {
+  return /^kimi-/i.test(String(modelId ?? ""))
+}
 
+export function stripKimiSampling(req) {
+  for (const f of SAMPLING_FIXED) delete req[f]
+  return req
+}
+
+// 只匹配 kimi-k3 本身。曾经是 /^kimi-k3(?:$|[-.])/，把 kimi-k3.1-pro 也框进来，
+// 于是它刚声明出来的档位被强制 max 抹掉 —— 实测 k3.1-pro 认完整档位。
+// 收窄后若上游真出 kimi-k3-xxx 变体，它不会被强制 max，这是安全的方向
+// （不会悄悄改掉用户选的档位）。
 export function isKimiK3(modelId) {
-  return /^kimi-k3(?:$|[-.])/i.test(String(modelId ?? ""))
+  return /^kimi-k3$/i.test(String(modelId ?? ""))
 }
 
+// 只做 k3 自己那部分；采样参数的删除由 stripKimiSampling 负责
 export function applyKimiK3(req) {
   delete req.thinking
   delete req.reasoningEffort
-  for (const f of K3_FIXED) delete req[f]
   req.reasoning_effort = "max"
-  if (!Array.isArray(req.messages)) return
+  return req
+}
+
+// 历史中的 Kimi assistant tool calls 缺 reasoning_content 时补空串；保留
+// 调用方提供的内容。它与只有 kimi-k3 才强制 max 是两条独立规则。
+export function repairKimiToolHistory(req, modelId = req?.model) {
+  if (!/^kimi-k3(?:$|[-.])/i.test(String(modelId ?? "")) || !Array.isArray(req.messages)) return req
   for (const m of req.messages) {
-    if (m?.role !== "assistant") continue
-    if (!Array.isArray(m.tool_calls) || m.tool_calls.length === 0) continue
+    if (m?.role !== "assistant" || !Array.isArray(m.tool_calls) || m.tool_calls.length === 0) continue
     if (!("reasoning_content" in m)) m.reasoning_content = ""
   }
+  return req
+}
+
+// 请求管线只调这一个入口，免得漏掉其中一步
+export function applyKimi(req, modelId) {
+  const model = modelId ?? req?.model
+  if (isKimi(model)) stripKimiSampling(req)
+  repairKimiToolHistory(req, model)
+  if (isKimiK3(model)) applyKimiK3(req)
+  return req
 }