@narumitw/pi-usage 0.57.0 → 0.59.0

package/src/query.ts

@@ -5,36 +5,71 @@ import {
 	fallbackOAuthCredentialCandidates,
 	type OAuthCredentialCandidateReader,
 } from "./oauth-credential-source.js";
+import { normalizeBasetenBillingUsagePayload } from "./providers/baseten.js";
 import { normalizeCodexBackendPayload } from "./providers/codex.js";
 import { normalizeDeepSeekBalancePayload } from "./providers/deepseek.js";
+import {
+	isFireworksAccountId,
+	normalizeFireworksAccountsPayload,
+	normalizeFireworksBillingSummaryPayload,
+} from "./providers/fireworks.js";
 import { normalizeGitHubCopilotUsagePayload } from "./providers/github-copilot.js";
 import { normalizeKimiCodingUsagePayload } from "./providers/kimi-coding.js";
+import {
+	type MiniMaxProviderId,
+	miniMaxUsageKind,
+	normalizeMiniMaxUsagePayload,
+} from "./providers/minimax.js";
+import { normalizeMoonshotBalancePayload } from "./providers/moonshot.js";
 import { normalizeOpenCodeZenPayload } from "./providers/opencode-zen.js";
 import { normalizeOpenRouterKeyPayload } from "./providers/openrouter.js";
+import { normalizeVercelAIGatewayCreditsPayload } from "./providers/vercel-ai-gateway.js";
 import { normalizeXaiBillingPayload } from "./providers/xai.js";
 import { normalizeZaiQuotaPayload } from "./providers/zai.js";
 import type {
+	BasetenBillingUsagePayload,
 	CodexBackendPayload,
 	DeepSeekBalancePayload,
+	FireworksAccountsPayload,
+	FireworksBillingSummaryPayload,
 	GitHubCopilotUsagePayload,
 	KimiCodingUsagePayload,
+	MiniMaxUsagePayload,
+	MoonshotBalancePayload,
 	OpenCodeZenPayload,
 	OpenRouterKeyPayload,
 	PiModel,
 	ResolvedUsageAuth,
 	UsageProviderAdapter,
+	UsageQuerySettings,
 	UsageReport,
+	VercelAIGatewayCreditsPayload,
 	XaiBillingPayload,
 	XaiUserPayload,
 	ZaiQuotaPayload,
 } from "./types.js";
 
+const BASETEN_BILLING_USAGE_URL = "https://api.baseten.co/v1/billing/usage_summary";
+const BASETEN_USAGE_WINDOW_DAYS = 30;
 const CODEX_USAGE_URL = "https://chatgpt.com/backend-api/wham/usage";
 const DEEPSEEK_BALANCE_URL = "https://api.deepseek.com/user/balance";
+const FIREWORKS_BILLING_SUMMARY_ORIGIN = "https://api.fireworks.ai";
+const FIREWORKS_SPEND_WINDOW_DAYS = 30;
+const FIREWORKS_MAX_ACCOUNT_PAGES = 5;
 const GITHUB_COPILOT_USAGE_URL = "https://api.github.com/copilot_internal/user";
 const OPENROUTER_KEY_URL = "https://openrouter.ai/api/v1/key";
+const VERCEL_AI_GATEWAY_CREDITS_URL = "https://ai-gateway.vercel.sh/v1/credits";
 const OPENCODE_GO_USAGE_URL = "https://opencode.ai/zen/go/v1/usage";
 const KIMI_CODING_USAGE_URL = "https://api.kimi.com/coding/v1/usages";
