opencode-lobster-auth 0.1.1 → 0.2.0

package/lib/jwt.mjs

@@ -1,34 +1,34 @@
-// LobsterAI 的 accessToken 是标准 JWT（未加密，仅签名）。
-// 插件只读它的载荷，不校验签名——校验由上游负责。
-
-function decode(part) {
-  try {
-    const s = Buffer.from(String(part).replace(/-/g, "+").replace(/_/g, "/"), "base64").toString("utf8")
-    const v = JSON.parse(s)
-    return v && typeof v === "object" ? v : null
-  } catch {
-    return null
-  }
-}
-
-export function jwtPayload(token) {
-  const parts = String(token ?? "").split(".")
-  if (parts.length < 2) return null
-  return decode(parts[1])
-}
-
-// exp 以秒计；返回毫秒，读不到就是 0（magpie 把 0 当作「不续期」）
-export function jwtExp(token) {
-  const p = jwtPayload(token)
-  const exp = Number(p?.exp)
-  return Number.isFinite(exp) && exp > 0 ? exp * 1000 : 0
-}
-
-export function accountOf(token) {
-  const p = jwtPayload(token)
-  if (!p) return {}
-  const out = {}
-  if (p.yid) out.yid = p.yid
-  if (p.sub !== undefined) out.id = p.sub
-  return out
-}
+// LobsterAI 的 accessToken 是标准 JWT（未加密，仅签名）。
+// 插件只读它的载荷，不校验签名——校验由上游负责。
+
+function decode(part) {
+  try {
+    const s = Buffer.from(String(part).replace(/-/g, "+").replace(/_/g, "/"), "base64").toString("utf8")
+    const v = JSON.parse(s)
+    return v && typeof v === "object" ? v : null
+  } catch {
+    return null
+  }
+}
+
+export function jwtPayload(token) {
+  const parts = String(token ?? "").split(".")
+  if (parts.length < 2) return null
+  return decode(parts[1])
+}
+
+// exp 以秒计；返回毫秒，读不到就是 0（magpie 把 0 当作「不续期」）
+export function jwtExp(token) {
+  const p = jwtPayload(token)
+  const exp = Number(p?.exp)
+  return Number.isFinite(exp) && exp > 0 ? exp * 1000 : 0
+}
+
+export function accountOf(token) {
+  const p = jwtPayload(token)
+  if (!p) return {}
+  const out = {}
+  if (p.yid) out.yid = p.yid
+  if (p.sub !== undefined) out.id = p.sub
+  return out
+}

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

@@ -1,67 +1,63 @@
-// LobsterAI 的推理端点永远以 SSE 作答，即使请求写了 stream:false。
-// 这里把字节流切成 {event, data} 记录，两种情形都由上层决定怎么用。
-
-const decoder = new TextDecoder()
-
-export async function* sse(body) {
-  let buf = ""
-  let event = ""
-  let data = []
-
-  // 一条空行结束一个事件；没有 data 的事件（只有注释）不产出
-  const flush = () => {
-    if (data.length === 0) { event = ""; return null }
-    const rec = { event, data: data.join("\n") }
-    event = ""
-    data = []
-    return rec
-  }
-
-  const feed = (raw) => {
-    const line = raw.endsWith("\r") ? raw.slice(0, -1) : raw
-    if (line === "") return flush()
-    if (line.startsWith(":")) return null // 注释 / keep-alive
-    const i = line.indexOf(":")
-    const field = i === -1 ? line : line.slice(0, i)
-    let value = i === -1 ? "" : line.slice(i + 1)
-    if (value.startsWith(" ")) value = value.slice(1)
-    if (field === "event") event = value
-    else if (field === "data") data.push(value)
-    return null
-  }
-
-  for await (const chunk of body) {
-    buf += typeof chunk === "string" ? chunk : decoder.decode(chunk, { stream: true })
-    let nl
-    while ((nl = buf.indexOf("\n")) !== -1) {
-      const rec = feed(buf.slice(0, nl))
-      buf = buf.slice(nl + 1)
-      if (rec) yield rec
-    }
-  }
-  buf += decoder.decode()
-  if (buf !== "") {
-    const rec = feed(buf)
-    if (rec) yield rec
-  }
-  const last = flush()
-  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
-  }
-}
+// LobsterAI 的推理端点永远以 SSE 作答，即使请求写了 stream:false。
+// 这里把字节流切成 {event, data} 记录，两种情形都由上层决定怎么用。
+
+const decoder = new TextDecoder()
+
+export async function* sse(body) {
+  let buf = ""
+  let event = ""
+  let data = []
+
+  // 一条空行结束一个事件；没有 data 的事件（只有注释）不产出
+  const flush = () => {
+    if (data.length === 0) { event = ""; return null }
+    const rec = { event, data: data.join("\n") }
+    event = ""
+    data = []
+    return rec
+  }
+
+  const feed = (raw) => {
+    const line = raw.endsWith("\r") ? raw.slice(0, -1) : raw
+    if (line === "") return flush()
+    if (line.startsWith(":")) return null // 注释 / keep-alive
+    const i = line.indexOf(":")
+    const field = i === -1 ? line : line.slice(0, i)
+    let value = i === -1 ? "" : line.slice(i + 1)
+    if (value.startsWith(" ")) value = value.slice(1)
+    if (field === "event") event = value
+    else if (field === "data") data.push(value)
+    return null
+  }
+
+  for await (const chunk of body) {
+    buf += typeof chunk === "string" ? chunk : decoder.decode(chunk, { stream: true })
+    let nl
+    while ((nl = buf.indexOf("\n")) !== -1) {
+      const rec = feed(buf.slice(0, nl))
+      buf = buf.slice(nl + 1)
+      if (rec) yield rec
+    }
+  }
+  buf += decoder.decode()
+  if (buf !== "") {
+    const rec = feed(buf)
+    if (rec) yield rec
+  }
+  const last = flush()
+  if (last) yield last
+}
+
+export async function* chain(held, it) {
+  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
 }

