@huai_xin/dsh-workbuddy 0.1.1 → 0.1.3

package/README.md

@@ -151,6 +151,8 @@ dsh-workbuddy/
 
 - 部署名旁的圆点是登录状态（绿=已登录 / 黄=等待授权 / 红=已过期 / 灰=未登录），悬停显示 `provider · endpoint`。
 - 积分右侧的 **⟳** 只刷新这一行（走 `GET /workbuddy/credits?region=…`），不动其它数据。
+- 同一行最右边还有 **「套餐」**：在浏览器打开该部署的官方套餐/用量页（大陆版 → `workbuddy.cn/profile/plans-usage`，海外版 → `workbuddy.ai/profile/plans-usage`）。地址由宿主从**页面白名单**解析，面板只传一个页面名，所以这个入口无法被用来打开任意网址。
+- 每列的**值贴左边缘**（与账号、到期对齐），**⟳ 与「套餐」贴右边缘**，中间留白，窄面板下也不会挤出横向滚动条。
 - **未登录的部署整列只显示一个居中的「登录」按钮**，不再是四行「未知」加一堆禁用按钮。
 - 签到按钮（只有大陆版有）跟在部署名右边，悬停显示上次自动领取的结果。
 
@@ -158,7 +160,8 @@ dsh-workbuddy/
 
 - 按**能不能用**分两组：`可用模型` / `不可用模型`（探测判定 + 真实调用的自学习）。不可用分组默认折叠。
 - 每行：左侧圆点是台账颜色（绿=可用、黄=排队、红=不可用/无权限、灰=未检测），中间是模型名，右侧依次是**可用性标签 · 促销标签 · 繁忙程度 · 实时倍率**，最后是该模型的**启停开关**（停用的行会变淡）。
-- 点任意一行展开详情：描述、标识、上下文、最大输出、模态、思考档位、可关闭思考、倍率、繁忙程度、促销类型/时限/详情。所有标签共用一种样式，颜色只表示语义。
+- 点任意一行展开详情：描述、标识、上下文、最大输出、模态、思考档位、倍率、繁忙程度、促销类型/时限/详情。所有标签共用一种样式，颜色只表示语义。
+- **思考恒为开启**：上游只声明"可否关闭思考"，却从不给出能兑现它的请求参数（实测见[协议文档 §4.3.1](docs/workbuddy-protocol.md)），所以详情里不放这一项 —— 能调的只有**档位**（低/中/高/超高/极致）。
 - 倍率取不到就显示「未知」（**不猜、不用旧值兜底**），`0` 显示「免费」标签。
 - 繁忙程度**只有大陆版有**（`POST /v2/chat/busy`；海外版 404，那一列整个不显示）：空闲 / 繁忙 / 拥堵 / 未知四档，用词与官方前端一致（官方把 `normal` 与 `idle` 并成「空闲」），悬停给出官方的完整说法（轻微拥堵 / 极度拥堵）。
 - 工具栏：搜索框、「全部启用 / 全部停用」（**只作用于可用分组**，不可用分组自己手动调）、「⟳ 刷新列表」、「检测可用性」（手动，立即执行）。这两个按钮宽度固定，「检测中…」不会把 ⟳ 挤走。

package/client/index.js