+const MINIMAX_API_ROOTS = Object.freeze({
+	minimax: "https://api.minimax.io",
+	"minimax-cn": "https://api.minimaxi.com",
+});
+const MOONSHOT_BALANCE_URLS = Object.freeze({
+	moonshotai: "https://api.moonshot.ai/v1/users/me/balance",
+	"moonshotai-cn": "https://api.moonshot.cn/v1/users/me/balance",
+});
+const SHARED_MOONSHOT_ENV_VAR = "MOONSHOT_API_KEY";
 const XAI_USER_URL = "https://cli-chat-proxy.grok.com/v1/user?include=subscription";
 const XAI_BILLING_URL = "https://cli-chat-proxy.grok.com/v1/billing?format=credits";
 const XAI_CLIENT_HEADERS = Object.freeze({
@@ -50,6 +85,27 @@ export const AUTH_FINGERPRINT_SALT = randomBytes(32);
 export type UsageRequestGuard = () => Promise<void>;
 
 export const SUPPORTED_ADAPTERS: readonly UsageProviderAdapter[] = [
+	{
+		id: "baseten",
+		displayName: "Baseten",
+		semantics: { kind: "api-key", label: "Organization Model APIs spend" },
+		async query(auth, signal, timeoutMs, guard) {
+			if (!guard) throw new Error("Baseten billing usage requires request-boundary revalidation.");
+			const startedAt = Date.now();
+			await guard();
+			const windowAt = Date.now();
+			const payload = (await fetchProviderJson(
+				basetenBillingUsageUrl(windowAt),
+				auth,
+				signal,
+				remainingTimeout(timeoutMs, startedAt, "fetching Baseten billing usage"),
+				"Baseten billing usage endpoint",
+				{ redirect: "error" },
+			)) as BasetenBillingUsagePayload;
+			await guard();
+			return normalizeBasetenBillingUsagePayload(payload, Date.now());
+		},
+	},
 	{
 		id: "openai-codex",
 		displayName: "OpenAI Codex",
@@ -122,6 +178,56 @@ export const SUPPORTED_ADAPTERS: readonly UsageProviderAdapter[] = [
 			return normalizeOpenRouterKeyPayload(payload as OpenRouterKeyPayload, Date.now());
 		},
 	},
+	{
+		id: "vercel-ai-gateway",
+		displayName: "Vercel AI Gateway",
+		semantics: { kind: "api-key", label: "AI Gateway credits and lifetime spend" },
+		async query(auth, signal, timeoutMs, guard) {
+			if (!guard)
+				throw new Error("Vercel AI Gateway usage requires request-boundary revalidation.");
+			const startedAt = Date.now();
+			await guard();
+			const payload = (await fetchProviderJson(
+				VERCEL_AI_GATEWAY_CREDITS_URL,
+				auth,
+				signal,
+				remainingTimeout(timeoutMs, startedAt, "fetching Vercel AI Gateway credits"),
+				"Vercel AI Gateway credits endpoint",
+				{ redirect: "error" },
+			)) as VercelAIGatewayCreditsPayload;
+			await guard();
+			return normalizeVercelAIGatewayCreditsPayload(payload, Date.now());
+		},
+	},
+	{
+		id: "fireworks",
+		displayName: "Fireworks",
+		semantics: { kind: "api-key", label: "Fireworks API spend" },
+		async query(auth, signal, timeoutMs, guard, settings) {
+			if (!guard) throw new Error("Fireworks API spend requires request-boundary revalidation.");
+			const startedAt = Date.now();
+			await guard();
+			const accountId = await resolveFireworksAccountId(
+				auth,
+				signal,
+				remainingTimeout(timeoutMs, startedAt, "resolving the Fireworks account"),
+				guard,
+				settings?.fireworksAccountId,
+			);
+			await guard();
+			const billingWindowAt = Date.now();
+			const payload = (await fetchProviderJson(
+				fireworksBillingSummaryUrl(accountId, billingWindowAt),
+				auth,
+				signal,
+				remainingTimeout(timeoutMs, startedAt, "fetching Fireworks rated spend"),
+				"Fireworks billing summary endpoint",
+				{ redirect: "error" },
+			)) as FireworksBillingSummaryPayload;
+			await guard();
+			return normalizeFireworksBillingSummaryPayload(payload, accountId, Date.now());
+		},
+	},
 	{
 		id: "opencode-go",
 		displayName: "OpenCode Go",
@@ -153,6 +259,38 @@ export const SUPPORTED_ADAPTERS: readonly UsageProviderAdapter[] = [
 			return normalizeKimiCodingUsagePayload(payload as KimiCodingUsagePayload, Date.now());
 		},
 	},
+	{
+		id: "minimax",
+		displayName: "MiniMax",
+		semantics: { kind: "consumer-subscription", label: "MiniMax usage" },
+		async query(auth, signal, timeoutMs, guard) {
+			return queryMiniMaxUsage("minimax", auth, signal, timeoutMs, guard);
+		},
+	},
+	{
+		id: "minimax-cn",
+		displayName: "MiniMax CN",
+		semantics: { kind: "consumer-subscription", label: "MiniMax usage" },
+		async query(auth, signal, timeoutMs, guard) {
+			return queryMiniMaxUsage("minimax-cn", auth, signal, timeoutMs, guard);
+		},
+	},
+	{
+		id: "moonshotai",
+		displayName: "Moonshot AI",
+		semantics: { kind: "api-key", label: "Moonshot API account balance" },
+		async query(auth, signal, timeoutMs, guard) {
+			return queryMoonshotBalance("moonshotai", auth, signal, timeoutMs, guard);
+		},
+	},
+	{
+		id: "moonshotai-cn",
+		displayName: "Moonshot AI CN",
+		semantics: { kind: "api-key", label: "Moonshot API account balance" },
+		async query(auth, signal, timeoutMs, guard) {
+			return queryMoonshotBalance("moonshotai-cn", auth, signal, timeoutMs, guard);
+		},
+	},
 	{
 		id: "zai",
 		displayName: "Z.AI",
@@ -289,11 +427,14 @@ export async function resolveUsageAuth(
 		if (!result.ok) throw new Error(redactUsageError(result.error));
 		return authorizationFrom(result) ? result : undefined;
 	};
-	if (adapter.id !== "deepseek") modelAuth = await resolveCurrentModelAuth();
+	const resolveSelectedAuthLast = ["deepseek", "minimax", "minimax-cn"].includes(adapter.id);
+	if (!resolveSelectedAuthLast) modelAuth = await resolveCurrentModelAuth();
 	if (typeof registry.getProviderAuth !== "function") {
 		throw new Error("pi-usage requires Pi 0.81.0 or newer to validate resolved provider auth.");
 	}
+	if (!moonshotProviderAuthIsAllowed(ctx, adapter.id)) return undefined;
 	const providerResult = await registry.getProviderAuth(adapter.id);
+	if (!moonshotProviderAuthIsAllowed(ctx, adapter.id)) return undefined;
 	if (
 		providerResult?.auth.baseUrl &&
 		!hasOfficialUrlOrigin(providerResult.auth.baseUrl, adapter.id)
@@ -302,9 +443,9 @@ export async function resolveUsageAuth(
 			`${adapter.displayName} usage cannot send a proxy-resolved credential to the official usage endpoint.`,
 		);
 	}
-	// DeepSeek reads selected-model auth last so a rotation during provider-origin validation
-	// cannot leave the earlier credential queued for the balance request.
-	if (adapter.id === "deepseek") modelAuth = await resolveCurrentModelAuth();
+	// Providers with credential-change retries read selected-model auth last so a rotation during
+	// provider-origin validation cannot leave the earlier credential queued for the usage request.
+	if (resolveSelectedAuthLast) modelAuth = await resolveCurrentModelAuth();
 	const auth = modelAuth ?? providerResult?.auth;
 	if (!auth) return undefined;
 	if (adapter.id === "github-copilot") {
@@ -370,9 +511,10 @@ export async function queryProviderUsage(
 	signal: AbortSignal,
 	timeoutMs: number,
 	guard?: UsageRequestGuard,
+	settings?: Readonly<UsageQuerySettings>,
 ): Promise<UsageReport> {
 	try {
-		return await adapter.query(auth, signal, timeoutMs, guard);
+		return await adapter.query(auth, signal, timeoutMs, guard, settings);
 	} catch (error) {
 		if (isStaleExtensionContextError(error) || isAbortError(error)) throw error;
 		throw new Error(redactUsageError(errorMessage(error), auth.secrets));
@@ -381,12 +523,53 @@ export async function queryProviderUsage(
 
 export function providerIsConfigured(ctx: ExtensionContext, providerId: string): boolean {
 	try {
-		return ctx.modelRegistry.getProviderAuthStatus(providerId).configured;
+		const status = ctx.modelRegistry.getProviderAuthStatus(providerId);
+		return (
+			status.configured &&
+			moonshotProviderAuthSourceIsAllowed(ctx, providerId, status.source, status.label)
+		);
+	} catch {
+		return (
+			!isMoonshotSiblingProvider(ctx, providerId) && candidateModels(ctx, providerId).length > 0
+		);
+	}
+}
+
+function moonshotProviderAuthIsAllowed(ctx: ExtensionContext, providerId: string): boolean {
+	if (!isMoonshotSiblingProvider(ctx, providerId)) return true;
+	try {
+		const status = ctx.modelRegistry.getProviderAuthStatus(providerId);
+		return moonshotProviderAuthSourceIsAllowed(ctx, providerId, status.source, status.label);
 	} catch {
-		return candidateModels(ctx, providerId).length > 0;
+		return false;
 	}
 }
 
+function moonshotProviderAuthSourceIsAllowed(
+	ctx: ExtensionContext,
+	providerId: string,
+	source: string | undefined,
+	label: string | undefined,
+): boolean {
+	if (!isMoonshotSiblingProvider(ctx, providerId)) return true;
+	if (source === undefined) return false;
+	if (source !== "environment") return true;
+	return (
+		label !== undefined &&
+		!label
+			.split(",")
+			.map((name) => name.trim())
+			.includes(SHARED_MOONSHOT_ENV_VAR)
+	);
+}
+
+function isMoonshotSiblingProvider(ctx: ExtensionContext, providerId: string): boolean {
+	return (
+		(providerId === "moonshotai" || providerId === "moonshotai-cn") &&
+		ctx.model?.provider !== providerId
+	);
+}
+
 function candidateModels(ctx: ExtensionContext, providerId: string): PiModel[] {
 	const candidates: PiModel[] = [];
 	const seen = new Set<string>();
@@ -731,11 +914,20 @@ function hasOfficialOrigin(model: PiModel, providerId: string): boolean {
 function hasOfficialUrlOrigin(value: string, providerId: string): boolean {
 	try {
 		const url = new URL(value);
+		if (providerId === "baseten") {
+			return ["https://inference.baseten.co", "https://api.baseten.co"].includes(url.origin);
+		}
 		if (providerId === "openai-codex") return url.origin === "https://chatgpt.com";
 		if (providerId === "deepseek") return url.origin === "https://api.deepseek.com";
+		if (providerId === "fireworks") return url.origin === FIREWORKS_BILLING_SUMMARY_ORIGIN;
 		if (providerId === "openrouter") return url.origin === "https://openrouter.ai";
+		if (providerId === "vercel-ai-gateway") return url.origin === "https://ai-gateway.vercel.sh";
 		if (providerId === "opencode-go") return url.origin === "https://opencode.ai";
 		if (providerId === "kimi-coding") return url.origin === "https://api.kimi.com";
+		if (providerId === "minimax") return url.origin === "https://api.minimax.io";
+		if (providerId === "minimax-cn") return url.origin === "https://api.minimaxi.com";
+		if (providerId === "moonshotai") return url.origin === "https://api.moonshot.ai";
+		if (providerId === "moonshotai-cn") return url.origin === "https://api.moonshot.cn";
 		if (providerId === "xai") return url.origin === "https://api.x.ai";
 		if (providerId === "zai") return url.origin === "https://api.z.ai";
 		if (providerId === "zai-coding-cn") return url.origin === "https://open.bigmodel.cn";
@@ -771,12 +963,166 @@ function validatedXaiUserId(value: unknown): string {
 	return value;
 }
 
-function remainingTimeout(timeoutMs: number, startedAt: number): number {
+function basetenBillingUsageUrl(windowAt: number): string {
+	const url = new URL(BASETEN_BILLING_USAGE_URL);
+	url.searchParams.set(
+		"start_date",
+		new Date(windowAt - BASETEN_USAGE_WINDOW_DAYS * 24 * 60 * 60 * 1_000).toISOString(),
+	);
+	url.searchParams.set("end_date", new Date(windowAt).toISOString());
+	return url.toString();
+}
+
+async function queryMiniMaxUsage(
+	providerId: MiniMaxProviderId,
+	auth: ResolvedUsageAuth,
+	signal: AbortSignal,
+	timeoutMs: number,
+	guard: UsageRequestGuard | undefined,
+): Promise<UsageReport> {
+	if (!guard) throw new Error("MiniMax usage requires request-boundary revalidation.");
+	const apiKey = bearerToken(headerValue(auth.headers, "Authorization")) ?? auth.apiKey;
+	if (!apiKey) throw new Error("MiniMax runtime API key was unavailable.");
+	const kind = miniMaxUsageKind(apiKey);
+	const path = kind === "account-balance" ? "/account/query_balance" : "/v1/token_plan/remains";
+	const startedAt = Date.now();
+	await guard();
+	const payload = (await fetchProviderJson(
+		`${MINIMAX_API_ROOTS[providerId]}${path}`,
+		auth,
+		signal,
+		remainingTimeout(timeoutMs, startedAt, "fetching MiniMax usage"),
+		"MiniMax usage endpoint",
+		{ redirect: "error" },
+	)) as MiniMaxUsagePayload;
+	await guard();
+	return normalizeMiniMaxUsagePayload(providerId, kind, payload, Date.now());
+}
+
+async function queryMoonshotBalance(
+	providerId: "moonshotai" | "moonshotai-cn",
+	auth: ResolvedUsageAuth,
+	signal: AbortSignal,
+	timeoutMs: number,
+	guard: UsageRequestGuard | undefined,
+): Promise<UsageReport> {
+	if (!guard) throw new Error("Moonshot AI balance requires request-boundary revalidation.");
+	const startedAt = Date.now();
+	await guard();
+	const payload = (await fetchProviderJson(
+		MOONSHOT_BALANCE_URLS[providerId],
+		auth,
+		signal,
+		remainingTimeout(timeoutMs, startedAt, "fetching Moonshot AI balance"),
+		"Moonshot AI balance endpoint",
+		{ redirect: "error" },
+	)) as MoonshotBalancePayload;
+	await guard();
+	return normalizeMoonshotBalancePayload(providerId, payload, Date.now());
+}
+
+function remainingTimeout(
+	timeoutMs: number,
+	startedAt: number,
+	description = "fetching xAI consumer usage",
+): number {
 	const remaining = timeoutMs - (Date.now() - startedAt);
-	if (remaining <= 0) throw new Error("Timed out while fetching xAI consumer usage.");
+	if (remaining <= 0) throw new Error(`Timed out while ${description}.`);
 	return remaining;
 }
 
+// Fireworks requires an account slug for its billing endpoints; discover it through the
+// documented account listing, requiring an explicit slug when a key can see several accounts.
+async function resolveFireworksAccountId(
+	auth: ResolvedUsageAuth,
+	signal: AbortSignal,
+	timeoutMs: number,
+	guard: () => Promise<void>,
+	configuredAccountId: string | undefined,
+): Promise<string> {
+	if (configuredAccountId !== undefined && !isFireworksAccountId(configuredAccountId)) {
+		throw new Error("The Fireworks account setting was not a safe account slug.");
+	}
+	const startedAt = Date.now();
+	const accounts: string[] = [];
+	let pageToken: string | undefined;
+	for (let page = 0; page < FIREWORKS_MAX_ACCOUNT_PAGES; page += 1) {
+		await guard();
+		const payload = (await fetchProviderJson(
+			fireworksAccountsUrl(pageToken),
+			auth,
+			signal,
+			remainingTimeout(timeoutMs, startedAt, "fetching Fireworks accounts"),
+			"Fireworks accounts endpoint",
+			{ redirect: "error" },
+		)) as FireworksAccountsPayload;
+		for (const accountId of normalizeFireworksAccountsPayload(
+			payload as FireworksAccountsPayload,
+		)) {
+			if (accounts.includes(accountId)) {
+				throw new Error(`Fireworks accounts listing repeated ${accountId}.`);
+			}
+			accounts.push(accountId);
+			if (configuredAccountId === accountId) return accountId;
+		}
+		pageToken = fireworksNextPageToken(payload.nextPageToken);
+		if (!pageToken) break;
+	}
+	if (pageToken) {
+		throw new Error(
+			configuredAccountId
+				? `The configured Fireworks account was not found within the first ${FIREWORKS_MAX_ACCOUNT_PAGES} listing pages.`
+				: `Fireworks account listing exceeded ${FIREWORKS_MAX_ACCOUNT_PAGES} pages; set fireworksAccountId in pi-usage.json to an account returned in those pages.`,
+		);
+	}
+	if (accounts.length === 0) {
+		throw new Error("Fireworks account discovery returned no accounts for this API key.");
+	}
+	if (configuredAccountId) {
+		throw new Error(
+			"The configured Fireworks account does not match an account visible to this API key.",
+		);
+	}
+	if (accounts.length === 1) return accounts[0] as string;
+	const preview = accounts.slice(0, 8).join(", ");
+	const suffix = accounts.length > 8 ? ` …and ${accounts.length - 8} more` : "";
+	throw new Error(
+		`The Fireworks key can see ${accounts.length} accounts (${preview}${suffix}); set fireworksAccountId in pi-usage.json to one of them.`,
+	);
+}
+
+function fireworksAccountsUrl(pageToken: string | undefined): string {
+	const url = new URL("/v1/accounts", FIREWORKS_BILLING_SUMMARY_ORIGIN);
+	url.searchParams.set("pageSize", "200");
+	if (pageToken !== undefined) url.searchParams.set("pageToken", pageToken);
+	return url.toString();
+}
+
+function fireworksNextPageToken(value: unknown): string | undefined {
+	if (value === undefined || value === null) return undefined;
+	if (typeof value !== "string" || !value || value.length > 512) {
+		throw new Error("Fireworks accounts listing returned an invalid page token.");
+	}
+	return value;
+}
+
+function fireworksBillingSummaryUrl(accountId: string, startedAt: number): string {
+	const dayMs = 24 * 60 * 60 * 1000;
+	const dayFloor = (time: number) => `${new Date(time).toISOString().slice(0, 10)}T00:00:00Z`;
+	const url = new URL(
+		`/v1/accounts/${accountId}/billing/summary`,
+		FIREWORKS_BILLING_SUMMARY_ORIGIN,
+	);
+	// The endpoint aggregates by UTC date; endTime is exclusive, so the window includes today
+	// plus the preceding 29 dates.
+	url.searchParams.set(
+		"startTime",
+		dayFloor(startedAt - (FIREWORKS_SPEND_WINDOW_DAYS - 1) * dayMs),
+	);
+	url.searchParams.set("endTime", dayFloor(startedAt + dayMs));
+	return url.toString();
+}
+
 function zaiMonitorUrl(baseUrl: string | undefined): string {
 	const base = baseUrl?.trim();
 	if (!base) throw new Error("Z.AI model base URL is unavailable.");

package/src/settings.ts

@@ -3,6 +3,7 @@ import { constants } from "node:fs";
 import { chmod, mkdir, open, rename, rm, writeFile } from "node:fs/promises";
 import { basename, dirname, join } from "node:path";
 import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import { isFireworksAccountId } from "./providers/fireworks.js";
 
 export const USAGE_SETTINGS_FILE = "pi-usage.json";
 export const MAX_USAGE_SETTINGS_BYTES = 64 * 1024;
@@ -10,6 +11,7 @@ export const MAX_USAGE_SETTINGS_BYTES = 64 * 1024;
 export interface UsageSettings {
 	codexFastMode: boolean;
 	codexStatusResetCountdown: boolean;
+	fireworksAccountId?: string;
 }
 
 export const DEFAULT_USAGE_SETTINGS: Readonly<UsageSettings> = Object.freeze({
@@ -60,6 +62,12 @@ export function normalizeUsageSettings(value: unknown): UsageSettings | undefine
 	) {
 		return undefined;
 	}
+	if (
+		Object.hasOwn(value, "fireworksAccountId") &&
+		!isFireworksAccountId(value.fireworksAccountId)
+	) {
+		return undefined;
+	}
 	return {
 		codexFastMode:
 			typeof value.codexFastMode === "boolean"
@@ -69,6 +77,9 @@ export function normalizeUsageSettings(value: unknown): UsageSettings | undefine
 			typeof value.codexStatusResetCountdown === "boolean"
 				? value.codexStatusResetCountdown
 				: DEFAULT_USAGE_SETTINGS.codexStatusResetCountdown,
+		...(isFireworksAccountId(value.fireworksAccountId)
+			? { fireworksAccountId: value.fireworksAccountId }
+			: {}),
 	};
 }
 
@@ -172,7 +183,11 @@ async function saveUsageSettingsPatch(
 	if (latest.kind === "invalid") {
 		throw new Error("Cannot overwrite an invalid pi-usage.json; repair it and reload first");
 	}
-	const document = { ...latest.document, ...patch };
+	const document = { ...latest.document };
+	for (const [key, value] of Object.entries(patch)) {
+		if (value === undefined) delete document[key];
+		else document[key] = value;
+	}
 	const settings = normalizeUsageSettings(document);
 	if (!settings) throw new Error("Refusing to save invalid pi-usage settings");
 	const directory = dirname(path);

package/src/types.ts

@@ -55,6 +55,10 @@ export interface ResolvedUsageAuth {
 	model: PiModel;
 }
 
+export interface UsageQuerySettings {
+	fireworksAccountId?: string;
+}
+
 export interface UsageProviderAdapter {
 	id: string;
 	displayName: string;
@@ -65,6 +69,7 @@ export interface UsageProviderAdapter {
 		signal: AbortSignal,
 		timeoutMs: number,
 		guard?: () => Promise<void>,
+		settings?: Readonly<UsageQuerySettings>,
 	): Promise<UsageReport>;
 }
 
@@ -84,11 +89,26 @@ export type ProviderUsageState =
 			message: string;
 	  };
 
+export type BasetenBillingUsagePayload = {
+	dedicated_usage?: unknown;
+	model_apis_usage?: unknown;
+	training_usage?: unknown;
+};
+
 export type DeepSeekBalancePayload = {
 	is_available?: unknown;
 	balance_infos?: unknown;
 };
 
+export type FireworksAccountsPayload = {
+	accounts?: unknown;
+	nextPageToken?: unknown;
+};
+
+export type FireworksBillingSummaryPayload = {
+	lineItems?: unknown;
+};
+
 export type GitHubCopilotUsagePayload = {
 	login?: unknown;
 	copilot_plan?: unknown;
@@ -105,6 +125,30 @@ export type OpenRouterKeyPayload = {
 	data?: unknown;
 };
 
+export type MiniMaxUsagePayload = {
+	available_amount?: unknown;
+	balance_alert_switch?: unknown;
+	balance_alert_threshold?: unknown;
+	base_resp?: unknown;
+	cash_balance?: unknown;
+	credit_balance?: unknown;
+	model_remains?: unknown;
+	owed_amount?: unknown;
+	voucher_balance?: unknown;
+};
+
+export type MoonshotBalancePayload = {
+	code?: unknown;
+	data?: unknown;
+	scode?: unknown;
+	status?: unknown;
+};
+
+export type VercelAIGatewayCreditsPayload = {
+	balance?: unknown;
+	total_used?: unknown;
+};
+
 export type OpenCodeZenPayload = {
 	usage?: unknown;
 };