dsh-any-deepseek 0.0.13 → 0.0.15

package/lib/balance.d.ts

@@ -119,6 +119,25 @@ export declare function parseOllamaBalance(body: unknown): BalanceReading | unde
  * @returns the reading, or undefined when neither body is this shape.
  */
 export declare function parseOpenAIBilling(subscription: unknown, usage: unknown): BalanceReading | undefined;
+/**
+ * Parse OpenCode Go's `GET /zen/go/v1/usage`.
+ *
+ * 🔴 **This surface reports WINDOWS, never money.** The owner remembered correctly that OpenCode
+ * exposes a usage query — and it does; what it does not expose (to an API key) is the credit
+ * wallet, which lives behind a logged-in browser session. The only key-authenticated money signal
+ * is the error thrown at $0 (anomalyco/opencode#44189), which is why the feature request asks for
+ * a `balance` object to be added to this very endpoint.
+ *
+ * Two response shapes are accepted, because a monitor should not break when the provider ships
+ * the requested addition:
+ *  · `{ usage: { rolling: {percent, resetsAt}, weekly: … , monthly: … } }`
+ *  · the same keys hoisted to the top level.
+ * A `balance` object is read IF PRESENT — so the day they merge that request, the number appears
+ * with no code change here.
+ * @param body - the parsed JSON body.
+ * @returns the reading, or undefined when the body carries no recognizable window.
+ */
+export declare function parseOpencodeWindows(body: unknown): BalanceReading | undefined;
 /**
  * Map one channel's raw bodies onto a reading, dispatching on the declared shape.
  * @param probe - the preset's declared probe.

package/lib/channels.d.ts

@@ -102,7 +102,10 @@ export interface ResolvedChannel {
      * How this endpoint's remaining balance can be read, when it can be.
      *
      * Absent means "no balance API" — a real state, not a missing value. See `presets.ts` for the
-     * three verified shapes and why OpenCode Go deliberately has none.
+     * four verified shapes. Note the two different kinds of "no number": OpenCode Go reports usage
+     * WINDOWS rather than money (it does have a surface), while Open Design publishes no surface at
+     * all (measured: seven candidates, all 404). The panel distinguishes them, and checks liveness
+     * for the latter instead of inventing an amount.
      */
     balance?: BalanceProbe;
     /** Facts the user should see because a default was applied rather than declared. */

package/lib/client.js

