dsh-connect-workbuddy 2.2.1 → 2.3.0

package/CHANGELOG.md

@@ -1,5 +1,47 @@
 # Changelog
 
+## 2.3.0 (2026-09-29)
+
+### Features
+
+#### 模型「测试」：一键查出限量模型的冷却恢复时间
+
+**新增模型可用性测试。** 卡片每个模型行新增一个**测试**按钮，模型区顶部新增**测试已勾选**（对 `enabledModelIds` 逐个测）。每个模型只发**一条最小请求**（`max_tokens: 1`），直接回答两件事：**这个模型现在能不能用**，以及**不能用时什么时候恢复**。
+
+限量模型的冷却时间过去只能靠反复试错去猜——现在点一下就有结论。
+
+**实测（本机真实账号，两个网关）**：CN 16 个与全球 23 个模型各抽样实打，全部 HTTP 200；单次耗时 0.8～3.4s。**成本可忽略**——响应体 `"credit"` 报 0～0.01，其中一次探测前后余额完全不变（933 → 933），而名册上正常一次回答是 0.79x 起。
+
+**关于「多久之后可以再次使用」，有一条必须先说清的事实：上游不给这个数据。**
+
+探测前先做了取证：200 响应头里**没有 `Retry-After`，也没有 `X-RateLimit-*`**；对同一模型**连续快速打 12 次全部成功**，未触发任何限流。因此本功能**不编造倒计时**，只在两种上游真的说了时间的情形下显示时间：
+
+| 情形 | 卡片显示 | 时间来源 |
+|---|---|---|
+| 成功 | `✓ 可用（1.2s）` | — |
+| 429 / 限流，上游未给时间 | `✗ 被限流 · 上游未给出何时恢复` | 无（如实说没有） |
+| 429 / 限流，带 `Retry-After` | `✗ 被限流 · {时间} 之后可再用` | `Retry-After` 头（秒数或 HTTP-date 两种形态） |
+| 积分耗尽，且该区域有月周期包 | `✗ 积分不足 · 积分包 {时间} 刷新` | 月周期包的 `refreshAtMs` |
+| 积分耗尽，无月周期包 | `✗ 积分不足 · 上游未给出何时恢复` | 无 |
+| 401/403 凭据被拒 | `✗ WorkBuddy 拒绝了这个账号的 token——请重新登录或换一个账号` | — |
+
+限流**不会**去借月周期包的刷新时间：那会让用户为几秒的限流去等几周。这个区分由 `cooldownOf` 强制，并有专门用例钉住。
+
+**为何每个探测请求都必须以 system 消息开头**：国际网关（`www.workbuddy.ai`）对 `[{role:'user'}]` 一律返回 HTTP 400 / 业务码 `11128`（`first message is not system prompt`）。按国内版那样只发一条 user 消息，会把**整个国际版误报成全部不可用**。实测加上 system 消息后立即 200，故探测请求始终带一条 system 消息。
+
+- **架构**：探测在 **Host** 侧发起（`src/probe.ts` 构造与解读，`WorkBuddyUpstreamClient.probeChat` 传输，`/plugins/dsh-connect-workbuddy/probe` 路由）。浏览器只发模型 id、只收回结论——**凭据绝不跨到页面**。
+- **串行而非并发**：路由逐模型依次探测。一次并发扇出正是制造「限流」最直接的办法，那样测出来的会是插件自己的负载，而不是上游的限制。有专门用例钉住这一点。
+- **不依赖 `dirty`**：测试按钮不受「有未保存改动」影响——它回答的是「这个模型现在能不能用」，这与是否已保存无关；把它绑在 dirty 上，按钮会在用户正决定取舍时恰好失效。也**不依赖 `canWrite`**（探测不写任何设置），但**依赖已登录**（没凭据只可能是「被拒」）。
+- **不改动运行时**：探测结果不写入设置、不影响 `enabledModelIds` / `imageModelIds`，运行时目录零改动。
+- **错误分类复用**：`outcomeOfFailure` 建立在既有的 `classifyUpstreamError` 之上（中英文额度标记、`soft_rate` / `hard_credit`），使探测与真实 chat 请求对同一上游应答的判定不可能分歧。
+- **失败不抛异常**：单个模型探测失败返回一条结果，不中断整批——一个坏模型不该把其余行的结论一起吞掉。失败正文经 `safeMessage` 同规则脱敏（JWT 与 `token=` 查询参数）。
+
+### Tests
+
+- `tests/probe.spec.ts`（新增，28 例）：请求体必带 system 首条且 `max_tokens: 1` / `stream:true`；`Retry-After` 的秒数与 HTTP-date 两形态、以及 0 / 负数 / 过期时间不被当作冷却；`cooldownOf` 的四种组合（含**限流绝不编造时间**、**限流不借月周期刷新时间**）；七类失败分类；成功流不被截断影响；**抛出异常不逃逸**；失败正文脱敏。
+- `tests/web-status.spec.ts`（+10 例）：逐模型串行调用（并发变异会红）、region 透传、空列表 / 非数组 / 超限批量一律 400、无能力时 503、非回环来源 403、非 POST 405、未知 region 400、抛错转 500 且不泄露 token。
+- **变异验证**（5 处，逐一实测变红）：给限流编造固定倒计时 → 3 例红；删掉 system 首条消息 → 2 例红；让限流借用月周期刷新时间 → 1 例红；把串行批改为并发扇出 → 1 例红；其余对照组全绿。
+
 ## 2.2.1 (2026-09-29)
 
 ### Fixes

package/README.en.md

