opencode-lobster-auth 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jasery
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,170 @@
-# Temporary Holding Version
+# opencode-lobster-auth
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Signs in to a [LobsterAI](https://lobsterai.youdao.com) (有道龙虾, NetEase
+Youdao's desktop agent) account and serves its models as the provider
+`lobster` in [magpie](https://usemagpie.ai). About 30 models: DeepSeek, GLM,
+Kimi, Qwen, MiniMax and Doubao.
+
+**English** · [中文](README.zh-CN.md)
+
+## Install
+
+A folder plugin — it is not published to npm:
+
+```sh
+magpie plugin add /path/to/magpie-lobster
+magpie plugin login lobster
+```
+
+## Signing in
+
+Two ways, either one is enough. Both name the account by the Youdao account
+id (`yid`), so signing in the second way to an account already signed in the
+first way replaces it in place.
+
+- **Browser (a Youdao account).** The plugin serves a callback on
+  `127.0.0.1` and magpie opens Youdao's sign-in page. The browser comes back
+  with a code, which is traded for tokens at `/api/auth/exchange`. Kept as
+  an `oauth` sign-in holding the access and refresh tokens and their expiry,
+  so magpie renews it.
+- **The desktop's sign-in.** Uses the account LobsterAI's own desktop app is
+  signed in to. **No page is opened and nothing is typed.** The app's SQLite
+  database is read, never written:
+  - Windows: `%APPDATA%\LobsterAI\lobsterai.sqlite`
+  - macOS: `~/Library/Application Support/LobsterAI/lobsterai.sqlite`
+  - 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.
+
+Both are kept in magpie's `plugin-auth.json`.
+
+### Why the import keeps no token
+
+The desktop way stores **no credential at all** — `access` and `refresh` are
+empty and `expires` is 0 — and reads the token from the app's database on
+every request:
+
+- A copied `refreshToken` would be shared with the app: whichever side
+  refreshes first signs the other out. Empty means neither disturbs the
+  other.
+- `expires` of 0 means magpie never renews it — magpie renews only an
+  `oauth` sign-in whose expiry is set — so the app's session is never
+  touched.
+- Reading it fresh means the plugin follows a token the app renewed, with no
+  need to sign in again.
+
+The cost: if the app is signed out, uninstalled, or its database becomes
+unreadable, the account stops working at once and magpie is told to ask for
+a new sign-in. That is more honest than a token that quietly went stale.
+
+### Renewal
+
+A browser sign-in is renewed by magpie through the plugin's `auth.refresh`,
+six hours before it ends. The desktop's sign-in is structurally never
+renewed, as above.
+
+The plugin never calls LobsterAI's own refresh endpoint to check or renew
+anything: `/api/auth/refresh` may spend the account's real refresh token, so
+it is deliberately left alone.
+
+## Requests
+
+Chats are chat completions at
+`https://lobsterai-server.youdao.com/api/proxy/v1`. Three of LobsterAI's
+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
+  genuine 401, passed through with magpie's lapse mark so the account is
+  flagged.
+- **Requests carry the desktop client's headers**
+  (`X-LobsterAI-Client-Version`, `X-LobsterAI-Client-Capabilities`).
+  LobsterAI doesn't insist on them, but they name the feature set the plugin
+  speaks.
+
+### 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"}}}`.
+
+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.
+
+Measured on `deepseek-flash`: `none` leaves `reasoning_content` at exactly
+0 bytes, while `high`, `max` and no level at all don't.
+
+### Kimi K3
+
+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. No model in the current catalogue is K3; the handling is
+there for when one is.
+
+## 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.
+
+`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.
+
+## 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.
+
+## Not here
+
+- **Company accounts.** LobsterAI sends them through a different page
+  (`EnterpriseIdentitySelect`). Only personal accounts are handled.
+- **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.
+
+## Development
+
+```sh
+bun test
+```
+
+The entry point only assembles the hooks. The logic lives in `lib/` as plain
+functions and is reached through `_internal`, because magpie and OpenCode
+both treat every exported function as a plugin of its own.
+
+## License
+
+MIT

package/README.zh-CN.md

@@ -0,0 +1,147 @@
+# opencode-lobster-auth
+
+为 [magpie](https://usemagpie.ai) 提供 provider `lobster`：登录
+[LobsterAI](https://lobsterai.youdao.com)（有道龙虾，网易有道的桌面 agent）
+账号，把它名下的模型接进来。约 30 个模型，含 DeepSeek、GLM、Kimi、Qwen、
+MiniMax、豆包。
+
+[English](README.md) · **中文**
+
+## 安装
+
+这是一个文件夹插件，没有发布到 npm：
+
+```sh
+magpie plugin add /path/to/magpie-lobster
+magpie plugin login lobster
+```
+
+## 登录
+
+两种方式，任选其一。两者都用有道账号标识（`yid`）给账号命名，所以对一个
+已经用第一种方式登录过的账号再用第二种登录，是原地替换。
+
+- **浏览器登录（有道账号）。** 插件在本机 `127.0.0.1` 起一个回调服务，
+  magpie 打开有道登录页。浏览器带着授权码跳回来，插件拿它在
+  `/api/auth/exchange` 换取 token。存成一个 `oauth` 账号，带 access 与
+  refresh token 及到期时间，因此 magpie 会为它续期。
+- **从桌面端导入。** 使用 LobsterAI 桌面端当前登录的账号。**不打开任何页面，
+  不需要输入任何东西。** 只读桌面端的 SQLite 库，绝不写入：
+  - Windows：`%APPDATA%\LobsterAI\lobsterai.sqlite`
+  - macOS：`~/Library/Application Support/LobsterAI/lobsterai.sqlite`
+  - Linux：`~/.config/LobsterAI/lobsterai.sqlite`
+
+  库不存在，或者被桌面端加密存放，这条路会带着说明失败，改用浏览器登录即可。
+
+两种方式都保存在 magpie 的 `plugin-auth.json`。
+
+### 为什么导入这条路不保存 token
+
+导入方式**一个字节的凭据都不存**（`access` 和 `refresh` 都是空串，`expires`
+为 0），只在每次请求时现读桌面端的库：
+
+- 抄一份 `refreshToken` 会与桌面端共用同一个凭据：**谁先续期谁就把对方踢
+  下线**。留空则双方互不干扰。
+- `expires` 为 0，magpie 因此永不续期（它只对设了到期时间的 `oauth` 账号做
+  续期），桌面端的会话不会被搅动。
+- 现读意味着桌面端续期之后，插件下一次请求自动用上新 token，不必重新登录。
+
+代价是：桌面端退出登录、卸载，或者库变得不可读，这个账号会**立刻**失效，
+并被标记为需要重新登录。这比用一个已经悄悄失效的旧 token 更诚实。
+
+### 续期
+
+浏览器登录的账号由 magpie 通过插件的 `auth.refresh` 在到期前 6 小时续期。
+导入的账号如上一节所述，结构性不会被续期。
+
+插件从不调用 LobsterAI 自己的续期接口去验证或刷新任何东西：
+`/api/auth/refresh` 可能消耗账号真实的 refresh token，因此刻意不碰它。
+
+## 请求
+
+对话走 `https://lobsterai-server.youdao.com/api/proxy/v1` 的 chat
+completions。LobsterAI 有三个习惯被处理掉了：
+
+- **所有回复都是 SSE**，即使请求里写了 `stream: false`。非流式调用方会拿到
+  由它重组出的一个完整 `chat.completion`；流式调用方拿到的就是原样的事件。
+- **错误藏在 200 里。** LobsterAI 把错误放进流里（`event: error`），状态码
+  仍是 200 —— 这样调用方没有可故障切换的依据。插件读首条记录，还原成它真正
+  表示的状态：`40100` → 401，`40300` → 403，`42900` 或限流措辞 → 429，其余
+  → 400。被 LobsterAI 拒绝的登录是真 401，原样透传并带上 magpie 的失效标记，
+  账号因此会被标出来。
+- **请求带上桌面端的标识头**（`X-LobsterAI-Client-Version`、
+  `X-LobsterAI-Client-Capabilities`）。LobsterAI 不强制要求，但它们标明了
+  插件所说的特性集。
+
+### 思考档位
+
+模型的 `thinkingConfig` 决定它有哪些档位 —— 当前目录里是 `off`、`high`、
+`max` —— 它们通过 LobsterAI 自己的字段上线：
+`{"lobsterai_options":{"version":1,"thinking":{"level":"off"}}}`。
+
+有两件事值得知道：
+
+- **`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`。
+
+在 `deepseek-flash` 上实测：`none` 会让 `reasoning_content` 恰好为 0 字节，
+而 `high`、`max` 和不指定档位都不会。
+
+### Kimi K3
+
+LobsterAI 的 `kimi-k3` 采样参数由服务端固定，因此 `temperature`、`top_p`、
+`n` 和两个 penalty 会被删掉，`reasoning_effort` 固定为 `max`，缺少
+`reasoning_content` 的 assistant 工具调用会被补一个空串。当前目录里没有 K3
+模型；这段处理是为将来出现 K3 准备的。
+
+## 模型
+
+登录后，列表来自账号自己（`/api/models/available`）：29 个模型，各带上下文
+窗口、是否收图片、以及它的思考档位。登录之前用一份 5 个模型的静态列表兜底，
+这样 provider 在登录前就可见。
+
+`costMultiplier` 成为 magpie 的 `rate`。它是**分时计价**：`deepseek-flash`
+在 LobsterAI 的空闲时段是 0.05，高峰时段是 0.1（高峰为北京时间
+09:00–12:00 与 14:00–18:00）。倍率是在拉列表时读的，所以可能有一阵子是过时
+的。
+
+## 用量
+
+`magpie quota` 显示免费额度、它的到期时间和剩余点数，数据来自
+`/api/user/quota` 与 `/api/user/profile-summary`。插件上报的是 `kept`：它自己
+不续期，因此不该声称做过一次它没做的续期。
+
+## 不做的事
+
+- **企业账号。** LobsterAI 让它们走另一个页面（`EnterpriseIdentitySelect`）。
+  目前只处理个人账号。
+- **经过验证的 `/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 只保留一份登录。
+
+## 开发
+
+```sh
+bun test
+```
+
+入口只负责装配钩子。逻辑都在 `lib/` 下，是普通函数，通过 `_internal` 暴露
+出来 —— 因为 magpie 和 OpenCode 都会把每一个导出的函数当成一个独立插件。
+
+## 许可
+
+MIT

package/index.mjs

@@ -0,0 +1,191 @@
+import { PROVIDER, NAME, API, CHAT_BASE, NPM, FALLBACK_MODELS } from "./lib/constants.mjs"
+import { makeFetch } from "./lib/proxy.mjs"
+import { modelsFromCatalog, profileOfFrom } from "./lib/models.mjs"
+import { usageFrom } from "./lib/usage.mjs"
+import { desktopSignIn, desktopToken } from "./lib/auth-import.mjs"
+import { beginSignIn } from "./lib/auth-login.mjs"
+import { jwtExp } from "./lib/jwt.mjs"
+
+const REFRESH_LEAD = 6 * 3600 * 1000
+
+// 每个账号的模型 → 思考档位，供请求管线查表
+const profiles = new Map()
+
+async function apiGet(path, token, timeout = 20_000) {
+  const res = await fetch(API + path, {
+    headers: { authorization: `Bearer ${token}` },
+    signal: AbortSignal.timeout(timeout),
+  })
+  const text = await res.text()
+  let v
+  try { v = JSON.parse(text) } catch { throw new Error(`LobsterAI ${path}: 响应无法解析`) }
+  if (res.status === 401) {
+    throw Object.assign(new Error("LobsterAI 的登录已过期，请重新登录"), { signIn: "expired" })
+  }
+  if (v?.code !== 0) throw new Error(`LobsterAI ${path}: ${v?.message || `code ${v?.code}`}`)
+  return v.data
+}
+
+// 取这次请求要用的 token。
+// 桌面端导入的账号自己不存 token（见 lib/auth-import.mjs），每次现读 ——
+// 桌面端续期后插件自动跟上。读不到就抛 signIn:"expired"。
+async function tokenOf(auth) {
+  if (!auth) return ""
+  if (auth.source === "desktop") return desktopToken()
+  return auth.type === "oauth" ? (auth.access ?? "") : (auth.key ?? "")
+}
+
+export const LobsterAuthPlugin = async () => ({
+  config: async (cfg) => {
+    cfg.provider ??= {}
+    cfg.provider[PROVIDER] ??= {
+      name: NAME,
+      npm: NPM,
+      api: API,
+      models: FALLBACK_MODELS,
+    }
+  },
+
+  auth: {
+    provider: PROVIDER,
+    refreshLead: REFRESH_LEAD,
+
+    methods: [
+      {
+        type: "oauth",
+        label: "浏览器登录（有道账号）",
+        async authorize() {
+          // 由 magpie 打开这个 url；插件不再自己开一次，否则会开两个标签页
+          const pending = await beginSignIn()
+          return {
+            url: pending.url,
+            instructions: "在浏览器里用有道账号登录，完成后回到这里。",
+            method: "auto",
+            callback: () => pending.finish(),
+          }
+        },
+      },
+      {
+        // 必须是 oauth：api 类型会让 magpie 强制从 stdin 读一个 key，
+        // 而这条路根本不需要用户输入任何东西（见设计文档 §4.3）。
+        type: "oauth",
+        label: "从本机 LobsterAI 导入登录",
+        async authorize() {
+          // url 留空：magpie 不打开任何页面，直接走 callback
+          return {
+            url: "",
+            instructions: "直接使用本机 LobsterAI 桌面端已登录的账号。",
+            method: "auto",
+            async callback() {
+              try {
+                return desktopSignIn()
+              } catch (e) {
+                return { type: "failed", error: e.message }
+              }
+            },
+          }
+        },
+      },
+    ],
+
+    // 只对路径 A（浏览器登录，有 refresh 和 expires）生效。
+    // 路径 B（桌面端导入）的 refresh 是空串、expires 为 0，
+    // magpie 不会调用这里，桌面端的会话因此不会被搅动。
+    async refresh(auth) {
+      if (auth?.type !== "oauth" || auth.source === "desktop" || !auth.refresh) return {}
+      const res = await fetch(`${API}/auth/refresh`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ refreshToken: auth.refresh }),
+        signal: AbortSignal.timeout(30_000),
+      })
+      const text = await res.text()
+      let v
+      try { v = JSON.parse(text) } catch { throw new Error("LobsterAI 续期：响应无法解析") }
+      if (v?.code !== 0 || !v?.data?.accessToken) {
+        throw Object.assign(new Error(`LobsterAI 续期失败：${v?.message || `code ${v?.code}`}`), { signIn: "expired" })
+      }
+      const d = v.data
+      return {
+        access: String(d.accessToken),
+        refresh: String(d.refreshToken ?? auth.refresh),
+        // 上游可能不给新 token 的 exp；读不到就沿用旧的到期时间
+        expires: jwtExp(d.accessToken) || auth.expires || 0,
+      }
+    },
+
+    async loader(getAuth) {
+      const auth = await getAuth()
+      // 这里只是给 magpie 一个「看起来已登录」的信号；真正的 token
+      // 由下面的 fetch 每次请求现取（桌面端账号尤其需要）。
+      let token = ""
+      try { token = await tokenOf(auth) } catch { return {} }
+      if (!token) return {}
+      return {
+        baseURL: CHAT_BASE,
+        apiKey: token,
+        headers: {},
+        fetch: makeFetch({
+          getAuth,
+          tokenOf,
+          profileOf: (id) => profiles.get(String(id)),
+          call: (input, init) => fetch(input, init),
+        }),
+      }
+    },
+
+    async usage(getAuth) {
+      const auth = await getAuth()
+      let token = ""
+      try { token = await tokenOf(auth) } catch (e) {
+        return { error: e.message, windows: [], signIn: e.signIn === "expired" ? "expired" : "kept" }
+      }
+      if (!token) return { error: "尚未登录", windows: [] }
+      try {
+        const [quota, profile] = await Promise.all([
+          apiGet("/user/quota", token),
+          apiGet("/user/profile-summary", token),
+        ])
+        // 插件自己不续期（交给 magpie 的 auth.refresh），所以这次请求用的
+        // 就是存下来的 token —— 如实报 kept。社区插件报 renewed 是因为它们
+        // 自己维护续期表，这里没有那张表，不该照抄。
+        return usageFrom(quota, profile, "kept")
+      } catch (e) {
+        return {
+          error: e.message,
+          windows: [],
+          signIn: e.signIn === "expired" ? "expired" : "kept",
+        }
+      }
+    },
+  },
+
+  provider: {
+    id: PROVIDER,
+    async models(provider, { auth } = {}) {
+      let token = ""
+      try { token = await tokenOf(auth) } catch (e) {
+        if (e.signIn === "expired") throw e
+        return provider.models
+      }
+      if (!token) return provider.models
+      try {
+        const list = await apiGet(
+          "/models/available?firstKeyfrom=official&latestKeyfrom=official",
+          token,
+        )
+        if (!Array.isArray(list) || list.length === 0) return provider.models
+        for (const [id, p] of Object.entries(profileOfFrom(list))) profiles.set(id, p)
+        const out = modelsFromCatalog(list, { ...provider, id: PROVIDER })
+        return Object.keys(out).length > 0 ? out : provider.models
+      } catch (e) {
+        // 登录失效要标记账号；其余情况保留原列表
+        if (e.signIn === "expired") throw e
+        return provider.models
+      }
+    },
+  },
+})
+
+// 唯一允许的函数导出：magpie 会把每个导出的函数都当成一个插件加载
+export const _internal = { PROVIDER, FALLBACK_MODELS, usageFrom, modelsFromCatalog }

package/lib/assemble.mjs

@@ -0,0 +1,87 @@
+// 上游给的是 OpenAI 形状的 chat.completion.chunk，只是永远走 SSE。
+// 流式请求原样转发；非流式请求要把分片拼成一个完整的 chat.completion。
+
+import { randomBytes } from "node:crypto"
+
+const enc = new TextEncoder()
+
+function newId() {
+  return "chatcmpl-" + randomBytes(12).toString("hex")
+}
+
+export async function mergeChunks(records, model) {
+  const out = {
+    id: newId(),
+    object: "chat.completion",
+    created: Math.floor(Date.now() / 1000),
+    model,
+    choices: [{ index: 0, message: { role: "assistant", content: "" }, finish_reason: "stop" }],
+    usage: null,
+  }
+  const calls = new Map()
+  let content = ""
+  let reasoning = ""
+
+  for await (const rec of records) {
+    if (rec.data === "[DONE]") break
+    let v
+    try { v = JSON.parse(rec.data) } catch { continue }
+    if (v?.usage) out.usage = v.usage
+    const ch = v?.choices?.[0]
+    if (!ch) continue
+    const d = ch.delta ?? {}
+    if (typeof d.content === "string") content += d.content
+    if (typeof d.reasoning_content === "string") reasoning += d.reasoning_content
+    for (const tc of d.tool_calls ?? []) {
+      const i = tc.index ?? 0
+      let c = calls.get(i)
+      if (!c) { c = { id: "", type: "function", function: { name: "", arguments: "" } }; calls.set(i, c) }
+      if (tc.id) c.id = tc.id
+      if (tc.type) c.type = tc.type
+      if (tc.function?.name) c.function.name = tc.function.name
+      if (typeof tc.function?.arguments === "string") c.function.arguments += tc.function.arguments
+    }
+    if (ch.finish_reason) out.choices[0].finish_reason = ch.finish_reason
+  }
+
+  const msg = out.choices[0].message
+  msg.content = content
+  if (reasoning) msg.reasoning_content = reasoning
+  if (calls.size > 0) {
+    msg.tool_calls = [...calls.entries()].sort((a, b) => a[0] - b[0]).map(([, c]) => c)
+    // OpenAI 的约定：只有工具调用时 content 为 null
+    if (!content) msg.content = null
+  }
+  return out
+}
+
+function streamOut(records) {
+  const body = new ReadableStream({
+    async start(controller) {
+      try {
+        for await (const rec of records) {
+          if (rec.data === "[DONE]") break
+          controller.enqueue(enc.encode(`data: ${rec.data}\n\n`))
+        }
+        controller.enqueue(enc.encode("data: [DONE]\n\n"))
+        controller.close()
+      } catch (e) {
+        controller.error(e)
+      }
+    },
+    cancel() { records.return?.() },
+  })
+  return new Response(body, {
+    status: 200,
+    headers: { "content-type": "text/event-stream", "cache-control": "no-cache" },
+  })
+}
+
+export async function respond(req, records) {
+  if (req.stream) return streamOut(records)
+  const body = await mergeChunks(records, req.model)
+  return new Response(JSON.stringify(body), {
+    status: 200,
+    headers: { "content-type": "application/json" },
+  })
+}