@narumitw/pi-usage 0.60.7 → 0.60.8

package/src/providers/minimax.ts

@@ -5,281 +5,276 @@ 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" },
+  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";
+  return apiKey.startsWith("sk-api-") ? "account-balance" : "token-plan";
 }
 
 export function normalizeMiniMaxUsagePayload(
-	providerId: MiniMaxProviderId,
-	kind: MiniMaxUsageKind,
-	payload: MiniMaxUsagePayload,
-	capturedAt: number,
+  providerId: MiniMaxProviderId,
+  kind: MiniMaxUsageKind,
+  payload: MiniMaxUsagePayload,
+  capturedAt: number,
 ): UsageReport {
-	return kind === "account-balance"
-		? normalizeBalance(providerId, payload, capturedAt)
-		: normalizeTokenPlan(providerId, payload, capturedAt);
+  return kind === "account-balance"
+    ? normalizeBalance(providerId, payload, capturedAt)
+    : normalizeTokenPlan(providerId, payload, capturedAt);
 }
 
 function normalizeBalance(
-	providerId: MiniMaxProviderId,
-	payload: MiniMaxUsagePayload,
-	capturedAt: number,
+  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,
-	};
+  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,
+  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: [],
-	};
+  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;
+  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);
-	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 {
-		id: fields.id,
-		label: fields.label,
-		groupId: fields.groupId,
-		groupLabel: fields.groupLabel,
-		...resolved,
-		unit: "count",
-		windowMinutes,
-		resetsAt,
-	};
+  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);
+  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 {
+    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,
+  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 };
+  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.");
-	}
+  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,
+  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 };
+  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>;
+  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;
+  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;
+  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;
+  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);
+  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;
+  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.");
+  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;
+  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

@@ -3,62 +3,57 @@ import type { MoonshotBalancePayload, UsageMetric, UsageReport } from "../types.
 export type MoonshotProviderId = "moonshotai" | "moonshotai-cn";
 
 const PROVIDERS = {
-	moonshotai: { name: "Moonshot AI", currency: "USD" },
-	"moonshotai-cn": { name: "Moonshot AI CN", currency: "CNY" },
+  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,
+  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,
-	};
+  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 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>;
+  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);
+  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);
 }