@narumitw/pi-usage 0.58.0 → 0.60.0

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);
+}

package/src/providers/vercel-ai-gateway.ts

@@ -0,0 +1,43 @@
+import type { UsageMetric, UsageReport, VercelAIGatewayCreditsPayload } from "../types.js";
+
+const DECIMAL_AMOUNT = /^(?:0|[1-9]\d*)(?:\.\d+)?$/u;
+
+export function normalizeVercelAIGatewayCreditsPayload(
+	payload: VercelAIGatewayCreditsPayload,
+	capturedAt: number,
+): UsageReport {
+	const balance = decimalAmount(payload.balance, "balance");
+	const totalUsed = decimalAmount(payload.total_used, "total used");
+	const metrics: UsageMetric[] = [
+		{
+			id: "credit-balance",
+			label: "Credit balance",
+			value: balance,
+			unit: "currency",
+			currency: "USD",
+		},
+		{
+			id: "lifetime-spend",
+			label: "Lifetime spend",
+			value: totalUsed,
+			unit: "currency",
+			currency: "USD",
+		},
+	];
+	return {
+		providerId: "vercel-ai-gateway",
+		providerName: "Vercel AI Gateway",
+		capturedAt,
+		source: "vercel-ai-gateway-credits",
+		semantics: { kind: "api-key", label: "AI Gateway credits and lifetime spend" },
+		buckets: [],
+		metrics,
+	};
+}
+
+function decimalAmount(value: unknown, label: string): string {
+	if (typeof value !== "string" || value.length > 64 || !DECIMAL_AMOUNT.test(value)) {
+		throw new Error(`Vercel AI Gateway ${label} was not a valid nonnegative amount.`);
+	}
+	return value;
+}

package/src/providers/zai.ts

@@ -1,5 +1,12 @@
 import { sanitizeDisplayText } from "../core.js";
-import type { UsageBucket, UsageMetric, UsageReport, ZaiQuotaPayload } from "../types.js";
+import type {
+	UsageBucket,
+	UsageMetric,
+	UsageReport,
+	ZaiPlanInfo,
+	ZaiQuotaPayload,
+	ZaiSubscriptionPayload,
+} from "../types.js";
 
 const FIVE_HOUR_WINDOW_MINUTES = 300;
 const WEEKLY_WINDOW_MINUTES = 10_080;
@@ -9,6 +16,7 @@ export function normalizeZaiQuotaPayload(
 	providerName: string,
 	payload: ZaiQuotaPayload,
 	capturedAt: number,
+	plan?: ZaiPlanInfo,
 ): UsageReport {
 	const data = asObject(payload.data);
 	if (!data) throw new Error("Z.AI quota response data was not an object.");
@@ -26,14 +34,20 @@ export function normalizeZaiQuotaPayload(
 			addCountBucket(buckets, limit, "mcp-monthly", "MCP monthly allowance");
 			addUsageDetailMetrics(metrics, limit.usageDetails);
 		} else if (isPlanUsage && unit === 3) {
-			addPercentBucket(buckets, limit, "five-hour", "5h window", FIVE_HOUR_WINDOW_MINUTES);
+			addPercentBucket(
+				buckets,
+				limit,
+				"five-hour",
+				sessionWindowLabel(limit),
+				sessionWindowMinutes(limit),
+			);
 		} else if (isPlanUsage && unit === 6) {
 			const used = asNonnegativeNumber(limit.currentValue);
 			const quota = asNonnegativeNumber(limit.usage);
 			if (used !== undefined && quota !== undefined) {
-				addCountBucket(buckets, limit, "weekly", "Weekly window", WEEKLY_WINDOW_MINUTES);
+				addCountBucket(buckets, limit, "weekly", "Weekly window", weeklyWindowMinutes(limit));
 			} else {
-				addPercentBucket(buckets, limit, "weekly", "Weekly window", WEEKLY_WINDOW_MINUTES);
+				addPercentBucket(buckets, limit, "weekly", "Weekly window", weeklyWindowMinutes(limit));
 			}
 		}
 	}
