opencode-lobster-auth 0.1.2 → 0.2.0

package/README.md

@@ -9,13 +9,21 @@ Kimi, Qwen, MiniMax and Doubao.
 
 ## Install
 
-A folder plugin — it is not published to npm:
+From npm:
 
 ```sh
-magpie plugin add /path/to/magpie-lobster
+magpie plugin add opencode-lobster-auth
 magpie plugin login lobster
 ```
 
+`magpie plugin update` picks up later versions.
+
+To run a checkout instead of the published package, point at the folder:
+
+```sh
+magpie plugin add /path/to/magpie-lobster
+```
+
 ## Signing in
 
 Two ways, either one is enough. Both name the account by the Youdao account
@@ -41,7 +49,9 @@ first way replaces it in place.
   - Linux: `~/.config/LobsterAI/lobsterai.sqlite`
 
   A database that isn't there, or one the app keeps encrypted, fails this
-  way with a message saying so; use the browser way instead.
+  way with a message saying so; use the browser way instead. The imported
+  identity is checked against the current token, and an incomplete or
+  conflicting identity fails closed rather than using another account's token.
 
 Both are kept in magpie's `plugin-auth.json`.
 
@@ -83,11 +93,14 @@ habits are handled:
 - **Every reply is SSE**, even one asked for with `stream: false`. A
   non-streaming caller gets one `chat.completion` reassembled from it; a
   streaming caller gets the events as they are.
-- **Failures ride inside a 200.** LobsterAI puts an error in the stream
-  (`event: error`) and still answers 200, which would leave a caller with
-  nothing to fail over on. The plugin reads the first record and answers the
-  status it means: `40100` → 401, `40300` → 403, `42900` or rate-limit
-  wording → 429, anything else → 400. A sign-in LobsterAI turns down is a
+- **Failures ride inside a 200.** LobsterAI puts errors in the stream
+  (`event: error`, or an error JSON record) and still answers 200, which
+  would leave a caller with nothing to fail over on. The plugin inspects the
+  early records, preserves plain-text error messages, and answers the status
+  it means: `40100` → 401, `40300` → 403, `42900` or rate-limit wording →
+  429, anything else → 400. Non-streaming requests also catch an error that
+  appears after an initial response chunk; streaming requests preserve such
+  an event after content has started. A sign-in LobsterAI turns down is a
   genuine 401, passed through with magpie's lapse mark so the account is
   flagged.
 - **Requests carry the desktop client's headers**
@@ -97,58 +110,109 @@ habits are handled:
 
 ### Thinking levels
 
-A model's `thinkingConfig` gives it levels — `off`, `high`, `max` in the
-current catalogue — and they reach the wire in LobsterAI's own field:
-`{"lobsterai_options":{"version":1,"thinking":{"level":"off"}}}`.
+There are two kinds of model in LobsterAI's catalogue, and the plugin
+speaks to each in its own way.
+
+**8 models carry a `thinkingConfig`** (`deepseek-*`, `glm-*`), with the
+levels `off`/`high`/`max`. Those go out in LobsterAI's own field:
+`{"lobsterai_options":{"version":1,"thinking":{"level":"off"}}}`. Sending
+that field to a model **without** a profile is a hard error (`code 4000`,
+*model does not have a valid thinkingConfig*), so it is written only where
+there is a profile to map it through. With a profile, only its declared
+levels are offered; separately measured `reasoning_effort` levels apply only
+while a model has no profile.
+
+**10 models carry no profile** but still report `supportsThinking: true`.
+For those the plugin declares levels and lets magpie's `reasoning_effort`
+pass straight through, which LobsterAI honours.
 
 Two things are worth knowing:
 
-- **`lobsterai_options` is only for models that have a thinking profile.**
-  21 of the 29 models have none, and sending the field to one of those is a
-  hard error (`code 4000`, *model does not have a valid thinkingConfig*), so
-  the whole chat fails. A level is passed on only where there is a profile
-  to map it through.
 - **The lowest level is offered as `none`, not `off`.** magpie doesn't use
   what a variant holds; it maps `reasoning_effort` onto a level name the
   model declared, from a ladder of its own
   (`none/minimal/low/medium/high/xhigh/max`). `off` is not on that ladder,