@@ -25,6 +25,7 @@ A [DeepSeek Harness (DSH)](https://github.com/deepseek-ai/deepseek-harness) bund
 - **Tabbed settings card** — the card's top carries a "Domestic / Global" tab bar; each tab holds its own account picker, credits overview, and model management. Account, directory, selection, and unsaved drafts are fully isolated per tab — switching accounts or refreshing models on one tab never touches the other side's runtime catalog or sessions.
 - **Switch either provider off on its own** — each tab carries an on/off checkbox (both checked by default). Unchecking one **withdraws that provider from DSH's model picker entirely** (it is not merely a hidden tab): its adapter route and its "Settings → Models" directory entry are both pulled, and startup no longer sends pointless requests for it. Account, credits, directory, and selection are all kept, and re-checking restores everything. The typical use is "I have no use for the international side" — switch it off and keep the picker clean. Note: a session that had already selected a model from the switched-off provider will report `NO_ADAPTER` on its next call; the card states this plainly on the switched-off tab instead of failing silently.
 - **Model management** — refresh the full catalog from upstream and enable or disable each model individually; refresh is a draft operation that only takes effect on save. Upstream also reports credit multiplier, context/output limits, and reasoning efforts; **image input is decided by a vendor-verified table**: a refresh pre-checks only models the vendor's own documentation calls natively multimodal, leaves documented text-only models unchecked, and treats anything without a vendor source as unverified and unchecked rather than guessing. Upstream's `supportsImages` is a *platform* declaration, not the model's capability, so it does not drive that decision at all. You can still tick any box by hand, and your selection is kept locally.
+- **Model availability testing, including cooldown recovery times** — working out when a limited model frees up used to mean guessing through repeated failures. Now every model row has a **Test** button and the models header has **Test selected**: each chosen model gets one minimal request (`max_tokens: 1`), and you get a direct answer for whether it works right now and, if not, when it comes back. Measured cost is negligible: the response reports `credit` between 0 and 0.01, and one probe left the balance unchanged (933 → 933), against 0.79x and up for a real reply; each probe took 0.8–3.4s. **On "when can I use this again", the upstream does not provide that data**: measured responses carry no `Retry-After` and no `X-RateLimit-*`, and 12 rapid requests to the same model all succeeded. So the plugin **never invents a countdown** — it shows a time only for the two cases where the upstream actually states one (a `Retry-After` header, or the monthly quota's refresh point when the quota is exhausted) and says plainly that no time was given otherwise. A rate limit deliberately does **not** borrow the monthly refresh time, which would tell you to wait weeks for a limit that clears in seconds. Probes run in the Host, so **the credential never reaches the page**, and results are not written to settings — your saved selection is untouched.
 - **Local account switching** — discovers the multiple sign-in credentials WorkBuddy's desktop app leaves behind and lets you switch per region. Tokens are never written to DSH settings.
 - **Actionable advice when a credential is refused** — when the upstream rejects the selected account's token, the plugin actually **probes** the other local sign-ins: if one still answers, it tells you to switch to it (with a one-click switch) instead of vaguely asking you to sign in again — re-authenticating fixes nothing while you are pinned to a revoked backup. Only when there is genuinely no other local account does it ask you to sign in again.
 - **Read-only credits overview** — remaining credit aggregated per package, plus each model's credit multiplier. Queries consume no credits.

package/README.md

@@ -31,6 +31,7 @@
 - **插件卡片 tab 切换** —— 设置卡片顶部为「国内版 / 国际版」两个 tab，各含独立的账号选择、积分概览与模型管理；每个 tab 的账号、目录、勾选与未保存草稿完全隔离——在一个 tab 里切账号或刷新模型，不会触碰另一边的运行时目录与会话。
 - **可单独关闭任一版本供应商** —— 每个 tab 右侧有一个勾选框（默认都勾选）。**取消勾选即把该供应商从 DSH 模型选择器里彻底撤掉**（不是只藏起 tab）：它的路由与「设置 → 模型」页的目录条目一并摘除，启动时也不再为它发无用请求。账号、积分、目录与勾选**全部保留**，重新勾选即完整恢复。典型用法是「我根本用不到国际版」——关掉它，让选择器干净。注意：若某会话此前选中的正是被关闭供应商的模型，该会话再调用会报 `NO_ADAPTER`，卡片会在关闭态的 tab 上明确提示这一点，不会静默失败。
 - **模型管理** —— 从上游刷新完整模型目录，逐项勾选启用或禁用；刷新是草稿操作，点保存才生效。上游同时给出积分倍率、上下文/输出上限与推理档位；**图片输入按厂商核验表判定**：刷新时只有厂商文档明确写为原生多模态的模型才自动勾选，文档写明纯文本的不勾，**没有厂商资料的一律按「未核实」不猜**（上游的 `supportsImages` 是平台侧声明，不等于模型能看图，不参与判定）。用户仍可随时手动勾选，勾选状态保存在本地。
+- **模型可用性测试（含冷却恢复时间）** —— 限量模型的冷却时间过去只能靠反复试错去猜。现在每个模型行有一个「测试」按钮，模型区顶部有「测试已勾选」，对勾选的模型**各发一条最小请求**（`max_tokens: 1`），直接告诉你它此刻能否使用、不能用时何时恢复。实测代价可忽略：`credit` 报 0～0.01，单次探测前后余额不变（933 → 933），而正常一次回答是 0.79x 起；单次耗时 0.8～3.4s。**关于「多久之后可以再次使用」，上游并不提供这个数据**：实测响应头里没有 `Retry-After`、也没有 `X-RateLimit-*`，对同一模型连续快速打 12 次全部成功。因此插件**不编造倒计时**，只在两种上游真的给出时间的情形下显示时间——`Retry-After` 头，或积分耗尽时该区域月周期包的刷新点；两者都没有时如实显示「上游未给出何时恢复」。限流**不会**去借月周期包的刷新时间（那会让人为几秒的限流去等几周）。探测在后台发起，**凭据不会传到页面**；结果不写入设置，也不改变你已保存的勾选。
 - **本机账号切换** —— 自动发现 WorkBuddy 桌面端留下的多个登录凭据，可按区域切换账号；Token 不写入 DSH 设置。
 - **凭据失效时给出可执行的建议** —— 上游拒绝当前账号的 token 时，插件会**实际探测**本机其他账号：若有账号仍然可用，就直接告诉你「切换到它即可」（并附一键切换），而不是笼统地让你重新登录——被钉在一个作废的旧备份上时，重新登录并不能解决问题。只有本机确实没有别的账号可切换时，才会提示重新登录。
 - **只读积分概览** —— 按套餐聚合展示剩余积分，并列出每个模型的积分倍率。查询不消耗积分。

package/lib/bin.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { O as workbuddyOwnAuthPath, T as legacyWorkbuddyOwnAuthPath, W as findWorkbuddyAppExecutable, _ as WorkBuddyCredentialStore, a as readHostHeartbeat, b as defaultDesktopAuthCandidates, c as WORKBUDDY_CONNECT_VERSION, g as WORKBUDDY_AUTH_FILE_ENV, j as WorkBuddyUpstreamClient, l as FALLBACK_WORKBUDDY_MODELS, o as workbuddyHostHeartbeatPath, r as isHeartbeatProcessAlive, u as FALLBACK_WORKBUDDY_MODELS_GLOBAL, x as defaultDesktopAuthDirs, z as WORKBUDDY_APP_EXECUTABLE_ENV } from "./host-heartbeat-Dy8fW3G5.js";
+import { O as workbuddyOwnAuthPath, T as legacyWorkbuddyOwnAuthPath, W as findWorkbuddyAppExecutable, _ as WorkBuddyCredentialStore, a as readHostHeartbeat, b as defaultDesktopAuthCandidates, c as WORKBUDDY_CONNECT_VERSION, g as WORKBUDDY_AUTH_FILE_ENV, j as WorkBuddyUpstreamClient, l as FALLBACK_WORKBUDDY_MODELS, o as workbuddyHostHeartbeatPath, r as isHeartbeatProcessAlive, u as FALLBACK_WORKBUDDY_MODELS_GLOBAL, x as defaultDesktopAuthDirs, z as WORKBUDDY_APP_EXECUTABLE_ENV } from "./host-heartbeat-Uh8JCXqk.js";
 import { realpathSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 //#region src/bin.ts

package/lib/client.js

@@ -28,6 +28,15 @@ window.__ModuleLoader__.load({
 		const WORKBUDDY_ACCOUNTS_REFRESH_PATH = "/plugins/dsh-connect-workbuddy/accounts/refresh";
 		/** Plugin-owned daily check-in action endpoint. */
 		const WORKBUDDY_CHECKIN_PATH = "/plugins/dsh-connect-workbuddy/checkin";
+		/**
+		* Plugin-owned model probe endpoint.
+		*
+		* Sends one minimal chat request per named model so the card can answer "is
+		* this model usable right now, and if it is limited, when can it be used
+		* again?". Lives on the Host because the credential must never reach the
+		* browser half.
+		*/
+		const WORKBUDDY_PROBE_PATH = "/plugins/dsh-connect-workbuddy/probe";
 		/** Query parameter naming the region a card request addresses. */
 		const WORKBUDDY_REGION_PARAM = "region";
 		/** Every region, in card tab order. */
@@ -592,6 +601,16 @@ window.__ModuleLoader__.load({
 .dsm-workbuddy-context-budget label{display:inline-flex;align-items:center;gap:4px;cursor:pointer}
 .dsm-workbuddy-context-budget input{margin:0;accent-color:var(--dsw-alias-brand-primary,#5686fe)}
 .dsm-workbuddy-model-capability-note{margin:0;color:var(--dsw-alias-label-tertiary,#999);font-size:12px;line-height:18px}
+/* Model probe (test button + result). The result line is its own row under the
+   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. */
+.dsm-workbuddy-models-head-actions{display:flex;align-items:center;gap:8px;flex:none}
+.dsm-workbuddy-model-probe{flex:none;padding:3px 10px;font-size:11px;line-height:16px}
+.dsm-workbuddy-model-probe-result{margin:0;font-size:12px;line-height:18px;word-break:break-word}
+.dsm-workbuddy-model-probe-result-ok{color:var(--dsw-alias-state-success-primary,#22a06b)}
+.dsm-workbuddy-model-probe-result-warn{color:var(--dsw-alias-state-warn-primary,#f59e0b)}
+.dsm-workbuddy-model-probe-result-bad{color:var(--dsw-alias-state-error-primary,#ef4444)}
 .dsm-workbuddy-model-actions{display:flex;align-items:center;justify-content:space-between;gap:12px;border-top:1px solid var(--dsw-alias-border-l2,#36373b);padding-top:12px}
 .dsm-workbuddy-model-save-error{flex:1;min-width:0;color:var(--dsw-alias-state-error-primary,#ef4444);font-size:12px;line-height:16px;text-align:right}
 .dsm-workbuddy-model-actions-buttons{display:flex;align-items:center;justify-content:flex-end;gap:8px}
@@ -868,6 +887,54 @@ window.__ModuleLoader__.load({
 		function dotStyle(status) {
 			return { background: status === "signed-in" ? "var(--dsw-alias-state-success-primary, #22a06b)" : status === "error" ? "var(--dsw-alias-state-error-primary, #d92d20)" : "var(--dsw-alias-label-dimmed, #9aa0a6)" };
 		}
+		/**
+		* The sentence a probe result gets, and how it should be coloured.
+		*
+		* The cooldown wording is the part that had to be got right. The upstream names
+		* a "use again" time in exactly two situations — a `Retry-After` header, or an
+		* exhausted monthly quota whose refresh point it declares — and its 200s and
+		* 429s carry NO rate-limit metadata at all (measured: no `Retry-After`, no
+		* `X-RateLimit-*`, and 12 rapid requests to one model all succeeded). So a
+		* limited result WITHOUT a stated time must say that plainly. Substituting a
+		* locally invented countdown would be the single most misleading thing this
+		* feature could do: it would look like an upstream answer while being a guess,
+		* and the user would wait for a moment that means nothing.
+		*/
+		function probeResultView(result, t) {
+			switch (result.outcome) {
+				case "ok": {
+					const elapsed = result.elapsedMs === void 0 ? void 0 : `${String(result.elapsedMs / 1e3)}s`;
+					return {
+						text: elapsed === void 0 ? t("row.probeOk") : t("row.probeOkMs", { ms: elapsed }),
+						tone: "ok"
+					};
+				}
+				case "rate-limited": return {
+					text: result.retryAtMs === void 0 ? t("row.probeRateLimitedUnknown") : t("row.probeRateLimitedAt", { at: formatDate(result.retryAtMs) }),
+					tone: "warn"
+				};
+				case "out-of-credit": return {
+					text: result.retryAtMs === void 0 ? t("row.probeOutOfCreditUnknown") : t("row.probeOutOfCreditAt", { at: formatDate(result.retryAtMs) }),
+					tone: "bad"
+				};
+				case "credential-rejected": return {
+					text: t("row.probeCredentialRejected"),
+					tone: "bad"
+				};
+				case "not-found": return {
+					text: t("row.probeNotFound"),
+					tone: "bad"
+				};
+				case "unavailable": return {
+					text: t("row.probeUnavailable"),
+					tone: "bad"
+				};
+				default: return {
+					text: result.status === void 0 ? t("row.probeFailed") : t("row.probeFailedStatus", { status: String(result.status) }),
+					tone: "bad"
+				};
+			}
+		}
 		/** Render WorkBuddy sign-in state, credits, and model selection as one card. */
 		function WorkBuddyCard({ t, settingsScope, view }) {
 			if (t === void 0) throw new Error("WorkBuddy plugin card requires its translation function");
@@ -909,6 +976,18 @@ window.__ModuleLoader__.load({
 			const [checkinActionError, setCheckinActionError] = (0, react.useState)(void 0);
 			/** Region whose on/off checkbox write is in flight, so its box can't race. */
 			const [togglingRegion, setTogglingRegion] = (0, react.useState)(void 0);
+			/**
+			* Probe results, keyed by region then model id.
+			*
+			* Kept per region for the same reason drafts are: the two tabs are separate
+			* provider stacks, so a test run on one tab must not be clobbered — or shown —
+			* as the other tab's answer.
+			*/
+			const [probes, setProbes] = (0, react.useState)({});
+			/** Model ids with a probe in flight, so each row's button can disable itself. */
+			const [probing, setProbing] = (0, react.useState)({});
+			/** Probe failure that is not attributable to one model (a dead route, say). */
+			const [probeError, setProbeError] = (0, react.useState)(void 0);
 			const mounted = (0, react.useRef)(true);
 			(0, react.useEffect)(() => {
 				mounted.current = true;
@@ -1154,6 +1233,8 @@ window.__ModuleLoader__.load({
 			* A bound scope is therefore all that is required to accept an edit.
 			*/
 			const canWrite = settingsScope !== void 0;
+			/** Whether any row's probe is in flight, so the batch button reflects it. */
+			const anyProbing = Object.keys(probing).length > 0;
 			const editDraft = (edit) => {
 				setDrafts((prev) => ({
 					...prev,
@@ -1201,6 +1282,59 @@ window.__ModuleLoader__.load({
 					return next;
 				});
 			};
+			/**
+			* Probe one or more models with a single minimal request each.
+			*
+			* The Host owns the request: the browser half sends only model ids and gets
+			* outcomes back, because the credential must never cross to the page. The
+			* route runs the batch sequentially and this waits for the whole answer, which
+			* is what lets the card report every row at once — a per-row response would
+			* race the shared `probing` map and make the batch button's state unknowable.
+			*
+			* Probing is deliberately independent of `dirty`: a test answers "does this
+			* model work right now", which is true of the SAVED selection and the draft
+			* alike, and blocking it on unsaved edits would make the button dead exactly
+			* when the user is deciding what to keep.
+			*/
+			const probeModels = async (modelIds) => {
+				if (modelIds.length === 0) return;
+				setProbeError(void 0);
+				setProbing((previous) => {
+					const next = { ...previous };
+					for (const id of modelIds) next[id] = true;
+					return next;
+				});
+				try {
+					const response = await fetch(withWorkBuddyRegion(WORKBUDDY_PROBE_PATH, activeRegion), {
+						method: "POST",
+						headers: {
+							"content-type": "application/json",
+							accept: "application/json"
+						},
+						credentials: "same-origin",
+						body: JSON.stringify({ modelIds })
+					});
+					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;
+					setProbes((previous) => {
+						const regionResults = { ...previous[activeRegion] ?? {} };
+						for (const result of body.results) regionResults[result.modelId] = result;
+						return {
+							...previous,
+							[activeRegion]: regionResults
+						};
+					});
+				} catch (error) {
+					if (mounted.current) setProbeError(error instanceof Error ? error.message : t("row.requestFailed"));
+				} finally {
+					if (mounted.current) setProbing((previous) => {
+						const next = { ...previous };
+						for (const id of modelIds) delete next[id];
+						return next;
+					});
+				}
+			};
 			const saveModels = async () => {
 				if (settingsScope === void 0) return;
 				if (status.status !== "signed-in") return;
@@ -1520,92 +1654,132 @@ window.__ModuleLoader__.load({
 											}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
 												className: "dsm-workbuddy-models-summary",
 												children: t("row.modelsSummary", { count: activeEnabledIds.size })
-											})] }), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
-												type: "button",
-												className: "dsm-btn dsm-btn-outline",
-												disabled: busy,
-												onClick: () => {
-													refreshModels();
-												},
-												children: busy ? t("row.modelsRefreshing") : t("row.modelsRefresh")
+											})] }), /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+												className: "dsm-workbuddy-models-head-actions",
+												children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+													type: "button",
+													className: "dsm-btn dsm-btn-outline",
+													disabled: activeEnabledIds.size === 0 || anyProbing,
+													title: t("row.probeAllHint"),
+													onClick: () => {
+														probeModels([...activeEnabledIds]);
+													},
+													children: anyProbing ? t("row.probing") : t("row.probeAll")
+												}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+													type: "button",
+													className: "dsm-btn dsm-btn-outline",
+													disabled: busy,
+													onClick: () => {
+														refreshModels();
+													},
+													children: busy ? t("row.modelsRefreshing") : t("row.modelsRefresh")
+												})]
 											})]
 										}),
+										probeError === void 0 ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+											className: "dsm-workbuddy-model-probe-result dsm-workbuddy-model-probe-result-bad",
+											role: "alert",
+											children: t("row.probeError", { message: probeError })
+										}),
 										/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
 											className: "dsm-workbuddy-model-list",
 											children: visibleModels.map((model) => /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
 												className: `dsm-workbuddy-model${activeEnabledIds.has(model.id) ? "" : " dsm-workbuddy-model-disabled"}`,
-												children: [/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
-													className: "dsm-workbuddy-model-head",
-													children: [
-														/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("label", {
-															className: "dsm-workbuddy-model-enabled",
-															children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("input", {
-																type: "checkbox",
-																checked: activeEnabledIds.has(model.id),
-																disabled: !canWrite || saving,
-																onChange: () => {
-																	toggleModel(model.id);
-																}
-															}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
-																className: "dsm-workbuddy-model-copy",
-																children: /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("span", {
-																	className: "dsm-workbuddy-model-name",
-																	children: [model.name, model.creditMultiplier === void 0 ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("span", {
-																		className: "dsm-workbuddy-model-name-rate",
-																		children: [
-																			"(",
-																			model.creditMultiplier.toFixed(2),
-																			"x)"
-																		]
-																	})]
-																})
-															})]
-														}),
-														/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("label", {
-															className: "dsm-workbuddy-model-image",
-															title: imageCheckboxHint(model, t),
-															children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("input", {
-																type: "checkbox",
-																checked: activeImageIds.has(model.id),
-																disabled: !canWrite || saving,
-																onChange: () => {
-																	toggleImage(model.id);
-																}
-															}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", { children: t("row.modelImage") })]
-														}),
-														/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("fieldset", {
-															className: "dsm-workbuddy-context-budget",
-															"aria-label": t("row.contextBudget"),
-															children: [model.nativeContextWindow > 2e5 ? /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("label", { children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("input", {
-																type: "radio",
-																name: `context-${model.id}`,
-																checked: (activeContextBudgets[model.id] ?? 2e5) === 2e5,
-																disabled: !canWrite || saving,
-																onChange: () => {
-																	setContextBudget(model.id, 2e5);
-																}
-															}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", { children: "200K" })] }) : null, /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("label", { children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("input", {
-																type: "radio",
-																name: `context-${model.id}`,
-																checked: model.nativeContextWindow <= 2e5 || activeContextBudgets[model.id] === model.nativeContextWindow,
-																disabled: model.nativeContextWindow <= 2e5 || !canWrite || saving,
-																onChange: () => {
-																	setContextBudget(model.id, model.nativeContextWindow);
-																}
-															}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", { children: formatCapacity(model.nativeContextWindow, t("row.modelUnknown")) })] })]
-														})
-													]
-												}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
-													className: "dsm-workbuddy-model-details",
-													children: /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
-														className: "dsm-workbuddy-model-meta",
+												children: [
+													/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+														className: "dsm-workbuddy-model-head",
 														children: [
-															/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", { children: t("row.modelContext", { context: formatCapacity(model.nativeContextWindow, t("row.modelUnknown")) }) }),
-															/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", { children: t("row.modelOutput", { output: formatCapacity(model.maxTokens, t("row.modelUnknown")) }) }),
-															model.reasoning === void 0 || model.reasoning.supportedEfforts === void 0 ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", { children: t("row.modelReasoning", { efforts: model.reasoning.supportedEfforts.join(" / ") }) })
+															/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("label", {
+																className: "dsm-workbuddy-model-enabled",
+																children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("input", {
+																	type: "checkbox",
+																	checked: activeEnabledIds.has(model.id),
+																	disabled: !canWrite || saving,
+																	onChange: () => {
+																		toggleModel(model.id);
+																	}
+																}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+																	className: "dsm-workbuddy-model-copy",
+																	children: /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("span", {
+																		className: "dsm-workbuddy-model-name",
+																		children: [model.name, model.creditMultiplier === void 0 ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("span", {
+																			className: "dsm-workbuddy-model-name-rate",
+																			children: [
+																				"(",
+																				model.creditMultiplier.toFixed(2),
+																				"x)"
+																			]
+																		})]
+																	})
+																})]
+															}),
+															/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("label", {
+																className: "dsm-workbuddy-model-image",
+																title: imageCheckboxHint(model, t),
+																children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("input", {
+																	type: "checkbox",
+																	checked: activeImageIds.has(model.id),
+																	disabled: !canWrite || saving,
+																	onChange: () => {
+																		toggleImage(model.id);
+																	}
+																}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", { children: t("row.modelImage") })]
+															}),
+															/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("fieldset", {
+																className: "dsm-workbuddy-context-budget",
+																"aria-label": t("row.contextBudget"),
+																children: [model.nativeContextWindow > 2e5 ? /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("label", { children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("input", {
+																	type: "radio",
+																	name: `context-${model.id}`,
+																	checked: (activeContextBudgets[model.id] ?? 2e5) === 2e5,
+																	disabled: !canWrite || saving,
+																	onChange: () => {
+																		setContextBudget(model.id, 2e5);
+																	}
+																}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", { children: "200K" })] }) : null, /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("label", { children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("input", {
+																	type: "radio",
+																	name: `context-${model.id}`,
+																	checked: model.nativeContextWindow <= 2e5 || activeContextBudgets[model.id] === model.nativeContextWindow,
+																	disabled: model.nativeContextWindow <= 2e5 || !canWrite || saving,
+																	onChange: () => {
+																		setContextBudget(model.id, model.nativeContextWindow);
+																	}
+																}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", { children: formatCapacity(model.nativeContextWindow, t("row.modelUnknown")) })] })]
+															}),
+															/* @__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",
+																title: t("row.probeHint"),
+																onClick: () => {
+																	probeModels([model.id]);
+																},
+																children: probing[model.id] === true ? t("row.probing") : t("row.probe")
+															})
 														]
-													})
-												})]
+													}),
+													/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+														className: "dsm-workbuddy-model-details",
+														children: /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+															className: "dsm-workbuddy-model-meta",
+															children: [
+																/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", { children: t("row.modelContext", { context: formatCapacity(model.nativeContextWindow, t("row.modelUnknown")) }) }),
+																/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", { children: t("row.modelOutput", { output: formatCapacity(model.maxTokens, t("row.modelUnknown")) }) }),
+																model.reasoning === void 0 || model.reasoning.supportedEfforts === void 0 ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", { children: t("row.modelReasoning", { efforts: model.reasoning.supportedEfforts.join(" / ") }) })
+															]
+														})
+													}),
+													(() => {
+														const result = probes[activeRegion]?.[model.id];
+														if (result === void 0) return null;
+														const view = probeResultView(result, t);
+														return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("p", {
+															className: `dsm-workbuddy-model-probe-result dsm-workbuddy-model-probe-result-${view.tone}`,
+															role: "status",
+															children: [view.text, result.message === void 0 ? null : " · " + result.message]
+														});
+													})()
+												]
 											}, model.id))
 										}),
 										/* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
@@ -1757,6 +1931,23 @@ window.__ModuleLoader__.load({
 			"row.modelReasoning": "Reasoning: {efforts}",
 			"row.modelUnknown": "Unknown",
 			"row.modelCapabilityPending": "Only capabilities advertised by WorkBuddy are shown.",
+			"row.probe": "Test",
+			"row.probing": "Testing…",
+			"row.probeAll": "Test selected",
+			"row.probeAllHint": "Send one minimal request (1 output token) to each enabled model and report which ones answer right now. Measured cost: 0 to 0.01 credits per model, against 0.79+ for a real reply.",
+			"row.probeHint": "Send one minimal request to this model to check it answers right now.",
+			"row.probeOk": "✓ Usable",
+			"row.probeOkMs": "✓ Usable ({ms})",
+			"row.probeRateLimitedUnknown": "✗ Rate limited · the upstream gave no time for when it frees up",
+			"row.probeRateLimitedAt": "✗ Rate limited · usable again after {at}",
+			"row.probeOutOfCreditUnknown": "✗ Not enough credits · the upstream gave no time for when it frees up",
+			"row.probeOutOfCreditAt": "✗ Not enough credits · quota refreshes {at}",
+			"row.probeCredentialRejected": "✗ WorkBuddy refused this account's token — sign in again or pick another account",
+			"row.probeNotFound": "✗ The upstream does not know this model",
+			"row.probeUnavailable": "✗ The upstream could not be reached — this is a network problem, not the model",
+			"row.probeFailed": "✗ Test failed",
+			"row.probeFailedStatus": "✗ Test failed (HTTP {status})",
+			"row.probeError": "Could not run the test: {message}",
 			"row.cheer": "Star on GitHub"
 		};
 		const zh = {
@@ -1834,6 +2025,23 @@ window.__ModuleLoader__.load({
 			"row.modelReasoning": "推理强度：{efforts}",
 			"row.modelUnknown": "未知",
 			"row.modelCapabilityPending": "仅展示 WorkBuddy 接口明确公布的模型能力。",
+			"row.probe": "测试",
+			"row.probing": "测试中…",
+			"row.probeAll": "测试已勾选",
+			"row.probeAllHint": "对每个已勾选的模型各发一条最小请求（只出 1 个 token），报告哪个现在真的能用。实测每个模型消耗 0～0.01 积分，而正常一次回答是 0.79 起。",
+			"row.probeHint": "对该模型发一条最小请求，检查它现在能不能用。",
+			"row.probeOk": "✓ 可用",
+			"row.probeOkMs": "✓ 可用（{ms}）",
+			"row.probeRateLimitedUnknown": "✗ 被限流 · 上游未给出何时恢复",
+			"row.probeRateLimitedAt": "✗ 被限流 · {at} 之后可再用",
+			"row.probeOutOfCreditUnknown": "✗ 积分不足 · 上游未给出何时恢复",
+			"row.probeOutOfCreditAt": "✗ 积分不足 · 积分包 {at} 刷新",
+			"row.probeCredentialRejected": "✗ WorkBuddy 拒绝了这个账号的 token——请重新登录或换一个账号",
+			"row.probeNotFound": "✗ 上游不认识这个模型",
+			"row.probeUnavailable": "✗ 连不上上游——这是网络问题，不是模型问题",
+			"row.probeFailed": "✗ 测试失败",
+			"row.probeFailedStatus": "✗ 测试失败（HTTP {status}）",
+			"row.probeError": "无法执行测试：{message}",
 			"row.cheer": "鼓励一下"
 		};
 		//#endregion

package/lib/{host-heartbeat-Dy8fW3G5.js → host-heartbeat-Uh8JCXqk.js}

@@ -827,6 +827,54 @@ var WorkBuddyUpstreamClient = class {
 			message: text
 		};
 	}
+	/**
+	* Send one minimal chat request for `bodyJson` and report the RAW answer.
+	*
+	* Shares {@link chatHeaders} and the chat base with {@link chatStream} on
+	* purpose: a probe is only meaningful if it reaches the same endpoint with the
+	* same authentication as a real request. The differences are deliberate and
+	* narrow — it returns the headers (for `Retry-After`) and the failure body
+	* (for classification) instead of a pre-classified error, so the probe module
+	* owns the interpretation and the network layer stays a transport.
+	*
+	* The caller MUST drain {@link WorkBuddyProbeAnswer.response}; an unread body
+	* holds the connection open.
+	*/
+	async probeChat(credential, bodyJson, signal) {
+		let response;
+		try {
+			response = await fetch(`${chatBase(credential)}/v2/chat/completions`, {
+				method: "POST",
+				headers: {
+					...chatHeaders(credential),
+					"Authorization": `Bearer ${credential.accessToken}`
+				},
+				body: bodyJson,
+				...signal === void 0 ? {} : { signal }
+			});
+		} catch (error) {
+			return {
+				ok: false,
+				status: 0,
+				retryAfter: null,
+				body: `transport error: ${String(error)}`
+			};
+		}
+		const retryAfter = response.headers.get("retry-after");
+		if (response.ok) return {
+			ok: true,
+			status: response.status,
+			retryAfter,
+			response
+		};
+		const body = (await response.text()).slice(0, ERROR_BODY_LIMIT);
+		return {
+			ok: false,
+			status: response.status,
+			retryAfter,
+			body
+		};
+	}
 	/** POST the token-refresh endpoint; the caller merges the outcome. */
 	async refreshToken(credential) {
 		const response = await fetch(`${chatBase(credential)}/v2/plugin/auth/token/refresh`, {
@@ -2210,7 +2258,7 @@ var WorkBuddyCatalog = class {
 //#endregion
 //#region src/version.ts
 /** The npm package version this build was produced from. */
-const WORKBUDDY_CONNECT_VERSION = "2.2.1";
+const WORKBUDDY_CONNECT_VERSION = "2.3.0";
 //#endregion
 //#region src/host-heartbeat.ts
 /**

package/lib/index.d.ts

@@ -512,6 +512,25 @@ type WorkBuddyChatResult = {
   kind: UpstreamErrorKind;
   message: string;
 };
+/**
+ * Chat answer that also carries the response headers.
+ *
+ * Used by the model probe, whose whole point is to ask "is this usable right
+ * now, and if not, when?" — and the only place an upstream ever names a
+ * cooldown is the `Retry-After` header, which {@link WorkBuddyChatResult}
+ * deliberately does not surface. Returning a separate shape keeps the ordinary
+ * chat path (and its callers) untouched.
+ */
+interface WorkBuddyProbeAnswer {
+  ok: boolean;
+  status: number;
+  /** Raw `Retry-After`, when the upstream sent one; null otherwise. */
+  retryAfter: string | null;
+  /** Failure body excerpt, only when `ok` is false. */
+  body?: string;
+  /** The live stream, only when `ok` is true. The caller drains and discards it. */
+  response?: Response;
+}
 /** Classify an upstream failure from its HTTP status and body excerpt. */
 declare function classifyUpstreamError(status: number, body: string): UpstreamErrorKind;
 /**
@@ -578,6 +597,20 @@ declare function parseUpstreamModel(value: unknown): WorkBuddyUpstreamModel | un
 declare class WorkBuddyUpstreamClient {
   /** POST the chat endpoint; a successful answer is the raw SSE response. */
   chatStream(credential: WorkBuddyCredential, bodyJson: string, signal?: AbortSignal): Promise<WorkBuddyChatResult>;
+  /**
+   * Send one minimal chat request for `bodyJson` and report the RAW answer.
+   *
+   * Shares {@link chatHeaders} and the chat base with {@link chatStream} on
+   * purpose: a probe is only meaningful if it reaches the same endpoint with the
+   * same authentication as a real request. The differences are deliberate and
+   * narrow — it returns the headers (for `Retry-After`) and the failure body
+   * (for classification) instead of a pre-classified error, so the probe module
+   * owns the interpretation and the network layer stays a transport.
+   *
+   * The caller MUST drain {@link WorkBuddyProbeAnswer.response}; an unread body
+   * holds the connection open.
+   */
+  probeChat(credential: WorkBuddyCredential, bodyJson: string, signal?: AbortSignal): Promise<WorkBuddyProbeAnswer>;
   /** POST the token-refresh endpoint; the caller merges the outcome. */
   refreshToken(credential: WorkBuddyCredential): Promise<WorkBuddyRefreshOutcome>;
   /**
@@ -1153,6 +1186,151 @@ declare function clearHostHeartbeat(): Promise<void>;
 /** The npm package version this build was produced from. */
 declare const WORKBUDDY_CONNECT_VERSION: string;
 //#endregion
+//#region src/probe.d.ts
+/**
+ * The system message every probe carries.
+ *
+ * Not decoration: the international gateway rejects a conversation that does not
+ * start with a system message (see the module note). A probe that omitted it
+ * would report every global model as broken.
+ */
+declare const PROBE_SYSTEM_PROMPT = "You are a connectivity check. Reply with a single word.";
+/** The one-word user turn; the smallest thing a chat endpoint accepts. */
+declare const PROBE_USER_PROMPT = "ping";
+/**
+ * Output cap for a probe. One token is enough to prove the model answers, and
+ * keeps the cost negligible: live measurements of `max_tokens: 1` probes
+ * reported `credit` between 0 and 0.01, and one such probe left the credit
+ * balance unchanged (933 → 933). For scale, a model on that roster bills 0.79+
+ * per real reply. The point of the feature is to learn whether a model works
+ * while spending as close to nothing as the service allows.
+ */
+declare const PROBE_MAX_TOKENS = 1;
+/**
+ * Build the request body for one probe.
+ *
+ * `stream` is forced because the upstream rejects non-streaming chat requests;
+ * `prepareChatBody` enforces that too, but sending it explicitly keeps this
+ * function's output valid on its own.
+ */
+declare function probeRequestBody(modelId: string): string;
+/**
+ * How one probe ended.
+ *
+ * `rate-limited` is split out from a generic failure because it is the one
+ * outcome the feature exists for: it means "this model works, but not right
+ * now". Everything else is a real, actionable failure or a success.
+ */
+type WorkBuddyProbeOutcome = 'ok' | 'rate-limited' | 'out-of-credit' | 'credential-rejected' | 'unavailable' | 'not-found' | 'failed';
+/**
+ * One probe result, as the card renders it.
+ *
+ * `retryAtMs` is present ONLY when the upstream actually stated a time (a
+ * `Retry-After` header, or the region's quota refresh point when the failure is
+ * an exhausted quota). Its absence is meaningful and must be rendered as "the
+ * upstream did not say", never as a locally invented countdown.
+ */
+interface WorkBuddyProbeResult {
+  modelId: string;
+  outcome: WorkBuddyProbeOutcome;
+  /** Round-trip time in ms, for a successful probe. */
+  elapsedMs?: number;
+  /** HTTP status the upstream answered with; 0 means the request never landed. */
+  status?: number;
+  /** Upstream's own words, redacted. Present on failures. */
+  message?: string;
+  /** A time the upstream named, in ms. Absent when it named none. */
+  retryAtMs?: number;
+  /** Where a supplied `retryAtMs` came from, so the card can say so. */
+  retrySource?: 'retry-after' | 'quota-refresh';
+}
+/**
+ * Parse a `Retry-After` header value into an absolute time.
+ *
+ * Both RFC 9110 forms are accepted: delay-seconds (`120`) and an HTTP-date
+ * (`Wed, 21 Oct 2026 07:28:00 GMT`). Returns undefined for anything else,
+ * including the negative/zero delays some gateways emit — a "retry now" is not
+ * a cooldown and reporting it as one would be worse than saying nothing.
+ *
+ * `nowMs` is injected so the delay-seconds branch is testable without a clock.
+ */
+declare function parseRetryAfter(value: string | null, nowMs: number): number | undefined;
+/**
+ * The cooldown the upstream stated, if it stated one.
+ *
+ * Two sources, in order of authority:
+ *
+ * 1. `Retry-After` on the failure response. This is the upstream naming a time
+ *    for THIS request, so it wins.
+ * 2. The region's monthly quota refresh point, but ONLY for an out-of-credit
+ *    outcome. A quota that resets at a known time is the one case where "when
+ *    can I use this again" has a real answer even without a header — and it is
+ *    the answer for the most common real limit on this service.
+ *
+ * A `rate-limited` outcome with neither source returns `{}`, which the card
+ * renders as "the upstream did not say when". That is the honest answer: the
+ * live probes found no rate-limit metadata in any response at all, so inventing
+ * a number here would be pure fiction.
+ */
+declare function cooldownOf(input: {
+  outcome: WorkBuddyProbeOutcome;
+  retryAfter: string | null;
+  nowMs: number;
+  /** The region's next monthly quota refresh, when the upstream declares one. */
+  quotaRefreshAtMs?: number;
+}): Pick<WorkBuddyProbeResult, 'retryAtMs' | 'retrySource'>;
+/**
+ * Classify one failed probe into the card's outcome vocabulary.
+ *
+ * Built on `classifyUpstreamError` rather than re-testing status codes, so a
+ * probe and a real chat request can never disagree about what the same upstream
+ * answer means. The extra split here is `credential-rejected`, which the
+ * upstream signals with a non-JSON 401/403 edge page and which needs completely
+ * different advice (re-auth, not "wait").
+ */
+declare function outcomeOfFailure(status: number, body: string): WorkBuddyProbeOutcome;
+/**
+ * Read the credit this probe consumed out of an SSE stream, when the upstream
+ * reports it.
+ *
+ * Purely informational — the card shows it so a user can see how little a probe
+ * actually costs rather than having to trust a claim. Absent when the stream
+ * carried no `usage` block.
+ */
+declare function creditOfStream(text: string): number | undefined;
+/** Whether a probe outcome means the model answered. */
+declare function probeSucceeded(outcome: WorkBuddyProbeOutcome): boolean;
+/** What one probe needs from the upstream client. */
+interface WorkBuddyProbeClient {
+  probeChat(credential: WorkBuddyCredential, bodyJson: string, signal?: AbortSignal): Promise<{
+    ok: boolean;
+    status: number;
+    retryAfter: string | null;
+    body?: string;
+    response?: Response;
+  }>;
+}
+/**
+ * Run one probe for one model and reduce it to the card's row.
+ *
+ * The successful path drains the SSE stream purely to read the `credit` figure
+ * the upstream reports, then discards the rest: the probe's question is "did
+ * this model answer", and `max_tokens: 1` means there is nothing else in the
+ * stream worth keeping.
+ *
+ * Never throws. A probe is a diagnostic the user asked for, so every failure is
+ * a RESULT — one dead model must not abort the batch and hide the other rows.
+ */
+declare function probeModel(input: {
+  client: WorkBuddyProbeClient;
+  credential: WorkBuddyCredential;
+  modelId: string;
+  nowMs: number;
+  /** The region's next monthly quota refresh, when known. */
+  quotaRefreshAtMs?: number;
+  signal?: AbortSignal;
+}): Promise<WorkBuddyProbeResult>;
+//#endregion
 //#region src/status-paths.d.ts
 /**
  * Node-free constants and types shared by the Host and browser halves.
@@ -1175,6 +1353,15 @@ declare const WORKBUDDY_MODELS_REFRESH_PATH = "/plugins/dsh-connect-workbuddy/mo
 declare const WORKBUDDY_ACCOUNTS_REFRESH_PATH = "/plugins/dsh-connect-workbuddy/accounts/refresh";
 /** Plugin-owned daily check-in action endpoint. */
 declare const WORKBUDDY_CHECKIN_PATH = "/plugins/dsh-connect-workbuddy/checkin";
+/**
+ * Plugin-owned model probe endpoint.
+ *
+ * Sends one minimal chat request per named model so the card can answer "is
+ * this model usable right now, and if it is limited, when can it be used
+ * again?". Lives on the Host because the credential must never reach the
+ * browser half.
+ */
+declare const WORKBUDDY_PROBE_PATH = "/plugins/dsh-connect-workbuddy/probe";
 /** Query parameter naming the region a card request addresses. */
 declare const WORKBUDDY_REGION_PARAM = "region";
 /** Every region, in card tab order. */
@@ -1444,6 +1631,38 @@ type WorkBuddyWebUsage =
   status: 'error';
   message: string;
 };
+/**
+ * Outcome vocabulary of one model probe, shared by the Host and the card.
+ *
+ * Mirrors `WorkBuddyProbeOutcome` in `./probe.ts`; kept as its own declaration
+ * here because this module is the node-free bridge and must not import the
+ * Host-side probe module (which pulls in the credential type).
+ */
+type WorkBuddyWebProbeOutcome = 'ok' | 'rate-limited' | 'out-of-credit' | 'credential-rejected' | 'unavailable' | 'not-found' | 'failed';
+/** One model's probe result, as the card renders it. */
+interface WorkBuddyWebProbeResult {
+  modelId: string;
+  outcome: WorkBuddyWebProbeOutcome;
+  /** Round-trip time in ms; present once the request landed. */
+  elapsedMs?: number;
+  /** HTTP status the upstream answered with; 0 means it never landed. */
+  status?: number;
+  /** Upstream's own words, already redacted. */
+  message?: string;
+  /**
+   * A time the upstream named for using this model again, in ms.
+   *
+   * ABSENT means the upstream named none, and the card must say exactly that.
+   * The live probes that shaped this feature found no rate-limit metadata in
+   * any response — no `Retry-After`, no `X-RateLimit-*` — so a client-invented
+   * countdown here would be fiction. Only two sources ever fill this:
+   * a real `Retry-After`, or (for an exhausted quota) the region's own quota
+   * refresh point, which the upstream does declare.
+   */
+  retryAtMs?: number;
+  /** Which of those two sources supplied {@link retryAtMs}. */
+  retrySource?: 'retry-after' | 'quota-refresh';
+}
 /**
  * Deep copy of a settings value with every `{get(): T}` live reference replaced
  * by the value it resolves to.
@@ -1511,6 +1730,24 @@ interface WorkBuddyStatusRouteOptions {
    * committed settings value rather than a local guess.
    */
   regionEnabled(region: WorkBuddyRegion): boolean;
+  /**
+   * Send one minimal request to each named model of a region and report what
+   * came back.
+   *
+   * Optional: it is the only dependency the card's test button needs, so a Host
+   * built without it (or a route mounted for a status-only consumer) simply
+   * answers 503 and the button reports that instead of failing the card.
+   */
+  probeModels?(region: WorkBuddyRegion, modelIds: readonly string[], signal?: AbortSignal): Promise<readonly WorkBuddyWebProbeResult[]>;
+  /**
+   * The region's next monthly quota refresh, when the upstream declares one.
+   *
+   * Used ONLY to answer "when can I use this again" for an out-of-credit
+   * outcome, which is the one cooldown the service actually states: a monthly
+   * resource that resets at a known time. Every other limited outcome has no
+   * time from any source and must be reported as such.
+   */
+  quotaRefreshAtMs?(region: WorkBuddyRegion): number | undefined;
   /**
    * Report whether a region still has at least one local sign-in.
    *
@@ -1739,4 +1976,4 @@ declare function legacyAttributionRegion(value: Config, accountsFor: (region: Wo
  */
 declare function apply(ctx: Context, config: Config): void;
 //#endregion
-export { CREDENTIAL_REJECTED_CODE, Config, ENCRYPTED_CREDENTIAL_CODE, FALLBACK_WORKBUDDY_MODELS, FALLBACK_WORKBUDDY_MODELS_GLOBAL, NATIVE_MODALITY_BY_MODEL_ID, 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_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, 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, createAccountUsabilityProbe, createWorkBuddyAdapter, createWorkBuddyShim, defaultDesktopAuthCandidates, defaultDesktopAuthDirs, defaultDesktopAuthPath, deriveAtRestKey, deriveAtRestKeyId, deriveCatalog, fallbackModelsFor, fetchAtRestKeyPayload, findWorkbuddyAppExecutable, hasEncryptedCredentialFields, imageDefaultFor, inject, isCredentialRejectedError, isEncryptedCredentialError, isEncryptedFieldWrapper, isHeartbeatProcessAlive, isWorkbuddyBundle, legacyAttributionRegion, legacyWorkbuddyOwnAuthPath, macosBundleExecutable, macosNestedAppBundles, name, nativeModalityOf, nextRegionEnabled, nextRegionSlots, openEncryptedField, parseCreditMultiplier, parseReasoning, parseUpstreamModel, parseWorkBuddyAuth, prepareChatBody, processStartTimeMs, readAtRestKey, readHostHeartbeat, regionCleared, regionEnabled, regionEnabledOf, regionOf, regionOfProvider, regionOfStatusUrl, regionStateOf, registerWorkBuddyStatusRoute, resolveCredentialRecovery, selectAccountFor, settingsNamespaceOf, toPersistedWorkBuddyModel, unwrapVolatileDeep, withWorkBuddyRegion, workBuddyDisplayName, workBuddyModelInput, workBuddyThinkingLevelMap, workBuddyWebStatus, workbuddyAccountId, workbuddyAppExecutableCandidates, workbuddyHostHeartbeatPath, workbuddyOwnAuthPath, writeHostHeartbeat };
+export { CREDENTIAL_REJECTED_CODE, Config, ENCRYPTED_CREDENTIAL_CODE, FALLBACK_WORKBUDDY_MODELS, FALLBACK_WORKBUDDY_MODELS_GLOBAL, NATIVE_MODALITY_BY_MODEL_ID, PROBE_MAX_TOKENS, PROBE_SYSTEM_PROMPT, PROBE_USER_PROMPT, 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, 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, deriveAtRestKey, deriveAtRestKeyId, deriveCatalog, fallbackModelsFor, fetchAtRestKeyPayload, findWorkbuddyAppExecutable, hasEncryptedCredentialFields, imageDefaultFor, inject, isCredentialRejectedError, isEncryptedCredentialError, isEncryptedFieldWrapper, isHeartbeatProcessAlive, isWorkbuddyBundle, legacyAttributionRegion, legacyWorkbuddyOwnAuthPath, macosBundleExecutable, macosNestedAppBundles, name, nativeModalityOf, nextRegionEnabled, nextRegionSlots, 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, withWorkBuddyRegion, workBuddyDisplayName, workBuddyModelInput, workBuddyThinkingLevelMap, workBuddyWebStatus, workbuddyAccountId, workbuddyAppExecutableCandidates, workbuddyHostHeartbeatPath, workbuddyOwnAuthPath, writeHostHeartbeat };

package/lib/index.js

@@ -1,4 +1,4 @@
-import { A as WorkBuddyCredentialRejectedError, B as clearAtRestKeyCache, C as hasEncryptedCredentialFields, D as workbuddyAccountId, E as parseWorkBuddyAuth, F as parseReasoning, G as isEncryptedFieldWrapper, H as deriveAtRestKeyId, I as parseUpstreamModel, J as macosNestedAppBundles, K as isWorkbuddyBundle, L as prepareChatBody, M as classifyUpstreamError, N as isCredentialRejectedError, O as workbuddyOwnAuthPath, P as parseCreditMultiplier, R as regionOf, S as defaultDesktopAuthPath, T as legacyWorkbuddyOwnAuthPath, U as fetchAtRestKeyPayload, V as deriveAtRestKey, W as findWorkbuddyAppExecutable, X as readAtRestKey, Y as openEncryptedField, Z as workbuddyAppExecutableCandidates, _ as WorkBuddyCredentialStore, a as readHostHeartbeat, b as defaultDesktopAuthCandidates, c as WORKBUDDY_CONNECT_VERSION, d as WorkBuddyCatalog, f as deriveCatalog, g as WORKBUDDY_AUTH_FILE_ENV, h as WORKBUDDY_AUTH_FILENAME, i as processStartTimeMs, j as WorkBuddyUpstreamClient, k as CREDENTIAL_REJECTED_CODE, l as FALLBACK_WORKBUDDY_MODELS, m as ENCRYPTED_CREDENTIAL_CODE, n as clearHostHeartbeat, o as workbuddyHostHeartbeatPath, p as fallbackModelsFor, q as macosBundleExecutable, r as isHeartbeatProcessAlive, s as writeHostHeartbeat, t as WORKBUDDY_HOST_HEARTBEAT_FILENAME, u as FALLBACK_WORKBUDDY_MODELS_GLOBAL, v as WorkBuddyEncryptedCredentialError, w as isEncryptedCredentialError, x as defaultDesktopAuthDirs, y as authFileName, z as WORKBUDDY_APP_EXECUTABLE_ENV } from "./host-heartbeat-Dy8fW3G5.js";
+import { A as WorkBuddyCredentialRejectedError, B as clearAtRestKeyCache, C as hasEncryptedCredentialFields, D as workbuddyAccountId, E as parseWorkBuddyAuth, F as parseReasoning, G as isEncryptedFieldWrapper, H as deriveAtRestKeyId, I as parseUpstreamModel, J as macosNestedAppBundles, K as isWorkbuddyBundle, L as prepareChatBody, M as classifyUpstreamError, N as isCredentialRejectedError, O as workbuddyOwnAuthPath, P as parseCreditMultiplier, R as regionOf, S as defaultDesktopAuthPath, T as legacyWorkbuddyOwnAuthPath, U as fetchAtRestKeyPayload, V as deriveAtRestKey, W as findWorkbuddyAppExecutable, X as readAtRestKey, Y as openEncryptedField, Z as workbuddyAppExecutableCandidates, _ as WorkBuddyCredentialStore, a as readHostHeartbeat, b as defaultDesktopAuthCandidates, c as WORKBUDDY_CONNECT_VERSION, d as WorkBuddyCatalog, f as deriveCatalog, g as WORKBUDDY_AUTH_FILE_ENV, h as WORKBUDDY_AUTH_FILENAME, i as processStartTimeMs, j as WorkBuddyUpstreamClient, k as CREDENTIAL_REJECTED_CODE, l as FALLBACK_WORKBUDDY_MODELS, m as ENCRYPTED_CREDENTIAL_CODE, n as clearHostHeartbeat, o as workbuddyHostHeartbeatPath, p as fallbackModelsFor, q as macosBundleExecutable, r as isHeartbeatProcessAlive, s as writeHostHeartbeat, t as WORKBUDDY_HOST_HEARTBEAT_FILENAME, u as FALLBACK_WORKBUDDY_MODELS_GLOBAL, v as WorkBuddyEncryptedCredentialError, w as isEncryptedCredentialError, x as defaultDesktopAuthDirs, y as authFileName, z as WORKBUDDY_APP_EXECUTABLE_ENV } from "./host-heartbeat-Uh8JCXqk.js";
 import z from "@deepseek-ai/schemastery";
 import { randomBytes, timingSafeEqual } from "node:crypto";
 import { createProvider } from "@earendil-works/pi-ai";
@@ -492,6 +492,210 @@ function createWorkBuddyShim(options) {
 	};
 }
 //#endregion
+//#region src/probe.ts
+/**
+* The system message every probe carries.
+*
+* Not decoration: the international gateway rejects a conversation that does not
+* start with a system message (see the module note). A probe that omitted it
+* would report every global model as broken.
+*/
+const PROBE_SYSTEM_PROMPT = "You are a connectivity check. Reply with a single word.";
+/** The one-word user turn; the smallest thing a chat endpoint accepts. */
+const PROBE_USER_PROMPT = "ping";
+/**
+* Output cap for a probe. One token is enough to prove the model answers, and
+* keeps the cost negligible: live measurements of `max_tokens: 1` probes
+* reported `credit` between 0 and 0.01, and one such probe left the credit
+* balance unchanged (933 → 933). For scale, a model on that roster bills 0.79+
+* per real reply. The point of the feature is to learn whether a model works
+* while spending as close to nothing as the service allows.
+*/
+const PROBE_MAX_TOKENS = 1;
+/**
+* Build the request body for one probe.
+*
+* `stream` is forced because the upstream rejects non-streaming chat requests;
+* `prepareChatBody` enforces that too, but sending it explicitly keeps this
+* function's output valid on its own.
+*/
+function probeRequestBody(modelId) {
+	return JSON.stringify({
+		model: modelId,
+		messages: [{
+			role: "system",
+			content: PROBE_SYSTEM_PROMPT
+		}, {
+			role: "user",
+			content: PROBE_USER_PROMPT
+		}],
+		max_tokens: 1,
+		stream: true
+	});
+}
+/**
+* Parse a `Retry-After` header value into an absolute time.
+*
+* Both RFC 9110 forms are accepted: delay-seconds (`120`) and an HTTP-date
+* (`Wed, 21 Oct 2026 07:28:00 GMT`). Returns undefined for anything else,
+* including the negative/zero delays some gateways emit — a "retry now" is not
+* a cooldown and reporting it as one would be worse than saying nothing.
+*
+* `nowMs` is injected so the delay-seconds branch is testable without a clock.
+*/
+function parseRetryAfter(value, nowMs) {
+	if (value === null) return void 0;
+	const trimmed = value.trim();
+	if (trimmed === "") return void 0;
+	if (/^\d+$/u.test(trimmed)) {
+		const seconds = Number(trimmed);
+		if (!Number.isFinite(seconds) || seconds <= 0) return void 0;
+		return nowMs + seconds * 1e3;
+	}
+	const parsed = Date.parse(trimmed);
+	if (Number.isNaN(parsed)) return void 0;
+	if (parsed <= nowMs) return void 0;
+	return parsed;
+}
+/**
+* The cooldown the upstream stated, if it stated one.
+*
+* Two sources, in order of authority:
+*
+* 1. `Retry-After` on the failure response. This is the upstream naming a time
+*    for THIS request, so it wins.
+* 2. The region's monthly quota refresh point, but ONLY for an out-of-credit
+*    outcome. A quota that resets at a known time is the one case where "when
+*    can I use this again" has a real answer even without a header — and it is
+*    the answer for the most common real limit on this service.
+*
+* A `rate-limited` outcome with neither source returns `{}`, which the card
+* renders as "the upstream did not say when". That is the honest answer: the
+* live probes found no rate-limit metadata in any response at all, so inventing
+* a number here would be pure fiction.
+*/
+function cooldownOf(input) {
+	const fromHeader = parseRetryAfter(input.retryAfter, input.nowMs);
+	if (fromHeader !== void 0) return {
+		retryAtMs: fromHeader,
+		retrySource: "retry-after"
+	};
+	if (input.outcome === "out-of-credit" && input.quotaRefreshAtMs !== void 0) return {
+		retryAtMs: input.quotaRefreshAtMs,
+		retrySource: "quota-refresh"
+	};
+	return {};
+}
+/**
+* Classify one failed probe into the card's outcome vocabulary.
+*
+* Built on `classifyUpstreamError` rather than re-testing status codes, so a
+* probe and a real chat request can never disagree about what the same upstream
+* answer means. The extra split here is `credential-rejected`, which the
+* upstream signals with a non-JSON 401/403 edge page and which needs completely
+* different advice (re-auth, not "wait").
+*/
+function outcomeOfFailure(status, body) {
+	if (status === 401 || status === 403) return "credential-rejected";
+	switch (classifyUpstreamError(status, body)) {
+		case "soft_rate": return "rate-limited";
+		case "hard_credit": return "out-of-credit";
+		case "session_dead": return "credential-rejected";
+		case "not_found": return "not-found";
+		default: return status === 0 || status >= 500 ? "unavailable" : "failed";
+	}
+}
+/**
+* Read the credit this probe consumed out of an SSE stream, when the upstream
+* reports it.
+*
+* Purely informational — the card shows it so a user can see how little a probe
+* actually costs rather than having to trust a claim. Absent when the stream
+* carried no `usage` block.
+*/
+function creditOfStream(text) {
+	const match = /"credit"\s*:\s*(-?[0-9]*\.?[0-9]+)/u.exec(text);
+	if (match === null) return void 0;
+	const value = Number(match[1]);
+	return Number.isFinite(value) ? value : void 0;
+}
+/** Whether a probe outcome means the model answered. */
+function probeSucceeded(outcome) {
+	return outcome === "ok";
+}
+/** Max characters of upstream text kept for display, after redaction. */
+const PROBE_MESSAGE_LIMIT = 300;
+/**
+* Redact token-shaped content out of upstream text before it is stored or sent.
+*
+* Duplicated from the route layer on purpose rather than imported: this module
+* is the one that reads raw failure bodies, so the redaction belongs at the
+* point of capture. A probe failure body is the one place a raw upstream string
+* from an arbitrary endpoint enters the plugin's data flow.
+*/
+function redact(text) {
+	return text.replace(/\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/gu, "[redacted token]").replace(/(\b(?:code|token|refresh_token|access_token)=)[^&\s]+/giu, "$1[redacted]").slice(0, PROBE_MESSAGE_LIMIT);
+}
+/**
+* Run one probe for one model and reduce it to the card's row.
+*
+* The successful path drains the SSE stream purely to read the `credit` figure
+* the upstream reports, then discards the rest: the probe's question is "did
+* this model answer", and `max_tokens: 1` means there is nothing else in the
+* stream worth keeping.
+*
+* Never throws. A probe is a diagnostic the user asked for, so every failure is
+* a RESULT — one dead model must not abort the batch and hide the other rows.
+*/
+async function probeModel(input) {
+	let answer;
+	const startedAt = Date.now();
+	try {
+		answer = await input.client.probeChat(input.credential, probeRequestBody(input.modelId), input.signal);
+	} catch (error) {
+		return {
+			modelId: input.modelId,
+			outcome: "unavailable",
+			message: redact(error instanceof Error ? error.message : String(error))
+		};
+	}
+	const elapsedMs = Date.now() - startedAt;
+	if (answer.ok) {
+		let credit;
+		if (answer.response !== void 0) try {
+			credit = creditOfStream(await answer.response.text());
+		} catch {}
+		return {
+			modelId: input.modelId,
+			outcome: "ok",
+			elapsedMs: Date.now() - startedAt,
+			status: answer.status,
+			...credit === void 0 ? {} : { message: `credit ${credit}` },
+			...cooldownOf({
+				outcome: "ok",
+				retryAfter: answer.retryAfter,
+				nowMs: input.nowMs,
+				...input.quotaRefreshAtMs === void 0 ? {} : { quotaRefreshAtMs: input.quotaRefreshAtMs }
+			})
+		};
+	}
+	const body = answer.body ?? "";
+	const outcome = outcomeOfFailure(answer.status, body);
+	return {
+		modelId: input.modelId,
+		outcome,
+		elapsedMs,
+		status: answer.status,
+		...body === "" ? {} : { message: redact(body) },
+		...cooldownOf({
+			outcome,
+			retryAfter: answer.retryAfter,
+			nowMs: input.nowMs,
+			...input.quotaRefreshAtMs === void 0 ? {} : { quotaRefreshAtMs: input.quotaRefreshAtMs }
+		})
+	};
+}
+//#endregion
 //#region src/status-paths.ts
 /**
 * Node-free constants and types shared by the Host and browser halves.
@@ -514,6 +718,15 @@ const WORKBUDDY_MODELS_REFRESH_PATH = "/plugins/dsh-connect-workbuddy/models/ref
 const WORKBUDDY_ACCOUNTS_REFRESH_PATH = "/plugins/dsh-connect-workbuddy/accounts/refresh";
 /** Plugin-owned daily check-in action endpoint. */
 const WORKBUDDY_CHECKIN_PATH = "/plugins/dsh-connect-workbuddy/checkin";
+/**
+* Plugin-owned model probe endpoint.
+*
+* Sends one minimal chat request per named model so the card can answer "is
+* this model usable right now, and if it is limited, when can it be used
+* again?". Lives on the Host because the credential must never reach the
+* browser half.
+*/
+const WORKBUDDY_PROBE_PATH = "/plugins/dsh-connect-workbuddy/probe";
 /** Query parameter naming the region a card request addresses. */
 const WORKBUDDY_REGION_PARAM = "region";
 /** Every region, in card tab order. */
@@ -684,6 +897,51 @@ function json(res, status, body) {
 	});
 	res.end(payload);
 }
+/**
+* Cap on how many models one probe request may name.
+*
+* A probe is a real (if tiny) request against a metered service, and the batch
+* runs sequentially, so an unbounded list would let one click hold the route for
+* minutes. The card never sends more than the models on its own screen.
+*/
+const PROBE_BATCH_LIMIT = 64;
+/** Request-body cap for the probe route: model ids only, never content. */
+const PROBE_BODY_LIMIT = 65536;
+/**
+* Read a small JSON request body.
+*
+* Bounded, unlike the settings route's reader: this endpoint takes a list of
+* model ids and has no legitimate use for a large payload, so an oversized body
+* is refused rather than buffered.
+*/
+function readJsonBody(req) {
+	return new Promise((resolve, reject) => {
+		const chunks = [];
+		let size = 0;
+		req.on("data", (chunk) => {
+			size += chunk.length;
+			if (size > PROBE_BODY_LIMIT) {
+				reject(/* @__PURE__ */ new Error("request body too large"));
+				req.destroy();
+				return;
+			}
+			chunks.push(chunk);
+		});
+		req.on("end", () => {
+			try {
+				const parsed = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+				if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+					reject(/* @__PURE__ */ new Error("request body must be a JSON object"));
+					return;
+				}
+				resolve(parsed);
+			} catch (error) {
+				reject(error instanceof Error ? error : new Error(String(error)));
+			}
+		});
+		req.on("error", reject);
+	});
+}
 /** Loopback browser origins only; other devices are refused until trusted origins exist. */
 function loopbackOrigin(req) {
 	const origin = req.headers.origin;
@@ -947,6 +1205,28 @@ function registerWorkBuddyStatusRoute(ctx, deps) {
 				}
 			}
 		});
+		const disposeProbe = ctx.webServer.register({
+			kind: "exact",
+			path: WORKBUDDY_PROBE_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.probeModels === void 0) return json(res, 503, { error: "model probe 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 > PROBE_BATCH_LIMIT) return json(res, 400, { error: `at most ${String(PROBE_BATCH_LIMIT)} models per probe` });
+					const results = [];
+					for (const modelId of modelIds) results.push(...await deps.probeModels(region, [modelId]));
+					json(res, 200, { results });
+				} catch (error) {
+					json(res, 500, { error: safeMessage(error) });
+				}
+			}
+		});
 		const disposeDiagWrite = ctx.webServer.register({
 			kind: "exact",
 			path: "/plugins/dsh-connect-workbuddy/__save",
@@ -1002,6 +1282,7 @@ function registerWorkBuddyStatusRoute(ctx, deps) {
 			disposeCheckin();
 			disposeAccounts();
 			disposeUsage();
+			disposeProbe();
 			disposeDiagWrite();
 		};
 	}, "dsh-connect-workbuddy: Web status route");
@@ -1393,10 +1674,63 @@ function apply(ctx, config) {
 		contextBudgets: (region) => regionStateOf(current(), region).contextBudgets ?? {},
 		discoverModels,
 		regionEnabled: (region) => regionEnabled(current(), region),
+		/**
+		* One minimal request per named model, through the region's own credential.
+		*
+		* Resolved here rather than in the route so the browser half never touches a
+		* token: the route passes only model ids and receives only outcomes.
+		*
+		* `quotaRefreshAtMs` is the region's nearest monthly refresh point, read from
+		* the SAME credit answer the card displays. It is the only cooldown this
+		* service ever states — an exhausted monthly resource that resets at a known
+		* time — so it is what makes "when can I use this again" answerable for an
+		* out-of-credit result. Every other limited outcome has no time anywhere, and
+		* the probe reports exactly that instead of inventing one.
+		*/
+		async probeModels(region, modelIds, signal) {
+			let credential;
+			try {
+				credential = await stacks[region].store.resolve();
+			} catch (error) {
+				return modelIds.map((modelId) => ({
+					modelId,
+					outcome: "credential-rejected",
+					message: error instanceof Error ? error.message.slice(0, 300) : String(error).slice(0, 300)
+				}));
+			}
+			const quotaRefreshAtMs = await quotaRefreshOf(region, credential);
+			const results = [];
+			for (const modelId of modelIds) results.push(await probeModel({
+				client,
+				credential,
+				modelId,
+				nowMs: Date.now(),
+				...quotaRefreshAtMs === void 0 ? {} : { quotaRefreshAtMs },
+				...signal === void 0 ? {} : { signal }
+			}));
+			return results;
+		},
 		regionUsable(region, usable) {
 			if (stacks[region].catalog.setRegionUsable(usable)) invalidateCatalog();
 		}
 	}));
+	/**
+	* The region's nearest monthly quota refresh, or undefined when unknown.
+	*
+	* The monthly resource (`CapacityType 4`) is the one package that never
+	* expires and resets on a cycle, so its `refreshAtMs` is a real answer to
+	* "when can I use this again" after the quota runs out. The probe passes it
+	* through; a failure to read it is not an error, because a probe without a
+	* cooldown is still a useful probe.
+	*/
+	const quotaRefreshOf = async (region, credential) => {
+		try {
+			const refreshes = (await client.fetchCredits(credential)).packages.filter((pack) => pack.monthly && pack.refreshAtMs !== void 0).map((pack) => pack.refreshAtMs);
+			return refreshes.length === 0 ? void 0 : Math.min(...refreshes);
+		} catch {
+			return;
+		}
+	};
 	ctx.inject(["settings"], (sctx) => {
 		const settings = sctx.settings;
 		ctx.effect(() => settings.configure({ auto: true }, ctx.fiber));
@@ -1513,4 +1847,4 @@ function apply(ctx, config) {
 	});
 }
 //#endregion
-export { CREDENTIAL_REJECTED_CODE, Config, ENCRYPTED_CREDENTIAL_CODE, FALLBACK_WORKBUDDY_MODELS, FALLBACK_WORKBUDDY_MODELS_GLOBAL, NATIVE_MODALITY_BY_MODEL_ID, 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_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, createAccountUsabilityProbe, createWorkBuddyAdapter, createWorkBuddyShim, defaultDesktopAuthCandidates, defaultDesktopAuthDirs, defaultDesktopAuthPath, deriveAtRestKey, deriveAtRestKeyId, deriveCatalog, fallbackModelsFor, fetchAtRestKeyPayload, findWorkbuddyAppExecutable, hasEncryptedCredentialFields, imageDefaultFor, inject, isCredentialRejectedError, isEncryptedCredentialError, isEncryptedFieldWrapper, isHeartbeatProcessAlive, isWorkbuddyBundle, legacyAttributionRegion, legacyWorkbuddyOwnAuthPath, macosBundleExecutable, macosNestedAppBundles, name, nativeModalityOf, nextRegionEnabled, nextRegionSlots, openEncryptedField, parseCreditMultiplier, parseReasoning, parseUpstreamModel, parseWorkBuddyAuth, prepareChatBody, processStartTimeMs, readAtRestKey, readHostHeartbeat, regionCleared, regionEnabled, regionEnabledOf, regionOf, regionOfProvider, regionOfStatusUrl, regionStateOf, registerWorkBuddyStatusRoute, resolveCredentialRecovery, selectAccountFor, settingsNamespaceOf, toPersistedWorkBuddyModel, unwrapVolatileDeep, withWorkBuddyRegion, workBuddyDisplayName, workBuddyModelInput, workBuddyThinkingLevelMap, workBuddyWebStatus, workbuddyAccountId, workbuddyAppExecutableCandidates, workbuddyHostHeartbeatPath, workbuddyOwnAuthPath, writeHostHeartbeat };
+export { CREDENTIAL_REJECTED_CODE, Config, ENCRYPTED_CREDENTIAL_CODE, FALLBACK_WORKBUDDY_MODELS, FALLBACK_WORKBUDDY_MODELS_GLOBAL, NATIVE_MODALITY_BY_MODEL_ID, PROBE_MAX_TOKENS, PROBE_SYSTEM_PROMPT, PROBE_USER_PROMPT, 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, deriveAtRestKey, deriveAtRestKeyId, deriveCatalog, fallbackModelsFor, fetchAtRestKeyPayload, findWorkbuddyAppExecutable, hasEncryptedCredentialFields, imageDefaultFor, inject, isCredentialRejectedError, isEncryptedCredentialError, isEncryptedFieldWrapper, isHeartbeatProcessAlive, isWorkbuddyBundle, legacyAttributionRegion, legacyWorkbuddyOwnAuthPath, macosBundleExecutable, macosNestedAppBundles, name, nativeModalityOf, nextRegionEnabled, nextRegionSlots, 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, 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": "2.2.1",
+  "version": "2.3.0",
   "author": "dingminhua",
   "copyright": "Copyright (c) 2026 LaoDing",
   "license": "MIT",