dsh-connect-workbuddy 5.0.1 → 5.2.2

package/CHANGELOG.md

@@ -1,5 +1,99 @@
 # Changelog
 
+## 5.2.2 (2026-10-22)
+
+### Fixes
+
+- **排队不再承诺、也不再触发自动重试（按维护者要求）** —— 两半都得改，因为它们是同一件事。
+  - **文案**：原来结尾是「约 N 秒后自动重试」。**没有任何东西在重试**：插件没有排队轮询循环（`src/queue.ts` 的 "WHAT THIS MODULE DOES NOT DO YET" 写明了这一点），也不会重发。现在改成「请稍后重新发送这条消息，或换一个模型」——位次照常报，但把决定权交回给用户。
+  - **请求本身**：那句谎言还有成本。`@deepseek-ai/dsh-llm` 把 HTTP 429 映射成 `RATE_LIMIT`，而 `RATE_LIMIT` 在它的 `DEFAULT_RETRYABLE_CODES` 里 —— 所以宿主会跑 **5 次** 原地重试（0.5s→8s 退避，实测合计约 15 秒）。一次排队在几千位之后，15 秒不可能排到，这 5 次全是**真实请求**，每次都只为再听一遍同一个位次。现在该响应带上 `x-should-retry: false`（两个客户端都**先**看这个头，再看状态码）与 `retry-after: 0`。
+  - **不转发上游的 `retry_after`**：7 秒也清不掉 9021 位的队，转发它只会让客户端先等一会再收到同一个答复。
+  - **`retryAfterSec` 字段一并删除**：它只用来喂那句倒计时，现在没人读。留着解析但不用的数据，等于给这个承诺留了条回头的路。
+  - **其他 429 仍然可以重试**：`model_busy`（14003）是模型级限流，确实约一分钟就恢复，宿主重试正是对的处置。只把排队这一类标成终局，不是一刀切。
+
+### Tests
+
+- `tests/queue-no-retry.spec.ts`（6 条，新增）：`x-should-retry: false`、`retry-after: 0`、不转发上游 `retry_after`、位次与队列长度仍在、文案里没有「自动重试」、**其他 429 不受影响**（最后这条防止把可恢复的限流也变成即时失败）。
+- `tests/queue.spec.ts`：`retryAfterSec` 相关断言改写为「不携带倒计时」。
+- 全量：**111 文件 / 1807 条全绿**；两个 tsconfig 均 exit 0；build 成功。
+
+## 5.2.1 (2026-10-22)
+
+### Fixes
+
+- **每一次成功请求前都要先浪费一次被拒请求（自查发现）** —— 重试阶梯是「先发原文→被 11128 拒→再发扰动版」。第一次这样是对的，但**之后每一次都重复这个失败**，而一个会话里提示词的形状并不变。实测每次多付 **209ms + 一次被拒请求**。
+  - 修法：扰动版成功过一次之后，记住它，**下一次直接从扰动版开始**。实测：第 1 次请求用 2 次上游调用，之后每次 1 次。
+  - **只记在内存里，不落盘**：上游的指纹名单是可以**撤销**的，不只是增加。落盘的标志会活过它成立的条件，继续扰动一个已经不再拒绝的网关。
+  - **而且会自我纠正**：扰动版一旦也被拒，立刻清掉标志、退回原文重新探测 —— 所以规则被撤销、或同一网关后面换了别的模型，都不会让插件卡在一个不再有用的形状上。
+  - 只在**成功**时记忆。一次也被拒的扰动没有教会我们任何关于网关想要什么的信息。
+
+### 关于用户反馈的那份「改提示词」方案
+
+有用户报告用 `dsm-prompt-easymanager` 取消勾选 `harness:identity` 并把它改成 `DSH` 就能解决。**我实测了，结论是部分有效、但不是根本解法**：
+
+| 做法 | 实测 |
+|---|---|
+| 只取消勾选 `harness:identity` | **400 / 11128**（不够） |
+| 只把 `identity` 改成 `DSH`，另两段原文 | **400 / 11128**（不够） |
+| 只改 `source` + `web`，`identity` 原文 | **400 / 11128**（不够） |
+| **三段全改成 `DSH`** | **200** ✅ |
+| 插件当前（零宽扰动） | **200** ✅ |
+
+也就是说**必须三段全部改**才有效，只改一段不够 —— 这份方案之所以在那个用户的机器上「可用」，是因为他改了三段。而插件的扰动方案不需要用户改任何东西。
+
+顺带定位到了一处更精确的事实：门 B 的触发条件不是「含 `DeepSeek Harness`」，而是**特定句子组合**。单独 `source` 段 200、单独 `web` 首句 200、单独 `web` 次句 200，但**两段一起**就 400；而 `web` 次句末尾的**句号**决定成败（改成感叹号则 200）。所以这是一条**内容指纹**规则，不是长度规则 —— 也再次确认 #105 里那个「需要 15,196 字符」的结论不成立。
+
+## 5.2.0 (2026-10-22)
+
+> 新功能：实测输出速度（issue #92）。默认不跑，点了才花积分。
+
+### Features
+
+- **一键测速 / 单模型测速：输出速度（issue #92）** —— 倍率不再是选模型的唯一依据了。DSH 会把模型当**子代理并行派发**，每个子任务还有多轮往返，所以**输出速度会乘进整个任务的实际耗时**：一个便宜但慢的模型，总耗时可能超过贵但快的。issue 报告者实测同倍率（x0.08）的四个模型，中位输出速度差 **3.8 倍**。
+  - **已有探针为什么给不出这个数**：现有可用性探测发 25,000 输入 token、输出上限 **1 个**（`PROBE_MAX_TOKENS = 1`），它的 `elapsedMs` 是**首字延迟**，没有生成跨度可除。测速需要相反的请求形状：极小输入 + 长输出。所以这是**独立的路由**，不是给老路由加字段。
+  - **成本比可用性探测低一个数量级**：这个网关按**输入**计价。可用性探测实测 `credit 0.72`；测速实测 **0.01–0.15**（取决于模型倍率）。每次 3 轮，也就是单模型约 0.03–0.45。
+  - **3 次取中位数，不是均值**：实测 `glm-5.3-flash` 五次是 110 / 105 / **177** / 103 / 109 tok/s —— 均值 121 被离群值拉高，而四次都在 103–110。中位数 109 才是它真实的位置。所以轮数取**奇数**（偶数中位数要平均两个中间值，等于把离群值的影响又请回来）。
+  - **失败的轮次丢弃，不记 0**：一个模型两次跑到 400 tok/s，不会因为第三次超时就变慢；差距体现在 `samples`（"3 次"变"2 次"）而不是速率上。
+  - **测不出就报测不出，绝不编**：分块太少（整个答案一次到达）→ 报「无法测速：分块太少」；上游没报 token 数 → 报「上游没报 token 数」。绝不拿 `elapsedMs` 倒推一个速率。
+  - **结果带时间戳**：速度随负载变，一个过期的数字比没有更糟。行里显示 `· 10-22 02:31 测`。
+  - **不影响可用性判定**：独立状态、独立路由、行里独立一行显示 —— 一个「快但不可用」的模型不会被渲染成一个不存在的合成状态。
+
+### Fixes
+
+- **测速的首字延迟一开始是错的（自查发现，未发布）** —— 第一版在 `probeChat` resolve 之后才取时钟，也就是「响应头到达」之后才计时，于是报的是「响应头→首块」而不是「发请求→首块」。实测三个模型里两个报 `timeToFirstTokenMs: 0`，正是这个错误的签名：读时钟时首块已经在缓冲区里了。
+  - **速率不受影响**（它是首块→末块），这恰恰是为什么容易漏掉：主数字一直是对的，副数字是垃圾。
+  - 已修，并补了一条测试：模拟服务端 120ms 才开始应答，断言 TTFT ≥ 100ms。时钟一旦被挪回响应头之后，这条会立刻红。
+
+### Tests
+
+- `tests/tps.spec.ts`（21 条，新增）：请求形状（输出上限远大于 1、输入极小、要求低推理档）、流式读取真的在测间隔（已知到达节奏下断言跨度）、只计 content 不计 reasoning、畸形/分片帧不抛、单块流报「无法测速」、中位数抗离群、丢失败轮不记 0、区分「无 token 数」与「分块太少」、积分求和去浮点噪声、真实循环驱动、单轮失败仍继续、全失败不抛、帧语法单测、以及**TTFT 时钟位置**的回归测试。
+- `tests/web-status.spec.ts`：路由清单断言补上测速路由。
+- 全量：**109 文件 / 1794 条全绿**；两个 tsconfig 均 exit 0；build 成功。
+
+## 5.1.0 (2026-10-22)
+
+> 版本号是 **minor**：修了两个行为缺陷（不是接口变更），但其中第一个会改变每一轮请求实际发出去的内容，所以不用 patch。
+
+### Fixes
+
+- **global 区的历史思考不再被降级成正文（issue #102）** —— 这是本仓库最严重的一个 bug，而且它被一条假绿的测试盖了四个版本。pi-ai 只在「记这条消息的 provider / api / model 三者都等于当前请求」时才把历史 thinking 重放成 thinking，否则整块摊平成 `text`。DSH 的 agent loop 写消息时用的是**路由名**（`source.provider = request.provider` → `workbuddy-global`），而插件给模型盖的章是**共享 identity**（`workbuddy`），两者永远不等。后果：global 会话**每一轮**都把模型自己的历史推理翻成正文，模型看到「我以前的思考全是正文」，于是把新推理也写进正文——这就是报告里「reasoning 只有 1 个字、text 里全是工作笔记」的形状。
+  - 国内区之所以正常，只是因为它**恰好**路由名 == 章名（`workbuddy` === `workbuddy`）。
+  - 修法：新增 `alignAssistantIdentities()`，在 transcript 交给 pi-ai 之前把历史 assistant 消息的 `provider` 改写成 identity。**只改 `provider`，不动 `api`**——`dsh-foreign` 消息的 api 是插件从不会发的形状，声称 `openai-completions` 等于断言一个它从未按之构建的线上格式；而 `isSameModel` 仍然要求 model id 匹配，所以真正的换模型照样降级（有测试钉住）。
+  - **测试先改红再改绿**：`tests/issue59-cross-region-thinking.spec.ts` 里那条「双向」用例原本是 `for (...) { void recorded; void replayed; ... }`——两个循环变量被直接丢弃，两次迭代断言的是同一件事，从未测过跨区域。现在按**真实形状**喂（`source.provider` = 路由名 + 请求侧 = identity），修复前必红。
+  - 新增 5 条边界用例：user / toolResult 不动（原对象返回，请求路径上不分配）、已对齐时不分配、只改 provider、不同 model id 仍降级、畸形条目不抛。
+
+- **`11115` 让宿主认不出「上下文溢出」，丢掉了自愈能力（issue #101）** —— 上游这个码有两种报文：形态 A 带 `prompt is too long: N tokens > M maximum`，形态 B 只有一句中文「本次输入加上历史对话超过了模型上限」。而宿主是靠**英文正则**（25 条 pattern，第一条就是 `prompt (?:is )?too long`）判断要不要跑压缩救援的——中文一句都不命中。于是形态 B 既不压缩也不重试，直接把 400 甩给用户，连它自己那句「请精简内容」的建议宿主都无法执行。
+  - 修法：错误文案前面加一句 `prompt is too long (upstream code 11115)`，上游原文紧跟在后面。机器拿到信号，人仍然看到网关自己的建议。
+  - **不编造 token 数字**：形态 B 根本没给数字，写一个「N tokens > M」正是这个仓库一直在避免的那种「自信的错误诊断」。
+  - `isContextTooLongBody()` 用带边界的正则，`111150` / `1111` 不会被误判成溢出——误判会让宿主跑一轮毫无用处的压缩。
+  - 分类不变：仍是 `client`，仍然不换号（溢出是请求的问题，换账号只会每个账号烧一次）。
+
+### Tests
+
+- `tests/issue101-context-overflow.spec.ts`（8 条，新增）：两种形态都识别、相邻码不误伤、marker 命中宿主 pattern 且不被误认为限流、不编造数字、分类不变；外加一条**端到端**用例真的把一次 11115 请求驱过 shim，读宿主会看到的那句文案，确认 marker 在、网关原文在、requestId 在。
+- `tests/issue59-cross-region-thinking.spec.ts`（12 条，改写 1 条 + 新增 5 条）。
+- 全量 `npx vitest run` = **108 文件 / 1773 测试全绿**；`tsc` 两个 project 均 exit 0；`npm run build` 成功。
+
 ## 5.0.1 (2026-10-22)
 
 > 版本号是 **patch**：改卡面上的一个字符串（标题）、去掉模型列表的一条 CSS 规则与两行路由项，以及几处描述它们的文档。没有接口或配置结构的变更——但如果你的配置里存着 `auto` / `default-model`，升级后它不再出现在列表里。

package/README.md