-  so a level declared as `off` can never be chosen. The plugin declares
-  `none` and turns it back into `off` for LobsterAI.
+  so a level declared as `off` can never be chosen. With a profile the
+  plugin declares `none` and turns it back into `off`; without one it sends
+  `none` as it is, since LobsterAI accepts it.
+- **Levels differ per model and were measured, not assumed.** LobsterAI
+  refuses some of them outright: `MiniMax-M3.1-Flash` rejects `none`
+  (*requires adaptive thinking*), `qwen3.7-max` stops at `xhigh`, and
+  `qwen3.7-plus` answers `max` with an occasional 500. `MiniMax-M3` writes
+  its thinking into `<think>` tags inside the content and `reasoning_content`
+  stays empty; its effort isn't graded at all, so it offers only `none` and
+  `max`. A model whose levels were not measured declares none, and magpie
+  shows it as *thinks, no levels*.
 
 Measured on `deepseek-flash`: `none` leaves `reasoning_content` at exactly
-0 bytes, while `high`, `max` and no level at all don't.
+0 bytes, while `high`, `max` and no level at all don't — and on
+`kimi-k3.1-pro`, `none` leaves it at 0 bytes while `xhigh` produces some.
 
-### Kimi K3
+### Kimi
 
-LobsterAI's `kimi-k3` takes its sampling parameters from the server, so
-`temperature`, `top_p`, `n` and the penalties are dropped, `reasoning_effort`
-is fixed to `max`, and an assistant tool call missing `reasoning_content` is
-given an empty one.
+Every Kimi model takes its sampling parameters from the server:
+`temperature` must be 1, `top_p` 0.95 and the penalties 0, so the plugin
+drops `temperature`, `top_p`, `n` and both penalties for the whole family —
+it measured that for `kimi-k3`, `kimi-k3.1-pro` and `kimi-k2.8-preview`
+alike. A client that always sends `temperature` (most agents do) would
+otherwise be answered `50204 invalid temperature: only 1 is allowed`.
 
-`kimi-k3` is one of the models LobsterAI serves but does not list:
-`/api/models/available` returns 29 models and none of them is K3, yet a chat
-against `kimi-k3` answers normally. It is kept in the list this package
-declares for a signed-out account, so `lobster/kimi-k3` is offered — and the
-handling above is live, not a precaution.
+Only `kimi-k3` has `reasoning_effort` fixed to `max`. That forcing is
+not extended to `kimi-k3.1-pro`, which honours the full ladder and would
+otherwise have every level silently overridden. Separately, tool-call
+history repair stays enabled for the `kimi-k3` family, including
+`kimi-k3.1-pro`: an assistant tool call missing `reasoning_content` is given
+an empty string without overwriting existing reasoning or the chosen effort.
+
+`kimi-k3` is one of the models LobsterAI serves without listing it in every
+catalogue revision. It is kept in the list this package declares for a
+signed-out account, so `lobster/kimi-k3` stays offered.
 
 ## Models
 
-Signed in, the list is the account's own (`/api/models/available`): 29
-models, each with its context window, whether it takes images, and its
-thinking levels. Until then a static list of five is used, so the provider
-is visible before signing in.
+Signed in, the list is the account's own (`/api/models/available`) — 18 or
+19 usable models, each with its context window, whether it takes images,
+and its thinking levels. Until then a static list of five is used, so the
+provider is visible before signing in.
 
 `costMultiplier` becomes magpie's `rate`. It is **time-of-day pricing**:
 `deepseek-flash` is 0.05 in LobsterAI's off-peak hours and 0.1 in the peak
 ones (09:00–12:00 and 14:00–18:00, Beijing time). The rate is read when the
 list is, so it can be a while out of date.
 
+The reply limit is 131,072. The catalogue's `maxTokens` field is always
+null, so this was measured: all 18 models answered `max_tokens=131072`,
+`glm-5.3` names `[1, 131072]` as its own range, and 524,288 is where
+LobsterAI starts answering 500.
+
 ## Usage
 