@@ -27,12 +27,20 @@ window.__ModuleLoader__.load({
 		*
 		* Deliberately total: every status produces words, never an empty string. A blank cell beside a
 		* working channel is indistinguishable from "zero balance" — the one thing this must never imply.
+		*
+		* 🔴 **`alive` is worded as 「余额未尽」, never as a number.** The check behind it is one minimal
+		* live request, which proves the endpoint serves and the account is not blocked for lack of
+		* credit. It does not measure an amount, so printing one — or printing `0.00` — would invent the
+		* very figure this status exists to avoid inventing (owner directive 2026-10-23: 「不支持查余额的，
+		* 改成直接测通，通则说明余额还是有的，没用完」).
 		* @param row - one row from `/balance`.
 		* @returns a short human label.
 		*/
 		function formatBalance(row) {
+			if (row.status === "alive") return `余额未尽（无余额接口，实测可用：${row.responded === void 0 ? `${Math.round(row.ms)}ms` : `${row.responded} · ${Math.round(row.ms)}ms`}）`;
 			if (row.status !== "ok") {
 				if (row.status === "no-key") return "未配置密钥";
+				if (row.code === "QUOTA") return "余额不足（实测被拒）";
 				if (row.status === "unavailable") return row.code === "HTTP_404" ? "不支持查询" : "读取失败";
 				return "不支持查询";
 			}
@@ -508,6 +516,7 @@ window.__ModuleLoader__.load({
 									type: "button",
 									className: "ad-link",
 									disabled: balancesLoading || rows.length === 0,
+									title: "无余额接口的渠道会用一次最小真实请求测通（消耗一两个 token）",
 									onClick: () => {
 										refreshBalances();
 									},

package/lib/http.d.ts

@@ -121,10 +121,11 @@ export declare function reportedName(text: string): string;
 /**
  * Fetch one channel's remaining balance from whatever surface it declares.
  *
- * 🔴 **Absence is a normal answer here, and is reported as such.** Three outcomes are kept apart
+ * 🔴 **Absence is a normal answer here, and is reported as such.** Outcomes are kept apart
  * because they mean different things to the user:
- *  · `unsupported` — the preset declares no balance shape (OpenCode Go: the provider has an open
- *    request for one, because today the only key-authenticated signal is an error at $0).
+ *  · `unsupported` — the preset declares no balance shape. This is no longer the end of the story
+ *    for the panel: `/{@link balanceRow}` turns it into a liveness verdict, because "the endpoint
+ *    will not tell me the amount" and "the account is fine" are different facts and both matter.
  *  · `unavailable` — a shape was declared but the endpoint did not answer as expected (404,
  *    non-JSON, unexpected body). The relay may simply not implement it.
  *  · `ok` — a reading, which itself may carry only a note (e.g. "unlimited, used $3.20").
@@ -147,6 +148,68 @@ export declare function fetchBalance(channel: ResolvedChannel, key: string, sign
     detail: string;
     code?: string;
 }>;
+/**
+ * One row of `/balance`, as it travels to the panel.
+ *
+ * `alive` is the fourth outcome and exists because of an owner directive (2026-10-23):
+ * 「对于不支持查余额的，改成直接测通，通则说明余额还是有的，没用完，显示出来（消耗一两个token）」.
+ *
+ * 🔴 **`alive` is NOT a balance number and must never be rendered as one.** It is the result of a
+ * minimal real inference request, and it proves exactly three things: the key works, the endpoint
+ * serves, and the account is not blocked for lack of credit (a $0 account answers 402/quota, it
+ * does not answer 200). It says nothing about HOW MUCH is left. The panel wording therefore says
+ * 「余额未尽」 — "not exhausted" — which is the strongest true claim available here, and stops
+ * short of the number a reader might otherwise assume.
+ */
+export type BalanceRowWire = {
+    id: string;
+    label: string;
+    status: 'ok';
+    reading: BalanceReading;
+} | {
+    id: string;
+    label: string;
+    status: 'unsupported';
+    detail: string;
+} | {
+    id: string;
+    label: string;
+    status: 'unavailable';
+    detail: string;
+    code?: string;
+} | {
+    id: string;
+    label: string;
+    status: 'alive';
+    /** How long the liveness request took. */
+    ms: number;
+    /** What the relay called its model — a serving endpoint answers with a name. */
+    responded?: string;
+    detail: string;
+};
+/**
+ * The stated reason an `alive` row carries no number.
+ *
+ * Kept as a constant so the server and every reader of the payload say the same thing: this row
+ * is about liveness, not about a balance.
+ */
+export declare const ALIVE_DETAIL: string;
+/**
+ * Build one `/balance` row, falling back to a liveness probe when there is no balance surface.
+ *
+ * 🔴 **The fallback spends tokens, so it is scoped as tightly as possible**: it runs ONLY when the
+ * balance surface is absent (`unsupported`), never for a channel whose balance API answered `ok`
+ * and never for one that exists but failed (`unavailable` — that is a "try again" state, and
+ * probing it would replace a transient error with a different-looking success).
+ *
+ * The cost is one prompt plus one output token on a completions channel (`max_tokens: 1` in
+ * {@link probeRequest}); the Responses cap is a ceiling, not a spend.
+ * @param channel - the resolved channel.
+ * @param key - its resolved credential (already resolved by the caller, so a probe and a real
+ *   request never read the key differently).
+ * @returns the row, always resolved — one dead relay must not blank the others.
+ */
+export declare function balanceRow(channel: ResolvedChannel, key: string): Promise<BalanceRowWire>;
 /**
  * Register the panel's routes.
  * @param ctx - plugin context (only used to bind the disposer when the host offers one).

package/lib/index.js

@@ -278,7 +278,25 @@ const CHANNEL_PRESETS = {
 		...V41_FLASH_CAPS,
 		compat: { ...DEEPSEEK_THINKING_COMPAT },
 		headers: { ...OPENCODE_HEADERS },
-		note: "Requires the OpenCode session headers; shipped with the preset. No balance API (subscription usage only)."
+		/**
+		* 🔴 **The owner was right that OpenCode has a query surface — and it reports WINDOWS, not
+		* money.** Both halves of that sentence were measured, in that order:
+		*
+		*  1. A route exists at `/zen/go/v1/usage`. Proven by status code discrimination without a
+		*     key: a made-up path under the same prefix answers **404**, while `/usage` answers
+		*     **401** (route present, auth required). `/zen/v1/balance` answers 404 — that one really
+		*     does not exist (it is what anomalyco/opencode#44189 is asking for).
+		*  2. What it returns is Go-subscription usage windows (rolling / weekly / monthly), **not**
+		*     the credit wallet. The balance is only reachable from a logged-in browser session
+		*     (`BillingTable.balance` behind a SolidStart server function), so a key cannot read it —
+		*     the only key-authenticated money signal is the error thrown at $0.
+		*
+		* ⇒ Declared as a `windows` shape, which is exactly what this endpoint honestly provides.
+		* The credit balance stays absent rather than invented; the panel shows the windows and does
+		* not pretend a currency amount exists.
+		*/
+		balance: { shape: "opencode-windows" },
+		note: "Requires the OpenCode session headers; shipped with the preset. Usage windows only — the credit balance is not readable with an API key."
 	},
 	commandcode: {
 		displayName: "CommandCode",
@@ -304,8 +322,7 @@ const CHANNEL_PRESETS = {
 		api: "openai-completions",
 		baseURL: "https://amr-link.open-design.ai/v1",
 		model: "deepseek-v4.1-flash",
-		...V41_FLASH_CAPS,
-		balance: { shape: "openai-billing" }
+		...V41_FLASH_CAPS
 	},
 	"deepseek-official": {
 		displayName: "DeepSeek Official",
@@ -1792,6 +1809,7 @@ function balanceUrls(probe, channelBaseURL) {
 	switch (probe.shape) {
 		case "deepseek": return [`${root}/user/balance`];
 		case "ollama": return [`${root}/api/balance`];
+		case "opencode-windows": return [`${root}/usage`];
 		case "openai-billing": return [`${root}/dashboard/billing/subscription`, `${root}/dashboard/billing/usage`];
 	}
 }
@@ -1951,6 +1969,58 @@ function parseOpenAIBilling(subscription, usage) {
 	};
 }
 /**
+* Parse OpenCode Go's `GET /zen/go/v1/usage`.
+*
+* 🔴 **This surface reports WINDOWS, never money.** The owner remembered correctly that OpenCode
+* exposes a usage query — and it does; what it does not expose (to an API key) is the credit
+* wallet, which lives behind a logged-in browser session. The only key-authenticated money signal
+* is the error thrown at $0 (anomalyco/opencode#44189), which is why the feature request asks for
+* a `balance` object to be added to this very endpoint.
+*
+* Two response shapes are accepted, because a monitor should not break when the provider ships
+* the requested addition:
+*  · `{ usage: { rolling: {percent, resetsAt}, weekly: … , monthly: … } }`
+*  · the same keys hoisted to the top level.
+* A `balance` object is read IF PRESENT — so the day they merge that request, the number appears
+* with no code change here.
+* @param body - the parsed JSON body.
+* @returns the reading, or undefined when the body carries no recognizable window.
+*/
+function parseOpencodeWindows(body) {
+	const root = asRecord(body);
+	if (root === void 0) return void 0;
+	const usage = asRecord(root.usage) ?? root;
+	const windows = [];
+	for (const name of [
+		"rolling",
+		"weekly",
+		"monthly"
+	]) {
+		const window = asRecord(usage[name]);
+		if (window === void 0) continue;
+		const used = num(window.percent);
+		if (used === void 0) continue;
+		windows.push({
+			name,
+			remainingPercent: Math.max(0, Math.min(100, 100 - used)),
+			...text(window.resetsAt) === void 0 ? {} : { resetsAt: text(window.resetsAt) }
+		});
+	}
+	const amounts = [];
+	const balance = asRecord(root.balance);
+	const usd = num(balance?.usd);
+	if (usd !== void 0) amounts.push({
+		currency: text(balance?.currency) ?? "USD",
+		remaining: usd
+	});
+	if (windows.length === 0 && amounts.length === 0) return void 0;
+	return {
+		amounts,
+		windows,
+		note: amounts.length === 0 ? "subscription usage windows; the credit balance is not readable with an API key" : void 0
+	};
+}
+/**
 * Map one channel's raw bodies onto a reading, dispatching on the declared shape.
 * @param probe - the preset's declared probe.
 * @param bodies - response bodies in the order {@link balanceUrls} returned URLs.
@@ -1960,6 +2030,7 @@ function readBalance(probe, bodies) {
 	switch (probe.shape) {
 		case "deepseek": return parseDeepSeekBalance(bodies[0]);
 		case "ollama": return parseOllamaBalance(bodies[0]);
+		case "opencode-windows": return parseOpencodeWindows(bodies[0]);
 		case "openai-billing": return parseOpenAIBilling(bodies[0], bodies[1]);
 	}
 }
@@ -2164,10 +2235,11 @@ function reportedName(text) {
 /**
 * Fetch one channel's remaining balance from whatever surface it declares.
 *
-* 🔴 **Absence is a normal answer here, and is reported as such.** Three outcomes are kept apart
+* 🔴 **Absence is a normal answer here, and is reported as such.** Outcomes are kept apart
 * because they mean different things to the user:
-*  · `unsupported` — the preset declares no balance shape (OpenCode Go: the provider has an open
-*    request for one, because today the only key-authenticated signal is an error at $0).
+*  · `unsupported` — the preset declares no balance shape. This is no longer the end of the story
+*    for the panel: `/{@link balanceRow}` turns it into a liveness verdict, because "the endpoint
+*    will not tell me the amount" and "the account is fine" are different facts and both matter.
 *  · `unavailable` — a shape was declared but the endpoint did not answer as expected (404,
 *    non-JSON, unexpected body). The relay may simply not implement it.
 *  · `ok` — a reading, which itself may carry only a note (e.g. "unlimited, used $3.20").
@@ -2200,11 +2272,29 @@ async function fetchBalance(channel, key, signal) {
 			...signal === void 0 ? {} : { signal }
 		});
 		const text = await response.text();
-		if (!response.ok) return {
-			status: "unavailable",
-			code: `HTTP_${response.status}`,
-			detail: `balance endpoint answered HTTP ${response.status}`
-		};
+		if (!response.ok) {
+			/**
+			* 🔴 **404 means "this relay has no such route", not "the read failed".**
+			*
+			* The distinction decides what the user does next: `unsupported` says "this endpoint
+			* does not publish a balance — stop looking", while `unavailable` says "it should have
+			* but did not answer — try again". Reporting a 404 as a failure invites a retry loop
+			* against a route that will never exist.
+			*
+			* Measured: Open Design answers 404 on every billing candidate while `/v1/models`
+			* answers 401 (route exists, auth required) — that difference is how the two were told
+			* apart without a key.
+			*/
+			if (response.status === 404) return {
+				status: "unsupported",
+				detail: "this relay has no balance route (HTTP 404)"
+			};
+			return {
+				status: "unavailable",
+				code: `HTTP_${response.status}`,
+				detail: `balance endpoint answered HTTP ${response.status}`
+			};
+		}
 		try {
 			bodies.push(JSON.parse(text));
 		} catch {
@@ -2230,6 +2320,61 @@ async function fetchBalance(channel, key, signal) {
 		reading
 	};
 }
+/**
+* The stated reason an `alive` row carries no number.
+*
+* Kept as a constant so the server and every reader of the payload say the same thing: this row
+* is about liveness, not about a balance.
+*/
+const ALIVE_DETAIL = "this endpoint publishes no balance API; a minimal live request succeeded, so it is serving and its credit is not exhausted (no amount is readable)";
+/**
+* Build one `/balance` row, falling back to a liveness probe when there is no balance surface.
+*
+* 🔴 **The fallback spends tokens, so it is scoped as tightly as possible**: it runs ONLY when the
+* balance surface is absent (`unsupported`), never for a channel whose balance API answered `ok`
+* and never for one that exists but failed (`unavailable` — that is a "try again" state, and
+* probing it would replace a transient error with a different-looking success).
+*
+* The cost is one prompt plus one output token on a completions channel (`max_tokens: 1` in
+* {@link probeRequest}); the Responses cap is a ceiling, not a spend.
+* @param channel - the resolved channel.
+* @param key - its resolved credential (already resolved by the caller, so a probe and a real
+*   request never read the key differently).
+* @returns the row, always resolved — one dead relay must not blank the others.
+*/
+async function balanceRow(channel, key) {
+	const outcome = await fetchBalance(channel, key);
+	if (outcome.status !== "unsupported") return {
+		id: channel.id,
+		label: channel.label,
+		...outcome
+	};
+	const verdict = await probeChannel(channel, key, `probe:${channel.id}`);
+	if (!verdict.ok)
+ /**
+	* The liveness request failed, so nothing was learned about the account.
+	*
+	* It is reported as `unavailable` rather than as a verdict of its own because that is what it
+	* is: we tried to find out and did not. `code` is passed through untouched, which is what lets
+	* the panel tell the one FAILURE THAT IS ACTUALLY AN ANSWER (`QUOTA` — the account is out of
+	* credit) from the ones that are just errors.
+	*/
+	return {
+		id: channel.id,
+		label: channel.label,
+		status: "unavailable",
+		detail: `no balance API, and the liveness request failed: ${verdict.message ?? verdict.code ?? "unknown"}`,
+		...verdict.code === void 0 ? {} : { code: verdict.code }
+	};
+	return {
+		id: channel.id,
+		label: channel.label,
+		status: "alive",
+		ms: verdict.ms,
+		...verdict.responded === void 0 || verdict.responded === "" ? {} : { responded: verdict.responded },
+		detail: ALIVE_DETAIL
+	};
+}
 /** Map an HTTP status from a probe onto the same codes the runtime uses. */
 function probeCode(status, body) {
 	if (status === 401 || status === 403) return "AUTH";
@@ -2380,10 +2525,12 @@ function registerStatsRoutes(ctx, webServer, deps) {
 			/**
 			* Remaining balance per channel.
 			*
-			* GET because it reads and costs nothing at the provider (all three surfaces are plain
-			* account reads, not model calls). Every channel is attempted independently: one relay
-			* without a balance API, or one that is down, must not blank the others — the same rule the
-			* channel list follows for a broken entry.
+			* GET because it is a read, but 🔴 **it is no longer free**: a channel whose endpoint has no
+			* balance surface is now checked with one minimal live request (owner directive 2026-10-23),
+			* which costs a prompt plus one output token. The route stays GET because the panel's
+			* button is what triggers it — nothing here fires on render. Every channel is attempted
+			* independently: one relay without a balance API, or one that is down, must not blank the
+			* others — the same rule the channel list follows for a broken entry.
 			*/
 			kind: "exact",
 			path: `${ROUTE_PREFIX}/balance`,
@@ -2397,12 +2544,7 @@ function registerStatsRoutes(ctx, webServer, deps) {
 						status: "no-key",
 						detail: "no key configured"
 					};
-					const outcome = await fetchBalance(channel, key);
-					return {
-						id: channel.id,
-						label: channel.label,
-						...outcome
-					};
+					return balanceRow(channel, key);
 				})) });
 			}
 		}

