@narumitw/pi-usage 0.60.0 → 0.60.2

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@narumitw/pi-usage",
-	"version": "0.60.0",
+	"version": "0.60.2",
 	"description": "Pi extension that shows current-account usage and DeepSeek API balance for supported providers.",
 	"type": "module",
 	"license": "MIT",

package/src/core.ts

@@ -54,13 +54,39 @@ export class UsageCache {
 }
 
 export function fingerprintResolvedAuth(
-	auth: { apiKey?: string; headers?: Record<string, string> },
+	auth: {
+		apiKey?: string;
+		headers?: Record<string, string | null>;
+		baseUrl?: string;
+		env?: Record<string, string>;
+		source?: string;
+		providerAuth?: {
+			apiKey?: string;
+			headers?: Record<string, string | null>;
+			baseUrl?: string;
+		};
+	},
 	salt: Uint8Array,
 ): string {
 	const headers = Object.entries(auth.headers ?? {})
 		.map(([name, value]) => [name.toLowerCase(), value] as const)
 		.sort(([left], [right]) => left.localeCompare(right));
-	const canonical = JSON.stringify({ apiKey: auth.apiKey ?? "", headers });
+	const env = Object.entries(auth.env ?? {}).sort(([left], [right]) => left.localeCompare(right));
+	const providerHeaders = Object.entries(auth.providerAuth?.headers ?? {})
+		.map(([name, value]) => [name.toLowerCase(), value] as const)
+		.sort(([left], [right]) => left.localeCompare(right));
+	const canonical = JSON.stringify({
+		apiKey: auth.apiKey ?? "",
+		headers,
+		baseUrl: auth.baseUrl ?? "",
+		env,
+		source: auth.source ?? "",
+		providerAuth: {
+			apiKey: auth.providerAuth?.apiKey ?? "",
+			headers: providerHeaders,
+			baseUrl: auth.providerAuth?.baseUrl ?? "",
+		},
+	});
 	return createHmac("sha256", salt).update(canonical).digest("hex");
 }
 

package/src/format.ts

@@ -94,6 +94,9 @@ export function formatProviderStates(states: readonly ProviderUsageState[]): str
 		.map((state) => {
 			if (state.status === "ready") return formatUsageReport(state.report, state.displayState);
 			const label = state.displayState === "current" ? "Current" : "Configured";
+			if (state.status === "selection-required") {
+				return `${state.providerName} · ${label}\nSelection required: choose this provider's ${state.singularLabel} by viewing it individually.`;
+			}
 			const status =
 				state.status === "auth-unavailable"
 					? "Authentication unavailable"
@@ -364,9 +367,11 @@ function formatMiniMaxReport(lines: string[], report: UsageReport): void {
 		const value =
 			bucket.period === "unlimited"
 				? "unlimited"
-				: bucket.limit && bucket.remaining !== undefined
-					? `${bucket.remaining} of ${bucket.limit} left · ${percentRemaining(bucket)}%${reset}`
-					: "unavailable";
+				: bucket.unit === "percent" && bucket.remaining !== undefined
+					? `${bucket.remaining}% remaining${reset}`
+					: bucket.limit !== undefined && bucket.remaining !== undefined
+						? `${bucket.remaining} of ${bucket.limit} left · ${percentRemaining(bucket)}%${reset}`
+						: "unavailable";
 		lines.push(`${`${bucket.label}:`.padEnd(VALUE_COLUMN)}${value}`);
 	}
 }
@@ -388,7 +393,11 @@ function formatMiniMaxStatusline(report: UsageReport, model?: UsageModel): strin
 			parts.push(`unlimited ${window}`);
 			continue;
 		}
-		if (!bucket.limit || bucket.remaining === undefined) continue;
+		if (bucket.unit === "percent" && bucket.remaining !== undefined) {
+			parts.push(`${bucket.remaining}% ${window}`);
+			continue;
+		}
+		if (bucket.limit === undefined || bucket.remaining === undefined) continue;
 		parts.push(`${percentRemaining(bucket)}% ${window}`);
 	}
 	return parts.length > 1 ? parts.join(" ") : undefined;