-`magpie quota` shows the free allowance, when it ends and the credits left,
-from `/api/user/quota` and `/api/user/profile-summary`. The plugin reports
-`kept`: it renews nothing itself, so it must not claim a renewal it didn't
-do.
+`magpie quota` shows the credits left and when the soonest batch expires,
+from `/api/user/quota` and `/api/user/profile-summary`. The credits are
+reported as a **wallet window** (`余额·点数` with `runsOut`/`runsOutAt`)
+rather than a plain string, so magpie can show the lapse and routing can
+spend the account that runs out first. Every day's check-in adds 100 points
+that lapse 30 days later, first in first out, so knowing the date matters.
+The plugin reports `kept`: it renews nothing itself, so it must not claim a
+renewal it didn't do.
+
+Expired free allowances are not reported as a live window — the free period
+ended in August 2026, and showing "6% used" looked like a usable allowance.
+
+## Daily check-in
+
+The plugin implements `auth.checkin`, so magpie can claim LobsterAI's daily
+gift (100 points) for you. **It is off by default**: turn it on under
+Settings → Usage → Plugins. Once on, every signed-in LobsterAI account is
+checked in once a day (Beijing time).
+
+This is the only way to collect those points without opening LobsterAI's own
+desktop app, whose sidebar holds the check-in. The claim is idempotent — a
+day already claimed answers `51104`, and the plugin reports `done` rather
+than claiming again — and every claim is confirmed by re-reading the state
+before it is reported as `claimed`. HTTP failures, malformed business
+responses and invalid state are reported as `failed`, not as an inactive
+activity or an ineligible account, so magpie can retry later that day.
 
 ## Not here
 
@@ -157,14 +221,24 @@ do.
 - **A verified `/api/auth/refresh`.** Calling it may spend the account's
   real refresh token, so it is not exercised. The renewal path is written
   from the app's own code and has not been confirmed against the service.
-- **An exact output limit.** The catalogue has no such field. The plugin
-  declares a conservative 32,000; measured, LobsterAI takes 262,144 and
-  answers 500 at 524,288, so the real ceiling is somewhere between.
 - **OpenCode.** The plugin is written in OpenCode's provider-plugin format —
   that is the format magpie loads — but it has only been exercised in magpie.
-  `auth.refresh`, `auth.refreshLead` and the `magpie` field in `package.json`
-  are magpie's own, which OpenCode ignores.
-- **Several accounts at once.** magpie keeps one sign-in per provider.
+  `auth.refresh`, `auth.refreshLead`, `auth.checkin` and the `magpie` field
+  in `package.json` are magpie's own, which OpenCode ignores.
+
+## Several accounts
+
+magpie can hold more than one sign-in per provider, and this plugin supports
+that: sign in to a second Youdao account through the browser and both are
+listed.
+
+The desktop import is the exception to watch. LobsterAI's desktop app has one
+signed-in account at a time, and the plugin reads that app's token on every
+request. So an account imported from the desktop is tied to the account that
+was signed in when it was imported: switch the desktop to another account,
+and the imported one is marked *signed out · sign in again* rather than
+quietly spending the other account's credits. Sign it in again, or use the
+browser sign-in for accounts you want to keep independent.
 
 ## Development
 

package/README.zh-CN.md

@@ -9,13 +9,21 @@ MiniMax、豆包。
 
 ## 安装
 
-这是一个文件夹插件，没有发布到 npm：
+从 npm 安装：
 
 ```sh
-magpie plugin add /path/to/magpie-lobster
+magpie plugin add opencode-lobster-auth
 magpie plugin login lobster
 ```
 
+之后用 `magpie plugin update` 升级。
+
+想跑本地 checkout 而不是已发布的包，就把路径指过去：
+
+```sh
+magpie plugin add /path/to/magpie-lobster
+```
+
 ## 登录
 
 两种方式，任选其一。两者都用有道账号标识（`yid`）给账号命名，所以对一个
@@ -37,6 +45,7 @@ magpie plugin login lobster
   - Linux：`~/.config/LobsterAI/lobsterai.sqlite`
 
   库不存在，或者被桌面端加密存放，这条路会带着说明失败，改用浏览器登录即可。
+  导入身份会与当前 token 交叉核对；身份缺失或冲突时会拒绝使用，避免误用别的账号。
 
 两种方式都保存在 magpie 的 `plugin-auth.json`。
 