@@ -43,7 +43,7 @@
 - **模型管理** —— 从上游刷新完整模型目录，逐项勾选启用或禁用；刷新是草稿操作，点保存才生效。上游同时给出积分倍率、上下文/输出上限与推理档位；**图片输入按厂商核验表判定**：刷新时只有厂商文档明确写为原生多模态的模型才自动勾选，文档写明纯文本的不勾，**没有厂商资料的一律按「未核实」不猜**（上游的 `supportsImages` 是平台侧声明，不等于模型能看图，不参与判定）。用户仍可随时手动勾选，勾选状态保存在本地。**每个模型行还有「可关闭思考」（`off`）勾选框**：决定要不要为该模型提供「完全关闭思考」这一档位。默认由内置复核名单给出（上游声称可关闭、实测却对它返回 HTTP 400 的 9 个模型默认不勾），你可以按模型改勾/取消——**取消**用于当前不需要该档位的模型；**名单内那 9 个模型不可勾选**（行上标「拒绝 off」，悬停有说明）：该档位被勾上后不只是多一个选项，pi-ai 会把它当作**所有未指定档位请求的默认值**，压缩摘要请求正属于这一类，勾一次等于让该模型的每一次 `/compact` 都 400 / 11133（issue #83）。名单外的模型仍完全由你的勾选与自身声明决定；首次保存即写入你的勾选，之后不再重算。
 - **模型行上的活动徽标** —— 上游的模型目录里带着活动信息（免费试用、夜间折扣、限时免费、订阅优先等），插件**不新增任何请求**（复用刷新模型时本来就会拉的那份目录配置），直接在模型行上画一枚胶囊徽标：颜色与文案都由上游给出，悬停能看到上游的活动说明、活动的起止日期与每日生效时段（例如「夜间 23:00–7:50」）。**徽标是「此刻」的函数**：活动只在它自己声明的时间窗内显示，窗口一关徽标就自己消失；跨零点的时段按上游声明的时区判断；同一个模型命中多条活动时只画优先级最高的那条。上游没给结束时间的权益标记（如「订阅优先」）则常驻，直到上游把它下架。**徽标只是提示，不改变模型行为**——它标注的是上游此刻给出的活动与折扣，不替你做选择。（两个区域的上游目录都下发活动字段：国内版按 App 身份读 `/v3/config` 时带 8 条促销 + 1 条等级标记，国际版带 5 条 + 1 条；取证与判定规则见 [docs/PROMO_BADGE.md](docs/PROMO_BADGE.md)。）
 - **模型行上的繁忙程度** —— 上游另有一条只读探针（`POST /v2/chat/busy`，一次最多 50 个 id，免费、不动账号状态）回答「这个模型此刻多忙」，插件在每次刷新目录时顺带问一次，把等级拼在倍率后面：`Hy4 preview · x0.29 · 极度拥堵`。**只画 `busy` / `congested` / `unavailable`**（轻微拥堵 / 极度拥堵 / 不可用）：`idle` 有词但不画——实测 20 个模型里 7 个空闲，每行都挂就成了装饰而不是警告；`normal` 与探针没回答的 `unknown` 一律不画，**「没被告知」不会被当成「一切正常」**。**等级不落盘**：目录是能活过重启的事实，负载只是那一分钟的事实，所以等级只盖在运行时目录上、随进程消失，探针失败只记一条 warn，绝不挡住目录刷新。实测这条探针在 CLI 与 App 两种身份下答案逐字节相同，50 个 id 的上限也真实存在（62 个 → HTTP 400），19 个模型 186 ms 返回。
-- **排队时说清楚你排在第几位** —— 上游用三个业务码表达排队（`6020` 等待、`6021` 队列满、`6022` 已达上限）。撞上它们时，插件不再给一句上游报错，而是「模型排队中：你排在第 8777 位，队列共 9021 个请求；约 7 秒后自动重试」。**排队不会触发换号**：队列跟随的是模型与平台级的队伍，换个账号拿到的还是同一个位次，所以这里既不走账号池也不烧额外请求（上游 `/v2/chat/queue/status` 回的 `message` 是 i18n key 而不是人话，插件因此从不转述它，只用自己的措辞）。**「排到之后自动重发」这一半没有实现**——它需要排队答案在 OpenAI 兼容通道上的真实信封，没测到就不写。
+- **排队时说清楚你排在第几位** —— 上游用三个业务码表达排队（`6020` 等待、`6021` 队列满、`6022` 已达上限）。撞上它们时，插件不再给一句上游报错，而是「模型排队中：你排在第 8777 位，队列共 9021 个请求。请稍后重新发送这条消息，或换一个模型」。**排队不会触发换号**：队列跟随的是模型与平台级的队伍，换个账号拿到的还是同一个位次，所以这里既不走账号池也不额外烧请求（上游 `/v2/chat/queue/status` 回的 `message` 是 i18n key 而不是人话，插件因此从不转述它，只用自己的措辞）。**排队不会自动重发，也不会被自动重试**——插件没有排队轮询循环（它需要排队答案在 OpenAI 兼容通道上的真实信封，没测到就不写），并且明确告诉宿主不要重试（`x-should-retry: false`）：一次排队在几千位之后，重试十几次也轮不到，只会把真实请求白白花掉。位次报出来，由你决定是重发还是换模型。
 - **模型可用性测试（含冷却恢复时间）** —— 限量模型的冷却时间过去只能靠反复试错去猜。现在每个模型行有一个「测试」按钮，直接告诉你它此刻能否使用、不能用时何时恢复。**它发的是一条真实体积的请求（约 25k 输入 token）**，而不是「发个 ping 看通不通」——因为上游的限流**按请求体积触发**（实测约 20k 能过、约 30k 被拒），小请求看着正常、长对话里却可能每次都被拒，那正是「测试通过、实际被限」的来源。**恢复时间的来源**：上游的 429 **不带** `Retry-After` 响应头（也没有 `X-RateLimit-*`），但它把重置时间写在**响应体**里——`{"code":6004,"msg":"…将在 2026-09-30 02:30:30 UTC+8 重置…"}`。插件从响应体解析该时间（并按其声明的 UTC 偏移换算，不受你本机时区影响），因此卡片能直接显示「✗ 被限流 · 2026/9/30 02:30:30 之后可再用」。三处来源都没说时，插件**不编造倒计时**，如实显示「上游未给出何时恢复」。限流**不会**去借月周期包的刷新时间（那会让人为几秒的限流去等几周）。探测在后台发起，**凭据不会传到页面**；结果不写入设置，也不改变你已保存的勾选。
 
   **两点需要知道**：① **它真的花钱**——实测一次报 `credit` 0.02（被限流时直接 429，几乎不花）。因此**只能按单个模型手工点**，没有「测试已勾选」这类批量按钮：一次覆盖整个列表就是一次不可控支出（服务端也据此**只接受单个模型**，多模型请求会被拒）。② 上游虽宣称 1M 上下文，但节流线远低于此；插件按模型的**原生窗口**向 DSH 宣称（3.5.0 起不再默认压到 200K），所以 DSH 很晚才压缩对话——长会话撞限流是这条机制的直接结果。想让 DSH 更早压缩，就在模型行上手动设一个「DSH 上下文预算」上限（可选 200K / 500K / 模型原生窗口）。