package/lib/presets.d.ts

@@ -32,23 +32,26 @@ export type ChannelModality = 'text' | 'image';
  * How to read one endpoint's remaining balance.
  *
  * Owner request (2026-10-23): 「其它渠道的查看方式你需要找到并实现它们的」. There is no single
- * answer — every provider invented its own surface, and some have none at all. This type is that
- * fact written down instead of guessed: a preset either names a known shape or says it has none.
- *
- * Three shapes were verified against real endpoints (see `balance.ts` for the response mapping):
- *  · `deepseek`  — DeepSeek's own `GET /user/balance`.
- *  · `ollama`    — `GET /api/balance` (note: under `/api`, NOT the `/v1` used for inference).
- *  · `openai-billing` — the OpenAI-legacy billing pair that new-api / one-api relays clone:
+ * answer — every provider invented its own surface, and some report windows instead of money.
+ * This type is that fact written down instead of guessed: a preset either names a known shape or
+ * says it has none.
+ *
+ * Four shapes were verified against real endpoints (see `balance.ts` for the response mapping):
+ *  · `deepseek`        — DeepSeek's own `GET /user/balance`.
+ *  · `ollama`          — `GET /api/balance` (note: under `/api`, NOT the `/v1` used for inference).
+ *  · `opencode-windows` — OpenCode Go's `GET /zen/go/v1/usage`: rolling/weekly/monthly WINDOWS.
+ *                         No currency amount — the credit wallet is not API-readable.
+ *  · `openai-billing`  — the OpenAI-legacy billing pair that new-api / one-api relays clone:
  *    `GET /v1/dashboard/billing/subscription` + `GET /v1/dashboard/billing/usage`.
  *