@@ -69,64 +78,103 @@ completions。LobsterAI 有三个习惯被处理掉了：
 
 - **所有回复都是 SSE**，即使请求里写了 `stream: false`。非流式调用方会拿到
   由它重组出的一个完整 `chat.completion`；流式调用方拿到的就是原样的事件。
-- **错误藏在 200 里。** LobsterAI 把错误放进流里（`event: error`），状态码
-  仍是 200 —— 这样调用方没有可故障切换的依据。插件读首条记录，还原成它真正
-  表示的状态：`40100` → 401，`40300` → 403，`42900` 或限流措辞 → 429，其余
-  → 400。被 LobsterAI 拒绝的登录是真 401，原样透传并带上 magpie 的失效标记，
-  账号因此会被标出来。
+- **错误藏在 200 里。** LobsterAI 把错误放进流里（`event: error` 或 JSON 错误帧），
+  状态码仍是 200 —— 这样调用方没有可故障切换的依据。插件检查开头的帧并保留
+  纯文本错误；非流式请求还会捕获首个回复分片之后出现的错误。它会还原成真正的
+  状态：`40100` → 401，`40300` → 403，`42900` 或限流措辞 → 429，其余 → 400。
+  流式请求开始输出后无法再改 HTTP 状态，因此中途错误事件会原样保留。被 LobsterAI
+  拒绝的登录是真 401，带上 magpie 的失效标记，账号因此会被标出来。
 - **请求带上桌面端的标识头**（`X-LobsterAI-Client-Version`、
   `X-LobsterAI-Client-Capabilities`）。LobsterAI 不强制要求，但它们标明了
   插件所说的特性集。
 
 ### 思考档位
 
-模型的 `thinkingConfig` 决定它有哪些档位 —— 当前目录里是 `off`、`high`、
-`max` —— 它们通过 LobsterAI 自己的字段上线：
-`{"lobsterai_options":{"version":1,"thinking":{"level":"off"}}}`。
+目录里的模型分两种，插件用两种方式对待。
+
+**8 个模型自带 `thinkingConfig`**（`deepseek-*`、`glm-*`），档位是
+`off`/`high`/`max`。它们走 LobsterAI 自己的字段：
+`{"lobsterai_options":{"version":1,"thinking":{"level":"off"}}}`。把该字段发给
+**没有**档位表的模型是硬错误（`code 4000`，*model does not have a valid
+thinkingConfig*），所以只在有档位表可映射时才写。有档位表时只声明当前 profile
+提供的档位；单独实测的 `reasoning_effort` 档位只用于尚无 profile 的模型。
+
+**10 个模型没有档位表**，但同样报 `supportsThinking: true`。对这些模型，插件
+声明档位、让 magpie 的 `reasoning_effort` 原样透传，LobsterAI 认这个字段。
 
 有两件事值得知道：
 
-- **`lobsterai_options` 只发给自带档位表的模型。** 29 个模型里有 21 个没有
-  档位表，给这些模型带上该字段是硬错误（`code 4000`，*model does not have a
-  valid thinkingConfig*），整轮对话直接失败。只有在有档位表可映射时，档位才会
-  被传下去。
 - **最低档对外叫 `none`，不叫 `off`。** magpie 不使用 variant 里存的东西，它
   按自己的一条阶梯（`none/minimal/low/medium/high/xhigh/max`）把
   `reasoning_effort` 映射到「模型声明过的那个档位名」。`off` 不在那条阶梯上，
-  所以声明成 `off` 的那一档永远选不中。插件对外声明 `none`，写给 LobsterAI
-  时再换回 `off`。
+  所以声明成 `off` 的那一档永远选不中。有档位表时插件声明 `none`、写给
+  LobsterAI 时换回 `off`；没有档位表时直接发 `none`，LobsterAI 就认它。
+- **每个模型的档位不一样，是实测出来的，不是假设的。** LobsterAI 会直接拒收
+  一部分：`MiniMax-M3.1-Flash` 拒收 `none`（*requires adaptive thinking*），
+  `qwen3.7-max` 只到 `xhigh`，`qwen3.7-plus` 的 `max` 偶发 500。`MiniMax-M3`
+  的思考写在 content 里的 `<think>` 标签中、`reasoning_content` 恒为空，上游
+  也不分档，所以只给 `none` 和 `max`。没实测过的模型一律不声明档位，magpie 会
+  显示成 *thinks, no levels*。
 
 在 `deepseek-flash` 上实测：`none` 会让 `reasoning_content` 恰好为 0 字节，