package/lib/bin.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { C as defaultDesktopAuthCandidates, I as WorkBuddyUpstreamClient, M as workbuddyOwnAuthPath, a as readHostHeartbeat, b as WorkBuddyCredentialStore, c as WORKBUDDY_CONNECT_VERSION, d as FALLBACK_WORKBUDDY_MODELS_GLOBAL, ht as WORKBUDDY_APP_EXECUTABLE_ENV, k as legacyWorkbuddyOwnAuthPath, kt as hostPeersInfo, l as piAiRuntimeInfo, o as workbuddyHostHeartbeatPath, r as isHeartbeatProcessAlive, u as FALLBACK_WORKBUDDY_MODELS, w as defaultDesktopAuthDirs, xt as findWorkbuddyAppExecutableWithSource, y as WORKBUDDY_AUTH_FILE_ENV } from "./host-heartbeat-DtMzOwZr.js";
+import { C as defaultDesktopAuthCandidates, Ct as findWorkbuddyAppExecutableWithSource, L as WorkBuddyUpstreamClient, M as workbuddyOwnAuthPath, _t as WORKBUDDY_APP_EXECUTABLE_ENV, a as readHostHeartbeat, b as WorkBuddyCredentialStore, c as WORKBUDDY_CONNECT_VERSION, d as FALLBACK_WORKBUDDY_MODELS_GLOBAL, jt as hostPeersInfo, k as legacyWorkbuddyOwnAuthPath, l as piAiRuntimeInfo, o as workbuddyHostHeartbeatPath, r as isHeartbeatProcessAlive, u as FALLBACK_WORKBUDDY_MODELS, w as defaultDesktopAuthDirs, y as WORKBUDDY_AUTH_FILE_ENV } from "./host-heartbeat-r1M_OXJI.js";
 import { realpathSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 //#region src/bin.ts

package/lib/client.js

@@ -62,6 +62,17 @@ window.__ModuleLoader__.load({
 		*/
 		const WORKBUDDY_PROBE_PATH = "/plugins/dsh-connect-workbuddy/probe";
 		/**
+		* Plugin-owned OUTPUT-SPEED measurement endpoint (issue #92).
+		*
+		* Separate from {@link WORKBUDDY_PROBE_PATH} because the two ask opposite
+		* questions and cost different amounts: the availability probe sends 25,000
+		* input tokens and caps output at one (measured `credit 0.72`), while this one
+		* sends ~35 input tokens and caps output at 256 (measured `credit 0.01`–`0.15`).
+		* Sharing the route would mean sharing its one-model-per-request cap and its
+		* cost wording, and the two would then be wrong for each other.
+		*/
+		const WORKBUDDY_TPS_PATH = "/plugins/dsh-connect-workbuddy/tps";
+		/**
 		* Plugin-owned account-pool endpoint: one batch action per call.
 		*
 		* `?action=checkin` claims the daily reward for every account of a region;
@@ -4294,10 +4305,12 @@ window.__ModuleLoader__.load({
    meta line, because a cooldown sentence ("rate limited - the upstream gave no
    time") does not fit next to the context/output chips, and truncating it would
    hide exactly the part the user needs. */
-/* Three buttons now live here (refresh + the two sweeps), and the sweep labels are
-   long in Chinese (一键测试所有模型). flex:none alone let the group run past the
-   header on a narrow card, so the group may WRAP and each label refuses to break
-   mid-word — the same failure the pool row's action buttons had. */
+/* FOUR buttons now live here (refresh + two availability sweeps + the speed
+   sweep added for issue #92), and the labels are long in Chinese
+   (一键测速启用模型). flex:none alone let the group run past the header on a
+   narrow card, so the group may WRAP and each label refuses to break mid-word —
+   the same failure the pool row's action buttons had. The wrap is what makes a
+   fourth button safe; without it the header would need a scroll. */
 .dsm-workbuddy-models-head-actions{display:flex;align-items:center;gap:8px;flex-wrap:wrap;justify-content:flex-end}
 .dsm-workbuddy-models-head-actions .dsm-btn{white-space:nowrap}
 /* The sweep buttons keep the outline weight of the refresh button beside them, so
@@ -5215,6 +5228,37 @@ window.__ModuleLoader__.load({
 			const remaining = remainingText(t, untilMs, nowMs);
 			return remaining === "" ? "" : ` · ${remaining}`;
 		}
+		/**
+		* Render one measured speed, or why there is none (issue #92).
+		*
+		* The timestamp is PART of the value, not decoration: speed changes with load,
+		* and a number without its moment is indistinguishable from a fresh one. When the
+		* measurement could not be timed the row says so and names the reason — never a
+		* zero, and never a guess extrapolated from `elapsedMs`, which for some runs is
+		* time-to-first-token and for others a whole-request duration.
+		*/
+		function tpsResultView(result, t, measuredAtMs) {
+			const stamp = measuredAtMs === void 0 ? "" : ` · ${t("row.tpsMeasuredAt", { at: formatDate(measuredAtMs) })}`;
+			if (result.tokensPerSecond === void 0) {
+				const reason = result.reason === "few-chunks" ? "row.tpsNoSample" : result.reason === "no-usage" ? "row.tpsNoUsage" : "row.tpsAllFailed";
+				return {
+					text: result.samples > 0 && result.reason !== void 0 ? `${t(reason)}${stamp}` : `${t("row.tpsAllFailed")}${stamp}`,
+					tone: "bad"
+				};
+			}
+			return {
+				text: `${result.samples < TPS_EXPECTED_RUNS ? t("row.tpsPartial", {
+					tps: String(result.tokensPerSecond),
+					samples: String(result.samples)
+				}) : result.timeToFirstTokenMs === void 0 ? t("row.tpsValue", { tps: String(result.tokensPerSecond) }) : t("row.tpsValueTtft", {
+					tps: String(result.tokensPerSecond),
+					ttft: (result.timeToFirstTokenMs / 1e3).toFixed(1)
+				})}${result.credit === void 0 ? "" : ` · ${t("row.tpsCredit", { credit: String(result.credit) })}`}${stamp}`,
+				tone: result.samples < TPS_EXPECTED_RUNS ? "warn" : "ok"
+			};
+		}
+		/** Runs a complete measurement takes; below this the row says "n runs". */
+		const TPS_EXPECTED_RUNS = 3;
 		function probeResultView(result, t, nowMs = Date.now()) {
 			switch (result.outcome) {
 				case "ok": {
@@ -5347,6 +5391,26 @@ window.__ModuleLoader__.load({
 			const probesRef = (0, react.useRef)({});
 			/** Progress of an in-flight sweep, or undefined when none is running. */
 			const [sweeping, setSweeping] = (0, react.useState)(void 0);
+			/**
+			* Measured output speed per model (issue #92), keyed by model id.
+			*
+			* Kept in its own map, NOT merged into `probes`: a speed run says nothing about
+			* availability and an availability run says nothing about speed, so one map
+			* holding both would let a fresh speed reading overwrite a stale availability
+			* verdict (or the reverse) with no field to tell them apart.
+			*
+			* Deliberately survives a region switch's re-render but is NOT persisted: a
+			* speed number is only meaningful with the moment it was taken, and a stored
+			* one would be indistinguishable from a fresh measurement. The row prints the
+			* time beside it for the same reason.
+			*/
+			const [tpsResults, setTpsResults] = (0, react.useState)({});
+			/** Which speed runs are in flight, so the row and the sweep button can spin. */
+			const [tpsProbing, setTpsProbing] = (0, react.useState)({});
+			/** Progress of a speed sweep, so the button can show "n/m" instead of hanging. */
+			const [tpsSweeping, setTpsSweeping] = (0, react.useState)(void 0);
+			/** When each model's speed was measured, in ms; printed beside the number. */
+			const [tpsMeasuredAt, setTpsMeasuredAt] = (0, react.useState)({});
 			/** The last sweep's tally, cleared when the next one starts. */
 			const [sweepSummary, setSweepSummary] = (0, react.useState)(void 0);
 			const mounted = (0, react.useRef)(true);
@@ -6008,6 +6072,83 @@ window.__ModuleLoader__.load({
 				sweepModels(visibleModels.filter((model) => activeEnabledIds.has(model.id)).map((model) => model.id));
 			};
 			/**
+			* Measure OUTPUT SPEED for one or more models (issue #92).
+			*
+			* One model per request, like every other spending route: the upstream route
+			* refuses more than one id, and that cap is what keeps a stale bundle from
+			* turning a click into an unaccounted spend over a whole roster. The loop for a
+			* sweep therefore lives here, not on the Host.
+			*
+			* A failed model does NOT abort the sweep. Unlike an availability sweep — where
+			* a rejected credential answers identically for every remaining model and
+			* continuing only spends credit to hear the same answer — a speed failure is
+			* specific to that model, so stopping would hide the one thing the sweep was
+			* asked to find out.
+			*/
+			const measureTpsFor = async (modelIds) => {
+				if (modelIds.length === 0) return;
+				setTpsProbing((previous) => {
+					const next = { ...previous };
+					for (const id of modelIds) next[id] = true;
+					return next;
+				});
+				try {
+					for (const [index, modelId] of modelIds.entries()) {
+						if (!mounted.current) return;
+						try {
+							const response = await fetch(withWorkBuddyRegion(WORKBUDDY_TPS_PATH, activeRegion), {
+								method: "POST",
+								headers: {
+									"content-type": "application/json",
+									accept: "application/json"
+								},
+								credentials: "same-origin",
+								body: JSON.stringify({ modelIds: [modelId] })
+							});
+							const body = await response.json().catch(() => void 0);
+							if (!response.ok || !Array.isArray(body?.results)) throw new Error(body?.error ?? `HTTP ${String(response.status)}`);
+							if (!mounted.current) return;
+							const landed = body.results[0];
+							if (landed !== void 0) {
+								setTpsResults((previous) => ({
+									...previous,
+									[landed.modelId]: landed
+								}));
+								setTpsMeasuredAt((previous) => ({
+									...previous,
+									[landed.modelId]: Date.now()
+								}));
+							}
+						} catch (error) {
+							if (!mounted.current) return;
+							setProbeError(error instanceof Error ? error.message : t("row.requestFailed"));
+						} finally {
+							if (mounted.current) setTpsProbing((previous) => {
+								const next = { ...previous };
+								delete next[modelId];
+								return next;
+							});
+						}
+						if (mounted.current) setTpsSweeping({
+							done: index + 1,
+							total: modelIds.length
+						});
+					}
+				} finally {
+					if (mounted.current) setTpsSweeping(void 0);
+				}
+			};
+			/**
+			* Sweep speed for the models this region has ENABLED.
+			*
+			* Enabled-only rather than the whole catalog: a speed run is three real
+			* requests, so covering a 20-model roster would cost 60 requests to learn
+			* something about 18 models the user does not use.
+			*/
+			const sweepTpsEnabledModels = () => {
+				measureTpsFor(visibleModels.filter((model) => activeEnabledIds.has(model.id)).map((model) => model.id));
+			};
+			/**
 			* Sweep EVERY model in the region's live catalog, enabled or not.
 			*
 			* Deliberately the whole VISIBLE catalog and nothing else: those are the ids
@@ -6469,6 +6610,17 @@ window.__ModuleLoader__.load({
 																done: sweeping.done,
 																total: sweeping.total
 															})
+														}),
+														/* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+															type: "button",
+															className: "dsm-btn dsm-btn-outline dsm-workbuddy-models-sweep",
+															disabled: busy || tpsSweeping !== void 0 || tpsProbing !== void 0 || activeEnabledIds.size === 0,
+															title: t("row.tpsSweepEnabledHint"),
+															onClick: sweepTpsEnabledModels,
+															children: tpsSweeping === void 0 ? t("row.tpsSweepEnabled") : t("row.tpsTesting", {
+																done: tpsSweeping.done,
+																total: tpsSweeping.total
+															})
 														})
 													]
 												})]
@@ -6579,9 +6731,9 @@ window.__ModuleLoader__.load({
 																		}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", { children: formatCapacity(model.nativeContextWindow, t("row.modelUnknown")) })] })
 																	]
 																}),
-																/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+																/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
 																	className: "dsm-workbuddy-model-actions-buttons",
-																	children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+																	children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
 																		type: "button",
 																		className: "dsm-btn dsm-btn-outline dsm-workbuddy-model-probe",
 																		disabled: probing[model.id] === true || status.status !== "signed-in",
@@ -6590,7 +6742,16 @@ window.__ModuleLoader__.load({
 																			probeModels([model.id]);
 																		},
 																		children: probing[model.id] === true ? t("row.probing") : t("row.probe")
-																	})
+																	}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+																		type: "button",
+																		className: "dsm-btn dsm-btn-outline dsm-workbuddy-model-probe",
+																		disabled: tpsProbing[model.id] === true || status.status !== "signed-in",
+																		title: t("row.tpsHint"),
+																		onClick: () => {
+																			measureTpsFor([model.id]);
+																		},
+																		children: tpsProbing[model.id] === true ? t("row.tpsMeasuring") : t("row.tpsMeasure")
+																	})]
 																})
 															]
 														}),
@@ -6616,6 +6777,16 @@ window.__ModuleLoader__.load({
 																...result.message === void 0 ? {} : { title: result.message },
 																children: [view.text, reason === void 0 ? null : " · " + reason]
 															});
+														})(),
+														(() => {
+															const measured = tpsResults[model.id];
+															if (measured === void 0) return null;
+															const view = tpsResultView(measured, t, tpsMeasuredAt[model.id]);
+															return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+																className: `dsm-workbuddy-model-probe-result dsm-workbuddy-model-probe-result-${view.tone}`,
+																role: "status",
+																children: view.text
+															});
 														})()
 													]
 												}, model.id))
@@ -7885,6 +8056,21 @@ window.__ModuleLoader__.load({
 			"row.modelsTesting": "Testing {done}/{total}…",
 			"row.modelsTestEnabledHint": "Tests every model you have ENABLED, one request each — each probe sends a real-volume request, so this spends real credit (about 0.01 per model at the default 25000-token size). Rows show their verdict as it lands. Stops early if the credential is rejected.",
 			"row.modelsTestAllHint": "Tests EVERY model in this region's catalog, including the ones you have NOT enabled — so it costs noticeably more than \"test enabled models\". Same per-probe cost, same early stop on a rejected credential.",
+			"row.tpsSweepEnabled": "Measure speed (enabled)",
+			"row.tpsSweepAll": "Measure speed (all)",
+			"row.tpsSweepEnabledHint": "Measures OUTPUT SPEED for every model you have ENABLED: three runs each, taking the median. Unlike the availability probes above, this sends a tiny prompt and asks for 256 output tokens back, so it costs far less per model (measured 0.01–0.15 credit against 0.72), because this gateway prices by input. Speed matters because DSH dispatches models as parallel sub-agents, so a slow model costs wall-clock time across the whole run.",
+			"row.tpsTesting": "Measuring {done}/{total}…",
+			"row.tpsMeasure": "Speed",
+			"row.tpsMeasuring": "Measuring…",
+			"row.tpsHint": "Measure this model's output speed: three short requests, median taken. Uses about 256 output tokens per run and costs far less than an availability probe (measured 0.01–0.15 credit). The result is shown with the time it was taken, because speed changes with load and an old number is worse than none.",
+			"row.tpsValue": "{tps} tok/s",
+			"row.tpsValueTtft": "{tps} tok/s · first token {ttft}s",
+			"row.tpsPartial": "{tps} tok/s ({samples} runs)",
+			"row.tpsNoSample": "Could not time this model (too few stream chunks)",
+			"row.tpsNoUsage": "Could not time this model (upstream reported no token count)",
+			"row.tpsAllFailed": "Speed measurement failed",
+			"row.tpsCredit": "cost {credit} credit",
+			"row.tpsMeasuredAt": "measured {at}",
 			"row.modelsTestDone": "Done: {available} of {total} available",
 			"row.modelsTestAuth": "Stopped: the credential was rejected, so every remaining model would answer the same way. Sign in again, then re-run.",
 			"row.probe": "Test",
@@ -8229,6 +8415,21 @@ window.__ModuleLoader__.load({
 			"row.modelsTesting": "测试中 {done}/{total}…",
 			"row.modelsTestEnabledHint": "逐个测试你**已启用**的模型，一个模型一次请求 —— 每次探测都发真实体积的请求，真花积分（默认 25000 token 体积下约 0.01/个）。每行的结果一出来就显示。凭据被拒时提前停止。",
 			"row.modelsTestAllHint": "测试本区域目录里的**每一个**模型，含**未启用**的 —— 所以比「仅测试启用模型」明显更贵。单次探测成本相同，凭据被拒时同样提前停止。",
+			"row.tpsSweepEnabled": "一键测速启用模型",
+			"row.tpsSweepAll": "一键测速所有模型",
+			"row.tpsSweepEnabledHint": "测**已启用**模型的**输出速度**：每个模型跑 3 次取中位数。和上面的可用性探测不同，它只发一个极小的提示、要求返回 256 个输出 token —— 这个网关按**输入**计价，所以单模型成本低得多（实测 0.01–0.15 积分，可用性探测是 0.72）。速度之所以重要：DSH 会把模型当子代理并行派发，慢模型拖的是整个任务的实际耗时。",
+			"row.tpsTesting": "测速中 {done}/{total}…",
+			"row.tpsMeasure": "测速",
+			"row.tpsMeasuring": "测速中…",
+			"row.tpsHint": "测量该模型的输出速度：3 次短请求取中位数。每次约 256 个输出 token，成本远低于可用性探测（实测 0.01–0.15 积分）。结果旁边会标出**测量时间** —— 速度随负载变化，一个过期的数字比没有更糟。",
+			"row.tpsValue": "{tps} tok/s",
+			"row.tpsValueTtft": "{tps} tok/s · 首字 {ttft}s",
+			"row.tpsPartial": "{tps} tok/s（{samples} 次）",
+			"row.tpsNoSample": "无法测速：流里的分块太少，算不出速率",
+			"row.tpsNoUsage": "无法测速：上游没报 token 数",
+			"row.tpsAllFailed": "测速失败",
+			"row.tpsCredit": "花费 {credit} 积分",
+			"row.tpsMeasuredAt": "{at} 测",
 			"row.modelsTestDone": "完成：{total} 个里 {available} 个可用",
 			"row.modelsTestAuth": "已停止：凭据被拒，剩下的模型都会得到同一个答案。请重新登录后再跑一次。",
 			"row.probe": "测试",

package/lib/{host-heartbeat-DtMzOwZr.js → host-heartbeat-r1M_OXJI.js}

@@ -1045,8 +1045,6 @@ const WORKBUDDY_QUEUE_CODES = [
 	6021,
 	6022
 ];
-/** The app's default when the upstream sends no `retry_after` (`?? 5`). */
-const WORKBUDDY_QUEUE_DEFAULT_RETRY_SEC = 5;
 /** True when a business code is one of the app's three queue codes. */
 function isQueueCode(value) {
 	return typeof value === "number" && WORKBUDDY_QUEUE_CODES.includes(value);
@@ -1058,12 +1056,10 @@ function reportFrom(code, data) {
 	const numberField = (key) => typeof body[key] === "number" && Number.isFinite(body[key]) ? body[key] : void 0;
 	const position = numberField("queue_position");
 	const size = numberField("queue_size");
-	const retryAfter = numberField("retry_after");
 	return {
 		code,
 		...position === void 0 ? {} : { position },
-		...size === void 0 ? {} : { size },
-		retryAfterSec: retryAfter !== void 0 && retryAfter > 0 ? retryAfter : WORKBUDDY_QUEUE_DEFAULT_RETRY_SEC
+		...size === void 0 ? {} : { size }
 	};
 }
 /**
@@ -1121,9 +1117,22 @@ function readEnvelope$1(value) {
 *
 * `waiting` names both numbers because they answer different questions: the
 * POSITION is how long the wait is, the SIZE is whether it is moving at all.
+*
+* IT NO LONGER PROMISES "自动重试" (removed 2026-10-22, at the maintainer's
+* request). The sentence used to end with 「约 N 秒后自动重试」, and nothing
+* retried: this plugin does not poll `/v2/chat/queue/status` and does not resend
+* (see "WHAT THIS MODULE DOES NOT DO YET" above). The only retry that ever
+* happened was the HOST's own bounded in-place retry on a 429 — two attempts,
+* 0.5s then 1s, about 1.5 seconds — which is not "N seconds" and gives up long
+* before a real queue of thousands moves.
+*
+* So the sentence now states the WAIT and leaves the next move to the reader.
+* Reporting the position stays honest and useful — knowing you are 8,777th is
+* the answer to "wait or switch" — but claiming a recovery the plugin does not
+* perform turned a diagnostic into a promise it could not keep.
 */
 function queueNoticeText(report) {
-	if (report.code === 6020) return `模型排队中：你排在第 ${report.position === void 0 ? "未知" : `${report.position}`} 位${report.size === void 0 ? "" : `，队列共 ${report.size} 个请求`}；约 ${report.retryAfterSec} 秒后自动重试`;
+	if (report.code === 6020) return `模型排队中：你排在第 ${report.position === void 0 ? "未知" : `${report.position}`} 位${report.size === void 0 ? "" : `，队列共 ${report.size} 个请求`}。请稍后重新发送这条消息，或换一个模型`;
 	if (report.code === 6021) return `模型队列已满${report.size === void 0 ? "" : `（共 ${report.size} 个请求排队）`}，现在无法排队；请稍后重试或换一个模型`;
 	return `你的排队任务已达上限${report.size === void 0 ? "" : `（共 ${report.size} 个请求排队）`}，请等待已排队请求完成后再试`;
 }
@@ -1997,6 +2006,59 @@ const MODEL_BUSY_CODE = "\"code\":14003";
 */
 const CHANNEL_REJECT_CODE = "\"code\":11128";
 /**
+* Business code for "the request exceeded the model's context window" (issue #101).
+*
+* The gateway answers `11115` in TWO shapes, and only one of them is
+* self-describing:
+*
+*   A. `prompt is too long: 100001 tokens > 100000 maximum` — carries numbers;
+*   B. the localized sentence only (「本次输入加上历史对话超过了模型上限…」), no numbers.
+*
+* Shape B is the one that hurt. The HOST decides whether to run its
+* context-overflow rescue by matching the error text against a list of ENGLISH
+* patterns (`prompt (?:is )?too long`, `exceeds the context window`,
+* `context[_ ]length[_ ]exceeded`, …25 of them), and a Chinese sentence matches
+* none of them. So on shape B the host neither compacts nor retries: the user
+* gets a bare 400 whose own advice ("请精简内容") the host cannot act on.
+*
+* {@link contextOverflowMarker} is the fix: the plugin adds an English clause
+* the host recognises, and keeps the upstream's own sentence beside it.
+*/
+/**
+* The business code, in either of the two spellings the plugin ever holds.
+*
+* Two forms are in circulation and BOTH reach this predicate:
+*   - the raw upstream body: `{"code":11115,...}`;
+*   - the reply this plugin already composed, which renders it as
+*     `（code 11115，requestId …）` — the form the retry path re-reads.
+*
+* The trailing `(?!\d)` matters: `111150` and `1111` both contain the digits
+* after a naive substring test, and misreading a DIFFERENT refusal as an
+* overflow would send the host into a compaction pass that cannot help.
+*/
+const CONTEXT_TOO_LONG_CODE = /"code"\s*:\s*11115(?!\d)|code\s+11115(?!\d)/u;
+/**
+* Whether this body is the context-length refusal, in EITHER of its shapes.
+*
+* Shape B carries no number and no English phrase, so the business code is the
+* only reliable handle — the same reasoning as {@link isChannelRejectBody}'s
+* code-plus-wording pair, except that here the wording is what VARIES.
+*/
+function isContextTooLongBody(body) {
+	return CONTEXT_TOO_LONG_CODE.test(body);
+}
+/**
+* An English clause the HOST's overflow detector recognises, for issue #101.
+*
+* `prompt is too long` is the first entry of the host's pattern list and the
+* phrasing Anthropic-compatible gateways already use, so it is the cheapest way
+* to say "this is an overflow" to a detector that only reads English. The
+* numbers are omitted deliberately: the upstream never gave them in shape B, and
+* inventing them would be the exact confident-wrong-diagnosis this plugin spends
+* its comments avoiding.
+*/
+const CONTEXT_OVERFLOW_MARKER = "prompt is too long (upstream code 11115)";
+/**
 * Wording that identifies the CHANNEL half of `11128` (the other halves being
 * `conversation id missing` and `first message is not system prompt`).
 *
@@ -5799,7 +5861,7 @@ function generationOf(version) {
 //#endregion
 //#region src/version.ts
 /** The npm package version this build was produced from. */
-const WORKBUDDY_CONNECT_VERSION = "5.0.1";
+const WORKBUDDY_CONNECT_VERSION = "5.2.2";
 //#endregion
 //#region src/host-heartbeat.ts
 /**
@@ -5957,4 +6019,4 @@ async function clearHostHeartbeat() {
 	await rm(workbuddyHostHeartbeatPath(), { force: true });
 }
 //#endregion
-export { busyDisplaySuffix as $, parseWorkBuddyAuth as A, resolveDshHome as At, isConversationIdGateBody as B, defaultDesktopAuthCandidates as C, isWorkbuddyBundle as Ct, isEncryptedCredentialError as D, readAtRestKey as Dt, hasEncryptedCredentialFields as E, openEncryptedField as Et, WorkBuddyCredentialRejectedError as F, openingEvidenceOfBody as G, isFirstMessageGateBody as H, WorkBuddyUpstreamClient as I, parseUpstreamModel as J, parseCreditMultiplier as K, classifyUpstreamError as L, workbuddyOwnAuthPath as M, writeFileAtomic as Mt, CREDENTIAL_REJECTED_CODE as N, isVaultAccountId as O, workbuddyAppExecutableCandidates as Ot, WORKBUDDY_FALLBACK_SYSTEM_PROMPT as P, attachBusyLevels as Q, declaredTools as R, authFileName as S, isEncryptedFieldWrapper as St, defaultDesktopAuthPath as T, macosNestedAppBundles as Tt, knownRegionOf as U, isCredentialRejectedError as V, modelIdOfBody as W, prepareChatBody as X, perturbChannelFingerprints as Y, regionOf as Z, ENCRYPTED_CREDENTIAL_CODE as _, deriveAtRestKey as _t, readHostHeartbeat as a, recordRefusal as at, WorkBuddyCredentialStore as b, findWorkbuddyAppExecutable as bt, WORKBUDDY_CONNECT_VERSION as c, WorkBuddyImageError as ct, FALLBACK_WORKBUDDY_MODELS_GLOBAL as d, queueNoticeText as dt, REFUSES_OFF_MODEL_IDS as et, WorkBuddyCatalog as f, NATIVE_MODALITY_BY_MODEL_ID as ft, withoutRouters as g, clearAtRestKeyCache as gt, fallbackModelsFor as h, WORKBUDDY_APP_EXECUTABLE_ENV as ht, processStartTimeMs as i, offRefused as it, workbuddyAccountId as j, withFileLock as jt, legacyWorkbuddyOwnAuthPath as k, hostPeersInfo as kt, piAiRuntimeInfo as l, pickImageModel as lt, deriveCatalog as m, nativeModalityOf as mt, clearHostHeartbeat as n, lastRefusalFor as nt, workbuddyHostHeartbeatPath as o, withEffectiveOff as ot, applyContextBudgets as p, imageDefaultFor as pt, parseReasoning as q, isHeartbeatProcessAlive as r, offDefaultFor as rt, writeHostHeartbeat as s, DEFAULT_IMAGE_SIZE as st, WORKBUDDY_HOST_HEARTBEAT_FILENAME as t, defaultOffModelIds as tt, FALLBACK_WORKBUDDY_MODELS as u, parseQueueAnswer as ut, WORKBUDDY_AUTH_FILENAME as v, deriveAtRestKeyId as vt, defaultDesktopAuthDirs as w, macosBundleExecutable as wt, WorkBuddyEncryptedCredentialError as x, findWorkbuddyAppExecutableWithSource as xt, WORKBUDDY_AUTH_FILE_ENV as y, fetchAtRestKeyPayload as yt, forceNeutralHead as z };
+export { regionOf as $, parseWorkBuddyAuth as A, workbuddyAppExecutableCandidates as At, forceNeutralHead as B, defaultDesktopAuthCandidates as C, findWorkbuddyAppExecutableWithSource as Ct, isEncryptedCredentialError as D, macosNestedAppBundles as Dt, hasEncryptedCredentialFields as E, macosBundleExecutable as Et, WORKBUDDY_FALLBACK_SYSTEM_PROMPT as F, knownRegionOf as G, isConversationIdGateBody as H, WorkBuddyCredentialRejectedError as I, parseCreditMultiplier as J, modelIdOfBody as K, WorkBuddyUpstreamClient as L, workbuddyOwnAuthPath as M, resolveDshHome as Mt, CONTEXT_OVERFLOW_MARKER as N, withFileLock as Nt, isVaultAccountId as O, openEncryptedField as Ot, CREDENTIAL_REJECTED_CODE as P, writeFileAtomic as Pt, prepareChatBody as Q, classifyUpstreamError as R, authFileName as S, findWorkbuddyAppExecutable as St, defaultDesktopAuthPath as T, isWorkbuddyBundle as Tt, isCredentialRejectedError as U, isContextTooLongBody as V, isFirstMessageGateBody as W, parseUpstreamModel as X, parseReasoning as Y, perturbChannelFingerprints as Z, ENCRYPTED_CREDENTIAL_CODE as _, WORKBUDDY_APP_EXECUTABLE_ENV as _t, readHostHeartbeat as a, offDefaultFor as at, WorkBuddyCredentialStore as b, deriveAtRestKeyId as bt, WORKBUDDY_CONNECT_VERSION as c, withEffectiveOff as ct, FALLBACK_WORKBUDDY_MODELS_GLOBAL as d, pickImageModel as dt, attachBusyLevels as et, WorkBuddyCatalog as f, parseQueueAnswer as ft, withoutRouters as g, nativeModalityOf as gt, fallbackModelsFor as h, imageDefaultFor as ht, processStartTimeMs as i, lastRefusalFor as it, workbuddyAccountId as j, hostPeersInfo as jt, legacyWorkbuddyOwnAuthPath as k, readAtRestKey as kt, piAiRuntimeInfo as l, DEFAULT_IMAGE_SIZE as lt, deriveCatalog as m, NATIVE_MODALITY_BY_MODEL_ID as mt, clearHostHeartbeat as n, REFUSES_OFF_MODEL_IDS as nt, workbuddyHostHeartbeatPath as o, offRefused as ot, applyContextBudgets as p, queueNoticeText as pt, openingEvidenceOfBody as q, isHeartbeatProcessAlive as r, defaultOffModelIds as rt, writeHostHeartbeat as s, recordRefusal as st, WORKBUDDY_HOST_HEARTBEAT_FILENAME as t, busyDisplaySuffix as tt, FALLBACK_WORKBUDDY_MODELS as u, WorkBuddyImageError as ut, WORKBUDDY_AUTH_FILENAME as v, clearAtRestKeyCache as vt, defaultDesktopAuthDirs as w, isEncryptedFieldWrapper as wt, WorkBuddyEncryptedCredentialError as x, fetchAtRestKeyPayload as xt, WORKBUDDY_AUTH_FILE_ENV as y, deriveAtRestKey as yt, declaredTools as z };

package/lib/index.d.ts

@@ -2770,6 +2770,17 @@ declare const WORKBUDDY_CHECKIN_PATH = "/plugins/dsh-connect-workbuddy/checkin";
  * browser half.
  */
 declare const WORKBUDDY_PROBE_PATH = "/plugins/dsh-connect-workbuddy/probe";
+/**
+ * Plugin-owned OUTPUT-SPEED measurement endpoint (issue #92).
+ *
+ * Separate from {@link WORKBUDDY_PROBE_PATH} because the two ask opposite
+ * questions and cost different amounts: the availability probe sends 25,000
+ * input tokens and caps output at one (measured `credit 0.72`), while this one
+ * sends ~35 input tokens and caps output at 256 (measured `credit 0.01`–`0.15`).
+ * Sharing the route would mean sharing its one-model-per-request cap and its
+ * cost wording, and the two would then be wrong for each other.
+ */
+declare const WORKBUDDY_TPS_PATH = "/plugins/dsh-connect-workbuddy/tps";
 /**
  * One entry of the transfer PREVIEW: display fields only, never token
  * material. `hasToken` is the import decision input — the import step skips
@@ -3265,6 +3276,33 @@ interface WorkBuddyWebProbeResult {
   /** Which of those four sources supplied {@link retryAtMs}. */
   retrySource?: 'retry-after' | 'upstream-message' | 'quota-refresh' | 'upstream-tips';
 }
+/**
+ * One model's output-speed result, as the card renders it (issue #92).
+ *
+ * Deliberately its own type rather than extra fields on
+ * {@link WorkBuddyWebProbeResult}: the two runs answer different questions, and
+ * a shared type would let a card render an availability verdict with a speed on
+ * it, or vice versa, with nothing to stop it.
+ */
+interface WorkBuddyWebTpsResult {
+  modelId: string;
+  /** `ok` when at least one run answered; the speed fields say what was learned. */
+  outcome: 'ok' | 'unavailable' | 'credential-rejected' | 'failed';
+  /** Median output tokens/second over the usable runs. */
+  tokensPerSecond?: number;
+  /** Median time to first content chunk, in ms. */
+  timeToFirstTokenMs?: number;
+  /** Output tokens the upstream counted for the fastest usable run. */
+  outputTokens?: number;
+  /** How many runs contributed; below the planned count when runs were lost. */
+  samples: number;
+  /** Why {@link tokensPerSecond} is absent, when it is. */
+  reason?: 'few-chunks' | 'no-usage' | 'all-failed';
+  /** Total credit the runs reported, rounded to 2dp. */
+  credit?: number;
+  /** Upstream's own words when the run failed outright. */
+  message?: string;
+}
 /** Why one account is currently out of the pool. */
 type WorkBuddyWebPoolExclusion = 'unusable' | 'rate-limited' |
 /**
@@ -3605,6 +3643,21 @@ interface WorkBuddyStatusRouteOptions {
   probeModels?(region: WorkBuddyRegion, modelIds: readonly string[], options?: {
     signal?: AbortSignal;
   }): Promise<readonly WorkBuddyWebProbeResult[]>;
+  /**
+   * Measure OUTPUT SPEED for each named model of a region (issue #92).
+   *
+   * Separate from {@link probeModels} because it answers the opposite question
+   * with the opposite request shape: tiny input, long output. The availability
+   * probe's `max_tokens: 1` means its `elapsedMs` is time-to-first-token and
+   * carries no rate information at all.
+   *
+   * Costs a fraction of a probe per model (measured `credit 0.01`–`0.15` against
+   * `0.72`), because this gateway prices by INPUT. It still spends real credit,
+   * so it stays one model per click like every other spending route.
+   */
+  measureTps?(region: WorkBuddyRegion, modelIds: readonly string[], options?: {
+    signal?: AbortSignal;
+  }): Promise<readonly WorkBuddyWebTpsResult[]>;
   /**
    * The region's next monthly quota refresh, when the upstream declares one.
    *
@@ -4263,4 +4316,4 @@ declare function legacyAttributionRegion(value: Config, accountsFor: (region: Wo
  */
 declare function apply(ctx: Context, config: Config): void;
 //#endregion
-export { CREDENTIAL_REJECTED_CODE, Config, DEFAULT_PROBE_INPUT_TOKENS, ENCRYPTED_CREDENTIAL_CODE, FALLBACK_WORKBUDDY_MODELS, FALLBACK_WORKBUDDY_MODELS_GLOBAL, NATIVE_MODALITY_BY_MODEL_ID, PROBE_INPUT_TOKEN_CHOICES, PROBE_MAX_TOKENS, PROBE_SYSTEM_PROMPT, REFUSES_OFF_MODEL_IDS, type UpstreamErrorKind, WORKBUDDY_ACCOUNTS_REFRESH_PATH, WORKBUDDY_APP_EXECUTABLE_ENV, WORKBUDDY_AUTH_FILENAME, WORKBUDDY_AUTH_FILE_ENV, WORKBUDDY_CHECKIN_PATH, WORKBUDDY_CONNECT_VERSION, WORKBUDDY_GLOBAL_PROVIDER, WORKBUDDY_HOST_HEARTBEAT_FILENAME, WORKBUDDY_MODELS_REFRESH_PATH, WORKBUDDY_PROBE_PATH, WORKBUDDY_PROVIDER, WORKBUDDY_PROVIDERS, WORKBUDDY_PROVIDER_DISPLAY_NAMES, WORKBUDDY_REGIONS, WORKBUDDY_REGION_PARAM, WORKBUDDY_SETTINGS_NS, WORKBUDDY_STREAM_IDLE_TIMEOUT_MS, WORKBUDDY_USAGE_PATH, type WorkBuddyAccountChoice, type WorkBuddyAdapter, type WorkBuddyAuthStatus, type WorkBuddyCandidateFailure, WorkBuddyCatalog, type WorkBuddyChatResult, type WorkBuddyCredential, type WorkBuddyCredentialRecovery, WorkBuddyCredentialRejectedError, WorkBuddyCredentialStore, type WorkBuddyCreditPackage, type WorkBuddyCredits, WorkBuddyEncryptedCredentialError, type WorkBuddyEncryptedField, type WorkBuddyHostHeartbeat, type WorkBuddyModelInfo, type WorkBuddyNativeModality, WorkBuddyPoolPreferences, type WorkBuddyProbeClient, type WorkBuddyProbeOutcome, type WorkBuddyProbeResult, type WorkBuddyProbeStore, type WorkBuddyReasoning, type WorkBuddyRecoveryCandidate, type WorkBuddyRefreshOutcome, WorkBuddyRegionState, type WorkBuddyShim, type WorkBuddyStatusRouteOptions, type WorkBuddyStoreOptions, WorkBuddyUpstreamClient, type WorkBuddyUpstreamModel, type WorkBuddyUsabilityProbeOptions, apply, asVolatile, authFileName, classifyUpstreamError, clearAtRestKeyCache, clearHostHeartbeat, cooldownOf, createAccountUsabilityProbe, createWorkBuddyAdapter, createWorkBuddyShim, creditOfStream, defaultDesktopAuthCandidates, defaultDesktopAuthDirs, defaultDesktopAuthPath, defaultOffModelIds, deriveAtRestKey, deriveAtRestKeyId, deriveCatalog, fallbackModelsFor, fetchAtRestKeyPayload, findWorkbuddyAppExecutable, hasEncryptedCredentialFields, imageDefaultFor, inject, isCredentialRejectedError, isEncryptedCredentialError, isEncryptedFieldWrapper, isHeartbeatProcessAlive, isWorkbuddyBundle, knownRegionOf, legacyAttributionRegion, legacyWorkbuddyOwnAuthPath, macosBundleExecutable, macosNestedAppBundles, modelIdOfBody, name, nativeModalityOf, nextRegionEnabled, nextRegionSlots, offDefaultFor, openEncryptedField, outcomeOfFailure, parseCreditMultiplier, parseReasoning, parseRetryAfter, parseUpstreamModel, parseWorkBuddyAuth, prepareChatBody, probeModel, probeRequestBody, probeSucceeded, processStartTimeMs, readAtRestKey, readHostHeartbeat, regionCleared, regionEnabled, regionEnabledOf, regionOf, regionOfProvider, regionOfStatusUrl, regionStateOf, registerWorkBuddyStatusRoute, resolveCredentialRecovery, selectAccountFor, settingsNamespaceOf, toPersistedWorkBuddyModel, unwrapVolatileDeep, withEffectiveOff, withWorkBuddyRegion, workBuddyDisplayName, workBuddyModelInput, workBuddyThinkingLevelMap, workBuddyWebStatus, workbuddyAccountId, workbuddyAppExecutableCandidates, workbuddyHostHeartbeatPath, workbuddyOwnAuthPath, writeHostHeartbeat };
+export { CREDENTIAL_REJECTED_CODE, Config, DEFAULT_PROBE_INPUT_TOKENS, ENCRYPTED_CREDENTIAL_CODE, FALLBACK_WORKBUDDY_MODELS, FALLBACK_WORKBUDDY_MODELS_GLOBAL, NATIVE_MODALITY_BY_MODEL_ID, PROBE_INPUT_TOKEN_CHOICES, PROBE_MAX_TOKENS, PROBE_SYSTEM_PROMPT, REFUSES_OFF_MODEL_IDS, type UpstreamErrorKind, WORKBUDDY_ACCOUNTS_REFRESH_PATH, WORKBUDDY_APP_EXECUTABLE_ENV, WORKBUDDY_AUTH_FILENAME, WORKBUDDY_AUTH_FILE_ENV, WORKBUDDY_CHECKIN_PATH, WORKBUDDY_CONNECT_VERSION, WORKBUDDY_GLOBAL_PROVIDER, WORKBUDDY_HOST_HEARTBEAT_FILENAME, WORKBUDDY_MODELS_REFRESH_PATH, WORKBUDDY_PROBE_PATH, WORKBUDDY_PROVIDER, WORKBUDDY_PROVIDERS, WORKBUDDY_PROVIDER_DISPLAY_NAMES, WORKBUDDY_REGIONS, WORKBUDDY_REGION_PARAM, WORKBUDDY_SETTINGS_NS, WORKBUDDY_STREAM_IDLE_TIMEOUT_MS, WORKBUDDY_TPS_PATH, WORKBUDDY_USAGE_PATH, type WorkBuddyAccountChoice, type WorkBuddyAdapter, type WorkBuddyAuthStatus, type WorkBuddyCandidateFailure, WorkBuddyCatalog, type WorkBuddyChatResult, type WorkBuddyCredential, type WorkBuddyCredentialRecovery, WorkBuddyCredentialRejectedError, WorkBuddyCredentialStore, type WorkBuddyCreditPackage, type WorkBuddyCredits, WorkBuddyEncryptedCredentialError, type WorkBuddyEncryptedField, type WorkBuddyHostHeartbeat, type WorkBuddyModelInfo, type WorkBuddyNativeModality, WorkBuddyPoolPreferences, type WorkBuddyProbeClient, type WorkBuddyProbeOutcome, type WorkBuddyProbeResult, type WorkBuddyProbeStore, type WorkBuddyReasoning, type WorkBuddyRecoveryCandidate, type WorkBuddyRefreshOutcome, WorkBuddyRegionState, type WorkBuddyShim, type WorkBuddyStatusRouteOptions, type WorkBuddyStoreOptions, WorkBuddyUpstreamClient, type WorkBuddyUpstreamModel, type WorkBuddyUsabilityProbeOptions, apply, asVolatile, authFileName, classifyUpstreamError, clearAtRestKeyCache, clearHostHeartbeat, cooldownOf, createAccountUsabilityProbe, createWorkBuddyAdapter, createWorkBuddyShim, creditOfStream, defaultDesktopAuthCandidates, defaultDesktopAuthDirs, defaultDesktopAuthPath, defaultOffModelIds, deriveAtRestKey, deriveAtRestKeyId, deriveCatalog, fallbackModelsFor, fetchAtRestKeyPayload, findWorkbuddyAppExecutable, hasEncryptedCredentialFields, imageDefaultFor, inject, isCredentialRejectedError, isEncryptedCredentialError, isEncryptedFieldWrapper, isHeartbeatProcessAlive, isWorkbuddyBundle, knownRegionOf, legacyAttributionRegion, legacyWorkbuddyOwnAuthPath, macosBundleExecutable, macosNestedAppBundles, modelIdOfBody, name, nativeModalityOf, nextRegionEnabled, nextRegionSlots, offDefaultFor, openEncryptedField, outcomeOfFailure, parseCreditMultiplier, parseReasoning, parseRetryAfter, parseUpstreamModel, parseWorkBuddyAuth, prepareChatBody, probeModel, probeRequestBody, probeSucceeded, processStartTimeMs, readAtRestKey, readHostHeartbeat, regionCleared, regionEnabled, regionEnabledOf, regionOf, regionOfProvider, regionOfStatusUrl, regionStateOf, registerWorkBuddyStatusRoute, resolveCredentialRecovery, selectAccountFor, settingsNamespaceOf, toPersistedWorkBuddyModel, unwrapVolatileDeep, withEffectiveOff, withWorkBuddyRegion, workBuddyDisplayName, workBuddyModelInput, workBuddyThinkingLevelMap, workBuddyWebStatus, workbuddyAccountId, workbuddyAppExecutableCandidates, workbuddyHostHeartbeatPath, workbuddyOwnAuthPath, writeHostHeartbeat };

package/lib/index.js

@@ -1,4 +1,4 @@
-import { $ as busyDisplaySuffix, A as parseWorkBuddyAuth, At as resolveDshHome, B as isConversationIdGateBody, C as defaultDesktopAuthCandidates, Ct as isWorkbuddyBundle, D as isEncryptedCredentialError, Dt as readAtRestKey, E as hasEncryptedCredentialFields, Et as openEncryptedField, F as WorkBuddyCredentialRejectedError, G as openingEvidenceOfBody, H as isFirstMessageGateBody, I as WorkBuddyUpstreamClient, J as parseUpstreamModel, K as parseCreditMultiplier, L as classifyUpstreamError, M as workbuddyOwnAuthPath, Mt as writeFileAtomic, N as CREDENTIAL_REJECTED_CODE, O as isVaultAccountId, Ot as workbuddyAppExecutableCandidates, P as WORKBUDDY_FALLBACK_SYSTEM_PROMPT, Q as attachBusyLevels, R as declaredTools, S as authFileName, St as isEncryptedFieldWrapper, T as defaultDesktopAuthPath, Tt as macosNestedAppBundles, U as knownRegionOf, V as isCredentialRejectedError, W as modelIdOfBody, X as prepareChatBody, Y as perturbChannelFingerprints, Z as regionOf, _ as ENCRYPTED_CREDENTIAL_CODE, _t as deriveAtRestKey, a as readHostHeartbeat, at as recordRefusal, b as WorkBuddyCredentialStore, bt as findWorkbuddyAppExecutable, c as WORKBUDDY_CONNECT_VERSION, ct as WorkBuddyImageError, d as FALLBACK_WORKBUDDY_MODELS_GLOBAL, dt as queueNoticeText, et as REFUSES_OFF_MODEL_IDS, f as WorkBuddyCatalog, ft as NATIVE_MODALITY_BY_MODEL_ID, g as withoutRouters, gt as clearAtRestKeyCache, h as fallbackModelsFor, ht as WORKBUDDY_APP_EXECUTABLE_ENV, i as processStartTimeMs, it as offRefused, j as workbuddyAccountId, jt as withFileLock, k as legacyWorkbuddyOwnAuthPath, l as piAiRuntimeInfo, lt as pickImageModel, m as deriveCatalog, mt as nativeModalityOf, n as clearHostHeartbeat, nt as lastRefusalFor, o as workbuddyHostHeartbeatPath, ot as withEffectiveOff, p as applyContextBudgets, pt as imageDefaultFor, q as parseReasoning, r as isHeartbeatProcessAlive, rt as offDefaultFor, s as writeHostHeartbeat, st as DEFAULT_IMAGE_SIZE, t as WORKBUDDY_HOST_HEARTBEAT_FILENAME, tt as defaultOffModelIds, u as FALLBACK_WORKBUDDY_MODELS, ut as parseQueueAnswer, v as WORKBUDDY_AUTH_FILENAME, vt as deriveAtRestKeyId, w as defaultDesktopAuthDirs, wt as macosBundleExecutable, x as WorkBuddyEncryptedCredentialError, y as WORKBUDDY_AUTH_FILE_ENV, yt as fetchAtRestKeyPayload, z as forceNeutralHead } from "./host-heartbeat-DtMzOwZr.js";
+import { $ as regionOf, A as parseWorkBuddyAuth, At as workbuddyAppExecutableCandidates, B as forceNeutralHead, C as defaultDesktopAuthCandidates, D as isEncryptedCredentialError, Dt as macosNestedAppBundles, E as hasEncryptedCredentialFields, Et as macosBundleExecutable, F as WORKBUDDY_FALLBACK_SYSTEM_PROMPT, G as knownRegionOf, H as isConversationIdGateBody, I as WorkBuddyCredentialRejectedError, J as parseCreditMultiplier, K as modelIdOfBody, L as WorkBuddyUpstreamClient, M as workbuddyOwnAuthPath, Mt as resolveDshHome, N as CONTEXT_OVERFLOW_MARKER, Nt as withFileLock, O as isVaultAccountId, Ot as openEncryptedField, P as CREDENTIAL_REJECTED_CODE, Pt as writeFileAtomic, Q as prepareChatBody, R as classifyUpstreamError, S as authFileName, St as findWorkbuddyAppExecutable, T as defaultDesktopAuthPath, Tt as isWorkbuddyBundle, U as isCredentialRejectedError, V as isContextTooLongBody, W as isFirstMessageGateBody, X as parseUpstreamModel, Y as parseReasoning, Z as perturbChannelFingerprints, _ as ENCRYPTED_CREDENTIAL_CODE, _t as WORKBUDDY_APP_EXECUTABLE_ENV, a as readHostHeartbeat, at as offDefaultFor, b as WorkBuddyCredentialStore, bt as deriveAtRestKeyId, c as WORKBUDDY_CONNECT_VERSION, ct as withEffectiveOff, d as FALLBACK_WORKBUDDY_MODELS_GLOBAL, dt as pickImageModel, et as attachBusyLevels, f as WorkBuddyCatalog, ft as parseQueueAnswer, g as withoutRouters, gt as nativeModalityOf, h as fallbackModelsFor, ht as imageDefaultFor, i as processStartTimeMs, it as lastRefusalFor, j as workbuddyAccountId, k as legacyWorkbuddyOwnAuthPath, kt as readAtRestKey, l as piAiRuntimeInfo, lt as DEFAULT_IMAGE_SIZE, m as deriveCatalog, mt as NATIVE_MODALITY_BY_MODEL_ID, n as clearHostHeartbeat, nt as REFUSES_OFF_MODEL_IDS, o as workbuddyHostHeartbeatPath, ot as offRefused, p as applyContextBudgets, pt as queueNoticeText, q as openingEvidenceOfBody, r as isHeartbeatProcessAlive, rt as defaultOffModelIds, s as writeHostHeartbeat, st as recordRefusal, t as WORKBUDDY_HOST_HEARTBEAT_FILENAME, tt as busyDisplaySuffix, u as FALLBACK_WORKBUDDY_MODELS, ut as WorkBuddyImageError, v as WORKBUDDY_AUTH_FILENAME, vt as clearAtRestKeyCache, w as defaultDesktopAuthDirs, wt as isEncryptedFieldWrapper, x as WorkBuddyEncryptedCredentialError, xt as fetchAtRestKeyPayload, y as WORKBUDDY_AUTH_FILE_ENV, yt as deriveAtRestKey, z as declaredTools } from "./host-heartbeat-r1M_OXJI.js";
 import z from "@deepseek-ai/schemastery";
 import { appendFile, mkdir, readFile, writeFile } from "node:fs/promises";
 import { randomBytes, randomUUID, timingSafeEqual } from "node:crypto";
@@ -589,16 +589,80 @@ function foldModernContext(context) {
 function transcript(context) {
 	return context;
 }
-function withLegacyContext(api, generation) {
+/**
+* Rewrite every historical assistant message to the identity this adapter stamps.
+*
+* ISSUE #102. pi-ai replays a thinking block as `thinking` only when the message
+* that produced it names the same `provider` / `api` / `model` as the request in
+* flight (`utils/transform-messages.js`, the `isSameModel` branch); everything
+* else is flattened to `{type:'text', text: thinking}`.
+*
+* The durable transcript the HOST hands back does not carry the identity. The
+* agent loop writes `source.provider = request.provider`, and `request.provider`
+* is the ROUTE id (`workbuddy` / `workbuddy-global`), while this adapter stamps
+* `provider: WORKBUDDY_MODEL_IDENTITY` on the model. So:
+*
+*   - CN sessions survive by COINCIDENCE: its route id happens to equal the
+*     identity (`workbuddy` === `workbuddy`).
+*   - GLOBAL sessions never match (`workbuddy-global` !== `workbuddy`), so every
+*     historical thinking block is downgraded on EVERY turn — not only when the
+*     user switches regions, which is what #59's write-up assumed.
+*
+* The model then sees a context in which all of its own past reasoning was
+* plain assistant text, and writes its new reasoning into `text` to match. That
+* is the reported symptom: reasoning collapses to a character or two while the
+* answer channel fills with working notes.
+*
+* WHY REWRITING IS SAFE. Every message here was produced by THIS plugin, in THIS
+* region — the transcript never contains another provider's assistant turns
+* (`dsh-llm` splits history by provider before the API sees it). The identity is
+* already the field this adapter stamps on the models it serves, and it resolves
+* as a registry key in both regions (issue #75). Nothing about routing, billing
+* or the destination changes: `baseUrl` comes from the model, not from the
+* message.
+*
+* Only `provider` is rewritten. `api` is left alone on purpose: a legacy
+* (`dsh-foreign`) message carries an api this plugin never sends, and claiming
+* `openai-completions` for it would assert a wire shape that message was never
+* built for. The `provider` mismatch is what decides the downgrade, and fixing
+* it is enough — `isSameModel` still requires the model id and api to match, so
+* a genuinely different model keeps degrading (covered by a test).
+*
+* Returns the same object when nothing changed, so the common case (an
+* already-normalized transcript) allocates nothing.
+*/
+function alignAssistantIdentities(context, identity = WORKBUDDY_MODEL_IDENTITY) {
+	const messages = context.messages;
+	if (!Array.isArray(messages) || messages.length === 0) return context;
+	let changed = false;
+	const next = messages.map((message) => {
+		if (typeof message !== "object" || message === null) return message;
+		const record = message;
+		if (record["role"] !== "assistant") return message;
+		if (record["provider"] === identity) return message;
+		changed = true;
+		return {
+			...record,
+			provider: identity
+		};
+	});
+	return changed ? {
+		...context,
+		messages: next
+	} : context;
+}
+function withLegacyContext(api, generation, identity = WORKBUDDY_MODEL_IDENTITY) {
+	/** One place so both branches and both entry points agree on the order. */
+	const prepare = (context) => alignAssistantIdentities(generation === "modern" ? foldModernContext(context) : adaptLegacyPiAiContext(context), identity);
 	if (generation === "modern") return {
 		...api,
-		stream: (model, context, options) => api.stream(model, transcript(foldModernContext(context)), options),
-		streamSimple: (model, context, options) => api.streamSimple(model, transcript(foldModernContext(context)), options)
+		stream: (model, context, options) => api.stream(model, transcript(prepare(context)), options),
+		streamSimple: (model, context, options) => api.streamSimple(model, transcript(prepare(context)), options)
 	};
 	return {
 		...api,
-		stream: (model, context, options) => api.stream(model, transcript(adaptLegacyPiAiContext(context)), options),
-		streamSimple: (model, context, options) => api.streamSimple(model, transcript(adaptLegacyPiAiContext(context)), options)
+		stream: (model, context, options) => api.stream(model, transcript(prepare(context)), options),
+		streamSimple: (model, context, options) => api.streamSimple(model, transcript(prepare(context)), options)
 	};
 }
 /**
@@ -776,7 +840,7 @@ function createWorkBuddyAdapter(options) {
 				}
 			} },
 			models: buildModels(),
-			api: withContextRescue(withLegacyContext(openAICompletionsApi(), generation), options.resolveContextRescue)
+			api: withContextRescue(withLegacyContext(openAICompletionsApi(), generation, modelIdentity), options.resolveContextRescue)
 		}),
 		getModels: () => buildModels()
 	};
@@ -2370,11 +2434,12 @@ const KIND_HOST_CODE = { soft_rate: "quota_exceeded" };
 function hostErrorCode(kind) {
 	return KIND_HOST_CODE[kind] ?? kind;
 }
-function writeJson(res, status, body) {
+function writeJson(res, status, body, headers) {
 	const payload = JSON.stringify(body);
 	res.writeHead(status, {
 		"Content-Type": "application/json",
-		"Content-Length": Buffer.byteLength(payload)
+		"Content-Length": Buffer.byteLength(payload),
+		...headers
 	});
 	res.end(payload);
 }
@@ -2386,13 +2451,38 @@ function writeJson(res, status, body) {
 * must not be disguised as one. The upstream failure path passes an explicit
 * `code` so the host classifies it correctly — see {@link KIND_HOST_CODE}.
 */
-function writeOpenAIError(res, status, kind, message, code) {
+function writeOpenAIError(res, status, kind, message, code, headers) {
 	writeJson(res, status, { error: {
 		message,
 		type: kind,
 		code: code ?? kind
-	} });
+	} }, headers);
 }
+/**
+* Tell every retrying client NOT to retry this failure (2026-10-22, at the
+* maintainer's request: the queue's automatic retry is removed).
+*
+* `x-should-retry` is a non-standard header that both clients in this stack
+* check BEFORE their status-based rules — the pinned OpenAI SDK's `shouldRetry`
+* and pi-ai's `isRetryableProviderError` each return false on "false".
+*
+* WHY THE QUEUE MUST NOT BE RETRIED. Without this header a 429 is retried by
+* construction: `@deepseek-ai/dsh-llm` maps status 429 to the `RATE_LIMIT` code
+* and `RATE_LIMIT` is in `DEFAULT_RETRYABLE_CODES`, so the HOST runs five
+* in-place attempts with 0.5s→8s backoff. Measured, that budget totals roughly
+* 15 seconds — against a queue the upstream reports in thousands. Every one of
+* those attempts is a real request spent to be told the same position again, and
+* none of them can clear the queue.
+*
+* So the queue is now reported ONCE, with the position intact, and the reader
+* decides whether to resend or switch models. That is exactly what
+* {@link queueNoticeText} tells them to do — the two changes are one decision: a
+* diagnostic that declares itself final must actually be final.
+*/
+const NO_RETRY_HEADERS = Object.freeze({
+	"x-should-retry": "false",
+	"retry-after": "0"
+});
 /** Read a request body with a size cap; over-limit bodies fail the request. */
 function readBody(req) {
 	return new Promise((resolve, reject) => {
@@ -3193,6 +3283,34 @@ function createWorkBuddyShim(options) {
 	const onRequestBody = options.onRequestBody;
 	const onUpstreamUsage = options.onUpstreamUsage;
 	const SHARED_SECRET = randomBytes(32).toString("base64url");
+	/**
+	* Whether this process's prompts have been PROVEN to need the invisible
+	* perturbation before the gateway will accept them.
+	*
+	* WHY THIS EXISTS (measured 2026-10-22). The retry ladder below is
+	* discover-by-failing: a request goes out unmodified, is refused with `11128`,
+	* and the ladder re-sends a perturbed copy. That is correct the first time and
+	* wasteful every time after — the prompt SHAPE that carries a fingerprinted
+	* substring does not change between turns of a session, so the plugin was
+	* paying one refused request (~209ms measured) on EVERY request, forever.
+	*
+	* So once the perturbation is what made a request succeed, the next request
+	* starts from the perturbed form and skips the doomed first attempt. The
+	* saving is one round trip plus one refused request per turn.
+	*
+	* WHY A PROCESS-LOCAL FLAG AND NOT A CONFIG. The gateway's fingerprint list is
+	* a snapshot the upstream can change at any time, in either direction: a rule
+	* can be withdrawn as easily as added. A persisted flag would therefore
+	* outlive the condition that justified it and could keep perturbing prompts a
+	* gateway no longer objects to. In memory it is forgotten at restart, which is
+	* the natural expiry for "what this gateway refused recently".
+	*
+	* AND IT SELF-CORRECTS. If a perturbed body is EVER refused with the channel
+	* gate, the flag is cleared and the request falls back to the plain ladder —
+	* so a withdrawn rule, or a different model behind the same gateway, cannot
+	* leave the plugin stuck sending a shape that no longer helps.
+	*/
+	let channelNeedsPerturbation = false;
 	/** Constant-time bearer check; absent or mismatched bearers are rejected. */
 	function bearerOk(req) {
 		const header = req.headers.authorization;
@@ -3326,7 +3444,25 @@ function createWorkBuddyShim(options) {
 		}
 		const controller = new AbortController();
 		res.on("close", () => controller.abort());
-		let result = await client.chatStream(credential, prepared, controller.signal);
+		/**
+		* The body to send FIRST, which is the perturbed form once this process has
+		* proven the gateway demands it.
+		*
+		* `perturbChannelFingerprints` is consulted only when the flag is set, so a
+		* fresh process still pays the plain attempt — that is what discovers
+		* whether the gate is on at all (see `channelNeedsPerturbation`).
+		*
+		* The perturbed form is a purely additive transform: it inserts zero-width
+		* spaces and changes no word the model reads, so starting from it is not a
+		* behaviour change, only a saved round trip.
+		*/
+		const preferred = channelNeedsPerturbation ? perturbChannelFingerprints(prepared) ?? prepared : prepared;
+		let result = await client.chatStream(credential, preferred, controller.signal);
+		if (channelNeedsPerturbation && !result.ok && result.kind === "channel_reject") {
+			channelNeedsPerturbation = false;
+			logger?.warn("dsh-connect-workbuddy: a perturbed body was refused too; clearing the learned preference and retrying from the plain form");
+			result = await client.chatStream(credential, prepared, controller.signal);
+		}
 		/**
 		* The retry ladder that does not depend on knowing the fingerprint
 		* (issue #98, both halves).
@@ -3374,6 +3510,7 @@ function createWorkBuddyShim(options) {
 					logger?.warn("dsh-connect-workbuddy: the channel gate refused the body again; retrying once with an invisible perturbation of the scanned text");
 					result = await client.chatStream(credential, rescued, controller.signal);
 					retriedWithPerturbation = true;
+					if (result.ok) channelNeedsPerturbation = true;
 				}
 			}
 		}
@@ -3459,7 +3596,7 @@ function createWorkBuddyShim(options) {
 			if (refusedReport !== void 0) reportRefusedTier(refusedReport);
 			const queue = result.kind === "model_queue" ? parseQueueAnswer(result.message) : void 0;
 			if (queue !== void 0) {
-				writeOpenAIError(res, 429, "model_queue", `${queueNoticeText(queue)}（上游 code ${queue.code}）${note}`);
+				writeOpenAIError(res, 429, "model_queue", `${queueNoticeText(queue)}（上游 code ${queue.code}）${note}`, void 0, NO_RETRY_HEADERS);
 				return;
 			}
 			if (result.kind === "policy_reject") {
@@ -3506,7 +3643,8 @@ function createWorkBuddyShim(options) {
 			const refusedTier = reasoningTierRefusal(result);
 			const receipt = refusedTier ?? detail?.tips ?? detail?.displayMsg ?? clippedUpstreamText(result.message, 400);
 			const advice = refusedTier !== void 0 ? "这不是账号或网络问题：该模型实测拒绝「off」推理档位，请到模型卡片里取消该行的「可关闭思考」勾选后重试" : result.kind === "client" ? "该请求被上游按参数拒绝：与网络、账号、额度都无关，换账号也不会改变结果，请按上面的提示调整后重试" : shortfall === void 0 ? "" : "建议换一个模型继续，或稍后等待该账号的额度恢复";
-			const body = siblingGate !== void 0 ? siblingGate : advice === "" ? receipt : `${receipt.replace(/[。.]$/u, "")}。${advice}`;
+			const overflow = isContextTooLongBody(result.message) ? `${CONTEXT_OVERFLOW_MARKER}。` : "";
+			const body = siblingGate !== void 0 ? siblingGate : `${overflow}${advice === "" ? receipt : `${receipt.replace(/[。.]$/u, "")}。${advice}`}`;
 			writeOpenAIError(res, KIND_STATUS[result.kind], result.kind, `workbuddy 上游失败：${failoverReasonText(result)}（http ${result.status}）${note}${why}${stamp}。${body}`, hostErrorCode(result.kind));
 			return;
 		}
@@ -4206,6 +4344,199 @@ async function probeModel(input) {
 	};
 }
 /**
+* Smallest spacing between content chunks, in milliseconds, that still counts
+* as generation.
+*
+* Guards the divide-by-zero case where a fast model delivers every token in a
+* single burst: `chunks === 1` means the stream told us nothing about the RATE,
+* and the run reports no speed rather than an invented one. The same applies
+* when the first and last content chunk land in the same millisecond.
+*/
+const MIN_GENERATION_MS = 1;
+/** Build the request body for one speed run. */
+function tpsProbeRequestBody(modelId) {
+	return JSON.stringify({
+		model: modelId,
+		messages: [{
+			role: "system",
+			content: "You are a throughput benchmark. Output a long, uninterrupted sequence of short words separated by spaces. No preamble, no explanation, no code block."
+		}, {
+			role: "user",
+			content: "List the numbers from 1 to 400 in words, separated by single spaces."
+		}],
+		max_tokens: 256,
+		...OFF_REASONING_FIELDS,
+		stream: true
+	});
+}
+/**
+* Ask for the lowest reasoning effort available.
+*
+* A reasoning model asked to count spends its `max_tokens` inside the reasoning
+* channel; the stream then carries thinking deltas and little or no content, and
+* timing it would measure the wrong thing. `none` is the widest supported
+* spelling; gateways that do not know it ignore the field (measured: the CN
+* gateway answers 200 with it).
+*/
+const OFF_REASONING_FIELDS = { reasoning_effort: "none" };
+/**
+* Read one SSE stream INCREMENTALLY, timing each content deltas arrival.
+*
+* The incremental read is the measurement. `response.text()` buffers the whole
+* body and hands it over once, which erases the only signal a throughput number
+* is made of: the interval between the first and last content chunk. A version of
+* this file that parsed a buffered string reported the PARSING time, not the
+* generation time, and looked entirely plausible — which is why the reader takes
+* the response body and not a string.
+*
+* Only `choices[0].delta.content` is timed. A reasoning delta is not output:
+* counting it would report a reasoning model as fast because it produced a lot of
+* private thinking, and reasoning models are precisely the ones where the
+* distinction matters.
+*
+* `startedAt` is the caller's clock reading taken BEFORE the request went out.
+* Defaulting it to "now" would turn time-to-first-token into "time to start
+* reading" — a plausible-looking number wrong by the whole connect+TTFB.
+*
+* Never throws on a malformed frame: the upstream is allowed to send comments,
+* blank lines and `[DONE]`, and a stream that ends early still reports what it
+* timed.
+*/
+async function readTimedStream(body, startedAt) {
+	const reader = body.getReader();
+	const decoder = new TextDecoder();
+	let pending = "";
+	let firstAt;
+	let lastAt;
+	let usage;
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			const arrival = Date.now();
+			pending += decoder.decode(value, { stream: true });
+			const lines = pending.split("\n");
+			pending = lines.pop() ?? "";
+			for (const line of lines) {
+				const reading = timingsOfLine(line, arrival);
+				if (reading.usage !== void 0) usage = reading.usage;
+				if (reading.content !== void 0) {
+					if (firstAt === void 0) firstAt = arrival;
+					lastAt = arrival;
+				}
+			}
+		}
+	} catch {} finally {
+		reader.cancel().catch(() => {});
+	}
+	const outputTokens = typeof usage?.["completion_tokens"] === "number" ? usage["completion_tokens"] : void 0;
+	const credit = typeof usage?.["credit"] === "number" ? usage["credit"] : void 0;
+	return {
+		...outputTokens === void 0 ? {} : { outputTokens },
+		...firstAt === void 0 ? {} : { firstContentMs: firstAt - startedAt },
+		...firstAt === void 0 || lastAt === void 0 ? {} : { generationMs: lastAt - firstAt },
+		...credit === void 0 ? {} : { credit }
+	};
+}
+/**
+* What one SSE line says: whether it carried content, and any usage frame.
+*
+* Split out so the frame grammar is testable without a stream. The `arrival`
+* timestamp is threaded in by the reader, because a parser that read the clock
+* itself would be timing the parse, not the arrival.
+*/
+function timingsOfLine(line, _arrival) {
+	if (!line.startsWith("data:")) return {};
+	const payload = line.slice(5).trim();
+	if (payload === "" || payload === "[DONE]") return {};
+	let frame;
+	try {
+		frame = JSON.parse(payload);
+	} catch {
+		return {};
+	}
+	if (typeof frame !== "object" || frame === null || Array.isArray(frame)) return {};
+	const record = frame;
+	const usageField = record["usage"];
+	const usage = typeof usageField === "object" && usageField !== null && !Array.isArray(usageField) ? usageField : void 0;
+	const choices = record["choices"];
+	const first = Array.isArray(choices) ? choices[0] : void 0;
+	const delta = typeof first === "object" && first !== null ? first["delta"] : void 0;
+	const content = typeof delta === "object" && delta !== null ? delta["content"] : void 0;
+	return {
+		...typeof content === "string" && content !== "" ? { content } : {},
+		...usage === void 0 ? {} : { usage }
+	};
+}
+/** The middle value; undefined for an empty list. */
+function median(values) {
+	if (values.length === 0) return void 0;
+	const sorted = [...values].sort((a, b) => a - b);
+	const middle = Math.floor(sorted.length / 2);
+	return sorted.length % 2 === 1 ? sorted[middle] : Math.round((sorted[middle - 1] + sorted[middle]) / 2);
+}
+/**
+* Reduce several run readings to one sample.
+*
+* The median per quantity is taken SEPARATELY rather than picking one "winner"
+* run: a run whose stream was truncated may still have timed its first chunk
+* honestly, and throwing that away would lose information for no reason. A
+* quantity with no usable reading is omitted, never filled in.
+*/
+function summarizeTps(modelId, runs, attempted) {
+	const complete = runs.length === attempted && attempted > 0;
+	const speeds = [];
+	const firsts = [];
+	let outputTokens;
+	let credit;
+	for (const run of runs) {
+		if (run.firstContentMs !== void 0) firsts.push(run.firstContentMs);
+		if (run.generationMs !== void 0 && run.generationMs >= MIN_GENERATION_MS && run.outputTokens !== void 0 && run.outputTokens > 0) speeds.push(run.outputTokens / (run.generationMs / 1e3));
+		if (run.outputTokens !== void 0) outputTokens = run.outputTokens;
+		if (run.credit !== void 0) credit = (credit ?? 0) + run.credit;
+	}
+	const tokensPerSecond = median(speeds.map((speed) => Math.round(speed)));
+	const reason = tokensPerSecond !== void 0 ? void 0 : runs.length === 0 ? "all-failed" : outputTokens === void 0 ? "no-usage" : "few-chunks";
+	return {
+		modelId,
+		...tokensPerSecond === void 0 ? {} : { tokensPerSecond },
+		...outputTokens === void 0 ? {} : { outputTokens },
+		...median(firsts) === void 0 ? {} : { timeToFirstTokenMs: median(firsts) },
+		samples: runs.length,
+		...credit === void 0 ? {} : { credit: Math.round(credit * 100) / 100 },
+		complete,
+		...reason === void 0 ? {} : { reason }
+	};
+}
+/**
+* Measure one model's output speed.
+*
+* Runs {@link TPS_PROBE_RUNS} times and takes per-quantity medians (see
+* {@link summarizeTps} for why a median and not a mean). A failed run is dropped
+* rather than counted as zero — a model that answered twice at 400 tok/s did not
+* get slower because the third request timed out — but the sample count records
+* the shortfall so the card can say "n/3".
+*
+* Never throws: this is a diagnostic the user asked for, and a dead model must
+* produce a result row, not an exception.
+*/
+async function measureTps(input) {
+	const runs = input.runs ?? 3;
+	const readings = [];
+	for (let index = 0; index < runs; index++) {
+		if (input.signal?.aborted === true) break;
+		const startedAt = Date.now();
+		try {
+			const answer = await input.client.probeChat(input.credential, tpsProbeRequestBody(input.modelId), input.signal);
+			if (!answer.ok || answer.response === void 0) continue;
+			readings.push(await readTimedStream(answer.response.body, startedAt));
+		} catch {
+			continue;
+		}
+	}
+	return summarizeTps(input.modelId, readings, runs);
+}
+/**
 * Check in every account, one at a time.
 *
 * Idempotent by design (see the module note): an account already checked in
@@ -5372,6 +5703,17 @@ const WORKBUDDY_CHECKIN_PATH = "/plugins/dsh-connect-workbuddy/checkin";
 */
 const WORKBUDDY_PROBE_PATH = "/plugins/dsh-connect-workbuddy/probe";
 /**
+* Plugin-owned OUTPUT-SPEED measurement endpoint (issue #92).
+*
+* Separate from {@link WORKBUDDY_PROBE_PATH} because the two ask opposite
+* questions and cost different amounts: the availability probe sends 25,000
+* input tokens and caps output at one (measured `credit 0.72`), while this one
+* sends ~35 input tokens and caps output at 256 (measured `credit 0.01`–`0.15`).
+* Sharing the route would mean sharing its one-model-per-request cap and its
+* cost wording, and the two would then be wrong for each other.
+*/
+const WORKBUDDY_TPS_PATH = "/plugins/dsh-connect-workbuddy/tps";
+/**
 * Plugin-owned account-pool endpoint: one batch action per call.
 *
 * `?action=checkin` claims the daily reward for every account of a region;
@@ -6227,6 +6569,28 @@ function registerWorkBuddyStatusRoute(ctx, deps) {
 				}
 			}
 		});
+		const disposeTps = ctx.webServer.register({
+			kind: "exact",
+			path: WORKBUDDY_TPS_PATH,
+			handler: async (req, res) => {
+				if (req.method !== "POST") return json(res, 405, { error: "method not allowed" });
+				if (!loopbackOrigin(req)) return json(res, 403, { error: "origin-not-trusted" });
+				if (deps.measureTps === void 0) return json(res, 503, { error: "tps measurement unavailable" });
+				const region = requestRegion(req, res);
+				if (region === void 0) return;
+				try {
+					const body = await readJsonBody(req);
+					const modelIds = Array.isArray(body.modelIds) ? body.modelIds.filter((id) => typeof id === "string" && id !== "") : [];
+					if (modelIds.length === 0) return json(res, 400, { error: "modelIds must be a non-empty array of strings" });
+					if (modelIds.length > 1) return json(res, 400, { error: "a tps measurement accepts exactly one model" });
+					const results = [];
+					for (const modelId of modelIds) results.push(...await deps.measureTps(region, [modelId]));
+					json(res, 200, { results });
+				} catch (error) {
+					json(res, 500, { error: safeMessage(error) });
+				}
+			}
+		});
 		const disposePool = ctx.webServer.register({
 			kind: "exact",
 			path: WORKBUDDY_POOL_PATH,
@@ -6502,6 +6866,7 @@ function registerWorkBuddyStatusRoute(ctx, deps) {
 			disposeUsage();
 			disposeAccountCredits();
 			disposeProbe();
+			disposeTps();
 			disposePool();
 			disposeOAuth();
 			disposeTransfer();
@@ -7152,6 +7517,51 @@ function apply(ctx, config) {
 			}));
 			return results;
 		},
+		/**
+		* Output-speed measurement (issue #92), region-scoped like every other
+		* spending path.
+		*
+		* Deliberately NOT routed through the probe's failover machinery: a speed
+		* number describes the MODEL, and having the pool silently serve the run
+		* from a different account would attach one account's rate limit (6004) to
+		* another's measurement. The selected credential runs all three samples, so
+		* "it failed" means this account could not measure it, which is the honest
+		* answer.
+		*/
+		async measureTps(region, modelIds, options) {
+			let credential;
+			try {
+				credential = await stacks[region].store.resolve();
+			} catch (error) {
+				const message = error instanceof Error ? error.message.slice(0, 300) : String(error).slice(0, 300);
+				return modelIds.map((modelId) => ({
+					modelId,
+					outcome: "credential-rejected",
+					samples: 0,
+					message
+				}));
+			}
+			const results = [];
+			for (const modelId of modelIds) {
+				const sample = await measureTps({
+					client,
+					credential,
+					modelId,
+					...options?.signal === void 0 ? {} : { signal: options.signal }
+				});
+				results.push({
+					modelId: sample.modelId,
+					outcome: sample.tokensPerSecond === void 0 ? "failed" : "ok",
+					...sample.tokensPerSecond === void 0 ? {} : { tokensPerSecond: sample.tokensPerSecond },
+					...sample.timeToFirstTokenMs === void 0 ? {} : { timeToFirstTokenMs: sample.timeToFirstTokenMs },
+					...sample.outputTokens === void 0 ? {} : { outputTokens: sample.outputTokens },
+					samples: sample.samples,
+					...sample.reason === void 0 ? {} : { reason: sample.reason },
+					...sample.credit === void 0 ? {} : { credit: sample.credit }
+				});
+			}
+			return results;
+		},
 		regionUsable(region, usable) {
 			if (stacks[region].catalog.setRegionUsable(usable)) invalidateCatalog();
 		},
@@ -8017,4 +8427,4 @@ function apply(ctx, config) {
 	});
 }
 //#endregion
-export { CREDENTIAL_REJECTED_CODE, Config, DEFAULT_PROBE_INPUT_TOKENS, ENCRYPTED_CREDENTIAL_CODE, FALLBACK_WORKBUDDY_MODELS, FALLBACK_WORKBUDDY_MODELS_GLOBAL, NATIVE_MODALITY_BY_MODEL_ID, PROBE_INPUT_TOKEN_CHOICES, PROBE_MAX_TOKENS, PROBE_SYSTEM_PROMPT, REFUSES_OFF_MODEL_IDS, WORKBUDDY_ACCOUNTS_REFRESH_PATH, WORKBUDDY_APP_EXECUTABLE_ENV, WORKBUDDY_AUTH_FILENAME, WORKBUDDY_AUTH_FILE_ENV, WORKBUDDY_CHECKIN_PATH, WORKBUDDY_CONNECT_VERSION, WORKBUDDY_GLOBAL_PROVIDER, WORKBUDDY_HOST_HEARTBEAT_FILENAME, WORKBUDDY_MODELS_REFRESH_PATH, WORKBUDDY_PROBE_PATH, WORKBUDDY_PROVIDER, WORKBUDDY_PROVIDERS, WORKBUDDY_PROVIDER_DISPLAY_NAMES, WORKBUDDY_REGIONS, WORKBUDDY_REGION_PARAM, WORKBUDDY_SETTINGS_NS, WORKBUDDY_STREAM_IDLE_TIMEOUT_MS, WORKBUDDY_USAGE_PATH, WorkBuddyCatalog, WorkBuddyCredentialRejectedError, WorkBuddyCredentialStore, WorkBuddyEncryptedCredentialError, WorkBuddyUpstreamClient, apply, asVolatile, authFileName, classifyUpstreamError, clearAtRestKeyCache, clearHostHeartbeat, cooldownOf, createAccountUsabilityProbe, createWorkBuddyAdapter, createWorkBuddyShim, creditOfStream, defaultDesktopAuthCandidates, defaultDesktopAuthDirs, defaultDesktopAuthPath, defaultOffModelIds, deriveAtRestKey, deriveAtRestKeyId, deriveCatalog, fallbackModelsFor, fetchAtRestKeyPayload, findWorkbuddyAppExecutable, hasEncryptedCredentialFields, imageDefaultFor, inject, isCredentialRejectedError, isEncryptedCredentialError, isEncryptedFieldWrapper, isHeartbeatProcessAlive, isWorkbuddyBundle, knownRegionOf, legacyAttributionRegion, legacyWorkbuddyOwnAuthPath, macosBundleExecutable, macosNestedAppBundles, modelIdOfBody, name, nativeModalityOf, nextRegionEnabled, nextRegionSlots, offDefaultFor, openEncryptedField, outcomeOfFailure, parseCreditMultiplier, parseReasoning, parseRetryAfter, parseUpstreamModel, parseWorkBuddyAuth, prepareChatBody, probeModel, probeRequestBody, probeSucceeded, processStartTimeMs, readAtRestKey, readHostHeartbeat, regionCleared, regionEnabled, regionEnabledOf, regionOf, regionOfProvider, regionOfStatusUrl, regionStateOf, registerWorkBuddyStatusRoute, resolveCredentialRecovery, selectAccountFor, settingsNamespaceOf, toPersistedWorkBuddyModel, unwrapVolatileDeep, withEffectiveOff, withWorkBuddyRegion, workBuddyDisplayName, workBuddyModelInput, workBuddyThinkingLevelMap, workBuddyWebStatus, workbuddyAccountId, workbuddyAppExecutableCandidates, workbuddyHostHeartbeatPath, workbuddyOwnAuthPath, writeHostHeartbeat };
+export { CREDENTIAL_REJECTED_CODE, Config, DEFAULT_PROBE_INPUT_TOKENS, ENCRYPTED_CREDENTIAL_CODE, FALLBACK_WORKBUDDY_MODELS, FALLBACK_WORKBUDDY_MODELS_GLOBAL, NATIVE_MODALITY_BY_MODEL_ID, PROBE_INPUT_TOKEN_CHOICES, PROBE_MAX_TOKENS, PROBE_SYSTEM_PROMPT, REFUSES_OFF_MODEL_IDS, WORKBUDDY_ACCOUNTS_REFRESH_PATH, WORKBUDDY_APP_EXECUTABLE_ENV, WORKBUDDY_AUTH_FILENAME, WORKBUDDY_AUTH_FILE_ENV, WORKBUDDY_CHECKIN_PATH, WORKBUDDY_CONNECT_VERSION, WORKBUDDY_GLOBAL_PROVIDER, WORKBUDDY_HOST_HEARTBEAT_FILENAME, WORKBUDDY_MODELS_REFRESH_PATH, WORKBUDDY_PROBE_PATH, WORKBUDDY_PROVIDER, WORKBUDDY_PROVIDERS, WORKBUDDY_PROVIDER_DISPLAY_NAMES, WORKBUDDY_REGIONS, WORKBUDDY_REGION_PARAM, WORKBUDDY_SETTINGS_NS, WORKBUDDY_STREAM_IDLE_TIMEOUT_MS, WORKBUDDY_TPS_PATH, WORKBUDDY_USAGE_PATH, WorkBuddyCatalog, WorkBuddyCredentialRejectedError, WorkBuddyCredentialStore, WorkBuddyEncryptedCredentialError, WorkBuddyUpstreamClient, apply, asVolatile, authFileName, classifyUpstreamError, clearAtRestKeyCache, clearHostHeartbeat, cooldownOf, createAccountUsabilityProbe, createWorkBuddyAdapter, createWorkBuddyShim, creditOfStream, defaultDesktopAuthCandidates, defaultDesktopAuthDirs, defaultDesktopAuthPath, defaultOffModelIds, deriveAtRestKey, deriveAtRestKeyId, deriveCatalog, fallbackModelsFor, fetchAtRestKeyPayload, findWorkbuddyAppExecutable, hasEncryptedCredentialFields, imageDefaultFor, inject, isCredentialRejectedError, isEncryptedCredentialError, isEncryptedFieldWrapper, isHeartbeatProcessAlive, isWorkbuddyBundle, knownRegionOf, legacyAttributionRegion, legacyWorkbuddyOwnAuthPath, macosBundleExecutable, macosNestedAppBundles, modelIdOfBody, name, nativeModalityOf, nextRegionEnabled, nextRegionSlots, offDefaultFor, openEncryptedField, outcomeOfFailure, parseCreditMultiplier, parseReasoning, parseRetryAfter, parseUpstreamModel, parseWorkBuddyAuth, prepareChatBody, probeModel, probeRequestBody, probeSucceeded, processStartTimeMs, readAtRestKey, readHostHeartbeat, regionCleared, regionEnabled, regionEnabledOf, regionOf, regionOfProvider, regionOfStatusUrl, regionStateOf, registerWorkBuddyStatusRoute, resolveCredentialRecovery, selectAccountFor, settingsNamespaceOf, toPersistedWorkBuddyModel, unwrapVolatileDeep, withEffectiveOff, withWorkBuddyRegion, workBuddyDisplayName, workBuddyModelInput, workBuddyThinkingLevelMap, workBuddyWebStatus, workbuddyAccountId, workbuddyAppExecutableCandidates, workbuddyHostHeartbeatPath, workbuddyOwnAuthPath, writeHostHeartbeat };

package/package.json

@@ -2,7 +2,7 @@
   "name": "dsh-connect-workbuddy",
   "displayName": "DSH Connect WorkBuddy",
   "description": "把本机登录的 WorkBuddy 模型（国内版与国际版）接入 DeepSeek Harness：每次刷新按上游目录自动读取每个模型的积分倍率，支持逐模型图片输入开关、多账号切换与账号池自动换号，并提供每日签到、卡片与输入框里的胶囊积分读数等只读积分概览。",
-  "version": "5.0.1",
+  "version": "5.2.2",
   "author": "dingminhua",
   "copyright": "Copyright (c) 2026 LaoDing",
   "license": "MIT",