@narumitw/pi-usage 0.58.0 → 0.59.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@narumitw/pi-usage",
-	"version": "0.58.0",
+	"version": "0.59.0",
 	"description": "Pi extension that shows current-account usage and DeepSeek API balance for supported providers.",
 	"type": "module",
 	"license": "MIT",
@@ -14,9 +14,15 @@
 		"balance",
 		"deepseek",
 		"fireworks",
+		"baseten",
+		"vercel-ai-gateway",
 		"codex",
 		"kimi",
 		"kimi-coding",
+		"moonshot",
+		"moonshotai",
+		"minimax",
+		"token-plan",
 		"copilot",
 		"openrouter",
 		"opencode",

package/src/format.ts

@@ -12,23 +12,39 @@ const VALUE_COLUMN = 29;
 export function formatUsageReport(report: UsageReport, displayState: UsageDisplayState): string {
 	const stateLabel = displayState === "current" ? "Current" : "Configured";
 	const title =
-		report.providerId === "deepseek"
-			? "DeepSeek API Balance"
-			: report.providerId === "fireworks"
-				? "Fireworks API Spend"
-				: `${report.providerName} Usage`;
+		report.providerId === "baseten"
+			? "Baseten Model APIs Spend"
+			: report.providerId === "deepseek"
+				? "DeepSeek API Balance"
+				: report.providerId === "fireworks"
+					? "Fireworks API Spend"
+					: report.providerId === "vercel-ai-gateway"
+						? "Vercel AI Gateway Credits"
+						: report.providerId === "moonshotai" || report.providerId === "moonshotai-cn"
+							? `${report.providerName} Balance`
+							: report.providerId === "minimax" || report.providerId === "minimax-cn"
+								? report.source === "minimax-account-balance"
+									? `${report.providerName} API Balance`
+									: `${report.providerName} Token Plan`
+								: `${report.providerName} Usage`;
 	const lines = [`${title} · ${stateLabel}`];
 	if (report.accountLabel) lines.push(`Account: ${report.accountLabel}`);
 	lines.push(`Semantics: ${report.semantics.label}`, "");
 
-	if (report.providerId === "openai-codex") formatCodexReport(lines, report);
+	if (report.providerId === "baseten") formatBasetenReport(lines, report);
+	else if (report.providerId === "openai-codex") formatCodexReport(lines, report);
 	else if (report.providerId === "deepseek") formatDeepSeekReport(lines, report);
 	else if (report.providerId === "fireworks") formatFireworksReport(lines, report);
+	else if (report.providerId === "vercel-ai-gateway") formatVercelAIGatewayReport(lines, report);
 	else if (report.providerId === "github-copilot") formatGitHubCopilotReport(lines, report);
 	else if (report.providerId === "openrouter") formatOpenRouterReport(lines, report);
 	else if (report.providerId === "opencode-go") formatOpenCodeZenReport(lines, report);
 	else if (report.providerId === "kimi-coding") formatKimiCodingReport(lines, report);
-	else if (report.providerId === "xai") formatXaiReport(lines, report);
+	else if (report.providerId === "moonshotai" || report.providerId === "moonshotai-cn") {
+		formatMoonshotReport(lines, report);
+	} else if (report.providerId === "minimax" || report.providerId === "minimax-cn") {
+		formatMiniMaxReport(lines, report);
+	} else if (report.providerId === "xai") formatXaiReport(lines, report);
 	else if (report.providerId === "zai" || report.providerId === "zai-coding-cn") {
 		formatZaiReport(lines, report);
 	} else formatGenericReport(lines, report);
@@ -45,11 +61,13 @@ export function formatUsageStatusline(
 	now = Date.now(),
 	showCodexResetCountdown = true,
 ): string | undefined {
+	if (report.providerId === "baseten") return formatBasetenStatusline(report);
 	if (report.providerId === "openai-codex") {
 		return formatCodexStatusline(report, model, now, showCodexResetCountdown);
 	}
 	if (report.providerId === "deepseek") return formatDeepSeekStatusline(report);
 	if (report.providerId === "fireworks") return formatFireworksStatusline(report);
+	if (report.providerId === "vercel-ai-gateway") return formatVercelAIGatewayStatusline(report);
 	if (report.providerId === "github-copilot") return formatGitHubCopilotStatusline(report);
 	if (report.providerId === "openrouter") {
 		const limit = report.buckets.find((bucket) => bucket.id === "key-limit");
@@ -59,6 +77,12 @@ export function formatUsageStatusline(
 	}
 	if (report.providerId === "opencode-go") return formatOpenCodeZenStatusline(report);
 	if (report.providerId === "kimi-coding") return formatKimiCodingStatusline(report);
+	if (report.providerId === "moonshotai" || report.providerId === "moonshotai-cn") {
+		return formatMoonshotStatusline(report);
+	}
+	if (report.providerId === "minimax" || report.providerId === "minimax-cn") {
+		return formatMiniMaxStatusline(report, model);
+	}
 	if (report.providerId === "zai" || report.providerId === "zai-coding-cn") {
 		return formatZaiStatusline(report);
 	}
@@ -81,6 +105,18 @@ export function formatProviderStates(states: readonly ProviderUsageState[]): str
 		.join("\n\n");
 }
 
+function formatBasetenReport(lines: string[], report: UsageReport): void {
+	lines.push(`${"Spend window:".padEnd(VALUE_COLUMN)}Last 30 days`);
+	for (const metric of report.metrics) {
+		lines.push(`${`${metric.label}:`.padEnd(VALUE_COLUMN)}USD ${metric.value}`);
+	}
+}
+
+function formatBasetenStatusline(report: UsageReport): string {
+	const subtotal = report.metrics.find((metric) => metric.id === "net-subtotal");
+	return subtotal ? `baseten USD ${subtotal.value} net` : "baseten no Model APIs usage";
+}
+
 function formatCodexReport(lines: string[], report: UsageReport): void {
 	let previousGroup: string | undefined;
 	for (const bucket of report.buckets) {
@@ -157,6 +193,17 @@ function fireworksCurrencies(report: UsageReport): string[] {
 	return currencies;
 }
 
+function formatVercelAIGatewayReport(lines: string[], report: UsageReport): void {
+	for (const metric of report.metrics) {
+		lines.push(`${`${metric.label}:`.padEnd(VALUE_COLUMN)}USD ${metric.value}`);
+	}
+}
+
+function formatVercelAIGatewayStatusline(report: UsageReport): string {
+	const balance = report.metrics.find((metric) => metric.id === "credit-balance");
+	return balance ? `vercel USD ${balance.value} left` : "vercel credits unavailable";
+}
+
 function formatGitHubCopilotReport(lines: string[], report: UsageReport): void {
 	const quota = findGitHubCopilotQuota(report);
 	if (!quota || quota.limit === undefined || quota.remaining === undefined) {
@@ -286,6 +333,113 @@ function formatKimiCodingStatusline(report: UsageReport): string | undefined {
 	return parts.length > 1 ? parts.join(" ") : undefined;
 }
 
+function formatMoonshotReport(lines: string[], report: UsageReport): void {
+	for (const metric of report.metrics) {
+		lines.push(`${`${metric.label}:`.padEnd(VALUE_COLUMN)}${metric.currency} ${metric.value}`);
+	}
+}
+
+function formatMoonshotStatusline(report: UsageReport): string {
+	const available = report.metrics.find((metric) => metric.id === "available-balance");
+	if (!available) return "moonshot balance unavailable";
+	return `moonshot ${available.currency ?? ""} ${available.value}`.replace(/\s+/gu, " ");
+}
+
+function formatMiniMaxReport(lines: string[], report: UsageReport): void {
+	if (report.source === "minimax-account-balance") {
+		for (const metric of report.metrics) {
+			lines.push(`${`${metric.label}:`.padEnd(VALUE_COLUMN)}${metric.currency} ${metric.value}`);
+		}
+		return;
+	}
+	let previousGroup: string | undefined;
+	for (const bucket of report.buckets) {
+		if (bucket.groupId !== previousGroup) lines.push(`${bucket.groupLabel ?? "Token Plan"}:`);
+		previousGroup = bucket.groupId;
+		const reset = bucket.resetsAt ? ` (resets ${formatReset(bucket.resetsAt)})` : "";
+		const value =
+			bucket.period === "unlimited"
+				? "unlimited"
+				: bucket.limit && bucket.remaining !== undefined
+					? `${bucket.remaining} of ${bucket.limit} left · ${percentRemaining(bucket)}%${reset}`
+					: "unavailable";
+		lines.push(`${`${bucket.label}:`.padEnd(VALUE_COLUMN)}${value}`);
+	}
+}
+
+function formatMiniMaxStatusline(report: UsageReport, model?: UsageModel): string | undefined {
+	const prefix = report.providerId === "minimax-cn" ? "minimax cn" : "minimax";
+	if (report.source === "minimax-account-balance") {
+		const available = report.metrics.find((metric) => metric.id === "available-balance");
+		return available ? `${prefix} ${available.currency} ${available.value}` : undefined;
+	}
+	const selectedGroup = selectMiniMaxGroup(report, model);
+	if (!selectedGroup) return undefined;
+	const selected = report.buckets.filter((bucket) => bucket.groupId === selectedGroup);
+	const parts = [prefix];
+	for (const bucket of selected) {
+		const fallback = bucket.id.endsWith(":weekly") ? "weekly" : "5h";
+		const window = formatWindowLabel(bucket.windowMinutes, fallback, true);
+		if (bucket.period === "unlimited") {
+			parts.push(`unlimited ${window}`);
+			continue;
+		}
+		if (!bucket.limit || bucket.remaining === undefined) continue;
+		parts.push(`${percentRemaining(bucket)}% ${window}`);
+	}
+	return parts.length > 1 ? parts.join(" ") : undefined;
+}
+
+function selectMiniMaxGroup(report: UsageReport, model?: UsageModel): string | undefined {
+	const groups = [
+		...new Set(
+			report.buckets
+				.map((bucket) => bucket.groupId)
+				.filter((group): group is string => group !== undefined),
+		),
+	];
+	if (groups.length <= 1) return groups[0];
+	if (model?.provider !== report.providerId) return undefined;
+	const modelKeys = [model.id, model.name]
+		.map(normalizeMiniMaxModelKey)
+		.filter((key): key is string => key !== undefined);
+	const candidates = groups.map((group) => {
+		const bucket = report.buckets.find((candidate) => candidate.groupId === group);
+		const patterns = [bucket?.groupLabel, ...(bucket?.modelKeys ?? []), group]
+			.map(normalizeMiniMaxModelKey)
+			.filter((key): key is string => key !== undefined);
+		return { group, patterns };
+	});
+	const exact = candidates.find(({ patterns }) =>
+		patterns.some((pattern) => !pattern.includes("*") && modelKeys.includes(pattern)),
+	);
+	if (exact) return exact.group;
+	return candidates.find(({ patterns }) =>
+		patterns.some(
+			(pattern) =>
+				pattern.includes("*") && modelKeys.some((key) => wildcardKeyMatches(pattern, key)),
+		),
+	)?.group;
+}
+
+function normalizeMiniMaxModelKey(value: string | undefined): string | undefined {
+	const key = value?.toLowerCase().replace(/[^a-z0-9*]+/gu, "");
+	return key && /[a-z0-9]/u.test(key) ? key : undefined;
+}
+
+function wildcardKeyMatches(pattern: string, value: string): boolean {
+	if (!pattern.includes("*")) return pattern === value;
+	const segments = pattern.split("*").filter(Boolean);
+	let offset = 0;
+	for (const [index, segment] of segments.entries()) {
+		const found = value.indexOf(segment, offset);
+		if (found < 0 || (index === 0 && !pattern.startsWith("*") && found !== 0)) return false;
+		offset = found + segment.length;
+	}
+	const last = segments.at(-1);
+	return pattern.endsWith("*") || (last !== undefined && value.endsWith(last));
+}
+
 function formatZaiStatusline(report: UsageReport): string | undefined {
 	const selected = [
 		report.buckets.find((bucket) => bucket.id === "five-hour"),

package/src/index.ts

@@ -32,6 +32,7 @@ export {
 	UsageCache,
 } from "./core.js";
 export { formatProviderStates, formatUsageReport, formatUsageStatusline } from "./format.js";
+export { normalizeBasetenBillingUsagePayload } from "./providers/baseten.js";
 export { normalizeCodexBackendPayload } from "./providers/codex.js";
 export { normalizeDeepSeekBalancePayload } from "./providers/deepseek.js";
 export {
@@ -40,8 +41,16 @@ export {
 } from "./providers/fireworks.js";
 export { normalizeGitHubCopilotUsagePayload } from "./providers/github-copilot.js";
 export { normalizeKimiCodingUsagePayload } from "./providers/kimi-coding.js";
+export type { MiniMaxProviderId, MiniMaxUsageKind } from "./providers/minimax.js";
+export {
+	miniMaxUsageKind,
+	normalizeMiniMaxUsagePayload,
+} from "./providers/minimax.js";
+export type { MoonshotProviderId } from "./providers/moonshot.js";
+export { normalizeMoonshotBalancePayload } from "./providers/moonshot.js";
 export { normalizeOpenCodeZenPayload } from "./providers/opencode-zen.js";
 export { normalizeOpenRouterKeyPayload } from "./providers/openrouter.js";
+export { normalizeVercelAIGatewayCreditsPayload } from "./providers/vercel-ai-gateway.js";
 export { normalizeXaiBillingPayload } from "./providers/xai.js";
 export { normalizeZaiQuotaPayload } from "./providers/zai.js";
 export {
@@ -67,10 +76,13 @@ export {
 	usageSettingsPath,
 } from "./settings.js";
 export type {
+	BasetenBillingUsagePayload,
 	DeepSeekBalancePayload,
 	FireworksAccountsPayload,
 	FireworksBillingSummaryPayload,
 	KimiCodingUsagePayload,
+	MiniMaxUsagePayload,
+	MoonshotBalancePayload,
 	ProviderUsageState,
 	ResolvedUsageAuth,
 	UsageBucket,
@@ -83,6 +95,7 @@ export type {
 	UsageSemantics,
 	UsageSemanticsKind,
 	UsageUnit,
+	VercelAIGatewayCreditsPayload,
 	XaiBillingPayload,
 	XaiUserPayload,
 } from "./types.js";

package/src/providers/baseten.ts

@@ -0,0 +1,55 @@
+import type { BasetenBillingUsagePayload, UsageMetric, UsageReport } from "../types.js";
+
+const DECIMAL_AMOUNT = /^(?:0|[1-9]\d*)(?:\.\d+)?$/u;
+
+export function normalizeBasetenBillingUsagePayload(
+	payload: BasetenBillingUsagePayload,
+	capturedAt: number,
+): UsageReport {
+	if (payload.model_apis_usage === undefined || payload.model_apis_usage === null) {
+		return report(capturedAt, [], ["Baseten returned no Model APIs usage for the last 30 days."]);
+	}
+	const usage = asObject(payload.model_apis_usage);
+	if (!usage) throw new Error("Baseten Model APIs usage was not an object.");
+	const metrics: UsageMetric[] = [
+		metric("gross-usage", "Gross usage", usage.total),
+		metric("credits-used", "Credits used", usage.credits_used),
+		metric("net-subtotal", "Net subtotal", usage.subtotal),
+	];
+	return report(capturedAt, metrics);
+}
+
+function report(capturedAt: number, metrics: UsageMetric[], notes?: string[]): UsageReport {
+	return {
+		providerId: "baseten",
+		providerName: "Baseten",
+		capturedAt,
+		source: "baseten-billing-usage-summary",
+		semantics: { kind: "api-key", label: "Organization Model APIs spend" },
+		buckets: [],
+		metrics,
+		...(notes ? { notes } : {}),
+	};
+}
+
+function metric(id: string, label: string, value: unknown): UsageMetric {
+	const amount = decimalAmount(value, label);
+	return { id, label, value: amount, unit: "currency", currency: "USD" };
+}
+
+function decimalAmount(value: unknown, label: string): string {
+	const normalized = typeof value === "number" && Number.isFinite(value) ? String(value) : value;
+	if (
+		typeof normalized !== "string" ||
+		normalized.length > 64 ||
+		!DECIMAL_AMOUNT.test(normalized)
+	) {
+		throw new Error(`Baseten ${label.toLowerCase()} was not a valid nonnegative amount.`);
+	}
+	return normalized;
+}
+
+function asObject(value: unknown): Record<string, unknown> | undefined {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+	return value as Record<string, unknown>;
+}

package/src/providers/minimax.ts

@@ -0,0 +1,264 @@
+import { sanitizeDisplayText } from "../core.js";
+import type { MiniMaxUsagePayload, UsageBucket, UsageMetric, UsageReport } from "../types.js";
+
+export type MiniMaxProviderId = "minimax" | "minimax-cn";
+export type MiniMaxUsageKind = "token-plan" | "account-balance";
+
+const PROVIDERS = {
+	minimax: { name: "MiniMax", currency: "USD" },
+	"minimax-cn": { name: "MiniMax CN", currency: "CNY" },
+} as const;
+const DECIMAL_AMOUNT = /^-?(?:0|[1-9]\d*)(?:\.\d+)?$/u;
+const PERCENT_TOLERANCE = 1;
+
+export function miniMaxUsageKind(apiKey: string): MiniMaxUsageKind {
+	return apiKey.startsWith("sk-api-") ? "account-balance" : "token-plan";
+}
+
+export function normalizeMiniMaxUsagePayload(
+	providerId: MiniMaxProviderId,
+	kind: MiniMaxUsageKind,
+	payload: MiniMaxUsagePayload,
+	capturedAt: number,
+): UsageReport {
+	return kind === "account-balance"
+		? normalizeBalance(providerId, payload, capturedAt)
+		: normalizeTokenPlan(providerId, payload, capturedAt);
+}
+
+function normalizeBalance(
+	providerId: MiniMaxProviderId,
+	payload: MiniMaxUsagePayload,
+	capturedAt: number,
+): UsageReport {
+	assertSuccess(payload);
+	const provider = PROVIDERS[providerId];
+	const metrics: UsageMetric[] = [
+		balanceMetric(
+			"available-balance",
+			"Available balance",
+			payload.available_amount,
+			provider.currency,
+		),
+		balanceMetric("cash-balance", "Cash balance", payload.cash_balance, provider.currency, true),
+		balanceMetric("voucher-balance", "Voucher balance", payload.voucher_balance, provider.currency),
+		balanceMetric("credit-balance", "Credit balance", payload.credit_balance, provider.currency),
+		balanceMetric("owed-amount", "Owed amount", payload.owed_amount, provider.currency),
+	];
+	return {
+		providerId,
+		providerName: provider.name,
+		capturedAt,
+		source: "minimax-account-balance",
+		semantics: { kind: "api-key", label: "MiniMax pay-as-you-go account balance" },
+		buckets: [],
+		metrics,
+	};
+}
+
+function normalizeTokenPlan(
+	providerId: MiniMaxProviderId,
+	payload: MiniMaxUsagePayload,
+	capturedAt: number,
+): UsageReport {
+	assertSuccess(payload);
+	if (!Array.isArray(payload.model_remains) || payload.model_remains.length === 0) {
+		throw new Error("MiniMax Token Plan returned no quota rows.");
+	}
+	const provider = PROVIDERS[providerId];
+	const buckets: UsageBucket[] = [];
+	const groups = new Set<string>();
+	for (const [index, raw] of payload.model_remains.entries()) {
+		const row = asObject(raw);
+		if (!row) throw new Error("MiniMax Token Plan quota row was not an object.");
+		const groupLabel = safeLabel(row.model_name, `Quota ${index + 1}`);
+		const groupId = uniqueGroupId(groupLabel, index, groups);
+		buckets.push(
+			normalizeWindow(row, {
+				id: `${groupId}:interval`,
+				label: "Rolling window",
+				groupId,
+				groupLabel,
+				countField: "current_interval_usage_count",
+				totalField: "current_interval_total_count",
+				percentField: "current_interval_remaining_percent",
+				statusField: "current_interval_status",
+				startField: "start_time",
+				endField: "end_time",
+			}),
+			normalizeWindow(row, {
+				id: `${groupId}:weekly`,
+				label: "Weekly window",
+				groupId,
+				groupLabel,
+				countField: "current_weekly_usage_count",
+				totalField: "current_weekly_total_count",
+				percentField: "current_weekly_remaining_percent",
+				statusField: "current_weekly_status",
+				startField: "weekly_start_time",
+				endField: "weekly_end_time",
+				boostPermille: row.weekly_boost_permille,
+			}),
+		);
+	}
+	return {
+		providerId,
+		providerName: provider.name,
+		capturedAt,
+		source: "minimax-token-plan",
+		semantics: { kind: "consumer-subscription", label: "MiniMax Token Plan quota" },
+		buckets,
+		metrics: [],
+	};
+}
+
+type WindowFields = {
+	id: string;
+	label: string;
+	groupId: string;
+	groupLabel: string;
+	countField: string;
+	totalField: string;
+	percentField: string;
+	statusField: string;
+	startField: string;
+	endField: string;
+	boostPermille?: unknown;
+};
+
+function normalizeWindow(row: Record<string, unknown>, fields: WindowFields): UsageBucket {
+	const status = optionalInteger(row[fields.statusField], fields.statusField);
+	if (status !== undefined && ![1, 2, 3].includes(status)) {
+		throw new Error(`MiniMax Token Plan ${fields.label} status was unsupported.`);
+	}
+	const percent = optionalPercent(row[fields.percentField], fields.percentField);
+	validateBoost(fields.boostPermille);
+	const start = timestamp(row[fields.startField], fields.startField);
+	const end = timestamp(row[fields.endField], fields.endField);
+	if (end < start) throw new Error(`MiniMax Token Plan ${fields.label} timestamps were reversed.`);
+	const resetsAt = Math.floor(end / 1_000);
+	const windowMinutes = Math.max(1, Math.round((end - start) / 60_000));
+	if (status === 3) {
+		return {
+			id: fields.id,
+			label: fields.label,
+			groupId: fields.groupId,
+			groupLabel: fields.groupLabel,
+			remaining: 100,
+			unit: "percent",
+			period: "unlimited",
+			windowMinutes,
+		};
+	}
+	const total = nonnegativeInteger(row[fields.totalField], fields.totalField);
+	const count = nonnegativeInteger(row[fields.countField], fields.countField);
+	const resolved = resolveQuotaCounts(count, total, percent);
+	if (!resolved) throw new Error(`MiniMax Token Plan ${fields.label} counts were inconsistent.`);
+	return {
+		id: fields.id,
+		label: fields.label,
+		groupId: fields.groupId,
+		groupLabel: fields.groupLabel,
+		...resolved,
+		unit: "count",
+		windowMinutes,
+		resetsAt,
+	};
+}
+
+function resolveQuotaCounts(
+	reportedCount: number,
+	total: number,
+	remainingPercent: number | undefined,
+): Pick<UsageBucket, "used" | "remaining" | "limit"> | undefined {
+	if (total <= 0 || reportedCount > total) return undefined;
+	let remaining = reportedCount;
+	if (remainingPercent !== undefined) {
+		const asRemaining = (reportedCount / total) * 100;
+		const asUsed = ((total - reportedCount) / total) * 100;
+		const remainingDistance = Math.abs(asRemaining - remainingPercent);
+		const usedDistance = Math.abs(asUsed - remainingPercent);
+		if (Math.min(remainingDistance, usedDistance) > PERCENT_TOLERANCE) return undefined;
+		if (usedDistance < remainingDistance) remaining = total - reportedCount;
+	}
+	return { used: total - remaining, remaining, limit: total };
+}
+
+function assertSuccess(payload: MiniMaxUsagePayload): void {
+	const base = asObject(payload.base_resp);
+	if (base?.status_code !== 0) {
+		throw new Error("MiniMax usage response did not report success.");
+	}
+}
+
+function balanceMetric(
+	id: string,
+	label: string,
+	value: unknown,
+	currency: "CNY" | "USD",
+	allowNegative = false,
+): UsageMetric {
+	if (
+		typeof value !== "string" ||
+		value.length > 64 ||
+		!DECIMAL_AMOUNT.test(value) ||
+		(!allowNegative && value.startsWith("-"))
+	) {
+		throw new Error(`MiniMax ${label.toLowerCase()} was not a valid amount.`);
+	}
+	return { id, label, value, unit: "currency", currency };
+}
+
+function asObject(value: unknown): Record<string, unknown> | undefined {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+	return value as Record<string, unknown>;
+}
+
+function safeLabel(value: unknown, fallback: string): string {
+	if (typeof value !== "string") throw new Error("MiniMax Token Plan model name was not a string.");
+	return sanitizeDisplayText(value, 80) || fallback;
+}
+
+function uniqueGroupId(label: string, index: number, groups: Set<string>): string {
+	const base =
+		label
+			.toLowerCase()
+			.replace(/[^a-z0-9]+/gu, "-")
+			.replace(/^-|-$/gu, "") || "quota";
+	const id = groups.has(base) ? `${base}-${index + 1}` : base;
+	groups.add(id);
+	return id;
+}
+
+function nonnegativeInteger(value: unknown, field: string): number {
+	if (!Number.isSafeInteger(value) || (value as number) < 0) {
+		throw new Error(`MiniMax Token Plan ${field} was not a nonnegative safe integer.`);
+	}
+	return value as number;
+}
+
+function optionalInteger(value: unknown, field: string): number | undefined {
+	if (value === undefined || value === null) return undefined;
+	return nonnegativeInteger(value, field);
+}
+
+function optionalPercent(value: unknown, field: string): number | undefined {
+	if (value === undefined || value === null) return undefined;
+	if (typeof value !== "number" || !Number.isFinite(value) || value < 0 || value > 100) {
+		throw new Error(`MiniMax Token Plan ${field} was not a percentage.`);
+	}
+	return value;
+}
+
+function validateBoost(boost: unknown): void {
+	if (boost === undefined || boost === null) return;
+	const permille = nonnegativeInteger(boost, "weekly_boost_permille");
+	if (permille > 10_000) throw new Error("MiniMax Token Plan weekly boost was unreasonable.");
+}
+
+function timestamp(value: unknown, field: string): number {
+	if (!Number.isSafeInteger(value) || (value as number) <= 0) {
+		throw new Error(`MiniMax Token Plan ${field} was not a valid timestamp.`);
+	}
+	return value as number;
+}

package/src/providers/moonshot.ts

@@ -0,0 +1,64 @@
+import type { MoonshotBalancePayload, UsageMetric, UsageReport } from "../types.js";
+
+export type MoonshotProviderId = "moonshotai" | "moonshotai-cn";
+
+const PROVIDERS = {
+	moonshotai: { name: "Moonshot AI", currency: "USD" },
+	"moonshotai-cn": { name: "Moonshot AI CN", currency: "CNY" },
+} as const;
+
+export function normalizeMoonshotBalancePayload(
+	providerId: MoonshotProviderId,
+	payload: MoonshotBalancePayload,
+	capturedAt: number,
+): UsageReport {
+	if (payload.code !== 0 || payload.status !== true) {
+		throw new Error("Moonshot AI balance response did not report success.");
+	}
+	const data = asObject(payload.data);
+	if (!data) throw new Error("Moonshot AI balance response data was not an object.");
+	const provider = PROVIDERS[providerId];
+	const available = amount(data.available_balance, "available balance", false);
+	const voucher = amount(data.voucher_balance, "voucher balance", false);
+	const cash = amount(data.cash_balance, "cash balance", true);
+	const metrics: UsageMetric[] = [
+		currencyMetric("available-balance", "Available balance", available, provider.currency),
+		currencyMetric("voucher-balance", "Voucher balance", voucher, provider.currency),
+		currencyMetric("cash-balance", "Cash balance", cash, provider.currency),
+	];
+	return {
+		providerId,
+		providerName: provider.name,
+		capturedAt,
+		source: "moonshot-balance",
+		semantics: { kind: "api-key", label: "Moonshot API account balance" },
+		buckets: [],
+		metrics,
+	};
+}
+
+function currencyMetric(
+	id: string,
+	label: string,
+	value: string,
+	currency: "CNY" | "USD",
+): UsageMetric {
+	return { id, label, value, unit: "currency", currency };
+}
+
+function asObject(value: unknown): Record<string, unknown> | undefined {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+	return value as Record<string, unknown>;
+}
+
+function amount(value: unknown, label: string, allowNegative: boolean): string {
+	if (
+		typeof value !== "number" ||
+		!Number.isFinite(value) ||
+		(!allowNegative && value < 0) ||
+		Math.abs(value) > Number.MAX_SAFE_INTEGER
+	) {
+		throw new Error(`Moonshot AI ${label} was not a valid amount.`);
+	}
+	return String(value);
+}