dsh-connect-minimaxcode 0.2.3 → 0.4.0

package/lib/index.js

@@ -1,11 +1,11 @@
 import { readFileSync } from "node:fs";
-import { readFile } from "node:fs/promises";
+import { readFile, rename, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { createProvider } from "@earendil-works/pi-ai";
 import { anthropicMessagesApi } from "@earendil-works/pi-ai/api/anthropic-messages.lazy";
+import { LlmAdapter, resolveRetryPolicy } from "@deepseek-ai/dsh-llm";
 import { PiAiAdapter } from "@deepseek-ai/dsh-llm-pi-ai";
-import { resolveRetryPolicy } from "@deepseek-ai/dsh-llm";
 //#region src/auth.ts
 /**
 * Reading the MiniMax Code desktop app's own sign-in.
@@ -494,6 +494,65 @@ function toPiModel(model, baseUrl, authorization) {
 	};
 }
 /**
+* An adapter that reports what each request used.
+*
+* The usage counters ride on the stream the gateway already sends, so
+* measuring costs nothing extra: the chunk is copied out of the stream and
+* handed to the callback, and the chunk itself still reaches the host
+* unchanged. Both entry points are covered — the plain stream and the one a
+* prepared call dispatches through — because the host may use either.
+*/
+var MeteredAdapter = class extends LlmAdapter {
+	#inner;
+	#onUsage;
+	constructor(inner, onUsage) {
+		super();
+		this.#inner = inner;
+		this.#onUsage = onUsage;
+	}
+	providerInfo(provider) {
+		return this.#inner.providerInfo(provider);
+	}
+	providerRetryPolicy(provider) {
+		return this.#inner.providerRetryPolicy(provider);
+	}
+	listModels(provider) {
+		return this.#inner.listModels(provider);
+	}
+	resolveModel(provider, model, signal) {
+		return this.#inner.resolveModel(provider, model, signal);
+	}
+	async prepareCall(provider, model, signal) {
+		const prepared = await this.#inner.prepareCall(provider, model, signal);
+		return {
+			...prepared,
+			stream: (options) => this.#metered(prepared.stream(options), model)
+		};
+	}
+	stream(options) {
+		return this.#metered(this.#inner.stream(options), options.model);
+	}
+	/** Copy the usage out of a stream, leaving the stream itself untouched. */
+	#metered(chunks, model) {
+		const onUsage = this.#onUsage;
+		return { async *[Symbol.asyncIterator]() {
+			for await (const chunk of chunks) {
+				if (chunk.type === "usage") {
+					const usage = chunk.usage;
+					onUsage(model, {
+						inputTokens: usage.inputTokens,
+						outputTokens: usage.outputTokens,
+						cacheReadTokens: usage.cacheReadTokens ?? 0,
+						cacheWriteTokens: usage.cacheWriteTokens ?? 0,
+						reasoningTokens: usage.reasoningTokens ?? 0
+					});
+				}
+				yield chunk;
+			}
+		} };
+	}
+};
+/**
 * Build the DSH adapter that serves the catalog.
 *
 * The model list is rebuilt on demand rather than snapshotted, which is what
@@ -550,12 +609,13 @@ function createMinimaxCodeAdapter(options) {
 		return /* @__PURE__ */ new Map([[MINIMAXCODE_PROVIDER_ID, route]]);
 	};
 	let profiles = buildProfiles();