-而 `high`、`max` 和不指定档位都不会。
+而 `high`、`max` 和不指定档位都不会。在 `kimi-k3.1-pro` 上实测：`none` 为
+0 字节，`xhigh` 有输出。
 
-### Kimi K3
+### Kimi
 
-LobsterAI 的 `kimi-k3` 采样参数由服务端固定，因此 `temperature`、`top_p`、
-`n` 和两个 penalty 会被删掉，`reasoning_effort` 固定为 `max`，缺少
-`reasoning_content` 的 assistant 工具调用会被补一个空串。
+所有 Kimi 模型的采样参数都由服务端固定：`temperature` 必须是 1、`top_p` 是
+0.95、两个 penalty 是 0。所以插件对整个家族删掉 `temperature`、`top_p`、
+`n` 和两个 penalty —— `kimi-k3`、`kimi-k3.1-pro`、`kimi-k2.8-preview` 三个
+都实测过。客户端只要带了非 1 的 `temperature`（多数 agent 都带），否则会被
+回一句 `50204 invalid temperature: only 1 is allowed`。
 
-`kimi-k3` 属于 LobsterAI「能用但没列出」的模型：`/api/models/available`
-返回 29 个模型，其中没有 K3，但对 `kimi-k3` 发请求能正常作答。它保留在
-本插件为未登录账号声明的兜底表里，所以 `lobster/kimi-k3` 是可选的 ——
-上面那段处理也因此是**实际生效的**，不是预防性代码。
+只有 `kimi-k3` 本身将 `reasoning_effort` 固定为 `max`；这个规则**没有**扩展到
+`kimi-k3.1-pro`：后者实测认完整档位，强制 max 会把每一档都悄悄覆盖掉。
+工具历史补齐是另一条独立规则：保留对 `kimi-k3` 前缀家族（含 `kimi-k3.1-pro`）
+的兼容处理，缺少 `reasoning_content` 的 assistant 工具调用补空串，但不覆盖已有
+思考内容，也不改变用户选择的档位。
+
+`kimi-k3` 属于 LobsterAI「能用但某些版本目录里没列出」的模型。它保留在本插件
+为未登录账号声明的兜底表里，所以 `lobster/kimi-k3` 仍可选。
 
 ## 模型
 
-登录后，列表来自账号自己（`/api/models/available`）：29 个模型，各带上下文
-窗口、是否收图片、以及它的思考档位。登录之前用一份 5 个模型的静态列表兜底，
-这样 provider 在登录前就可见。
+登录后，列表来自账号自己（`/api/models/available`）—— 18 或 19 个可用模型，
+各带上下文窗口、是否收图片、以及它的思考档位。登录之前用一份 5 个模型的静态
+列表兜底，这样 provider 在登录前就可见。
 
 `costMultiplier` 成为 magpie 的 `rate`。它是**分时计价**：`deepseek-flash`
 在 LobsterAI 的空闲时段是 0.05，高峰时段是 0.1（高峰为北京时间
 09:00–12:00 与 14:00–18:00）。倍率是在拉列表时读的，所以可能有一阵子是过时
 的。
 
+输出上限是 131,072。目录里的 `maxTokens` 字段恒为 null，所以这是实测的：
+18 个模型全部接受 `max_tokens=131072`，`glm-5.3` 自己报的范围就是
+`[1, 131072]`，要到 524,288 才开始 500。
+
 ## 用量
 
-`magpie quota` 显示免费额度、它的到期时间和剩余点数，数据来自
-`/api/user/quota` 与 `/api/user/profile-summary`。插件上报的是 `kept`：它自己
+`magpie quota` 显示剩余点数与最早到期的那批积分，数据来自
+`/api/user/quota` 与 `/api/user/profile-summary`。积分按**钱包窗口**上报
+（`余额·点数`，带 `runsOut`/`runsOutAt`），而不是一个字符串 —— 这样 magpie
+能显示出到期时间，路由也能优先用快过期的账号。每天签到领的 100 点各是一批、
+30 天后到期、先到先用，所以知道日期是有意义的。插件上报的是 `kept`：它自己
 不续期，因此不该声称做过一次它没做的续期。
 