@@ -51,6 +51,9 @@ window.__ModuleLoader__.load({
         colCredits: '积分',
         colActions: '操作',
         refreshCredits: '刷新积分',
+        openPlans: '套餐',
+        openPlansHint: '在浏览器打开该部署的官方套餐页（用量与订阅）',
+        openPlansFailed: (url) => `没能自动打开浏览器，请手动访问：${url}`,
         creditsRate: '消耗速度（实时）',
         models: '模型',
         login: '登录',
@@ -103,8 +106,6 @@ window.__ModuleLoader__.load({
         detailRate: '倍率',
         detailDescription: '描述',
         detailModality: '模态',
-        detailCanDisableThinking: '可关闭思考',
-        detailNo: '否',
         freeModel: '免费',
         promoDiscount: '折扣',
         detailPromoKind: '促销类型',
@@ -117,7 +118,6 @@ window.__ModuleLoader__.load({
         busyBusyOfficial: '轻微拥堵',
         busyCongestedOfficial: '极度拥堵',
         busyUnknown: '未知',
-        detailYes: '是',
         modalityText: '文本',
         modalityImage: '图像',
         noModels: '登录后这里会显示该账号可用的模型'
@@ -135,6 +135,9 @@ window.__ModuleLoader__.load({
         colCredits: 'Credits',
         colActions: 'Actions',
         refreshCredits: 'Refresh credits',
+        openPlans: 'Plans',
+        openPlansHint: 'Open this deployment’s official plans page in your browser',
+        openPlansFailed: (url) => `Could not launch a browser — open this instead: ${url}`,
         creditsRate: 'Consumption rate (live)',
         models: 'Models',
         login: 'Sign in',
@@ -187,8 +190,6 @@ window.__ModuleLoader__.load({
         detailRate: 'Rate',
         detailDescription: 'Description',
         detailModality: 'Modality',
-        detailCanDisableThinking: 'Thinking switch',
-        detailNo: 'no',
         freeModel: 'free',
         promoDiscount: 'discount',
         detailPromoKind: 'Promotion',
@@ -201,7 +202,6 @@ window.__ModuleLoader__.load({
         busyBusyOfficial: 'slightly congested',
         busyCongestedOfficial: 'extremely congested',
         busyUnknown: 'unknown',
-        detailYes: 'yes',
         modalityText: 'text',
         modalityImage: 'image',
         noModels: 'Models appear here once the account is signed in'
@@ -236,6 +236,11 @@ window.__ModuleLoader__.load({
 .wb-card + .wb-card { margin-top: 16px; }
 .wb-card-head { display: flex; flex-wrap: wrap; align-items: center; gap: 10px; padding: 14px 16px 12px; }
 .wb-card-title { font-size: 12px; font-weight: 600; letter-spacing: .06em; text-transform: uppercase; color: var(--wb-muted); }
+.wb-account-card { border-radius: 12px; border-color: var(--wb-line-soft); }
+.wb-account-card .wb-card-head { gap: 10px; }
+.wb-account-card .wb-card-title { letter-spacing: 0; text-transform: none; color: var(--wb-text); }
+.wb-account-card .wb-btn { border-radius: 6px; }
+.wb-account-card .wb-card-head .wb-btn { min-width: 52px; }
 .wb-head { display: flex; align-items: center; gap: 12px; padding: 14px 16px 12px; }
 /* The mark is a mask painted with the accent colour: one asset, both themes. */
 .wb-logo { flex: none; width: 30px; height: 30px; display: block; background: var(--wb-accent-strong);
@@ -245,47 +250,51 @@ window.__ModuleLoader__.load({
 /* account table — transposed: deployments are columns, fields are rows ------
    One grid for the whole table so a signed-out deployment can occupy its whole
    column with a single centred sign-in button. */
-.wb-table { display: grid; padding: 0 12px 14px; overflow-x: auto; --wb-cols: 2; position: relative;
-  /* A label column on the left and an empty spacer of the same width on the
-     right: that is what makes the pair of deployment columns sit symmetrically
-     in the card instead of being pushed right by the labels. Centring keeps the
-     block in the middle once the columns hit their cap. */
-  /* The minimum keeps a row on one line; below that the table scrolls instead of
-     reflowing a row. Kept small because the balance row only ever holds the
-     number and its refresh. */
-  grid-template-columns: 64px repeat(var(--wb-cols), minmax(150px, 240px)) 64px;
-  justify-content: center;
-  /* Rows are a fixed height in every state, so the card does not change size
-     between "loading" and "signed in", and the separators line up. */
-  grid-auto-rows: 52px;
-  column-gap: 24px; row-gap: 0; align-items: stretch; }
-/* One continuous separator between the deployments, drawn down the middle of
-   the symmetric grid. It fades out at both ends, so it reads as a division of
-   the two accounts rather than a stray table border. */
-.wb-table-split::before { content: ''; position: absolute; left: 50%; top: 16px; bottom: 20px; width: 1px;
-  background: linear-gradient(to bottom, transparent, var(--wb-line) 14%, var(--wb-line) 86%, transparent); }
+.wb-table { display: grid; position: relative; padding: 0 10px 8px; overflow-x: auto; --wb-cols: 2;
+  /* No trailing spacer: both accounts need enough width for an unbroken action
+     pair in the settings column. Narrower views scroll instead of wrapping. */
+  grid-template-columns: 56px repeat(var(--wb-cols), minmax(180px, 1fr));
+  /* Fixed tracks prevent account loading or login from resizing the card; the
+     action row needs less air than the four information rows above it. */
+  grid-template-rows: repeat(4, 52px) 34px;
+  column-gap: 32px; row-gap: 0; align-items: stretch; }
+/* Centre the divider on the card, not the account-column gap: the label
+   column makes that gap visually off-centre. Account contents stay in place. */
+.wb-table-split::before { content: ''; position: absolute; left: 50%; top: 18px; bottom: 8px; width: 1px;
+  transform: translateX(-50%); pointer-events: none;
+  background: linear-gradient(to bottom, transparent, var(--wb-line-soft) 12%, var(--wb-line-soft) 92%, transparent); }
 .wb-row-label { display: flex; align-items: center; font-size: 11px; letter-spacing: .05em;
   text-transform: uppercase; color: var(--wb-muted); }
-.wb-th { display: flex; align-items: center; font-size: 12.5px; font-weight: 620; }
-.wb-th .wb-btn { padding: 3px 8px; font-size: 11px; font-weight: 500; margin-left: 2px; }
+.wb-th { min-width: 0; display: flex; align-items: center; font-size: 12.5px; font-weight: 620; white-space: nowrap; }
+.wb-th .wb-btn { padding: 3px 8px; font-size: 11px; font-weight: 500; line-height: 1.2; }
 .wb-deploy { display: flex; align-items: center; gap: 8px; }
 .wb-deploy-dot { flex: none; width: 7px; height: 7px; border-radius: 50%; }
 /* The cell fills its row and holds its content left, the way the signed-in rows
    read; only the standalone sign-in cell is centred. No rule between rows: the
    spacing and the vertical separator already say where the columns are. */
 .wb-td { min-width: 0; display: flex; flex-wrap: wrap; align-items: center; gap: 8px; }
+/* Keep refresh and plans beside the balance, not at the far column edge. */
+.wb-cell-actions { flex: none; display: inline-flex; align-items: center; gap: 8px; }
+.wb-td-credits, .wb-td-last { flex-wrap: nowrap; }
+.wb-td-last { gap: 6px; }
 .wb-td-span { display: flex; align-items: center; justify-content: center; }
 .wb-account-name { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
 .wb-num { font-variant-numeric: tabular-nums; color: var(--wb-muted); }
 .wb-credits-value { font-size: 16.5px; font-weight: 650; color: var(--wb-accent-strong);
   font-variant-numeric: tabular-nums; letter-spacing: -.01em; }
 /* A bare icon action: no box, just the glyph, tinted on hover. */
-.wb-icon-btn { font: inherit; font-size: 13px; line-height: 1; padding: 5px 7px; border-radius: 6px; cursor: pointer;
-  border: 0; background: transparent; color: var(--wb-muted); transition: background .15s, color .15s; }
+.wb-icon-btn { font: inherit; font-size: 13px; line-height: 1; padding: 5px 7px; border-radius: 6px; cursor: pointer;  border: 0; background: transparent; color: var(--wb-muted); transition: background .15s, color .15s; }
 .wb-icon-btn:hover:not(:disabled) { background: var(--wb-accent-soft); color: var(--wb-accent-strong); }
 .wb-icon-btn:disabled { opacity: .4; cursor: not-allowed; }
-.wb-td .wb-btn { display: inline-flex; align-items: center; justify-content: center;
-  padding: 5px 10px; font-size: 11.5px; min-width: 78px; }
+/* The link out to the official plans page: same quiet weight as the icon
+   actions beside it, but it needs words to say where it goes — kept tight so the
+   balance row still fits one line in a narrow panel. */
+.wb-link-btn { font: inherit; font-size: 11px; line-height: 1; padding: 4px 7px; border-radius: 6px;
+  cursor: pointer; border: 1px solid var(--wb-line-soft); background: transparent; color: var(--wb-muted);
+  white-space: nowrap; transition: background .15s, color .15s, border-color .15s; }
+.wb-link-btn:hover { background: var(--wb-accent-soft); color: var(--wb-accent-strong); border-color: transparent; }
+.wb-td .wb-btn { display: inline-flex; align-items: center; justify-content: center; box-sizing: border-box;
+  padding: 4px 10px; font-size: 11.5px; min-width: 78px; min-height: 26px; white-space: nowrap; }
 .wb-td-span .wb-btn { padding: 7px 16px; }
 
 /* tab strip: two equal halves, the selected one a tinted segment ------------- */
@@ -851,6 +860,25 @@ window.__ModuleLoader__.load({
         }
       }
 
+      /**
+       * Open the deployment's official plans page in the user's browser.
+       *
+       * The host resolves the URL from its own allowlist, so the panel only ever
+       * names a page. When launching fails the reply still carries the URL and
+       * the panel shows it, rather than pretending nothing happened.
+       */
+      const openPlans = async (regionId) => {
+        setError('')
+        try {
+          const result = await request('/open', { method: 'POST', body: JSON.stringify({ region: regionId, page: 'plans' }) })
+          if (result.opened !== true && typeof result.url === 'string') {
+            setError(t('openPlansFailed')(result.url))
+          }
+        } catch (cause) {
+          setError(cause instanceof Error ? cause.message : String(cause))
+        }
+      }
+
       const credits = region?.credits
       const checkin = region?.checkin
       const models = region === undefined ? undefined : modelMap[region.id]
@@ -970,9 +998,6 @@ window.__ModuleLoader__.load({
         add(t('detailEfforts'), model.efforts.length === 0
           ? undefined
           : h('span', { className: 'wb-tags' }, model.efforts.map((level) => detailTag(level))))
-        add(t('detailCanDisableThinking'), typeof model.canDisableThinking === 'boolean'
-          ? (model.canDisableThinking === true ? t('detailYes') : t('detailNo'))
-          : undefined)
         add(t('detailRate'), model.credits === undefined
           ? t('unknown')
           : (isFreeModel(model) ? detailTag(t('freeModel'), ' wb-tag-accent') : (formatRate(model.credits) ?? model.credits)))
@@ -1161,16 +1186,29 @@ window.__ModuleLoader__.load({
             entry.credits !== null && entry.credits !== undefined && entry.credits.ok === true
               ? h('span', { key: 'value', className: 'wb-credits-value' }, formatCredits(entry.credits.total))
               : h('span', { key: 'value', className: 'wb-muted' }, t('unknown')),
-            h('button', {
-              key: 'refresh',
-              type: 'button',
-              className: 'wb-icon-btn',
-              title: t('refreshCredits'),
-              'aria-label': t('refreshCredits'),
-              disabled: creditBusy === entry.id,
-              onClick: () => void refreshCredits(entry.id)
-            }, creditBusy === entry.id ? '…' : '⟳')
-          ]))
+            // All values share a left edge; the quiet balance actions follow
+            // the figure directly so each deployment reads as one compact group.
+            h('span', { key: 'actions', className: 'wb-cell-actions' }, [
+              h('button', {
+                key: 'refresh',
+                type: 'button',
+                className: 'wb-icon-btn',
+                title: t('refreshCredits'),
+                'aria-label': t('refreshCredits'),
+                disabled: creditBusy === entry.id,
+                onClick: () => void refreshCredits(entry.id)
+              }, creditBusy === entry.id ? '…' : '⟳'),
+              // The official plans page needs the deployment's own signed-in
+              // session, so it opens in the user's browser rather than in here.
+              h('button', {
+                key: 'plans',
+                type: 'button',
+                className: 'wb-link-btn',
+                title: t('openPlansHint'),
+                onClick: () => void openPlans(entry.id)
+              }, t('openPlans'))
+            ])
+          ], 'wb-td-credits'))
           cells.push(cell(3, 'actions', accountActions(entry)))
         })
         return cells
@@ -1256,7 +1294,7 @@ window.__ModuleLoader__.load({
         error.length > 0 ? h('p', { className: 'wb-error', role: 'alert' }, error) : null,
 
         // Cards are separate concerns: who is signed in, and what they can run.
-        h('div', { className: 'wb-card' },
+        h('div', { className: 'wb-card wb-account-card' },
           h('div', { className: 'wb-card-head' },
             h(Logomark, null),
             h('span', { className: 'wb-card-title' }, t('cardAccounts')),
@@ -1274,8 +1312,8 @@ window.__ModuleLoader__.load({
             )
           ),
           h('div', {
-            // The separator between deployments is drawn once, down the middle
-            // of the symmetric grid, when there is exactly a pair of them.
+            // A single separator stays at the card's centre when there are
+            // exactly two deployments.
             className: regions.length === 2 ? 'wb-table wb-table-split' : 'wb-table',
             role: 'table',
             style: { '--wb-cols': String(Math.max(1, regions.length)) }

package/docs/workbuddy-protocol.md

@@ -176,9 +176,56 @@ POST <chatEndpoint>/v2/chat/completions
 | `tools` | 否 | OpenAI function 形态，70 个工具 / 60 KB 实测通过 ✅ |
 | `prompt_cache_key` | 否 | 服务端前缀缓存键；缺失时缓存命中恒为 0 📖 |
 | `thinking` | 否 | `{"type":"enabled"}`，deepseek 系使用 📖✅ |
-| `reasoning_effort` | 否 | `low` / `medium` / `high` / `xhigh` / `max`，取值须在该模型支持列表内 📖 |
+| `reasoning_effort` | 否 | `low` / `medium` / `high` / `xhigh` / `max`，取值须在该模型支持列表内 ✅ 网关会校验（见下） |
 | `temperature` / `stop` | 否 | 直通 ✅ |
 
+**`reasoning_effort` 是真实生效的参数**（2026-10-22 实测，海外版 `deepseek-v4.1-flash`，免费模型，
+脚本 `test/live/effort-effect.mjs`，`ROUNDS` 可重复）：
+
+1. **网关会校验它**：传一个目录里没有的值（`totally-bogus`）→ HTTP 400
+   `{"code":11133,"msg":"the request parameters were rejected by the model provider",
+   "extError":{"code":"invalid_parameter_value"}}`——说明字段确实被转发给模型服务商，不是被忽略 ✅
+2. **在一句话就能答的题上，三档看不出区别**：鸡兔同笼题 12 次采样，
+   `low` 241 字 / `high` 232 字 / `max` 214 字（单档内波动 44–81 字）——低档也会思考 200+ 字，
+   所以差距被噪声淹没。
+3. **在需要多步推理的题上，档位单调分档**（三位数推理题，各 3 次）：
+
+   | 档位 | 思考字数（均值） | 范围 | completion tokens（均值） |
+   | --- | --- | --- | --- |
+   | `low` | 982 | 674–1512 | 615 |
+   | `high` | 3605 | 1463–5759 | 1324 |
+   | `max` | 6115 | 5460–6461 | 2048（撞到 `max_tokens` 上限） |
+
+   → 档位有意义，但**题越简单越看不出来**；`max` 在难题上会一路顶到 `max_tokens`。
+
+4. **用量里有 `completion_tokens_details.reasoning_tokens`**，与思考文字数一致；免费模型返回
+   `credit: 0` ✅（这也是"免费"标签的判据之一）。
+
+**不同厂商的请求结构由厂商自己校验，网关只做转发**（2026-10-22 实测，`test/live/request-structure.mjs`
+逐字段试探；免费模型优先，海外版免费档有 `deepseek-v4.1-flash` / `hy3` / `step-5-preview`）：
+
+| 变体 | deepseek-v4.1-flash | step-5-preview（阶跃） | hy3（混元） | glm-5.3-flash（智谱） |
+| --- | --- | --- | --- | --- |
+| 基线（不带档位） | 200，思考 **0 字** | 200，思考 596 字 | 200，思考 370 字 | 200，思考 **0 字** |
+| `+ reasoning_effort:"<合法档>"` | 200，思考 **261 字** | 200，447 字 | 200，502 字 | 200，思考 **337 字** |
+| `+ reasoning_effort:"totally-bogus"` | **400 `11133` 拒绝** | 200 静默忽略 | 200 静默忽略 | 200 静默忽略 |
+| `+ thinking:{type:"enabled"}` | 200，仍 0 字 | 200 | 200 | 200，35 字 |
+| `+ thinking:{type:"disabled"}` | 200 | 200，仍思考 379 字 | 200 | 200，0 字 |
+| `+ thinking:{type:"nonsense"}` | 200 | 200 | 200 | 200 |
+| `+ max_completion_tokens`（去掉 `max_tokens`） | 200 | — | 200 | 200 |
+| `+ 未知字段` | 200 | 200 | 200 | 200 |
+
+结论：
+
+1. **只有 DeepSeek 系会校验 `reasoning_effort`**（非法值 400 `11133`）；其余厂商静默忽略非法值。
+   说明网关**不做统一校验/改写**，请求体基本按原样转给各厂商自己的 API ✅
+2. **`thinking` 字段实际上不是开关**：`enabled` / `disabled` / 乱填一律 200，思考量也没跟着变
+   （glm 那次 35 字的差异在噪声范围内）。所以插件只在官方客户端确实会发的 deepseek 系带这个字段。
+3. **真正决定"思不思考"的是有没有 `reasoning_effort`**：deepseek 与 glm **不带该字段 → 思考 0 字**
+   （完全不思考）；hy3 / step 属于强制思考型（`onlyReasoning`），不带也会思考。
+   → 因此适配器对**任何声明了档位的模型**都必须带上档位（选中的，否则目录里的 `defaultEffort`，
+   再次是 `high`），这正是"思考恒为开启"的落地方式；没声明档位的模型才不带 ✅
+
 **历史消息里的 `reasoning_content` 会原样回放**，服务端接受 ✅（不做回放也能跑通）。
 
 ### 3.2 响应（SSE）
@@ -193,6 +240,14 @@ data: [DONE]
 - `delta` 实测字段：`role` / `content` / `reasoning_content` / `function_call` / `refusal` / `tool_calls` / `extra_fields` ✅
 - 流式工具调用：**仅首个分片带真实 `id`**，后续分片只有 `index`，需按 index 归并 📖✅
 - 末帧 `finish_reason`：`stop` / `tool_calls` / `length` ✅
+- **流一定以 `data: [DONE]` 收尾**；没有它、也没有 `finish_reason` 就断流 = 连接被中途掐断
+  （不是模型"决定停下"）📖。插件据此判定：这种情况必须上报 `TRANSPORT` 错误交给重试策略，
+  **绝不能**当成正常 `stop` —— 曾经因此出现"看着还没说完就结束了，也不重试"的现象 ✅（已修）。
+  判定与补救都有日志：断流时打一行带证据的告警（收到多少字节、用时多久、中断时在输出哪一类内容），
+  重试时再由插件订阅 `session/event` 的 `llm/retry` 打一行"第 N/M 次重试（TRANSPORT）… 后重试"。
+  频率实测工具：`node test/live/stream-cut-probe.mjs [cn|intl] [次数] [模型] [--long] [--selftest]`
+  （2026-10-22 实测：大陆版短问答 4/4 正常、海外版 `deepseek-v4.1-flash` 长回答 10/10 正常，
+  即断流是间歇性的，常规探测不易复现）
 - `usage`（末帧携带）：`prompt_tokens` / `completion_tokens` / `total_tokens` / `prompt_tokens_details.cached_tokens` / `completion_tokens_details.reasoning_tokens` / `prompt_cache_hit_tokens` / `prompt_cache_miss_tokens` / `credit` ✅
 
 ---
@@ -253,7 +308,7 @@ data: [DONE]
 | `contextWindow` | 仅部分模型有：`{defaultLength, supportedLengths:[…]}`（如 step-5: `[300000, 1000000]`） |
 | `maxOutputTokens` | 输出上限 |
 | `supportsImages` / `supportsReasoning` / `supportsToolCall` / `disabledMultimodal` | 能力位 |
-| `onlyReasoning` / `canDisableThinking` | 是否强制思考 / 可否关闭 |
+| `onlyReasoning` / `canDisableThinking` | 是否强制思考 / 上游的"可否关闭思考"声明 —— **插件忽略它**，理由见 §4.3.1 |
 | `reasoning` | `{effort, summary, defaultEffort, supportedEfforts:[…]}`；`effort` 是默认档，`supportedEfforts` 才是可选集合 |
 | `relatedModels` | 关联模型映射，如 `{lite, reasoning, builtin-lite}` |
 | `credits` | 倍率字符串，如 `"x0.00 credits"` / `"x2.20 credits"` / `"x0.05"` |
@@ -263,8 +318,32 @@ data: [DONE]
 | `iconUrl` / `iconUrl_en` | 图标（base64 data-URI 或 HTTPS URL，按语言选） |
 | `AccountAttributes` ❓ | 出现在积分包里，模型侧未见 |
 
-### 4.3 `/v3/config` 结构
+#### 4.3.1 `canDisableThinking`：上游没给关闭参数，插件选择"忽略它、思考恒开"（2026-10-22 实测）
+
+三条结论都有原始响应与缓存对比支撑（`node test/live/reasoning-audit.mjs [cn|intl]`）：
+
+1. **上游只发一个布尔位，不发参数名。** `reasoning` 块出现过的字段只有
+   `canDisableThinking` / `defaultEffort` / `effort` / `summary` / `supportedEfforts`；
+   整条记录里像"开关"的字段只有 `canDisableThinking` 和 `disabledMultimodal`（后者是
+   多模态能力，与思考无关）。也就是说：**"能不能关"它说了，"怎么关"它没说。**
+   反向参数（`thinking:{type:'disabled'}` / `enable_thinking:false` /
+   `reasoning:{effort:'none'}` 之类）**一个都没验证过**。
+2. **两个部署各自独立声明，而且会变。** 同一天里：大陆版对 `glm-5.2`、`kimi-k3-1`、
+   `deepseek-v4-flash`、`deepseek-v4-pro`、`hy3` **完全不发**该字段，海外版对同样的 id
+   一律发 `true`/`false`；大陆版过去发过、现在不发了 —— 说明它不是稳定契约。
+3. **插件的决定：忽略这个字段，思考恒开。** 既然"能关"无法兑现（没有参数），就不要在
+   面板上宣称它 —— 于是：
+   - 目录解析不再读取该字段（`catalog.js`），合并、面板载荷、账号名单富化里也一并去掉；
+   - 面板详情不再有「可关闭思考」这一行（没有开关就不摆开关）；
+   - **唯一能调的仍然是档位**（`reasoning.supportedEfforts` → 低/中/高/超高/极致）；
+   - `thinking:{type:'enabled'}` 目前只对 deepseek 系发送（§4.5 表，📖✅ 已验证），
+     其它族不发这个字段（它们本身就是 `onlyReasoning` 模型，默认就在思考）；
+   - 缓存里把该字段当作**已废弃字段**处理：老快照读出来就丢掉，不再留痕。
+
+   如果将来上游给出真正的关闭参数，正确做法是把它变成一个档位（例如「关闭」）交给
+   选择器，而不是恢复一个布尔位。
 
+### 4.3 `/v3/config` 结构
 ```json
 {"code":0,"data":{
   "$schema":"product-schema.json",
@@ -320,7 +399,7 @@ Web 端 picker 的悬停卡片会显示简介、消耗速度、繁忙程度、
 | 名称（含「极致」「快速」等预设名） | 目录 | `name` ✅ |
 | 简介「优先深度与准确性…」 | 目录 | `descriptionZh` / `descriptionEn`，前端按 locale 选（`zh*` → `descriptionZh`）✅ |
 | 消耗速度 `1.20x 倍率` | 目录 | `credits`，如 `"x1.20 credits"`；前端只取数字再加 `x`（`/(\d+(?:\.\d+)?)/` → `1.20x`）✅ |
-| 思考档位（低/中/高/超高/极致） | 目录 | `reasoning.supportedEfforts`（可选集合）、`reasoning.defaultEffort`、`onlyReasoning`、`canDisableThinking`、`supportsReasoning`；**档位文案是前端 i18n**（`model.effort.{low,medium,high,xhigh,max}.label` → 低/中/高/超高/极致），不是服务端下发 ✅ |
+| 思考档位（低/中/高/超高/极致） | 目录 | `reasoning.supportedEfforts`（可选集合）、`reasoning.defaultEffort`、`onlyReasoning`、`supportsReasoning`；**档位文案是前端 i18n**（`model.effort.{low,medium,high,xhigh,max}.label` → 低/中/高/超高/极致），不是服务端下发 ✅ |
 | 上下文窗口选择 | 目录 | `contextWindow.supportedLengths` + `maxInputTokens`（前端命名 `supportedContextWindows` / `defaultContextWindow`）✅ |
 | 徽章（如「限时免费」） | 目录 | `tags`，形如 `badge:限时免费:#FF0000`；另有 `isDefault`、`badges` / `tierBadges`（前端派生）✅ |
 | **繁忙程度**（空闲 / 轻微拥堵 / 极度拥堵 / 不可用） | **`POST /v2/chat/busy`** | 见下 ✅ |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@huai_xin/dsh-workbuddy",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "WorkBuddy model provider for DeepSeek Harness (international + China deployments)",
   "type": "module",
   "main": "./src/index.js",

package/src/adapter.js

@@ -656,6 +656,12 @@ export class WorkBuddyAdapter {
     const maxTokens = positiveInt(options.maxTokens) ?? entry?.maxTokens
     if (maxTokens !== undefined) body.max_tokens = maxTokens
 
+    // Thinking is pinned on: there is no switch anywhere in the plugin. Upstream
+    // publishes `reasoning.canDisableThinking` without naming a request parameter
+    // that would act on it (protocol §4.3.1), so the effort level is the only
+    // reasoning control, and the explicit `thinking` field is sent where the
+    // official client is known to send it (deepseek family, §4.5) — the other
+    // families ignore it, whatever the value.
     const isDeepSeek = model.startsWith('deepseek-')
     if (isDeepSeek) body.thinking = { type: 'enabled' }
     // `efforts` is optional: many catalog entries declare no level set, and
@@ -773,6 +779,16 @@ export class WorkBuddyAdapter {
     let streamEnded = false
     const reader = response.body.getReader()
     const decoder = new TextDecoder()
+    // Evidence for the "the stream was cut" report below: how much arrived, how
+    // long it took, how long the silence before the cut was, and what was being
+    // written when it happened. The remote's own reason is not observable, so the
+    // report has to carry what *is*.
+    const startedAt = Date.now()
+    let receivedBytes = 0
+    let lastDataAt = startedAt
+    let lastDelta = '无内容'
+    /** Output tokens the last usage frame reported, for the truncation log. */
+    let outputTokens
 
     const textBlock = () => {
       let block = blocks.find((candidate) => candidate.kind === 'text')
@@ -795,6 +811,8 @@ export class WorkBuddyAdapter {
       while (!streamEnded) {
         const result = await reader.read()
         if (result.done) break
+        receivedBytes += result.value?.byteLength ?? 0
+        lastDataAt = Date.now()
         buffer += decoder.decode(result.value, { stream: true })
         let newline
         while ((newline = buffer.indexOf('\n')) !== -1) {
@@ -826,12 +844,14 @@ export class WorkBuddyAdapter {
             const block = textBlock()
             if (block.text.length === 0) yield { type: 'block-start', index: block.index, blockType: 'text' }
             block.text += delta.content
+            lastDelta = '正文'
             yield { type: 'text-delta', index: block.index, text: delta.content }
           }
           if (typeof delta?.reasoning_content === 'string' && delta.reasoning_content.length > 0) {
             const block = reasoningBlock()
             if (block.text.length === 0) yield { type: 'block-start', index: block.index, blockType: 'reasoning' }
             block.text += delta.reasoning_content
+            lastDelta = '思考'
             yield { type: 'reasoning-delta', index: block.index, text: delta.reasoning_content }
           }
           for (const call of delta?.tool_calls ?? []) {
@@ -845,6 +865,7 @@ export class WorkBuddyAdapter {
             }
             block.callId = callId
             if (typeof call.function?.name === 'string' && call.function.name.length > 0) block.name = call.function.name
+            lastDelta = '工具调用'
             const fragment = call.function?.arguments ?? ''
             block.text += fragment
             if (!block.announced) {
@@ -867,6 +888,7 @@ export class WorkBuddyAdapter {
             const promptTokens = data.usage.prompt_tokens ?? 0
             const cachedTokens = data.usage.prompt_tokens_details?.cached_tokens ?? data.usage.prompt_cache_hit_tokens ?? 0
             const reasoningTokens = data.usage.completion_tokens_details?.reasoning_tokens
+            outputTokens = data.usage.completion_tokens ?? 0
             yield {
               type: 'usage',
               usage: {
@@ -887,6 +909,11 @@ export class WorkBuddyAdapter {
     for (const index of toolOrder) {
       const block = [...toolCalls.values()].find((candidate) => candidate.index === index)
       if (block === undefined || !hasUsableToolName(block.name)) continue
+      // A call whose arguments never finished arriving cannot be executed: handed
+      // over, it becomes a parse error in the transcript instead of the truncation
+      // that actually happened. It is reported as `max-tokens` below instead, so
+      // the step can be continued rather than failed.
+      if (isTruncatedArguments(block.text)) continue
       blockCount += 1
       yield {
         type: 'block-end',
@@ -895,7 +922,7 @@ export class WorkBuddyAdapter {
           type: 'tool-call',
           id: block.callId,
           name: block.name,
-          arguments: isTruncatedArguments(block.text) ? block.text : normalizeToolArguments(block.text)
+          arguments: normalizeToolArguments(block.text)
         }
       }
     }
@@ -911,15 +938,67 @@ export class WorkBuddyAdapter {
     }
 
     const argsTruncated = [...toolCalls.values()].some((block) => isTruncatedArguments(block.text))
+    // A stream that stops without the `[DONE]` sentinel was cut, not finished:
+    // upstream closed the connection mid-answer. Reporting that as a normal stop
+    // ends the turn silently — the model looks like it simply chose to stop — and
+    // the retry policy never sees a failure. It has to be an error so a truncated
+    // answer is retried and, failing that, surfaced.
+    if (!streamEnded && finishReason === undefined) {
+      const detail = describeCut({ receivedBytes, startedAt, lastDataAt, lastDelta })
+      this.ctx.logger.warn(`[workbuddy] ${this.region.id}: ${options.model} 的响应在 finish_reason/[DONE] 之前中断（${detail}），按传输错误上报，可自动重试`)
+      yield {
+        type: 'finish',
+        reason: {
+          kind: 'error',
+          failure: {
+            message: `${this.region.provider}: 上游没有给出结束原因就断开了响应（${detail}；可重试的传输错误）`,
+            code: 'TRANSPORT'
+          }
+        }
+      }
+      return
+    }
+    if (argsTruncated && !streamEnded) {
+      const detail = describeCut({ receivedBytes, startedAt, lastDataAt, lastDelta })
+      this.ctx.logger.warn(`[workbuddy] ${this.region.id}: ${options.model} 的工具调用参数在传输中被截断（${detail}），按传输错误上报，可自动重试`)
+      yield {
+        type: 'finish',
+        reason: {
+          kind: 'error',
+          failure: {
+            message: `${this.region.provider}: 工具调用的参数在传输中被截断（${detail}；可重试的传输错误）`,
+            code: 'TRANSPORT'
+          }
+        }
+      }
+      return
+    }
+    // Truncated arguments are checked before the empty-response rule: a step whose
+    // only tool call was cut short has no usable block to hand over, and calling
+    // that "empty" would hide what happened.
+    if (argsTruncated) {
+      this.ctx.logger.warn(`[workbuddy] ${this.region.id}: ${options.model} 的工具调用参数被输出上限截断，本步按 max-tokens 上报（harness 可续跑）`)
+      yield { type: 'finish', reason: { kind: 'max-tokens' } }
+      return
+    }
     if (blockCount === 0) {
       yield { type: 'finish', reason: { kind: 'error', failure: { message: '模型返回了空响应', code: 'EMPTY_RESPONSE' } } }
       return
     }
     const reason = finishReason === 'tool_calls' || toolOrder.length > 0
       ? { kind: 'tool-calls' }
-      : finishReason === 'length' || argsTruncated
+      : finishReason === 'length'
         ? { kind: 'max-tokens' }
         : { kind: 'stop' }
+    // Two endings are complete-looking but are not the model choosing to stop, and
+    // nothing downstream can tell them apart. Both get a line of their own:
+    //   · the answer ran into the output budget (a truncation reads as a finish);
+    //   · upstream closed with `[DONE]` but never said *why* the answer ended.
+    if (reason.kind === 'max-tokens') {
+      this.ctx.logger.warn(`[workbuddy] ${this.region.id}: ${options.model} 的输出达到上限，本步被截断（输出 ${outputTokens ?? '未知'} tokens）`)
+    } else if (reason.kind === 'stop' && finishReason === undefined) {
+      this.ctx.logger.warn(`[workbuddy] ${this.region.id}: ${options.model} 的响应以 [DONE] 收尾但没有 finish_reason，按 stop 处理（输出 ${outputTokens ?? '未知'} tokens）`)
+    }
     yield { type: 'finish', reason }
   }
 }
@@ -927,3 +1006,21 @@ export class WorkBuddyAdapter {
 function positiveInt(value) {
   return typeof value === 'number' && Number.isSafeInteger(value) && value > 0 ? value : undefined
 }
+
+/**
+ * Describe a stream that ended without its terminator.
+ *
+ * The rule is deliberately mechanical: a response is complete only when it carries
+ * `finish_reason` (and the SSE stream reaches `[DONE]`) or delivers a tool call.
+ * Anything else is a cut connection, reported as a retryable `TRANSPORT` failure.
+ *
+ * Why the *remote* closed the connection is not observable from here, so the report
+ * carries what is: how much arrived, how long it took, how long the silence before
+ * the cut, and what was being written at the time.
+ */
+function describeCut({ receivedBytes, startedAt, lastDataAt, lastDelta }) {
+  const elapsed = ((Date.now() - startedAt) / 1000).toFixed(1)
+  const silence = ((Date.now() - lastDataAt) / 1000).toFixed(1)
+  const size = receivedBytes < 1024 ? `${receivedBytes} B` : `${(receivedBytes / 1024).toFixed(1)} kB`
+  return `收到 ${size}，用时 ${elapsed}s，最后一段数据在 ${silence}s 前，中断时正在输出${lastDelta}`
+}

package/src/api.js

@@ -21,7 +21,7 @@ import { claimDailyCheckin, fetchCheckinStatus, fetchCredits } from './credits.j
 import { localDayKey } from './http.js'
 import { isEnabled, readPrefs, setEnabled } from './model-prefs.js'
 import { readOfficialList, writeOfficialList } from './official-list.js'
-import { REGIONS, REGION_IDS } from './regions.js'
+import { REGIONS, REGION_IDS, sitePageUrl } from './regions.js'
 import { notifyModelTopology } from './topology.js'
 
 const API_PREFIX = '/workbuddy'
@@ -33,6 +33,12 @@ const MASK_PATH = fileURLToPath(new URL('../icon-mask.png', import.meta.url))
 let iconBytes
 let maskBytes
 
+/** Late-bound so importing this module never pulls in the child-process helper. */
+async function defaultOpenInBrowser(url) {
+  const { openInBrowser } = await import('./regions.js')
+  return openInBrowser(url)
+}
+
 /**
  * Which build of this file the running host actually loaded.
  *
@@ -135,8 +141,14 @@ async function statePayload(ctx, adapters) {
 /**
  * Register the panel's routes. Call inside `ctx.inject(['webServer'], …)` so a
  * composition without an HTTP carrier keeps the adapter and the command.
+ *
+ * @param {object} ctx - host plugin context.
+ * @param {Record<string, object>} adapters - per-deployment adapters.
+ * @param {{ openInBrowser?: (url: string) => boolean }} [options] - the browser
+ *   opener is injectable so tests never launch a real one.
  */
-export function registerWorkbuddyApi(ctx, adapters) {
+export function registerWorkbuddyApi(ctx, adapters, options = {}) {
+  const openInBrowser = options.openInBrowser ?? defaultOpenInBrowser
   const rejected = (req, res) => {
     const connection = ctx.get('connection')
     if (connection === undefined || typeof connection.requestRejection !== 'function') return false
@@ -249,7 +261,6 @@ export function registerWorkbuddyApi(ctx, adapters) {
               credits: entry.credits,
               efforts: entry.efforts === undefined ? [] : Object.keys(entry.efforts),
               defaultEffort: entry.defaultEffort,
-              canDisableThinking: entry.canDisableThinking,
               thinking: entry.thinking === true,
               contextWindow: entry.contextWindow,
               maxTokens: entry.maxTokens,
@@ -313,6 +324,32 @@ export function registerWorkbuddyApi(ctx, adapters) {
         return
       }
 
+      /**
+       * Open one of the deployment's own site pages in the user's browser.
+       *
+       * The panel sends a page *name*; the URL comes from `SITE_PAGES`, so this
+       * route can never be talked into opening an arbitrary address. The reply
+       * carries the URL even when launching failed, so the panel can show it.
+       */
+      if (path === `${API_PREFIX}/open` && method === 'POST') {
+        const body = await readJsonBody(req)
+        const region = REGIONS[String(body?.region ?? '').toLowerCase()]
+        const url = sitePageUrl(region, body?.page)
+        if (url === undefined) {
+          sendJson(res, 400, { error: 'unknown region or page' })
+          return
+        }
+        let opened = false
+        try {
+          opened = (await openInBrowser(url)) !== false
+        } catch (error) {
+          ctx.logger.warn(`[workbuddy] ${region.id}: 打开 ${url} 失败 — ${error instanceof Error ? error.message : String(error)}`)
+        }
+        ctx.logger.info(`[workbuddy] ${region.id}: 打开官方页面 ${url}（${opened ? '已交给浏览器' : '启动失败'}）`)
+        sendJson(res, 200, { region: region.id, url, opened })
+        return
+      }
+
       if (path === `${API_PREFIX}/availability`) {
         const id = String(url.searchParams.get('region') ?? '').toLowerCase()
         const region = REGIONS[id]

package/src/catalog-cache.js

@@ -42,8 +42,18 @@ const MODALITY_ORDER = ['text', 'image']
  * ago is not a fallback — it is wrong. The cache stores no copy, and a cached
  * entry therefore reports no rate at all; the panel shows 未知 rather than a
  * stale number.
+ *
+ * `promotion` is a live *statement* rather than a measurement, and the cache is
+ * append-only (a field another read omits is never cleared), so keeping it would
+ * let an old claim outlive the payload that made it: the deployment's
+ * `modelPromotions` block moves with each campaign, and a cached badge can
+ * advertise a promotion that ended.
+ *
+ * `canDisableThinking` is retired — the plugin pins thinking on and never reads
+ * the flag (protocol §4.3.1). It stays in this set only so that snapshots written
+ * before the retirement drop it on read instead of leaving a dead field behind.
  */
-const VOLATILE_FIELDS = new Set(['credits'])
+const VOLATILE_FIELDS = new Set(['credits', 'promotion', 'canDisableThinking'])
 
 function cacheDir() {
   const home = typeof process.env.DSH_HOME === 'string' && process.env.DSH_HOME.length > 0

package/src/catalog.js

@@ -199,7 +199,11 @@ export function entryFromMeta(id, meta) {
     input: meta?.supportsImages === true ? ['text', 'image'] : ['text'],
     ...(levels.length === 0 ? {} : { efforts: Object.fromEntries(levels.map((level) => [level, level])) }),
     ...(declared === undefined ? {} : { defaultEffort: declared }),
-    ...(reasoning?.canDisableThinking === undefined ? {} : { canDisableThinking: reasoning.canDisableThinking === true }),
+    // `reasoning.canDisableThinking` is deliberately ignored. Upstream publishes
+    // the flag without naming any parameter that would act on it (measured
+    // 2026-10-22, protocol §4.3.1), and it also stops sending the flag for models
+    // it used to describe, so the plugin pins thinking on instead of advertising a
+    // switch it cannot honour. The effort level is the only reasoning control.
     ...(id.startsWith('deepseek-') ? { thinking: true } : {}),
     // `/v3/config` publishes which tier a model needs; that is a free, static
     // entitlement signal (see `account-info.js`), so it is carried along.
@@ -306,7 +310,6 @@ export function mergeEntries(entries, extra) {
       ...(entry.contextWindow === undefined && other.contextWindow !== undefined ? { contextWindow: other.contextWindow } : {}),
       ...(entry.maxTokens === undefined && other.maxTokens !== undefined ? { maxTokens: other.maxTokens } : {}),
       ...(entry.defaultEffort === undefined && other.defaultEffort !== undefined ? { defaultEffort: other.defaultEffort } : {}),
-      ...(entry.canDisableThinking === undefined && other.canDisableThinking !== undefined ? { canDisableThinking: other.canDisableThinking } : {}),
       ...(entry.promotion === undefined && other.promotion !== undefined ? { promotion: other.promotion } : {}),
       ...(levels.length === 0 ? {} : { efforts: Object.fromEntries(levels.map((level) => [level, level])) }),
       // `official` is only ever set by the account-scoped payload (see

package/src/index.js

@@ -267,6 +267,29 @@ export function apply(ctx) {
   }, AVAILABILITY_BOOT_DELAY_MS)
   availabilityTimer.unref?.()
 
+  /**
+   * Retry log.
+   *
+   * The retry itself belongs to `@deepseek-ai/dsh-llm-retry`, which appends
+   * `llm/retry` to the session; nothing prints it, so a step that failed three
+   * times and then succeeded looks identical to one that succeeded first try.
+   * Logging the decision keeps a truncated answer visible even when the retry
+   * hides it — which is exactly the case that used to be reported as a clean stop.
+   */
+  ctx.effect(() => {
+    const byProvider = new Map(Object.values(REGIONS).map((region) => [region.provider, region]))
+    const off = ctx.on('session/event', (_session, event) => {
+      if (event?.type !== 'llm/retry') return
+      const region = byProvider.get(event.data?.provider)
+      if (region === undefined) return
+      const failure = event.data?.failure ?? {}
+      const delay = typeof event.data?.delayMs === 'number' ? `${(event.data.delayMs / 1000).toFixed(1)}s` : '未知延迟'
+      const message = String(failure.message ?? '').replace(/\s+/g, ' ').slice(0, 200)
+      ctx.logger.warn(`[workbuddy] ${region.id}: 第 ${event.data?.retry ?? '?'}/${event.data?.maxRetries ?? '?'} 次重试（${failure.code ?? '未知'}）${message.length > 0 ? ` — ${message}` : ''}；${delay} 后重试`)
+    })
+    return () => { if (typeof off === 'function') off() }
+  }, 'dsh-workbuddy: retry log')
+
   ctx.effect(() => () => {
     ctx.logger.info(`[workbuddy] 定时器全部撤销（实例 ${instance}）`)
     clearTimeout(bootTimer)

package/src/official-list.js

@@ -132,7 +132,7 @@ export function writeOfficialList(regionId, models, options = {}) {
  * current. A model whose rate cannot be read right now reads 「未知」 — which is
  * why the console capture keeps the other fields only.
  */
-const ENRICHABLE = ['name', 'descriptionZh', 'descriptionEn', 'contextWindow', 'maxTokens', 'defaultEffort', 'canDisableThinking', 'requiredUserType']
+const ENRICHABLE = ['name', 'descriptionZh', 'descriptionEn', 'contextWindow', 'maxTokens', 'defaultEffort', 'requiredUserType']
 
 const same = (a, b) => JSON.stringify(a) === JSON.stringify(b)
 

package/src/regions.js

@@ -76,6 +76,30 @@ export function regionList(raw) {
   return region === undefined ? [] : [region]
 }
 
+/**
+ * Site pages the panel may ask the user's browser to open.
+ *
+ * A fixed list on purpose: the panel sends a page *name*, never a URL, so a
+ * compromised or careless client cannot make the host open an arbitrary address
+ * (or a different host) through this route.
+ */
+export const SITE_PAGES = {
+  plans: '/profile/plans-usage'
+}
+
+/**
+ * Resolve one allowed site page for a deployment.
+ *
+ * @param {object} region - entry from `REGIONS`.
+ * @param {string} page - key from `SITE_PAGES`.
+ * @returns {string|undefined} absolute URL, or `undefined` when the pair is unknown.
+ */
+export function sitePageUrl(region, page) {
+  const path = SITE_PAGES[String(page ?? '').toLowerCase()]
+  if (region === undefined || path === undefined) return undefined
+  return `${region.endpoint}${path}`
+}
+
 /** Chat routes in preference order: the gateway first, the web host as fallback. */
 export function chatRoutes(region) {
   const primary = {