@@ -43,7 +57,12 @@ export function normalizeZaiQuotaPayload(
 
 	const notes: string[] = [];
 	const level = asString(data.level);
-	if (level) notes.push(`Plan: ${level}`);
+	const planLabel = plan?.name ?? level;
+	if (planLabel) {
+		notes.push(
+			plan?.renewsAt ? `Plan: ${planLabel} · renews ${plan.renewsAt}` : `Plan: ${planLabel}`,
+		);
+	}
 
 	return {
 		providerId,
@@ -57,6 +76,79 @@ export function normalizeZaiQuotaPayload(
 	};
 }
 
+// The undocumented subscription endpoint can include historical products. Prefer the current,
+// valid product and fail closed to the quota plan level when only explicitly inactive products exist.
+export function normalizeZaiSubscriptionPayload(
+	payload: ZaiSubscriptionPayload,
+): ZaiPlanInfo | undefined {
+	if (payload.success === false) return undefined;
+	if (typeof payload.code === "number" && payload.code !== 0 && payload.code !== 200) {
+		return undefined;
+	}
+	if (!Array.isArray(payload.data)) return undefined;
+
+	const candidates: Array<{
+		plan: ZaiPlanInfo;
+		status?: string;
+		inCurrentPeriod?: boolean;
+	}> = [];
+	for (const raw of payload.data) {
+		const entry = asObject(raw);
+		if (!entry) continue;
+		const name = asString(entry.productName);
+		if (!name) continue;
+		const renewsAt = planRenewalDate(entry.nextRenewTime);
+		const status = asString(entry.status)?.toUpperCase();
+		const inCurrentPeriod = asBoolean(entry.inCurrentPeriod);
+		candidates.push({
+			plan: { name, ...(renewsAt !== undefined ? { renewsAt } : {}) },
+			...(status !== undefined ? { status } : {}),
+			...(inCurrentPeriod !== undefined ? { inCurrentPeriod } : {}),
+		});
+	}
+
+	const hasStateMetadata = candidates.some(
+		(candidate) => candidate.status !== undefined || candidate.inCurrentPeriod !== undefined,
+	);
+	if (!hasStateMetadata) return candidates[0]?.plan;
+	return (
+		candidates.find(
+			(candidate) => candidate.inCurrentPeriod === true && candidate.status === "VALID",
+		)?.plan ??
+		candidates.find(
+			(candidate) => candidate.inCurrentPeriod === true && candidate.status === undefined,
+		)?.plan ??
+		candidates.find(
+			(candidate) => candidate.status === "VALID" && candidate.inCurrentPeriod === undefined,
+		)?.plan
+	);
+}
+
+function planRenewalDate(value: unknown): string | undefined {
+	if (typeof value === "string" && /^\d{4}-\d{2}-\d{2}/u.test(value)) return value.slice(0, 10);
+	const millis = asNonnegativeNumber(value);
+	if (millis === undefined || millis === 0) return undefined;
+	return new Date(millis).toISOString().slice(0, 10);
+}
+
+// Z.AI encodes each window as a (unit, number) pair — unit 3 counts hours and unit 6 counts
+// weeks — so the payload's number drives the window length and session label; the established
+// 5-hour and weekly constants remain the fallback when the payload omits it.
+function sessionWindowMinutes(limit: Record<string, unknown>): number {
+	const hours = asPositiveNumber(limit.number);
+	return hours === undefined ? FIVE_HOUR_WINDOW_MINUTES : Math.round(hours * 60);
+}
+
+function sessionWindowLabel(limit: Record<string, unknown>): string {
+	const minutes = sessionWindowMinutes(limit);
+	return minutes === FIVE_HOUR_WINDOW_MINUTES ? "5h window" : `${Math.round(minutes / 60)}h window`;
+}
+
+function weeklyWindowMinutes(limit: Record<string, unknown>): number {
+	const weeks = asPositiveNumber(limit.number);
+	return weeks === undefined ? WEEKLY_WINDOW_MINUTES : Math.round(weeks * WEEKLY_WINDOW_MINUTES);
+}
+
 function addPercentBucket(
 	buckets: UsageBucket[],
 	limit: Record<string, unknown>,
@@ -130,6 +222,18 @@ function asNonnegativeNumber(value: unknown): number | undefined {
 	return value;
 }
 
+function asPositiveNumber(value: unknown): number | undefined {
+	const number = asNonnegativeNumber(value);
+	return number !== undefined && number > 0 ? number : undefined;
+}
+
+function asBoolean(value: unknown): boolean | undefined {
+	if (typeof value === "boolean") return value;
+	if (value === 1) return true;
+	if (value === 0) return false;
+	return undefined;
+}
+
 function asEpochSeconds(value: unknown): number | undefined {
 	const millis = asNonnegativeNumber(value);
 	if (millis === undefined) return undefined;