dsh-connect-workbuddy 2.2.1 → 2.3.1

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-CDZRWbFv.js";
 import z from "@deepseek-ai/schemastery";
 import { randomBytes, timingSafeEqual } from "node:crypto";
 import { createProvider } from "@earendil-works/pi-ai";
@@ -492,6 +492,304 @@ 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.";
+/**
+* Output cap for a probe. One token is enough to prove the model answers.
+*
+* The probe's cost comes from its INPUT, not its output (see
+* {@link PROBE_INPUT_TOKENS}), so paying for a long completion would add money
+* without adding signal.
+*/
+const PROBE_MAX_TOKENS = 1;
+/**
+* How much input a probe sends, in tokens.
+*
+* This is the whole point of the probe, and it is NOT a free choice. The
+* upstream's rate limit (business code 6004) fires on request SIZE, measured on
+* 2026-09-29 by varying only the input against one account and one model:
+*
+*   | input     | prompt_tokens the upstream counted | result |
+*   | ---       | ---                                | ---    |
+*   | ~10       | 38                                 | ok     |
+*   | ~1,000    | 1,138                              | ok     |
+*   | ~10,000   | 11,138                             | ok     |
+*   | ~18,000   | 20,018                             | ok     |
+*   | ~25,000   | 25,023                             | ok     |
+*   | ~30,000   | ~32k                               | **429 / 6004** |
+*
+* So the threshold sits between 20k and 30k, a SINGLE large request is enough to
+* trip it (it is not a running total), and each account reports its own reset
+* time (two accounts at the same moment: `22:20:33` and `00:32:51`).
+*
+* A probe that sent a handful of tokens answered "usable" while every real
+* request in a long conversation was refused — the probe was asking too small a
+* question. 25k is sized to be a realistic long-conversation payload.
+*/
+const PROBE_INPUT_TOKENS = 25e3;
+/**
+* Characters per token for the filler text, measured.
+*
+* Filling with a fixed English sentence, the upstream counted about 4.5
+* characters per token. An estimate rather than a bundled tokenizer: the body
+* only needs to be the right SIZE CLASS, and the target has ample margin over
+* the measured threshold, so estimate error cannot change the verdict.
+*/
+const CHARS_PER_TOKEN = 4.5;
+/** Neutral filler; carries no user content, only volume. */
+const FILLER_LINE = "The quick brown fox jumps over the lazy dog. ";
+/**
+* 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.
+*
+* Measured on the built artifact: 112,713 bytes of body, and the upstream
+* counted `prompt_tokens: 25023` at a cost of `credit: 0.72`.
+*/
+function probeRequestBody(modelId) {
+	const targetChars = Math.ceil(PROBE_INPUT_TOKENS * CHARS_PER_TOKEN);
+	const filler = FILLER_LINE.repeat(Math.ceil(targetChars / 45));
+	return JSON.stringify({
+		model: modelId,
+		messages: [{
+			role: "system",
+			content: PROBE_SYSTEM_PROMPT
+		}, {
+			role: "user",
+			content: `${filler}Reply with a single word.`
+		}],
+		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 upstream's reset sentence, as its Chinese gateway writes it.
+*
+* Measured on a live 429 (code 6004), verbatim:
+*
+*   `您的使用量已超出频率限制，将在 2026-09-30 02:30:30 UTC+8 重置，您也可以切换其他模型继续使用。`
+*
+* The two halves are captured separately because the second one is the whole
+* reason this parser exists: the upstream DOES name a time, and the plugin was
+* showing "the upstream gave no time" while the answer was sitting right there
+* in the body. The earlier note in this module ("the upstream provides no
+* rate-limit metadata") was drawn from the RESPONSE HEADERS alone — true as far
+* as it went, and wrong as a conclusion, because the time is in the body text.
+*
+* Deliberately loose about the surrounding wording (`[\s\S]*?` on both sides)
+* and strict about the parts that must not be guessed: the keyword 重置, the
+* timestamp shape, and an explicit UTC offset. A message that merely mentions
+* 重置 without a parsable offset yields no time, which is the honest answer.
+*/
+const UPSTREAM_RESET_PATTERN = /将在?\s*(\d{4})-(\d{2})-(\d{2})[ T](\d{2}):(\d{2}):(\d{2})\s*UTC\s*([+-])(\d{1,2})(?::?(\d{2}))?[\s\S]*?重置/u;
+/**
+* Parse the reset time out of an upstream failure message.
+*
+* Returns epoch ms, or undefined when the message names no parsable time — the
+* caller must then say "the upstream gave no time", never invent one.
+*
+* THE OFFSET IS HONOURED, NOT ASSUMED. `2026-09-30 02:30:30 UTC+8` is 18:30:30
+* UTC the previous day, and `Date.parse` on the bare string would read it as
+* LOCAL time — on a machine set to UTC+8 that happens to be right, and on any
+* other machine it is silently wrong by the offset. So the components are
+* assembled with `Date.UTC` and the stated offset subtracted, which is correct
+* on every host regardless of its own zone.
+*
+* A whole-second resolution is what the upstream prints; sub-second precision
+* would be fiction in the other direction.
+*/
+function parseUpstreamResetAt(message) {
+	const match = UPSTREAM_RESET_PATTERN.exec(message);
+	if (match === null) return void 0;
+	const [, year, month, day, hour, minute, second, sign, offsetHours, offsetMinutes] = match;
+	const offsetTotalMinutes = (sign === "-" ? -1 : 1) * (Number(offsetHours) * 60 + Number(offsetMinutes ?? "0"));
+	const utcMs = Date.UTC(Number(year), Number(month) - 1, Number(day), Number(hour), Number(minute), Number(second));
+	const parsed = new Date(utcMs);
+	if (parsed.getUTCFullYear() !== Number(year) || parsed.getUTCMonth() !== Number(month) - 1 || parsed.getUTCDate() !== Number(day) || parsed.getUTCHours() !== Number(hour) || parsed.getUTCMinutes() !== Number(minute) || parsed.getUTCSeconds() !== Number(second)) return;
+	if (Math.abs(offsetTotalMinutes) > 840) return void 0;
+	return utcMs - offsetTotalMinutes * 6e4;
+}
+/**
+* The cooldown the upstream stated, if it stated one.
+*
+* Three 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 reset time the upstream writes into its own failure body (see
+*    {@link parseUpstreamResetAt}). This is the case that actually fires on
+*    this service: a 429 from the Chinese gateway carries code 6004 and a
+*    `将在 … 重置` sentence, with no `Retry-After` header at all.
+* 3. 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 limited outcome with none of the three returns `{}`, which the card renders
+* as "the upstream did not say when". That remains the honest answer for a
+* genuinely timeless failure; 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"
+	};
+	const fromBody = input.body === void 0 ? void 0 : parseUpstreamResetAt(input.body);
+	if (fromBody !== void 0) return {
+		retryAtMs: fromBody,
+		retrySource: "upstream-message"
+	};
+	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 question is whether this
+* model answers a real-sized request, 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,
+			body,
+			...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 +812,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 +991,43 @@ function json(res, status, body) {
 	});
 	res.end(payload);
 }
+/** 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 +1291,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 > 1) return json(res, 400, { error: "a probe accepts exactly one model" });
+					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 +1368,7 @@ function registerWorkBuddyStatusRoute(ctx, deps) {
 			disposeCheckin();
 			disposeAccounts();
 			disposeUsage();
+			disposeProbe();
 			disposeDiagWrite();
 		};
 	}, "dsh-connect-workbuddy: Web status route");
@@ -1393,10 +1760,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, options) {
+			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 },
+				...options?.signal === void 0 ? {} : { signal: options.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 +1933,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_INPUT_TOKENS, PROBE_MAX_TOKENS, PROBE_SYSTEM_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.1",
   "author": "dingminhua",
   "copyright": "Copyright (c) 2026 LaoDing",
   "license": "MIT",