+已失效的免费额度不再作为有效窗口显示 —— 免费期 2026 年 8 月就结束了，
+之前还按「6% used」显示，看起来像还有一笔可用额度。
+
+## 每日签到
+
+插件实现了 `auth.checkin`，所以 magpie 可以替你领 LobsterAI 的每日积分礼
+（100 点）。**默认关闭**：在 Settings → Usage → Plugins 打开。打开后，每个
+已登录的 LobsterAI 账号每天（北京时间）各签一次。
+
+这是不开 LobsterAI 桌面端时唯一能领到这些积分的办法 —— 签到入口在桌面端侧栏。
+领取是幂等的：当天已领会回 `51104`，插件报 `done` 而不是重复领；每次领取都会
+重新读一次状态复核，通过了才报 `claimed`。HTTP 故障、损坏的业务响应或无效
+状态统一报 `failed`，不冒充“无活动”或“无资格”，让 magpie 可以当天稍后重试。
+
 ## 不做的事
 
 - **企业账号。** LobsterAI 让它们走另一个页面（`EnterpriseIdentitySelect`）。
@@ -134,13 +182,20 @@ LobsterAI 的 `kimi-k3` 采样参数由服务端固定，因此 `temperature`、
 - **经过验证的 `/api/auth/refresh`。** 调用它可能消耗账号真实的 refresh
   token，因此没有实测。续期这条路是照着桌面端自己的代码写的，没有与服务端
   核对过。
-- **精确的输出上限。** 目录里没有这个字段。插件声明了保守的 32,000；实测
-  LobsterAI 接受 262,144，在 524,288 时返回 500，所以真实上限在两者之间。
 - **OpenCode。** 这个插件是按 OpenCode 的 provider 插件格式写的 —— magpie
   加载的正是这个格式 —— 但只在 magpie 上实测过。`auth.refresh`、
-  `auth.refreshLead` 以及 `package.json` 里的 `magpie` 字段是 magpie 自己的，
-  OpenCode 会忽略它们。
-- **同时使用多个账号。** magpie 每个 provider 只保留一份登录。
+  `auth.refreshLead`、`auth.checkin` 以及 `package.json` 里的 `magpie` 字段
+  是 magpie 自己的，OpenCode 会忽略它们。
+
+## 多个账号
+
+magpie 允许一个 provider 挂多个登录，本插件支持这一点：用浏览器再登一个有道
+账号，两个都会列出来。
+
+桌面端导入是需要注意的那个。LobsterAI 桌面端同一时间只有一个账号登录，而插件
+每次请求都现读它的 token。所以桌面导入的账号绑在「导入那一刻登录的账号」上：
+把桌面端切到别的账号后，原账号会被标成 *需要重新登录*，而不是悄悄花掉另一个
+账号的积分。重新登录它，或者对需要独立存在的账号改用浏览器登录。
 
 ## 开发
 

package/index.mjs

@@ -4,6 +4,7 @@ import { modelsFromCatalog, profileOfFrom } from "./lib/models.mjs"
 import { usageFrom } from "./lib/usage.mjs"
 import { desktopSignIn, desktopToken } from "./lib/auth-import.mjs"
 import { beginSignIn, beginSignInAnnounced } from "./lib/auth-login.mjs"
+import { checkinWith } from "./lib/checkin.mjs"
 import { jwtExp } from "./lib/jwt.mjs"
 
 const REFRESH_LEAD = 6 * 3600 * 1000
@@ -28,10 +29,11 @@ async function apiGet(path, token, timeout = 20_000) {
 
 // 取这次请求要用的 token。
 // 桌面端导入的账号自己不存 token（见 lib/auth-import.mjs），每次现读 ——
-// 桌面端续期后插件自动跟上。读不到就抛 signIn:"expired"。
+// 桌面端续期后插件自动跟上。读不到、或桌面端已经换成别的账号，都抛
+// signIn:"expired"（多账号时后者防止串号）。
 async function tokenOf(auth) {
   if (!auth) return ""
-  if (auth.source === "desktop") return desktopToken()
+  if (auth.source === "desktop") return desktopToken(process.env, auth.accountId, auth.uid)
   return auth.type === "oauth" ? (auth.access ?? "") : (auth.key ?? "")
 }
 
@@ -177,6 +179,20 @@ export const LobsterAuthPlugin = async () => ({
         }
       }
     },
