@huai_xin/dsh-workbuddy 0.1.2 → 0.1.4

package/README.md

@@ -160,7 +160,8 @@ dsh-workbuddy/
 
 - 按**能不能用**分两组：`可用模型` / `不可用模型`（探测判定 + 真实调用的自学习）。不可用分组默认折叠。
 - 每行：左侧圆点是台账颜色（绿=可用、黄=排队、红=不可用/无权限、灰=未检测），中间是模型名，右侧依次是**可用性标签 · 促销标签 · 繁忙程度 · 实时倍率**，最后是该模型的**启停开关**（停用的行会变淡）。
-- 点任意一行展开详情：描述、标识、上下文、最大输出、模态、思考档位、可关闭思考、倍率、繁忙程度、促销类型/时限/详情。所有标签共用一种样式，颜色只表示语义。
+- 点任意一行展开详情：描述、标识、上下文、最大输出、模态、思考档位、倍率、繁忙程度、促销类型/时限/详情。所有标签共用一种样式，颜色只表示语义。
+- **思考恒为开启**：上游只声明"可否关闭思考"，却从不给出能兑现它的请求参数（实测见[协议文档 §4.3.1](docs/workbuddy-protocol.md)），所以详情里不放这一项 —— 能调的只有**档位**（低/中/高/超高/极致）。
 - 倍率取不到就显示「未知」（**不猜、不用旧值兜底**），`0` 显示「免费」标签。
 - 繁忙程度**只有大陆版有**（`POST /v2/chat/busy`；海外版 404，那一列整个不显示）：空闲 / 繁忙 / 拥堵 / 未知四档，用词与官方前端一致（官方把 `normal` 与 `idle` 并成「空闲」），悬停给出官方的完整说法（轻微拥堵 / 极度拥堵）。
 - 工具栏：搜索框、「全部启用 / 全部停用」（**只作用于可用分组**，不可用分组自己手动调）、「⟳ 刷新列表」、「检测可用性」（手动，立即执行）。这两个按钮宽度固定，「检测中…」不会把 ⟳ 挤走。

package/client/index.js

@@ -106,8 +106,6 @@ window.__ModuleLoader__.load({
         detailRate: '倍率',
         detailDescription: '描述',
         detailModality: '模态',
-        detailCanDisableThinking: '可关闭思考',
-        detailNo: '否',
         freeModel: '免费',
         promoDiscount: '折扣',
         detailPromoKind: '促销类型',
@@ -120,7 +118,6 @@ window.__ModuleLoader__.load({
         busyBusyOfficial: '轻微拥堵',
         busyCongestedOfficial: '极度拥堵',
         busyUnknown: '未知',
-        detailYes: '是',
         modalityText: '文本',
         modalityImage: '图像',
         noModels: '登录后这里会显示该账号可用的模型'
@@ -193,8 +190,6 @@ window.__ModuleLoader__.load({
         detailRate: 'Rate',
         detailDescription: 'Description',
         detailModality: 'Modality',
-        detailCanDisableThinking: 'Thinking switch',
-        detailNo: 'no',
         freeModel: 'free',
         promoDiscount: 'discount',
         detailPromoKind: 'Promotion',
@@ -207,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'
@@ -1004,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)))

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,19 @@ 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 正常，
+  即断流是间歇性的，常规探测不易复现）
+- **finish 帧带一个 `response` 诊断块**（`kind`/`version`/`api`/`provider`/`model`/`responseId`/
+  `stopReason`/`outputTokens`/`blocks`）。它不是 harness 的契约字段（`dsh-llm` 的类型里没有
+  `response` / `stopReason`），纯属遥测：会话诊断里会原样显示，用来一眼回答"这一步是谁答的、
+  上游叫它什么 id"，不必再从 `request/header` 反推。`responseId` 取自上游流里的 `id`
+  （形如 `chatcmpl-…`），可以直接和上游日志对账；harness 不会据此改变行为 ✅
 - `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 +313,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 +323,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 +404,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.2",
+  "version": "0.1.4",
   "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,41 @@ 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
+    /** The gateway's own response id, for correlating with upstream logs. */
+    let responseId
+    /**
+     * The finish chunk's diagnostics block.
+     *
+     * Not part of the harness contract — the other adapters attach their own and
+     * the session diagnostics show it verbatim, which is how a "who answered this,
+     * and what did upstream call it" question gets answered without reconstructing
+     * it from the request headers. Carries nothing the harness acts on.
+     */
+    const finishChunk = (reason) => ({
+      type: 'finish',
+      reason,
+      response: {
+        kind: 'workbuddy',
+        version: 1,
+        api: 'openai-completions',
+        provider: this.region.provider,
+        model: options.model,
+        ...(responseId === undefined ? {} : { responseId }),
+        stopReason: finishReason ?? reason.kind,
+        ...(outputTokens === undefined ? {} : { outputTokens }),
+        blocks: blocks.map((block) => ({ type: block.kind }))
+      }
+    })
 
     const textBlock = () => {
       let block = blocks.find((candidate) => candidate.kind === 'text')
@@ -795,6 +836,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) {
@@ -820,18 +863,21 @@ export class WorkBuddyAdapter {
           }
           const choice = data.choices?.[0]
           const delta = choice?.delta
+          if (responseId === undefined && typeof data.id === 'string' && data.id.length > 0) responseId = data.id
           if (typeof choice?.finish_reason === 'string' && choice.finish_reason.length > 0) finishReason = choice.finish_reason
 
           if (typeof delta?.content === 'string' && delta.content.length > 0) {
             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 +891,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 +914,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 +935,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 +948,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,19 +964,83 @@ 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 finishChunk({
+        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 finishChunk({
+        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 finishChunk({ kind: 'max-tokens' })
+      return
+    }
     if (blockCount === 0) {
-      yield { type: 'finish', reason: { kind: 'error', failure: { message: '模型返回了空响应', code: 'EMPTY_RESPONSE' } } }
+      yield finishChunk({ 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' }
-    yield { type: 'finish', reason }
+    // 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 finishChunk(reason)
   }
 }
 
 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

@@ -261,7 +261,6 @@ export function registerWorkbuddyApi(ctx, adapters, options = {}) {
               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,

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)