package/lib/usage.mjs

@@ -7,6 +7,30 @@ const round = (n, d = 2) => {
   return Math.round(Number(n) * p) / p
 }
 
+// 上游的时间不带时区（如 2026-11-11T09:11:24）。magpie 用 new Date(...) 读它，
+// 裸时间会被当成本机本地时间 —— magpie 跑在 UTC 的容器 / NAS 上就差 8 小时。
+// 上游是北京时间（签到 context 的 state.timezone 是 Asia/Shanghai），补上 +08:00。
+//
+// 形态不止一种（带秒/不带秒/带毫秒/空格分隔），漏掉哪一种就等于那个 bug 换了
+// 形状还在。所以：先把空格分隔规整成 T，再判断「有没有已经写明的偏移量」；
+// 只有日期（2026-11-01）保持原样，那是整天语义、没有时刻可言。
+// 认不出的原样透传，绝不编一个时间出来。
+const rfc3339 = (s) => {
+  let v = String(s ?? "").trim()
+  if (!v) return v
+  // 2026-11-11 09:11:24 → 2026-11-11T09:11:24
+  if (/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}/.test(v)) v = v.replace(" ", "T")
+  // 只有日期：整天语义
+  if (/^\d{4}-\d{2}-\d{2}$/.test(v)) return v
+  // 有时刻但没写偏移量（Z 或 ±hh:mm 都算写了）
+  if (/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}/.test(v) && !/(?:Z|[+-]\d{2}:?\d{2})$/.test(v)) {
+    // 补足秒位，magpie 的 Date 解析对 `T09:11` 的支持不统一
+    const withSeconds = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}$/.test(v) ? `${v}:00` : v
+    return `${withSeconds}+08:00`
+  }
+  return v
+}
+
 export function usageFrom(quota, profile, signIn) {
   const q = quota ?? {}
   const p = profile ?? {}
@@ -15,18 +39,36 @@ export function usageFrom(quota, profile, signIn) {
   if (q.planName) out.plan = String(q.planName)
   if (p.nickname) out.user = String(p.nickname)
 
+  // 钱包窗口。积分是一批批的余额，不是「用了几成」的额度：magpie 的匹配规则里
+  // 窗口带 balance 才被当钱包（不当 Text/Aside），路由才会按余额排序、先花快
+  // 到期的。原来把它塞进顶层 balance 字符串，magpie 只能当文字显示，路由读不到。
   const left = Number(p.totalCreditsRemaining)
-  out.balance = Number.isFinite(left) && left > 0 ? `${round(left)} 点数` : ""
+  if (Number.isFinite(left)) {
+    // 名字只当标签用。magpie 把它渲染成「<窗口名> <余额> <单位> left」，
+    // 叫「点数」会读成「点数 2,487.54 点数 left」，所以用「余额」。
+    const w = { name: "余额", balance: round(left), unit: "点数" }
+    // 每天领的 100 点各是一批、逐日到期，先到期先扣；不报出来就白作废。
+    // 只剩 0 的批次不算「将要到期」，否则永远指向一批已经用完的。
+    const soonest = (Array.isArray(p.creditItems) ? p.creditItems : [])
+      .filter((c) => Number(c?.creditsRemaining) > 0 && typeof c?.expiresAt === "string" && c.expiresAt !== "")
+      .sort((a, b) => String(a.expiresAt).localeCompare(String(b.expiresAt)))[0]
+    if (soonest) {
+      w.runsOutAt = rfc3339(soonest.expiresAt)
+      w.runsOut = round(soonest.creditsRemaining)
+    }
+    out.windows.push(w)
+  }
 
+  // 免费额度只在还没过期时才算一笔有效额度。免费期 2026-08 就结束了，
+  // 过了还按「6% used」显示，看起来像还有一笔可用额度。
   const total = Number(q.freeCreditsTotal)
   const used = Number(q.freeCreditsUsed)
-  if (Number.isFinite(total) && total > 0) {
+  if (Number.isFinite(total) && total > 0 && !q.freeCreditsExpired) {
     const u = Number.isFinite(used) ? used : 0
     out.windows.push({
       name: "免费额度",
       used: round((u / total) * 100),
       display: `${round(u, 1)} / ${round(total, 1)} 免费积分`,
-      aside: !!q.freeCreditsExpired,
     })
   }
 
@@ -34,7 +76,7 @@ export function usageFrom(quota, profile, signIn) {
     .map((c) => c?.expiresAt)
     .filter((d) => typeof d === "string" && d !== "")
     .sort()
-  if (dates.length > 0) out.until = dates[0]
+  if (dates.length > 0) out.until = rfc3339(dates[0])
 
   if (signIn) out.signIn = signIn
   return out

package/package.json

@@ -1,38 +1,39 @@
-{
-  "name": "opencode-lobster-auth",
-  "version": "0.1.1",
-  "description": "OpenCode provider plugin: NetEase Youdao LobsterAI (有道龙虾)",
-  "type": "module",
-  "main": "./index.mjs",
-  "exports": "./index.mjs",
-  "files": [
-    "index.mjs",
-    "lib",
-    "README.md",
-    "README.zh-CN.md",
-    "LICENSE"
-  ],
-  "keywords": [
-    "opencode",
-    "opencode-plugin",
-    "magpie",
-    "lobster",
-    "lobsterai",
-    "youdao"
-  ],
-  "license": "MIT",
-  "author": "Jasery <jaserydev@163.com>",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/Jasery/opencode-lobster-auth.git"
-  },
-  "homepage": "https://github.com/Jasery/opencode-lobster-auth#readme",
-  "bugs": "https://github.com/Jasery/opencode-lobster-auth/issues",
-  "scripts": {
-    "test": "bun test"
-  },
-  "magpie": {
-    "maxConcurrency": 8,
-    "icon": "https://lobsterai.youdao.com/portal/lobsterai-logo.png"
-  }
+{
+  "name": "opencode-lobster-auth",
+  "version": "0.2.0",
+  "description": "OpenCode provider plugin: NetEase Youdao LobsterAI (有道龙虾)",
+  "type": "module",
+  "main": "./index.mjs",
+  "exports": "./index.mjs",
+  "files": [
+    "index.mjs",
+    "lib",
+    "README.md",
+    "README.zh-CN.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "opencode",
+    "opencode-plugin",
+    "magpie",
+    "lobster",
+    "lobsterai",
+    "youdao"
+  ],
+  "license": "MIT",
+  "author": "Jasery <jaserydev@163.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Jasery/opencode-lobster-auth.git"
+  },
+  "homepage": "https://github.com/Jasery/opencode-lobster-auth#readme",
+  "bugs": "https://github.com/Jasery/opencode-lobster-auth/issues",
+  "scripts": {
+    "test": "bun test"
+  },
+  "magpie": {
+    "maxConcurrency": 8,
+    "icon": "https://lobsterai.youdao.com/portal/lobsterai-logo.png"
+  }
 }
+