@@ -403,27 +412,32 @@ function selectMiniMaxGroup(report: UsageReport, model?: UsageModel): string | u
 		),
 	];
 	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]
+	if (model && model.provider !== report.providerId) return undefined;
+	if (model) {
+		const modelKeys = [model.id, model.name]
 			.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;
+		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;
+		const wildcard = candidates.find(({ patterns }) =>
+			patterns.some(
+				(pattern) =>
+					pattern.includes("*") && modelKeys.some((key) => wildcardKeyMatches(pattern, key)),
+			),
+		);
+		if (wildcard) return wildcard.group;
+	}
+	// Prefer the Coding Plan catch-all over hiding the chip.
+	return groups.find((group) => group === "general");
 }
 
 function normalizeMiniMaxModelKey(value: string | undefined): string | undefined {

package/src/index.ts

@@ -36,6 +36,7 @@ export { normalizeBasetenBillingUsagePayload } from "./providers/baseten.js";
 export { normalizeCodexBackendPayload } from "./providers/codex.js";
 export { normalizeDeepSeekBalancePayload } from "./providers/deepseek.js";
 export {
+	createFireworksAdapter,
 	normalizeFireworksAccountsPayload,
 	normalizeFireworksBillingSummaryPayload,
 } from "./providers/fireworks.js";
@@ -67,6 +68,7 @@ export type {
 	UsageSettings,
 	UsageSettingsRuntime,
 	UsageSettingsState,
+	UsageTargetPublicationCheck,
 } from "./settings.js";
 export {
 	createUsageSettingsRuntime,
@@ -90,13 +92,24 @@ export type {
 	UsageMetric,
 	UsageModel,
 	UsageProviderAdapter,
+	UsageProviderTarget,
 	UsageQuerySettings,
 	UsageReport,
+	UsageRequestGuard,
 	UsageSemantics,
 	UsageSemanticsKind,
+	UsageTargetResolver,
 	UsageUnit,
 	VercelAIGatewayCreditsPayload,
 	XaiBillingPayload,
 	XaiUserPayload,
 } from "./types.js";
 export { default } from "./usage.js";
+export type { UsageTargetResolution, UsageTargetSelectOptions } from "./usage-targets.js";
+export {
+	createUsageTargetSelectOptions,
+	isBoundedTargetId,
+	listUsageTargets,
+	normalizeUsageTargets,
+	resolveUsageTarget,
+} from "./usage-targets.js";

package/src/providers/fireworks.ts

@@ -2,7 +2,9 @@ import { sanitizeDisplayText } from "../core.js";
 import type {
 	FireworksAccountsPayload,
 	FireworksBillingSummaryPayload,
+	ResolvedUsageAuth,
 	UsageMetric,
+	UsageProviderAdapter,
 	UsageReport,
 } from "../types.js";
 
@@ -14,6 +16,9 @@ const INT64_MIN = -(2n ** 63n);
 const INT64_MAX = 2n ** 63n - 1n;
 const MAX_UNITS_CHARS = 20;
 const MAX_NANOS_CHARS = 11;
+const FIREWORKS_BILLING_SUMMARY_ORIGIN = "https://api.fireworks.ai";
+const FIREWORKS_SPEND_WINDOW_DAYS = 30;
+const FIREWORKS_MAX_ACCOUNT_PAGES = 5;
 
 const SERIES_KEYS = ["serverless", "dedicated", "training", "other"] as const;
 type SeriesKey = (typeof SERIES_KEYS)[number];
@@ -53,6 +58,77 @@ export function normalizeFireworksAccountsPayload(payload: FireworksAccountsPayl
 	return accounts;
 }
 
+type FetchProviderJson = (
+	url: string,
+	auth: ResolvedUsageAuth,
+	signal: AbortSignal,
+	timeoutMs: number,
+	description: string,
+	request?: { redirect?: RequestRedirect },
+) => Promise<Record<string, unknown>>;
+
+export function createFireworksAdapter(fetchProviderJson: FetchProviderJson): UsageProviderAdapter {
+	return {
+		id: "fireworks",
+		displayName: "Fireworks",
+		semantics: { kind: "api-key", label: "Fireworks API spend" },
+		targets: {
+			singularLabel: "account",
+			pluralLabel: "accounts",
+			async list(auth, signal, timeoutMs, guard) {
+				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;
+					await guard();
+					for (const accountId of normalizeFireworksAccountsPayload(payload)) {
+						if (accounts.includes(accountId)) {
+							throw new Error(`Fireworks accounts listing repeated ${accountId}.`);
+						}
+						accounts.push(accountId);
+					}
+					pageToken = fireworksNextPageToken(payload.nextPageToken);
+					if (!pageToken) break;
+				}
+				if (pageToken) {
+					throw new Error(
+						`Fireworks account listing exceeded ${FIREWORKS_MAX_ACCOUNT_PAGES} pages.`,
+					);
+				}
+				return accounts.map((id) => ({ id, label: id }));
+			},
+		},
+		async query(auth, signal, timeoutMs, guard, targetId) {
+			if (!guard) throw new Error("Fireworks API spend requires request-boundary revalidation.");
+			if (!isFireworksAccountId(targetId)) {
+				throw new Error("Fireworks billing requires a safe selected account slug.");
+			}
+			const startedAt = Date.now();
+			await guard();
+			const billingWindowAt = Date.now();
+			const payload = (await fetchProviderJson(
+				fireworksBillingSummaryUrl(targetId, billingWindowAt),
+				auth,
+				signal,
+				remainingTimeout(timeoutMs, startedAt, "fetching Fireworks rated spend"),
+				"Fireworks billing summary endpoint",
+				{ redirect: "error" },
+			)) as FireworksBillingSummaryPayload;
+			await guard();
+			return normalizeFireworksBillingSummaryPayload(payload, targetId, Date.now());
+		},
+	};
+}
+
 export function normalizeFireworksBillingSummaryPayload(
 	payload: FireworksBillingSummaryPayload,
 	accountId: string,
@@ -192,6 +268,42 @@ function formatMoneyAmount(amount: bigint): string {
 	return `${negative ? "-" : ""}${units.toString()}${nanos ? `.${nanos}` : ""}`;
 }
 
+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,
+	);
+	url.searchParams.set(
+		"startTime",
+		dayFloor(startedAt - (FIREWORKS_SPEND_WINDOW_DAYS - 1) * dayMs),
+	);
+	url.searchParams.set("endTime", dayFloor(startedAt + dayMs));
+	return url.toString();
+}
+
+function remainingTimeout(timeoutMs: number, startedAt: number, description: string): number {
+	const remaining = timeoutMs - (Date.now() - startedAt);
+	if (remaining <= 0) throw new Error(`Timed out while ${description}.`);
+	return remaining;
+}
+
 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

@@ -152,6 +152,27 @@ function normalizeWindow(row: Record<string, unknown>, fields: WindowFields): Us
 	}
 	const total = nonnegativeInteger(row[fields.totalField], fields.totalField);
 	const count = nonnegativeInteger(row[fields.countField], fields.countField);
+	if (total === 0) {
+		if (count !== 0) {
+			throw new Error(`MiniMax Token Plan ${fields.label} counts were inconsistent.`);
+		}
+		if (percent === undefined) {
+			throw new Error(`MiniMax Token Plan ${fields.label} returned no quota and no percent.`);
+		}
+		// Token Plan reports remaining_percent as the quota when both counts are 0.
+		return {
+			id: fields.id,
+			label: fields.label,
+			groupId: fields.groupId,
+			groupLabel: fields.groupLabel,
+			remaining: percent,
+			used: 100 - percent,
+			limit: 0,
+			unit: "percent",
+			windowMinutes,
+			resetsAt,
+		};
+	}
 	const resolved = resolveQuotaCounts(count, total, percent);
 	if (!resolved) throw new Error(`MiniMax Token Plan ${fields.label} counts were inconsistent.`);
 	return {