+	const inner = new PiAiAdapter({
+		profiles: () => profiles,
+		resolveApiKey: options.resolveApiKey,
+		auth: INERT_AUTH
+	});
 	return {
-		adapter: new PiAiAdapter({
-			profiles: () => profiles,
-			resolveApiKey: options.resolveApiKey,
-			auth: INERT_AUTH
-		}),
+		adapter: options.onUsage === void 0 ? inner : new MeteredAdapter(inner, options.onUsage),
 		invalidate: () => {
 			profiles = buildProfiles();
 		}
@@ -586,7 +646,9 @@ function statusDocument(deps) {
 		catalogSource: deps.catalogSource,
 		...deps.catalogError === void 0 ? {} : { catalogError: deps.catalogError },
 		models: deps.models,
-		refreshing: deps.refreshing
+		refreshing: deps.refreshing,
+		...deps.credits === void 0 ? {} : { credits: deps.credits },
+		...deps.usage === void 0 ? {} : { usage: deps.usage }
 	};
 	if (auth.state === "expired") return {
 		...base,
@@ -611,6 +673,576 @@ function isLoopback(host) {
 	return name === "127.0.0.1" || name === "localhost" || name === "[::1]" || name === "::1";
 }
 //#endregion
+//#region src/credits.ts
+/**
+* The MiniMax Code account's credit balance.
+*
+* Two credentials exist on this machine and they are not interchangeable:
+*
+* - `local-runtime.auth.json` holds a JWT the model gateway accepts. It cannot
+*   read account data: every credit endpoint answers `401`.
+* - `auth/prod/<region>/mcode-public/auth.json` holds the desktop app's OAuth
+*   token (`mmoat_`). That is the credential the account endpoints accept.
+*
+* The balance itself comes from the membership endpoint the desktop app calls
+* itself: `POST /matrix/api/v1/commerce/get_membership_info`, whose response
+* carries `op_credit_summary` — the same three numbers the app's own settings
+* page renders ("remaining credits", free vs purchased).
+*
+* Nothing here performs a login. The plugin may refresh an *expired* token
+* with the refresh token the app already stored, and writes the rotated pair
+* back in the app's own format so the app keeps working; it never starts a
+* sign-in, never revokes, and never touches the app's accounts.
+*
+* @module dsh-connect-minimaxcode/credits
+*/
+/** The desktop app's own OAuth client id. */
+const MINIMAX_OAUTH_CLIENT_ID = "mcode-public";
+/** The scope the app requests. */
+const MINIMAX_OAUTH_SCOPES = ["agent.default"];
+/** The audience the app's tokens are issued for. */
+const MINIMAX_OAUTH_AUDIENCE = "agent-backend";
+/** Authorization server per region. */
+const MINIMAX_AUTH_HOSTS = {
+	cn: "https://account.minimax.cn",
+	io: "https://account.minimax.io",
+	com: "https://account.minimaxi.com"
+};
+/** Gateway serving the account endpoints per region. */
+const MINIMAX_ACCOUNT_HOSTS = {
+	cn: "https://agent.minimax.cn",
+	io: "https://agent.minimax.io",
+	com: "https://agent.minimaxi.com"
+};
+/** Membership endpoint: carries the credit summary. */
+const MEMBERSHIP_PATH = "/matrix/api/v1/commerce/get_membership_info";
+/** Credit ledger endpoint: per-grant amounts and expiry. */
+const CREDIT_DETAILS_PATH = "/minimax-cloud/api/v1/credit/details";
+/** OAuth token endpoint. */
+const TOKEN_PATH = "/oauth2/token";
+/** Absolute path of the app's credential file for a region. */
+function oauthAuthPath(region, env = process.env) {
+	return join(dataDir(env), "auth", "prod", region, "mcode-public", "auth.json");
+}
+/** Milliseconds until the credential expires; negative once it has. */
+function expiresInMs$1(credential, now = Date.now()) {
+	return credential.expiresAtMs === void 0 ? void 0 : credential.expiresAtMs - now;
+}
+/** Whether the credential is close enough to expiry to be worth refreshing. */
+function needsRefresh(credential, now = Date.now()) {
+	const remaining = expiresInMs$1(credential, now);
+	return remaining !== void 0 && remaining <= 12e4;
+}
+/**
+* Parse the app's credential document.
+*
+* The record key is generated per install, so the record is found by value
+* rather than by a hard-coded name.
+*/
+function parseOAuthDocument(text, now = Date.now()) {
+	let parsed;
+	try {
+		parsed = JSON.parse(text);
+	} catch {
+		return {
+			state: "signed-out",
+			reason: "unreadable"
+		};
+	}
+	const records = parsed.records;
+	if (typeof records !== "object" || records === null) return {
+		state: "signed-out",
+		reason: "not-signed-in"
+	};
+	const record = Object.values(records)[0];
+	if (typeof record !== "object" || record === null) return {
+		state: "signed-out",
+		reason: "not-signed-in"
+	};
+	const entry = record;
+	const token = entry.accessToken;
+	if (typeof token !== "string" || token.length === 0) return {
+		state: "signed-out",
+		reason: "not-signed-in"
+	};
+	const expiresAtMs = typeof entry.expiresAtMs === "number" ? entry.expiresAtMs : void 0;
+	const credential = {
+		token,
+		refreshToken: typeof entry.refreshToken === "string" ? entry.refreshToken : void 0,
+		expiresAtMs,
+		clientId: typeof entry.clientId === "string" ? entry.clientId : MINIMAX_OAUTH_CLIENT_ID,
+		scopes: Array.isArray(entry.scopes) ? entry.scopes.filter((s) => typeof s === "string") : [...MINIMAX_OAUTH_SCOPES],
+		audience: typeof entry.audience === "string" ? entry.audience : MINIMAX_OAUTH_AUDIENCE,
+		generation: typeof entry.generation === "number" ? entry.generation : void 0
+	};
+	return expiresAtMs !== void 0 && expiresAtMs <= now ? {
+		state: "expired",
+		credential
+	} : {
+		state: "signed-in",
+		credential
+	};
+}
+/**
+* Read the desktop app's OAuth credential.
+*
+* Every failure is a state, not an exception: an app that is not installed, or
+* not signed in, is a normal condition the UI renders rather than an error the
+* host logs on every request.
+*/
+async function readOAuthCredential(region, env = process.env, now = Date.now()) {
+	let text;
+	try {
+		text = await readFile(oauthAuthPath(region, env), "utf8");
+	} catch {
+		return {
+			state: "signed-out",
+			reason: "app-missing"
+		};
+	}
+	return parseOAuthDocument(text, now);
+}
+/**
+* Exchange the stored refresh token for a fresh access token.
+*
+* The authorization server rotates the refresh token, so the new pair is
+* written back into the app's own file, in the app's own format, with an
+* atomic replace. `generation` is left untouched on purpose: the app uses it
+* to decide whether a stored credential still belongs to its own login, and
+* raising it would make the app believe it had been signed in elsewhere.
+*/
+async function refreshOAuthCredential(region, credential, env = process.env, now = Date.now(), fetchImpl = fetch) {
+	if (credential.refreshToken === void 0) return {
+		state: "expired",
+		credential
+	};
+	const body = new URLSearchParams({
+		grant_type: "refresh_token",
+		refresh_token: credential.refreshToken,
+		client_id: credential.clientId,
+		scope: credential.scopes.join(" "),
+		audience: credential.audience
+	});
+	const response = await fetchImpl(`${MINIMAX_AUTH_HOSTS[region]}${TOKEN_PATH}`, {
+		method: "POST",
+		headers: {
+			accept: "application/json",
+			"content-type": "application/x-www-form-urlencoded"
+		},
+		body
+	});
+	if (!response.ok) throw new Error(`OAuth refresh failed: HTTP ${response.status}`);
+	const document = await response.json();
+	const token = document.access_token;
+	if (typeof token !== "string" || token.length === 0) throw new Error("OAuth refresh returned no access token");
+	const expiresInSec = typeof document.expires_in === "number" ? document.expires_in : void 0;
+	const next = {
+		...credential,
+		token,
+		refreshToken: typeof document.refresh_token === "string" ? document.refresh_token : credential.refreshToken,
+		expiresAtMs: expiresInSec === void 0 ? void 0 : now + expiresInSec * 1e3
+	};
+	await writeOAuthCredential(region, next, env);
+	return {
+		state: "signed-in",
+		credential: next
+	};
+}
+/**
+* Write a rotated credential back into the app's store.
+*
+* The document is rewritten as a whole so the app's own reader keeps seeing
+* the shape it wrote, and the replace is atomic so a crash mid-write cannot
+* leave a truncated credential file behind.
+*/
+async function writeOAuthCredential(region, credential, env = process.env) {
+	const path = oauthAuthPath(region, env);
+	let document;
+	try {
+		document = JSON.parse(await readFile(path, "utf8"));
+	} catch {
+		return;
+	}
+	const records = document.records;
+	if (typeof records !== "object" || records === null) return;
+	const first = Object.entries(records)[0];
+	if (first === void 0) return;
+	const [key, record] = first;
+	if (typeof record !== "object" || record === null) return;
+	const existing = record;
+	const updated = {
+		...existing,
+		accessToken: credential.token,
+		refreshToken: credential.refreshToken ?? existing.refreshToken,
+		tokenType: "Bearer",
+		clientId: credential.clientId,
+		scopes: credential.scopes,
+		audience: credential.audience,
+		expiresAtMs: credential.expiresAtMs
+	};
+	const payload = {
+		...document,
+		records: {
+			...records,
+			[key]: updated
+		}
+	};
+	const temporary = `${path}.dsh-connect-minimaxcode.tmp`;
+	await writeFile(temporary, `${JSON.stringify(payload, null, 2)}\n`, { mode: 384 });
+	await rename(temporary, path);
+}
+/**
+* Read the credential, refreshing it when it is close to expiry.
+*
+* A refresh is only attempted for a credential the app already stored, and
+* only when it is actually stale: a fresh token is left alone, so the plugin
+* never competes with the app for the same grant.
+*/
+async function ensureOAuthCredential(region, env = process.env, now = Date.now(), fetchImpl = fetch) {
+	const state = await readOAuthCredential(region, env, now);
+	if (state.state === "signed-in" && !needsRefresh(state.credential, now)) return state;
+	if (state.state === "signed-out") return state;
+	try {
+		return await refreshOAuthCredential(region, state.credential, env, now, fetchImpl);
+	} catch {
+		return state;
+	}
+}
+/**
+* Read the credit summary out of a membership response.
+*
+* The app's settings page prefers the summary and falls back to the flat
+* balance fields, so the same fallback chain is used here.
+*/
+function parseCreditSummary(document) {
+	if (typeof document !== "object" || document === null) return void 0;
+	const record = document;
+	const summary = record.op_credit_summary;
+	if (typeof summary === "object" && summary !== null) {
+		const entry = summary;
+		const total = toNumber(entry.total_remaining_amount);
+		if (total !== void 0) {
+			const purchased = toNumber(entry.purchased_remaining_amount) ?? 0;
+			return {
+				total,
+				purchased,
+				free: toNumber(entry.free_remaining_amount) ?? total - purchased
+			};
+		}
+	}
+	const flat = toNumber(record.opcredit_balance) ?? toNumber(record.total_remains_credit);
+	return flat === void 0 ? void 0 : {
+		total: flat,
+		purchased: 0,
+		free: flat
+	};
+}
+/** Read a numeric field the upstream may send as a string. */
+function toNumber(value) {
+	if (typeof value === "number" && Number.isFinite(value)) return value;
+	if (typeof value === "string" && value.trim() !== "") {
+		const parsed = Number(value);
+		return Number.isFinite(parsed) ? parsed : void 0;
+	}
+}
+/**
+* Fetch the current credit balance.
+*
+* @returns The balance, or `undefined` when the account has no credit summary.
+*/
+async function fetchCreditSummary(credential, region, fetchImpl = fetch) {
+	const response = await fetchImpl(`${MINIMAX_ACCOUNT_HOSTS[region]}${MEMBERSHIP_PATH}`, {
+		method: "POST",
+		headers: {
+			"content-type": "application/json",
+			authorization: `Bearer ${credential.token}`
+		},
+		body: "{}"
+	});
+	if (!response.ok) throw new Error(`membership request failed: HTTP ${response.status}`);
+	return parseCreditSummary(await response.json());
+}
+/**
+* Read the credit lots out of a ledger response.
+*
+* Lots that carry no expiry are ignored: a lot without an expiry date would
+* otherwise be treated as one that never expires.
+*/
+function parseCreditLots(document) {
+	if (typeof document !== "object" || document === null) return [];
+	const details = document.details;
+	if (!Array.isArray(details)) return [];
+	const lots = [];
+	for (const entry of details) {
+		if (typeof entry !== "object" || entry === null) continue;
+		const record = entry;
+		const expireAtMs = toNumber(record.expire_at_ms);
+		if (expireAtMs === void 0) continue;
+		const granted = toNumber(record.granted_amount) ?? 0;
+		const remaining = toNumber(record.remaining_amount) ?? 0;
+		lots.push({
+			granted,
+			remaining,
+			consumed: toNumber(record.consumed_amount) ?? Math.max(0, granted - remaining),
+			grantedAtMs: toNumber(record.granted_at_ms) ?? 0,
+			expireAtMs,
+			creditType: toNumber(record.credit_type)
+		});
+	}
+	return lots.sort((a, b) => a.expireAtMs - b.expireAtMs);
+}
+/**
+* Fetch the credit ledger.
+*
+* The ledger is paginated, so every page is read. The number of pages comes
+* from the account's own `total_count` rather than from a guess, and a lot
+* count that stops growing ends the walk.
+*/
+async function fetchCreditLots(credential, region, fetchImpl = fetch) {
+	const pageSize = 100;
+	const lots = [];
+	let page = 1;
+	let total = Number.POSITIVE_INFINITY;
+	while (lots.length < total && page <= 50) {
+		const response = await fetchImpl(`${MINIMAX_ACCOUNT_HOSTS[region]}${CREDIT_DETAILS_PATH}?page=${page}&page_size=${pageSize}`, { headers: { authorization: `Bearer ${credential.token}` } });
+		if (!response.ok) throw new Error(`credit ledger request failed: HTTP ${response.status}`);
+		const document = await response.json();
+		const batch = parseCreditLots(document);
+		lots.push(...batch);
+		const count = toNumber(document.total_count);
+		if (count !== void 0) total = count;
+		if (batch.length < pageSize) break;
+		page += 1;
+	}
+	return lots;
+}
+/**
+* Summarize what is about to expire.
+*
+* Only lots that still hold credits count: a lot that was granted and used up
+* expires with nothing to lose, and counting it would make every account look
+* like it is about to lose credits.
+*/
+function summarizeExpiry(lots, now = Date.now()) {
+	const alive = lots.filter((lot) => lot.remaining > 0 && lot.expireAtMs > now);
+	const within = (days) => alive.filter((lot) => lot.expireAtMs - now <= days * 864e5);
+	const week = within(7);
+	const month = within(30);
+	return {
+		expiring: week.reduce((sum, lot) => sum + lot.remaining, 0),
+		expiringLots: week.length,
+		expiringSoon: month.reduce((sum, lot) => sum + lot.remaining, 0),
+		nextExpiryAtMs: alive[0]?.expireAtMs,
+		upcoming: alive.slice(0, 5).map((lot) => ({
+			amount: lot.remaining,
+			expireAtMs: lot.expireAtMs
+		})),
+		totalRemaining: lots.reduce((sum, lot) => sum + lot.remaining, 0)
+	};
+}
+/**
+* Keeps the current balance and the change between reads.
+*
+* The first read has nothing to compare against, so it reports no movement
+* rather than pretending the whole balance was spent.
+*/
+var MinimaxCredits = class {
+	#snapshot;
+	#error;
+	#lots = [];
+	#expiry;
+	#ledgerAtMs;
+	#ledgerError;
+	/** The balance as last read. */
+	get snapshot() {
+		return this.#snapshot;
+	}
+	/** Why the last read failed, when one did. */
+	get error() {
+		return this.#error;
+	}
+	/** The credit lots as last read. */
+	get lots() {
+		return this.#lots;
+	}
+	/** What the lots say about expiry, when the ledger could be read. */
+	get expiry() {
+		return this.#expiry;
+	}
+	/** When the ledger was last read. */
+	get ledgerAtMs() {
+		return this.#ledgerAtMs;
+	}
+	/** Why the ledger could not be read, when it could not. */
+	get ledgerError() {
+		return this.#ledgerError;
+	}
+	/**
+	* Read the balance and record how much was consumed since the last read.
+	*
+	* The credit ledger is read alongside it, but a ledger that cannot be read
+	* never hides the balance: the two come from different endpoints and only
+	* the balance is essential.
+	*
+	* @returns Whether the balance changed.
+	*/
+	async refresh(credential, region, fetchImpl = fetch, now = Date.now()) {
+		let changed = false;
+		try {
+			const summary = await fetchCreditSummary(credential, region, fetchImpl);
+			if (summary === void 0) this.#error = "membership response carried no credit summary";
+			else {
+				const previous = this.#snapshot;
+				this.#snapshot = {
+					summary,
+					fetchedAtMs: now,
+					consumed: previous === void 0 ? 0 : previous.summary.total - summary.total
+				};
+				this.#error = void 0;
+				changed = previous === void 0 || previous.summary.total !== summary.total;
+			}
+		} catch (error) {
+			this.#error = error instanceof Error ? error.message : String(error);
+		}
+		await this.refreshLedger(credential, region, fetchImpl, now);
+		return changed;
+	}
+	/**
+	* Read the credit ledger and work out what is about to expire.
+	*
+	* A failure here is remembered but never thrown: the balance is what the
+	* user needs most, and a ledger that is temporarily unavailable must not
+	* take it down with it.
+	*/
+	async refreshLedger(credential, region, fetchImpl = fetch, now = Date.now()) {
+		try {
+			const lots = await fetchCreditLots(credential, region, fetchImpl);
+			this.#lots = lots;
+			this.#expiry = summarizeExpiry(lots, now);
+			this.#ledgerAtMs = now;
+			this.#ledgerError = void 0;
+		} catch (error) {
+			this.#ledgerError = error instanceof Error ? error.message : String(error);
+		}
+	}
+};
+//#endregion
+//#region src/usage.ts
+/** An empty usage record. */
+const EMPTY_USAGE = {
+	inputTokens: 0,
+	outputTokens: 0,
+	cacheReadTokens: 0,
+	cacheWriteTokens: 0,
+	reasoningTokens: 0
+};
+/** The published domestic prices of the models this plugin serves. */
+const MODEL_PRICES = {
+	"MiniMax-M3.1-Flash": {
+		input: 1,
+		output: 4,
+		cacheRead: .1
+	},
+	"MiniMax-M3": {
+		input: 2.1,
+		output: 8.4,
+		cacheRead: .42
+	}
+};
+/**
+* The price for one model at one input size.
+*
+* M3 is billed in two tiers: requests above 512k input tokens cost double.
+* The tier is decided by the billed input, which is the uncached input plus
+* the cache read.
+*/
+function priceFor(model, billedInputTokens) {
+	const price = MODEL_PRICES[model];
+	if (price === void 0) return void 0;
+	if (model === "MiniMax-M3" && billedInputTokens > 512e3) return {
+		input: price.input * 2,
+		output: price.output * 2,
+		cacheRead: price.cacheRead * 2
+	};
+	return price;
+}
+/**
+* The equivalent amount of one request, in 元.
+*
+* Returns `undefined` for a model without a published price, rather than
+* pretending the request was free.
+*/
+function estimateCny(model, usage) {
+	const price = priceFor(model, usage.inputTokens + usage.cacheReadTokens);
+	if (price === void 0) return void 0;
+	const perMillion = (tokens, rate) => tokens / 1e6 * rate;
+	return perMillion(usage.inputTokens, price.input) + perMillion(usage.outputTokens, price.output) + perMillion(usage.cacheReadTokens, price.cacheRead);
+}
+/**
+* Accumulates what the sessions routed through this plugin have used.
+*
+* The meter is the plugin's own view: it counts the requests this host made,
+* with the counters the gateway returned. It is not the account's total, and
+* it is not the credit balance — the balance comes from the account API.
+*/
+var UsageMeter = class {
+	#records = [];
+	#byModel = /* @__PURE__ */ new Map();
+	/** Every recorded request, oldest first. */
+	get records() {
+		return this.#records;
+	}
+	/** The most recent request. */
+	get last() {
+		return this.#records[this.#records.length - 1];
+	}
+	/** Record one request's usage. */
+	record(model, usage) {
+		const entry = {
+			model,
+			usage: { ...usage },
+			cny: estimateCny(model, usage)
+		};
+		this.#records.push(entry);
+		const totals = this.#byModel.get(model) ?? { ...EMPTY_USAGE };
+		this.#byModel.set(model, {
+			inputTokens: totals.inputTokens + usage.inputTokens,
+			outputTokens: totals.outputTokens + usage.outputTokens,
+			cacheReadTokens: totals.cacheReadTokens + usage.cacheReadTokens,
+			cacheWriteTokens: totals.cacheWriteTokens + usage.cacheWriteTokens,
+			reasoningTokens: totals.reasoningTokens + usage.reasoningTokens
+		});
+		return entry;
+	}
+	/** Totals across every recorded request. */
+	totals() {
+		let total = { ...EMPTY_USAGE };
+		for (const usage of this.#byModel.values()) total = {
+			inputTokens: total.inputTokens + usage.inputTokens,
+			outputTokens: total.outputTokens + usage.outputTokens,
+			cacheReadTokens: total.cacheReadTokens + usage.cacheReadTokens,
+			cacheWriteTokens: total.cacheWriteTokens + usage.cacheWriteTokens,
+			reasoningTokens: total.reasoningTokens + usage.reasoningTokens
+		};
+		return total;
+	}
+	/** Totals per model. */
+	byModel() {
+		return this.#byModel;
+	}
+	/** The equivalent amount of everything recorded, in 元. */
+	estimatedCny() {
+		let total = 0;
+		for (const record of this.#records) if (record.cny !== void 0) total += record.cny;
+		return total;
+	}
+	/** Forget everything recorded. */
+	reset() {
+		this.#records = [];
+		this.#byModel.clear();
+	}
+};
+//#endregion
 //#region src/index.ts
 /** Loader entry name; also the id the bundle patch inserts. */
 const name = "dsh-connect-minimaxcode";