- * 🔴 **A fourth answer is legitimate and must be representable: "this endpoint has no balance
- * API".** OpenCode Zen is exactly that case — its owner has an open feature request asking for
- * one, because today the only key-authenticated signal is the error thrown at $0
- * (anomalyco/opencode#44189). Pretending otherwise would mean showing a number nobody measured.
+ * 🔴 **"This endpoint has no balance API" must be representable, and is**: a preset simply omits
+ * `balance`. Open Design is a measured case (every billing candidate answers 404 while
+ * `/v1/models` answers 401, i.e. inference only). Pretending otherwise would mean showing a
+ * number nobody measured.
  */
 export interface BalanceProbe {
     /** Which response shape to read. */
-    shape: 'deepseek' | 'ollama' | 'openai-billing';
+    shape: 'deepseek' | 'ollama' | 'opencode-windows' | 'openai-billing';
     /**
      * Overrides the base URL for the balance call.
      *
@@ -95,7 +98,9 @@ export interface ChannelPreset {
      *
      * Absent means "this endpoint has no balance API we know of" — a real and common state, not an
      * omission. The panel says so explicitly rather than leaving a blank cell that could be read
-     * as zero.
+     * as zero, and then checks the endpoint is ALIVE with one minimal live request (owner directive
+     * 2026-10-23): "no amount is readable" and "the credit is spent" are different facts, and a
+     * successful call proves the second is not true. See `http.ts`'s `balanceRow`.
      */
     balance?: BalanceProbe;
     /** One-line note for the panel, when the relay needs explaining. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-any-deepseek",
-  "version": "0.0.13",
+  "version": "0.0.15",
   "description": "One DeepSeek V4.1 Flash provider for DeepSeek Harness: paste a key per channel, switch channels manually, token usage booked per real upstream.",
   "license": "MIT",
   "repository": {