+
+    // 每日积分礼（签到）。magpie 在开关打开后，对每个已登录账号每天各调一次。
+    // 这是写操作，开关默认关，由用户在 Settings → Usage → Plugins 打开。
+    // 逻辑见 lib/checkin.mjs；这里只负责取 token 和兜住异常。
+    async checkin(getAuth) {
+      const auth = await getAuth()
+      let token = ""
+      try {
+        token = await tokenOf(auth)
+      } catch (e) {
+        return { outcome: "failed", message: e.message }
+      }
+      return checkinWith(token)
+    },
   },
 
   provider: {

package/lib/assemble.mjs

@@ -2,6 +2,8 @@
 // 流式请求原样转发；非流式请求要把分片拼成一个完整的 chat.completion。
 
 import { randomBytes } from "node:crypto"
+import { errorFrame, StreamError } from "./stream-error.mjs"
+export { StreamError } from "./stream-error.mjs"
 
 const enc = new TextEncoder()
 
@@ -23,6 +25,8 @@ export async function mergeChunks(records, model) {
   let reasoning = ""
 
   for await (const rec of records) {
+    const bad = errorFrame(rec)
+    if (bad) throw new StreamError(bad)
     if (rec.data === "[DONE]") break
     let v
     try { v = JSON.parse(rec.data) } catch { continue }
@@ -61,7 +65,9 @@ function streamOut(records) {
       try {
         for await (const rec of records) {
           if (rec.data === "[DONE]") break
-          controller.enqueue(enc.encode(`data: ${rec.data}\n\n`))
+          const event = rec.event ? `event: ${rec.event}\n` : ""
+          const data = rec.data.split("\n").map((line) => `data: ${line}`).join("\n")
+          controller.enqueue(enc.encode(`${event}${data}\n\n`))
         }
         controller.enqueue(enc.encode("data: [DONE]\n\n"))
         controller.close()

package/lib/auth-import.mjs

@@ -30,6 +30,12 @@ const parse = (s) => {
   } catch { return null }
 }
 
+const identityValue = (value) => {
+  if (typeof value === "string") return value.trim() || undefined
+  if (typeof value === "number" && Number.isFinite(value)) return String(value)
+  return undefined
+}
+
 export function readCredentials(path) {
   if (!path || !existsSync(path)) return null
   let db
@@ -43,11 +49,18 @@ export function readCredentials(path) {
     if (!accessToken) return null
     const user = parse(byKey.auth_user) ?? {}
     const claims = accountOf(accessToken)
+    // 两行可能分开更新。身份必须来自实际使用的 token；用户行只能在已有
+    // 共同标识吻合、且没有任何冲突时补全字段，不能让旧用户行替新 token 作证。
+    const fields = ["yid", "id"]
+    const shared = fields.filter((key) => identityValue(claims[key]) !== undefined && identityValue(user[key]) !== undefined)
+    const identityConflict = shared.some((key) => identityValue(claims[key]) !== identityValue(user[key]))
+    const verifiedUser = shared.length > 0 && !identityConflict
     return {
       accessToken,
       refreshToken: String(tokens?.refreshToken ?? ""),
-      yid: user.yid ?? claims.yid,
-      id: user.id ?? claims.id,
+      yid: identityValue(claims.yid) !== undefined ? claims.yid : verifiedUser ? user.yid : undefined,
+      id: identityValue(claims.id) !== undefined ? claims.id : verifiedUser ? user.id : undefined,
+      identityConflict,
       nickname: user.nickname,
       expires: jwtExp(accessToken),
     }
@@ -65,6 +78,24 @@ export function readCredentials(path) {
 // 为什么不把 token 抄一份：抄下来的 refreshToken 会是桌面端和插件共用的，
 // 谁先续期谁就把对方踢下线。留空则 magpie 永不续期（expires 为 0），
 // 桌面端的会话不受任何影响。
+// 账号身份。magpie 支持一个插件挂多个账号，靠 accountId 区分，所以这个值
+// 既是「这个号叫什么」，也是下次读桌面端时核对「还是不是同一个号」的依据。
+// 优先用 yid（有道的账号标识），没有就退回数字 id 的字符串形式。
+// yid 一律转成字符串：magpie 往返一轮后回来的是字符串，留着数字会让
+// 同一个号在两侧比不相等，把好账号误判成「切换了账号」。
+export function accountIdOf(c) {
+  return identityValue(c?.yid) ?? identityValue(c?.id)
+}
+
+function requireIdentity(c) {
+  if (c.identityConflict) {
+    throw Object.assign(new Error("LobsterAI 桌面端 token 与账号身份不一致（可能正在切换账号），请稍后重新登录"), { signIn: "expired" })
+  }
+  if (!accountIdOf(c)) {
+    throw Object.assign(new Error("LobsterAI 桌面端 token 的账号身份不可读，请重新登录本账号"), { signIn: "expired" })
+  }
+}
+
 export function desktopSignIn(env = process.env) {
   const path = dbPath(env)
   const c = readCredentials(path)
@@ -74,21 +105,31 @@ export function desktopSignIn(env = process.env) {
       "请先在 LobsterAI 桌面端登录，或改用「浏览器登录」。",
     )
   }
+  requireIdentity(c)
   return {
     type: "success",
     refresh: "",
     access: "",
     expires: 0,
     source: "desktop",
-    accountId: c.yid ?? (c.id !== undefined ? String(c.id) : undefined),
-    uid: c.id,
+    accountId: accountIdOf(c),
+    // magpie 只认字符串 uid（源码 uidOf），存数字等于没存
+    uid: identityValue(c.id),
   }
 }
 
 // 桌面端账号的 token：每次现读，桌面端换了 token 插件立刻跟上。
 // 读不到就是账号不可用（桌面端退出登录、库被删、文件被加密），
 // 报 signIn:"expired" 让 magpie 给账号打上失效标记，提示用户重新登录。
-export function desktopToken(env = process.env) {
+//
+// expected 是这个账号签入时记下的身份，expectedUid 是当时记下的数字 id。
+// 桌面端只有一个「当前登录」，换账号后现读到的就是别人的 token —— 不核对的话，
+// 原账号会显示别人的余额、扣别人的积分、签到签在别人头上。
+//
+// 至少一个绑定标识要匹配，同时不能有其它可比较标识冲突。签入时只有数字 id、
+// 后来补上 yid 的情况仍可按 id 识别；但 uid 相同不能掩盖已绑定 yid 的变化。
+// 没保存绑定身份的老账号仍兼容；token 无身份或与用户行冲突时一律 fail-closed。
+export function desktopToken(env = process.env, expected, expectedUid) {
   const c = readCredentials(dbPath(env))
   if (!c) {
     throw Object.assign(
@@ -96,5 +137,29 @@ export function desktopToken(env = process.env) {
       { signIn: "expired" },
     )
   }
+  requireIdentity(c)
+  const account = identityValue(expected)
+  const uid = identityValue(expectedUid)
+  if (account === undefined && uid === undefined) return c.accessToken
+  const now = accountIdOf(c)
+  const currentYid = identityValue(c.yid)
+  const currentUid = identityValue(c.id)
+  const accountWasUid = account !== undefined && (account === uid || account === currentUid)
+  const conflict =
+    (uid !== undefined && currentUid !== undefined && uid !== currentUid) ||
+    (account !== undefined && currentYid !== undefined && account !== currentYid && !accountWasUid)
+  const sameAccount =
+    (account !== undefined && (account === now || account === currentUid)) ||
+    (uid !== undefined && uid === currentUid)
+  if (conflict || !sameAccount) {
+    throw Object.assign(
+      new Error(
+        now
+          ? `LobsterAI 桌面端已切换到其它账号（当前 ${now}，本账号 ${expected}），请重新登录本账号`
+          : "LobsterAI 桌面端当前登录的账号身份不可读（可能刚切换过），请确认后在桌面端重新登录本账号",
+      ),
+      { signIn: "expired" },
+    )
+  }
   return c.accessToken
 }