@@ -624,6 +1256,13 @@ function pickRegion(preferred) {
 /** How often the card may pull a fresh catalog. */
 const CATALOG_TTL_MS = 3e5;
 /**
+* How often the account's credit balance may be re-read.
+*
+* The balance is a live counter upstream, but it is an account-wide value:
+* reading it too often buys nothing except load on the account API.
+*/
+const CREDIT_TTL_MS = 3e4;
+/**
 * Compose the plugin.
 *
 * The credential is re-read on every request rather than cached at start: the
@@ -634,10 +1273,14 @@ const CATALOG_TTL_MS = 3e5;
 */
 function apply(ctx) {
 	const catalog = new MinimaxCatalog();
+	const credits = new MinimaxCredits();
+	const meter = new UsageMeter();
 	let region = "cn";
 	let credential;
 	let lastCatalogAtMs = 0;
+	let lastCreditAtMs = 0;
 	let refreshing = false;
+	let creditState = "unavailable";
 	const readNow = async () => {
 		const state = await readCredential();
 		if (state.state !== "signed-in") {
@@ -659,25 +1302,97 @@ function apply(ctx) {
 			refreshing = false;
 		}
 	};
+	/**
+	* Read the account's credit balance, at most once per TTL.
+	*
+	* The account API needs the desktop app's own OAuth token, not the model
+	* gateway's JWT, so this reads a second credential file. A stale token is
+	* refreshed through the app's own grant and written back in the app's own
+	* format, which keeps the app signed in.
+	*/
+	const refreshCredits = async () => {
+		const now = Date.now();
+		if (now - lastCreditAtMs < CREDIT_TTL_MS) return;
+		lastCreditAtMs = now;
+		const state = await ensureOAuthCredential(region, process.env, now);
+		if (state.state === "signed-out") {
+			creditState = "signed-out";
+			return;
+		}
+		if (state.state === "expired") {
+			creditState = "expired";
+			return;
+		}
+		await credits.refresh(state.credential, region, fetch, now);
+		creditState = credits.snapshot === void 0 ? "unavailable" : "ok";
+	};
+	/** The credit balance as the card and the browser half read it. */
+	const buildCreditStatus = () => {
+		const snapshot = credits.snapshot;
+		const expiry = credits.expiry;
+		if (snapshot === void 0) return {
+			state: creditState,
+			...credits.error === void 0 ? {} : { error: credits.error }
+		};
+		return {
+			state: "ok",
+			total: snapshot.summary.total,
+			purchased: snapshot.summary.purchased,
+			free: snapshot.summary.free,
+			consumed: snapshot.consumed,
+			updatedAtMs: snapshot.fetchedAtMs,
+			...expiry === void 0 ? {} : {
+				expiring: expiry.expiring,
+				expiringLots: expiry.expiringLots,
+				expiringSoon: expiry.expiringSoon,
+				nextExpiryAtMs: expiry.nextExpiryAtMs,
+				upcoming: expiry.upcoming
+			},
+			...credits.ledgerAtMs === void 0 ? {} : { ledgerAtMs: credits.ledgerAtMs },
+			...credits.ledgerError === void 0 ? {} : { ledgerError: credits.ledgerError }
+		};
+	};
+	/** What this host's own requests have used. */
+	const buildUsageStatus = () => {
+		const totals = meter.totals();
+		const last = meter.last;
+		return {
+			inputTokens: totals.inputTokens,
+			outputTokens: totals.outputTokens,
+			cacheReadTokens: totals.cacheReadTokens,
+			cacheWriteTokens: totals.cacheWriteTokens,
+			reasoningTokens: totals.reasoningTokens,
+			estimatedCny: meter.estimatedCny(),
+			...last?.cny === void 0 ? {} : { lastCny: last.cny },
+			...last === void 0 ? {} : { lastModel: last.model },
+			requests: meter.records.length
+		};
+	};
 	const { adapter, invalidate } = createMinimaxCodeAdapter({
 		catalog,
 		region: () => region,
 		resolveApiKey: async () => (await readNow())?.token,
-		bearerToken: () => bearerToken()
+		bearerToken: () => bearerToken(),
+		onUsage: (model, usage) => {
+			meter.record(model, usage);
+			refreshCredits();
+		}
 	});
 	ctx.llm.registerAdapter(["minimaxcode"], adapter);
 	/** Build the document the card renders, without ever exposing the token. */
 	const buildStatus = async () => {
 		const state = await readCredential();
+		const auth = state.state === "signed-in" ? {
+			state: "signed-in",
+			daysRemaining: Math.ceil(expiresInMs(state.credential.claims) / 864e5),
+			expiry: expiryLevel(state.credential.claims)
+		} : state.state === "expired" ? { state: "expired" } : {
+			state: "signed-out",
+			reason: state.reason
+		};
+		await refreshCredits();
 		return statusDocument({
-			auth: state.state === "signed-in" ? {
-				state: "signed-in",
-				daysRemaining: Math.ceil(expiresInMs(state.credential.claims) / 864e5),
-				expiry: expiryLevel(state.credential.claims)
-			} : state.state === "expired" ? { state: "expired" } : {
-				state: "signed-out",
-				reason: state.reason
-			},
+			auth,
 			region,
 			catalogSource: catalog.source,
 			catalogError: catalog.error,
@@ -686,7 +1401,9 @@ function apply(ctx) {
 				name: modelName,
 				contextWindow
 			})),
-			refreshing
+			refreshing,
+			credits: buildCreditStatus(),
+			usage: buildUsageStatus()
 		});
 	};
 	(async () => {
@@ -719,4 +1436,4 @@ function apply(ctx) {
 	});
 }
 //#endregion
-export { FALLBACK_MODELS, MINIMAXCODE_PROVIDER_ID, MINIMAX_AUTH_FILENAME, MINIMAX_DATA_DIR, MINIMAX_GATEWAYS, MINIMAX_REGIONS, MINIMAX_STATUS_PATH, MINIMAX_STREAM_IDLE_TIMEOUT_MS, MinimaxCatalog, apply, authPath, bearerToken, catalogUrl, chatBaseUrl, createMinimaxCodeAdapter, dataDir, daysRemaining, decodeClaims, expiresInMs, expiryLevel, inject, name, parseAuthDocument, parseCatalog, readCredential, statusDocument };
+export { EMPTY_USAGE, FALLBACK_MODELS, MEMBERSHIP_PATH, MINIMAXCODE_PROVIDER_ID, MINIMAX_AUTH_FILENAME, MINIMAX_DATA_DIR, MINIMAX_GATEWAYS, MINIMAX_OAUTH_CLIENT_ID, MINIMAX_REGIONS, MINIMAX_STATUS_PATH, MINIMAX_STREAM_IDLE_TIMEOUT_MS, MODEL_PRICES, MinimaxCatalog, MinimaxCredits, UsageMeter, apply, authPath, bearerToken, catalogUrl, chatBaseUrl, createMinimaxCodeAdapter, dataDir, daysRemaining, decodeClaims, ensureOAuthCredential, estimateCny, expiresInMs, expiryLevel, fetchCreditSummary, inject, name, parseAuthDocument, parseCatalog, parseCreditSummary, parseOAuthDocument, priceFor, readCredential, readOAuthCredential, refreshOAuthCredential, statusDocument, writeOAuthCredential };