@hk_net/pi-usage-bars 0.3.0 → 0.4.1

package/extensions/usage-bars/core.ts

@@ -2,18 +2,63 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 
-export type ProviderKey = "codex" | "claude" | "zai" | "zai-cn";
-export type PiProviderId = "openai-codex" | "anthropic" | "zai" | "zai-coding-cn";
+export type ProviderKey =
+  | "codex"
+  | "claude"
+  | "zai"
+  | "zai-cn"
+  | "kimi"
+  | "minimax"
+  | "minimax-cn"
+  | "openrouter"
+  | "deepseek"
+  | "moonshot"
+  | "moonshot-cn";
+export type PiProviderId =
+  | "openai-codex"
+  | "anthropic"
+  | "zai"
+  | "zai-coding-cn"
+  | "kimi-coding"
+  | "minimax"
+  | "minimax-cn"
+  | "openrouter"
+  | "deepseek"
+  | "moonshotai"
+  | "moonshotai-cn";
+
+export interface AccountBalance {
+  amount: number;
+  unit: string;
+  label: string;
+}
+
+export interface AccountSpend {
+  unit: string;
+  daily?: number;
+  weekly?: number;
+  monthly?: number;
+  lifetime?: number;
+}
 
 export interface UsageData {
   session: number;
   weekly: number;
+  quotaHidden?: boolean;
+  accountBalance?: AccountBalance;
+  accountBalanceDetails?: AccountBalance[];
+  accountSpend?: AccountSpend;
   sessionResetsIn?: string;
   weeklyResetsIn?: string;
   sessionResetsAt?: string;
   weeklyResetsAt?: string;
   extraSpend?: number;
   extraLimit?: number;
+  sessionLabel?: string;
+  weeklyLabel?: string;
+  sessionHidden?: boolean;
+  weeklyHidden?: boolean;
+  notice?: string;
   warning?: string;
   stale?: boolean;
   fetchedAt?: number;
@@ -26,6 +71,16 @@ export type UsageTokens = Partial<Record<ProviderKey, string>>;
 export interface UsageEndpoints {
   zai: string;
   zaiCn: string;
+  kimi: string;
+  minimax: string;
+  minimaxLegacy: string;
+  minimaxCn: string;
+  minimaxCnLegacy: string;
+  openRouterCredits: string;
+  openRouterKey: string;
+  deepSeekBalance: string;
+  moonshotBalance: string;
+  moonshotCnBalance: string;
 }
 
 export interface HeadersLike {
@@ -108,6 +163,16 @@ const CLAUDE_LOCK_STALE_MS = 20_000;
 export const DEFAULT_USAGE_CACHE_FILE = path.join(os.tmpdir(), "pi", "usage-bars-cache.json");
 export const DEFAULT_ZAI_USAGE_ENDPOINT = "https://api.z.ai/api/monitor/usage/quota/limit";
 export const DEFAULT_ZAI_CN_USAGE_ENDPOINT = "https://open.bigmodel.cn/api/monitor/usage/quota/limit";
+export const DEFAULT_KIMI_USAGE_ENDPOINT = "https://api.kimi.com/coding/v1/usages";
+export const DEFAULT_MINIMAX_USAGE_ENDPOINT = "https://api.minimax.io/v1/token_plan/remains";
+export const DEFAULT_MINIMAX_LEGACY_USAGE_ENDPOINT = "https://api.minimax.io/v1/api/openplatform/coding_plan/remains";
+export const DEFAULT_MINIMAX_CN_USAGE_ENDPOINT = "https://api.minimaxi.com/v1/token_plan/remains";
+export const DEFAULT_MINIMAX_CN_LEGACY_USAGE_ENDPOINT = "https://api.minimaxi.com/v1/api/openplatform/coding_plan/remains";
+export const DEFAULT_OPENROUTER_CREDITS_ENDPOINT = "https://openrouter.ai/api/v1/credits";
+export const DEFAULT_OPENROUTER_KEY_ENDPOINT = "https://openrouter.ai/api/v1/key";
+export const DEFAULT_DEEPSEEK_BALANCE_ENDPOINT = "https://api.deepseek.com/user/balance";
+export const DEFAULT_MOONSHOT_BALANCE_ENDPOINT = "https://api.moonshot.ai/v1/users/me/balance";
+export const DEFAULT_MOONSHOT_CN_BALANCE_ENDPOINT = "https://api.moonshot.cn/v1/users/me/balance";
 
 export function resolveUsageEndpoints(env: NodeJS.ProcessEnv = process.env): UsageEndpoints {
   const configured = (value: string | undefined, fallback: string) => {
@@ -118,6 +183,16 @@ export function resolveUsageEndpoints(env: NodeJS.ProcessEnv = process.env): Usa
   return {
     zai: configured(env.PI_ZAI_USAGE_ENDPOINT, DEFAULT_ZAI_USAGE_ENDPOINT),
     zaiCn: configured(env.PI_ZAI_CODING_CN_USAGE_ENDPOINT, DEFAULT_ZAI_CN_USAGE_ENDPOINT),
+    kimi: configured(env.PI_KIMI_USAGE_ENDPOINT, DEFAULT_KIMI_USAGE_ENDPOINT),
+    minimax: configured(env.PI_MINIMAX_USAGE_ENDPOINT, DEFAULT_MINIMAX_USAGE_ENDPOINT),
+    minimaxLegacy: configured(env.PI_MINIMAX_LEGACY_USAGE_ENDPOINT, DEFAULT_MINIMAX_LEGACY_USAGE_ENDPOINT),
+    minimaxCn: configured(env.PI_MINIMAX_CN_USAGE_ENDPOINT, DEFAULT_MINIMAX_CN_USAGE_ENDPOINT),
+    minimaxCnLegacy: configured(env.PI_MINIMAX_CN_LEGACY_USAGE_ENDPOINT, DEFAULT_MINIMAX_CN_LEGACY_USAGE_ENDPOINT),
+    openRouterCredits: configured(env.PI_OPENROUTER_CREDITS_ENDPOINT, DEFAULT_OPENROUTER_CREDITS_ENDPOINT),
+    openRouterKey: configured(env.PI_OPENROUTER_KEY_ENDPOINT, DEFAULT_OPENROUTER_KEY_ENDPOINT),
+    deepSeekBalance: configured(env.PI_DEEPSEEK_BALANCE_ENDPOINT, DEFAULT_DEEPSEEK_BALANCE_ENDPOINT),
+    moonshotBalance: configured(env.PI_MOONSHOT_BALANCE_ENDPOINT, DEFAULT_MOONSHOT_BALANCE_ENDPOINT),
+    moonshotCnBalance: configured(env.PI_MOONSHOT_CN_BALANCE_ENDPOINT, DEFAULT_MOONSHOT_CN_BALANCE_ENDPOINT),
   };
 }
 
@@ -384,12 +459,21 @@ function snapshotUsage(usage: UsageData, nowMs = Date.now()): UsageData {
   return {
     session: usage.session,
     weekly: usage.weekly,
+    quotaHidden: usage.quotaHidden,
+    accountBalance: usage.accountBalance,
+    accountBalanceDetails: usage.accountBalanceDetails,
+    accountSpend: usage.accountSpend,
     sessionResetsAt: usage.sessionResetsAt,
     weeklyResetsAt: usage.weeklyResetsAt,
     sessionResetsIn: usage.sessionResetsIn,
     weeklyResetsIn: usage.weeklyResetsIn,
     extraSpend: usage.extraSpend,
     extraLimit: usage.extraLimit,
+    sessionLabel: usage.sessionLabel,
+    weeklyLabel: usage.weeklyLabel,
+    sessionHidden: usage.sessionHidden,
+    weeklyHidden: usage.weeklyHidden,
+    notice: usage.notice,
     fetchedAt: usage.fetchedAt ?? nowMs,
   };
 }
@@ -438,6 +522,41 @@ function readClaudeCacheOutcome(cacheFile = DEFAULT_USAGE_CACHE_FILE, nowMs = Da
   return null;
 }
 
+export function parseCodexRateLimit(data: any): UsageData {
+  const rateLimit = data?.rate_limit ?? data?.rate_limits;
+  const primary = rateLimit?.primary_window ?? rateLimit?.primary ?? rateLimit?.five_hour;
+  const secondary = rateLimit?.secondary_window ?? rateLimit?.secondary ?? rateLimit?.weekly;
+
+  let sessionWindow: any = null;
+  let weeklyWindow: any = null;
+  for (const [position, window] of [["primary", primary], ["secondary", secondary]] as const) {
+    if (!window || typeof window !== "object") continue;
+    const duration = window.limit_window_seconds;
+    if (typeof duration === "number" && Number.isFinite(duration)) {
+      // Some Codex accounts return their seven-day quota as primary_window
+      // and omit secondary_window, so position alone does not identify it.
+      if (duration >= 2 * 24 * 60 * 60) weeklyWindow ??= window;
+      else sessionWindow ??= window;
+    } else if (position === "primary") {
+      sessionWindow ??= window;
+    } else {
+      weeklyWindow ??= window;
+    }
+  }
+
+  const reset = (window: any) =>
+    typeof window?.reset_after_seconds === "number" ? formatDuration(window.reset_after_seconds) : undefined;
+
+  return {
+    session: readPercentCandidate(sessionWindow?.used_percent) ?? 0,
+    weekly: readPercentCandidate(weeklyWindow?.used_percent) ?? 0,
+    ...(!sessionWindow ? { sessionHidden: true } : {}),
+    ...(!weeklyWindow ? { weeklyHidden: true } : {}),
+    sessionResetsIn: reset(sessionWindow),
+    weeklyResetsIn: reset(weeklyWindow),
+  };
+}
+
 export async function fetchCodexUsage(token: string, config: RequestConfig = {}): Promise<UsageData> {
   const result = await requestJson(
     "https://chatgpt.com/backend-api/wham/usage",
@@ -445,16 +564,7 @@ export async function fetchCodexUsage(token: string, config: RequestConfig = {})
     config,
   );
   if (!result.ok) return { session: 0, weekly: 0, error: result.error };
-
-  const data = result.data as any;
-  const primary = data?.rate_limit?.primary_window;
-  const secondary = data?.rate_limit?.secondary_window;
-  return {
-    session: readPercentCandidate(primary?.used_percent) ?? 0,
-    weekly: readPercentCandidate(secondary?.used_percent) ?? 0,
-    sessionResetsIn: typeof primary?.reset_after_seconds === "number" ? formatDuration(primary.reset_after_seconds) : undefined,
-    weeklyResetsIn: typeof secondary?.reset_after_seconds === "number" ? formatDuration(secondary.reset_after_seconds) : undefined,
-  };
+  return parseCodexRateLimit(result.data);
 }
 
 async function fetchClaudeUsageAttempt(
@@ -545,6 +655,463 @@ export async function fetchClaudeUsageWithFallback(
   }
 }
 
+function readNumber(value: unknown): number | null {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string" && value.trim()) {
+    const parsed = Number(value);
+    if (Number.isFinite(parsed)) return parsed;
+  }
+  return null;
+}
+
+function usedPercentFromCounts(
+  value: Record<string, unknown> | null | undefined,
+  options: { remainingPercent?: string; used?: string; total?: string; remaining?: string } = {},
+): number | null {
+  if (!value) return null;
+  const remainingPercent = readNumber(value[options.remainingPercent ?? "remaining_percent"]);
+  if (remainingPercent !== null) return Math.max(0, Math.min(100, 100 - remainingPercent));
+
+  const total = readNumber(value[options.total ?? "limit"]);
+  const used = readNumber(value[options.used ?? "used"]);
+  const remaining = readNumber(value[options.remaining ?? "remaining"]);
+  if (total === null || total <= 0) return null;
+  if (used !== null) return Math.max(0, Math.min(100, used / total * 100));
+  if (remaining !== null) return Math.max(0, Math.min(100, (total - remaining) / total * 100));
+  return null;
+}
+
+function normalizeIsoDate(value: unknown): string | undefined {
+  if (typeof value !== "string" || !value.trim()) return undefined;
+  const normalized = value.trim().replace(/(\.\d{3})\d+(?=Z|[+-]\d\d:\d\d$)/, "$1");
+  return Number.isFinite(new Date(normalized).getTime()) ? normalized : undefined;
+}
+
+function isoFromEpoch(value: unknown): string | undefined {
+  const raw = readNumber(value);
+  if (raw === null || raw <= 0) return undefined;
+  const milliseconds = raw > 1_000_000_000_000 ? raw : raw * 1000;
+  const date = new Date(milliseconds);
+  return Number.isFinite(date.getTime()) ? date.toISOString() : undefined;
+}
+
+function resetFromRemains(value: unknown, nowMs: number): string | undefined {
+  const raw = readNumber(value);
+  if (raw === null || raw <= 0) return undefined;
+  const milliseconds = raw > 1_000_000 ? raw : raw * 1000;
+  return new Date(nowMs + milliseconds).toISOString();
+}
+
+export function extractKimiUsageFromPayload(payload: unknown, nowMs = Date.now()): UsageData | null {
+  const root = asObject(payload);
+  if (!root) return null;
+  const webUsages = Array.isArray(root.usages) ? root.usages : undefined;
+  const codingUsage = webUsages?.map(asObject).find((entry) =>
+    String(entry?.scope ?? "").toUpperCase() === "FEATURE_CODING") ?? root;
+  const dataRows = Array.isArray(codingUsage.data) ? codingUsage.data.map(asObject).filter(Boolean) : [];
+  const usage = asObject(codingUsage.usage) ?? asObject(codingUsage.detail) ??
+    dataRows.find((entry) => String(entry?.model_name ?? entry?.modelName ?? "").toLowerCase() === "all");
+  const limits = Array.isArray(codingUsage.limits)
+    ? codingUsage.limits
+    : dataRows.filter((entry) => entry !== usage);
+  const sessionLimit = limits.map(asObject).find((entry) => {
+    const window = asObject(entry?.window);
+    const duration = readNumber(window?.duration);
+    const unit = String(window?.timeUnit ?? window?.time_unit ?? "").toUpperCase();
+    return duration === 300 && unit.includes("MINUTE");
+  }) ?? limits.map(asObject).find((entry) => entry !== null);
+  const sessionDetail = asObject(sessionLimit?.detail) ?? sessionLimit;
+
+  const session = usedPercentFromCounts(sessionDetail);
+  const weekly = usedPercentFromCounts(usage);
+  if (session === null || weekly === null) return null;
+
+  const sessionReset = normalizeIsoDate(sessionDetail?.resetTime ?? sessionDetail?.reset_at ?? sessionDetail?.reset_time);
+  const weeklyReset = normalizeIsoDate(usage?.resetTime ?? usage?.reset_at ?? usage?.reset_time);
+  return hydrateUsageResets({
+    ...normalizeUsagePair(session, weekly),
+    sessionLabel: "5-hour",
+    weeklyLabel: "Weekly",
+    sessionResetsAt: sessionReset,
+    weeklyResetsAt: weeklyReset,
+  }, nowMs);
+}
+
+export async function fetchKimiUsage(token: string, config: FetchConfig = {}): Promise<UsageData> {
+  const endpoints = config.endpoints ?? resolveUsageEndpoints(config.env);
+  const result = await requestJson(endpoints.kimi, {
+    headers: {
+      Authorization: `Bearer ${token}`,
+      "User-Agent": "KimiCLI/1.5",
+    },
+  }, config);
+  if (!result.ok) return { session: 0, weekly: 0, error: result.error };
+  return extractKimiUsageFromPayload(result.data) ?? {
+    session: 0,
+    weekly: 0,
+    error: "unrecognized response shape",
+  };
+}
+
+interface MiniMaxWindow {
+  percent: number;
+  resetsAt?: string;
+}
+
+function pickHighestWindow(windows: MiniMaxWindow[]): MiniMaxWindow | undefined {
+  return windows.reduce<MiniMaxWindow | undefined>((highest, window) =>
+    !highest || window.percent > highest.percent ? window : highest, undefined);
+}
+
+function miniMaxResetAt(value: Record<string, unknown>, prefix: "current" | "weekly", nowMs: number): string | undefined {
+  const end = prefix === "current"
+    ? value.end_time ?? value.endTime
+    : value.weekly_end_time ?? value.weeklyEndTime;
+  const remains = prefix === "current"
+    ? value.remains_time ?? value.remainsTime
+    : value.weekly_remains_time ?? value.weeklyRemainsTime;
+  const resetsAt = prefix === "current"
+    ? value.current_resets_at ?? value.currentResetsAt
+    : value.weekly_resets_at ?? value.weeklyResetsAt;
+  return normalizeIsoDate(resetsAt) ?? isoFromEpoch(end) ?? resetFromRemains(remains, nowMs);
+}
+
+function extractMiniMaxCreditBalance(payload: unknown): AccountBalance | undefined {
+  const root = asObject(payload);
+  const data = asObject(root?.data) ?? root;
+  if (!data) return undefined;
+  const amount = readNumber(
+    data.points_balance ?? data.pointsBalance ??
+    data.point_balance ?? data.pointBalance ??
+    data.credits_balance ?? data.creditsBalance ??
+    data.credit_balance ?? data.creditBalance,
+  );
+  return amount === null ? undefined : { amount, unit: "credits", label: "Credit balance" };
+}
+
+export function extractMiniMaxUsageFromPayload(payload: unknown, nowMs = Date.now()): UsageData | null {
+  const root = asObject(payload);
+  const data = asObject(root?.data) ?? root;
+  if (!data) return null;
+  const accountBalance = extractMiniMaxCreditBalance(payload);
+
+  const intervalWindows: MiniMaxWindow[] = [];
+  const weeklyWindows: MiniMaxWindow[] = [];
+  if (Array.isArray(data.services)) {
+    for (const rawService of data.services) {
+      const service = asObject(rawService);
+      if (!service) continue;
+      const directPercent = readPercentCandidate(readNumber(service.percent));
+      const percent = directPercent ?? usedPercentFromCounts(service, { total: "limit", used: "usage" });
+      if (percent === null) continue;
+      const windowType = String(service.window_type ?? service.windowType ?? "").toLowerCase();
+      const resetsAt = normalizeIsoDate(service.resets_at ?? service.reset_time ?? service.end_time);
+      (windowType.includes("week") ? weeklyWindows : intervalWindows).push({ percent, resetsAt });
+    }
+  }
+
+  if (Array.isArray(data.model_remains ?? data.modelRemains)) {
+    for (const rawModel of (data.model_remains ?? data.modelRemains) as unknown[]) {
+      const raw = asObject(rawModel);
+      if (!raw) continue;
+      const model: Record<string, unknown> = {
+        ...raw,
+        current_interval_remaining_percent:
+          raw.current_interval_remaining_percent ?? raw.currentIntervalRemainingPercent,
+        current_interval_total_count: raw.current_interval_total_count ?? raw.currentIntervalTotalCount,
+        current_interval_usage_count: raw.current_interval_usage_count ?? raw.currentIntervalUsageCount,
+        current_interval_status: raw.current_interval_status ?? raw.currentIntervalStatus,
+        current_weekly_remaining_percent:
+          raw.current_weekly_remaining_percent ?? raw.currentWeeklyRemainingPercent,
+        current_weekly_total_count: raw.current_weekly_total_count ?? raw.currentWeeklyTotalCount,
+        current_weekly_usage_count: raw.current_weekly_usage_count ?? raw.currentWeeklyUsageCount,
+        current_weekly_status: raw.current_weekly_status ?? raw.currentWeeklyStatus,
+      };
+      const unavailable = (prefix: "interval" | "weekly") =>
+        readNumber(model[`current_${prefix}_status`]) === 3 &&
+        (readNumber(model[`current_${prefix}_remaining_percent`]) ?? 0) >= 100 &&
+        (readNumber(model[`current_${prefix}_total_count`]) ?? 0) === 0 &&
+        (readNumber(model[`current_${prefix}_usage_count`]) ?? 0) === 0;
+      const interval = unavailable("interval") ? null : usedPercentFromCounts(model, {
+        remainingPercent: "current_interval_remaining_percent",
+        total: "current_interval_total_count",
+        remaining: "current_interval_usage_count",
+      });
+      if (interval !== null) {
+        intervalWindows.push({ percent: interval, resetsAt: miniMaxResetAt(model, "current", nowMs) });
+      }
+      const weekly = unavailable("weekly") ? null : usedPercentFromCounts(model, {
+        remainingPercent: "current_weekly_remaining_percent",
+        total: "current_weekly_total_count",
+        remaining: "current_weekly_usage_count",
+      });
+      if (weekly !== null) {
+        weeklyWindows.push({ percent: weekly, resetsAt: miniMaxResetAt(model, "weekly", nowMs) });
+      }
+    }
+  }
+
+  const session = pickHighestWindow(intervalWindows);
+  const weekly = pickHighestWindow(weeklyWindows);
+  if (!session) {
+    return accountBalance
+      ? { session: 0, weekly: 0, quotaHidden: true, accountBalance }
+      : null;
+  }
+  return hydrateUsageResets({
+    session: Number(session.percent.toFixed(2)),
+    accountBalance,
+    weekly: Number((weekly?.percent ?? 0).toFixed(2)),
+    sessionLabel: "Interval",
+    weeklyLabel: "Weekly",
+    weeklyHidden: !weekly,
+    sessionResetsAt: session.resetsAt,
+    weeklyResetsAt: weekly?.resetsAt,
+  }, nowMs);
+}
+
+function miniMaxPayloadStatus(payload: unknown): number | null {
+  const root = asObject(payload);
+  const data = asObject(root?.data);
+  const baseResponse = asObject(data?.base_resp ?? data?.baseResp ?? root?.base_resp ?? root?.baseResp);
+  return readNumber(baseResponse?.status_code ?? baseResponse?.statusCode);
+}
+
+function miniMaxPayloadError(payload: unknown): string | null {
+  const root = asObject(payload);
+  const data = asObject(root?.data);
+  const baseResponse = asObject(data?.base_resp ?? data?.baseResp ?? root?.base_resp ?? root?.baseResp);
+  const status = miniMaxPayloadStatus(payload);
+  if (status === null || status === 0) return null;
+  const message = baseResponse?.status_msg ?? baseResponse?.statusMessage;
+  return typeof message === "string" && message.trim()
+    ? `API ${status}: ${message.trim()}`
+    : `API ${status}`;
+}
+
+export async function fetchMiniMaxUsage(
+  token: string,
+  provider: "minimax" | "minimax-cn" = "minimax",
+  config: FetchConfig = {},
+): Promise<UsageData> {
+  const endpoints = config.endpoints ?? resolveUsageEndpoints(config.env);
+  const candidates = provider === "minimax-cn"
+    ? [endpoints.minimaxCn, endpoints.minimaxCnLegacy]
+    : [endpoints.minimax, endpoints.minimaxLegacy];
+  let lastError = "usage request failed";
+  let credentialError: string | undefined;
+  let noActiveTokenPlan = false;
+
+  for (const endpoint of [...new Set(candidates)]) {
+    const result = await requestJson(endpoint, {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        Accept: "application/json",
+      },
+    }, config);
+    if (!result.ok) {
+      lastError = result.error;
+      if (result.status === 401 || result.status === 403) credentialError ??= result.error;
+      if (config.signal?.aborted) break;
+      continue;
+    }
+    const payloadStatus = miniMaxPayloadStatus(result.data);
+    const payloadError = miniMaxPayloadError(result.data);
+    const usage = extractMiniMaxUsageFromPayload(result.data);
+    if (usage && (!payloadError || usage.quotaHidden)) return usage;
+    if (payloadStatus === 2062) {
+      noActiveTokenPlan = true;
+      continue;
+    }
+    if (payloadError) {
+      lastError = payloadError;
+      continue;
+    }
+    lastError = "unrecognized response shape";
+  }
+
+  if (noActiveTokenPlan) {
+    return {
+      session: 0,
+      weekly: 0,
+      quotaHidden: true,
+      notice: "No active Token Plan · check Credit balance in the MiniMax console",
+    };
+  }
+  return { session: 0, weekly: 0, error: credentialError ?? lastError };
+}
+
+export function extractOpenRouterUsageFromPayloads(
+  creditsPayload: unknown,
+  keyPayload: unknown,
+): UsageData | null {
+  const credits = asObject(asObject(creditsPayload)?.data) ?? asObject(creditsPayload);
+  const key = asObject(asObject(keyPayload)?.data) ?? asObject(keyPayload);
+
+  const totalCredits = readNumber(credits?.total_credits ?? credits?.totalCredits);
+  const totalUsage = readNumber(credits?.total_usage ?? credits?.totalUsage);
+  const accountBalance = totalCredits !== null && totalUsage !== null
+    ? {
+        amount: Number((totalCredits - totalUsage).toFixed(6)),
+        unit: "USD",
+        label: "Balance",
+      }
+    : undefined;
+
+  const spendValues = {
+    daily: readNumber(key?.usage_daily ?? key?.usageDaily),
+    weekly: readNumber(key?.usage_weekly ?? key?.usageWeekly),
+    monthly: readNumber(key?.usage_monthly ?? key?.usageMonthly),
+    lifetime: readNumber(key?.usage),
+  };
+  const accountSpend = Object.values(spendValues).some((value) => value !== null)
+    ? {
+        unit: "USD",
+        daily: spendValues.daily ?? undefined,
+        weekly: spendValues.weekly ?? undefined,
+        monthly: spendValues.monthly ?? undefined,
+        lifetime: spendValues.lifetime ?? undefined,
+      }
+    : undefined;
+
+  const limit = readNumber(key?.limit);
+  const remaining = readNumber(key?.limit_remaining ?? key?.limitRemaining);
+  const limitUsed = limit !== null && limit > 0 && remaining !== null
+    ? Math.max(0, Math.min(limit, limit - remaining))
+    : null;
+  const limitPercent = limitUsed !== null && limit !== null ? limitUsed / limit * 100 : null;
+  if (!accountBalance && !accountSpend && limitPercent === null) return null;
+
+  return {
+    session: limitPercent === null ? 0 : Number(limitPercent.toFixed(2)),
+    weekly: 0,
+    quotaHidden: limitPercent === null,
+    weeklyHidden: true,
+    sessionLabel: "Key limit",
+    accountBalance,
+    accountSpend,
+  };
+}
+
+export async function fetchOpenRouterUsage(token: string, config: FetchConfig = {}): Promise<UsageData> {
+  const endpoints = config.endpoints ?? resolveUsageEndpoints(config.env);
+  const headers = { Authorization: `Bearer ${token}`, Accept: "application/json" };
+  const [creditsResult, keyResult] = await Promise.all([
+    requestJson(endpoints.openRouterCredits, { headers }, config),
+    requestJson(endpoints.openRouterKey, { headers }, config),
+  ]);
+  const usage = extractOpenRouterUsageFromPayloads(
+    creditsResult.ok ? creditsResult.data : undefined,
+    keyResult.ok ? keyResult.data : undefined,
+  );
+  if (usage) return usage;
+
+  const errors = [
+    creditsResult.ok ? undefined : `credits: ${creditsResult.error}`,
+    keyResult.ok ? undefined : `key: ${keyResult.error}`,
+  ].filter((value): value is string => Boolean(value));
+  return {
+    session: 0,
+    weekly: 0,
+    error: errors.length > 0 ? errors.join("; ") : "unrecognized response shape",
+  };
+}
+
+export function extractDeepSeekBalanceFromPayload(payload: unknown): UsageData | null {
+  const root = asObject(payload);
+  const rawBalances = Array.isArray(root?.balance_infos) ? root.balance_infos : [];
+  const balances = rawBalances.map(asObject).filter((value): value is Record<string, unknown> => value !== null);
+  if (balances.length === 0) return null;
+
+  const parsed = balances.flatMap((balance) => {
+    const unit = typeof balance.currency === "string" ? balance.currency.toUpperCase() : "USD";
+    const total = readNumber(balance.total_balance ?? balance.totalBalance);
+    if (total === null) return [];
+    return [{
+      total: { amount: total, unit, label: "Total balance" } satisfies AccountBalance,
+      toppedUp: readNumber(balance.topped_up_balance ?? balance.toppedUpBalance),
+      granted: readNumber(balance.granted_balance ?? balance.grantedBalance),
+    }];
+  });
+  const primary = parsed[0];
+  if (!primary) return null;
+
+  const details: AccountBalance[] = [];
+  if (primary.toppedUp !== null) {
+    details.push({ amount: primary.toppedUp, unit: primary.total.unit, label: "Topped up" });
+  }
+  if (primary.granted !== null) {
+    details.push({ amount: primary.granted, unit: primary.total.unit, label: "Granted" });
+  }
+  for (const additional of parsed.slice(1)) details.push(additional.total);
+
+  return {
+    session: 0,
+    weekly: 0,
+    quotaHidden: true,
+    accountBalance: primary.total,
+    accountBalanceDetails: details,
+    warning: root?.is_available === false ? "Balance is not currently available for API use" : undefined,
+  };
+}
+
+export async function fetchDeepSeekBalance(token: string, config: FetchConfig = {}): Promise<UsageData> {
+  const endpoints = config.endpoints ?? resolveUsageEndpoints(config.env);
+  const result = await requestJson(endpoints.deepSeekBalance, {
+    headers: { Authorization: `Bearer ${token}`, Accept: "application/json" },
+  }, config);
+  if (!result.ok) return { session: 0, weekly: 0, error: result.error };
+  return extractDeepSeekBalanceFromPayload(result.data) ?? {
+    session: 0,
+    weekly: 0,
+    error: "unrecognized response shape",
+  };
+}
+
+export function extractMoonshotBalanceFromPayload(
+  payload: unknown,
+  provider: "moonshot" | "moonshot-cn" = "moonshot",
+): UsageData | null {
+  const root = asObject(payload);
+  const data = asObject(root?.data) ?? root;
+  if (!data) return null;
+  const available = readNumber(data.available_balance ?? data.availableBalance);
+  if (available === null) return null;
+  const cash = readNumber(data.cash_balance ?? data.cashBalance);
+  const voucher = readNumber(data.voucher_balance ?? data.voucherBalance);
+  const unit = provider === "moonshot-cn" ? "CNY" : "USD";
+  const details: AccountBalance[] = [];
+  if (cash !== null) details.push({ amount: cash, unit, label: "Cash" });
+  if (voucher !== null) details.push({ amount: voucher, unit, label: "Voucher" });
+
+  return {
+    session: 0,
+    weekly: 0,
+    quotaHidden: true,
+    accountBalance: { amount: available, unit, label: "Available balance" },
+    accountBalanceDetails: details,
+    warning: available <= 0 ? "Balance exhausted; inference requests may be rejected" : undefined,
+  };
+}
+
+export async function fetchMoonshotBalance(
+  token: string,
+  provider: "moonshot" | "moonshot-cn" = "moonshot",
+  config: FetchConfig = {},
+): Promise<UsageData> {
+  const endpoints = config.endpoints ?? resolveUsageEndpoints(config.env);
+  const endpoint = provider === "moonshot-cn" ? endpoints.moonshotCnBalance : endpoints.moonshotBalance;
+  const result = await requestJson(endpoint, {
+    headers: { Authorization: `Bearer ${token}`, Accept: "application/json" },
+  }, config);
+  if (!result.ok) return { session: 0, weekly: 0, error: result.error };
+  return extractMoonshotBalanceFromPayload(result.data, provider) ?? {
+    session: 0,
+    weekly: 0,
+    error: "unrecognized response shape",
+  };
+}
+
 /** Parse ZAI limits where unit 3 is the five-hour window and unit 6 the weekly window. */
 export function extractZaiUsageFromPayload(payload: unknown, nowMs = Date.now()): UsageData | null {
   const data = payload as any;
@@ -597,6 +1164,13 @@ export function detectProvider(
     case "anthropic": return "claude";
     case "zai": return "zai";
     case "zai-coding-cn": return "zai-cn";
+    case "kimi-coding": return "kimi";
+    case "minimax": return "minimax";
+    case "minimax-cn": return "minimax-cn";
+    case "openrouter": return "openrouter";
+    case "deepseek": return "deepseek";
+    case "moonshotai": return "moonshot";
+    case "moonshotai-cn": return "moonshot-cn";
     default: return null;
   }
 }
@@ -607,6 +1181,13 @@ export function providerToPiProviderId(provider: ProviderKey): PiProviderId {
     case "claude": return "anthropic";
     case "zai": return "zai";
     case "zai-cn": return "zai-coding-cn";
+    case "kimi": return "kimi-coding";
+    case "minimax": return "minimax";
+    case "minimax-cn": return "minimax-cn";
+    case "openrouter": return "openrouter";
+    case "deepseek": return "deepseek";
+    case "moonshot": return "moonshotai";
+    case "moonshot-cn": return "moonshotai-cn";
   }
 }
 
@@ -626,7 +1207,19 @@ export async function fetchAllUsages(
   config: FetchAllUsagesConfig = {},
 ): Promise<UsageByProvider> {
   const endpoints = config.endpoints ?? resolveUsageEndpoints(config.env);
-  const results: UsageByProvider = { codex: null, claude: null, zai: null, "zai-cn": null };
+  const results: UsageByProvider = {
+    codex: null,
+    claude: null,
+    zai: null,
+    "zai-cn": null,
+    kimi: null,
+    minimax: null,
+    "minimax-cn": null,
+    openrouter: null,
+    deepseek: null,
+    moonshot: null,
+    "moonshot-cn": null,
+  };
   const tasks: Promise<void>[] = [];
 
   const assign = (provider: ProviderKey, request: Promise<UsageData>) => {
@@ -647,7 +1240,29 @@ export async function fetchAllUsages(
   }
   if (tokens.zai) assign("zai", fetchZaiUsage(tokens.zai, "zai", { ...config, endpoints }));
   if (tokens["zai-cn"]) assign("zai-cn", fetchZaiUsage(tokens["zai-cn"], "zai-cn", { ...config, endpoints }));
+  if (tokens.kimi) assign("kimi", fetchKimiUsage(tokens.kimi, { ...config, endpoints }));
+  if (tokens.minimax) assign("minimax", fetchMiniMaxUsage(tokens.minimax, "minimax", { ...config, endpoints }));
+  if (tokens["minimax-cn"]) {
+    assign("minimax-cn", fetchMiniMaxUsage(tokens["minimax-cn"], "minimax-cn", { ...config, endpoints }));
+  }
+  if (tokens.openrouter) assign("openrouter", fetchOpenRouterUsage(tokens.openrouter, { ...config, endpoints }));
+  if (tokens.deepseek) assign("deepseek", fetchDeepSeekBalance(tokens.deepseek, { ...config, endpoints }));
+  if (tokens.moonshot) assign("moonshot", fetchMoonshotBalance(tokens.moonshot, "moonshot", { ...config, endpoints }));
+  if (tokens["moonshot-cn"]) {
+    assign("moonshot-cn", fetchMoonshotBalance(tokens["moonshot-cn"], "moonshot-cn", { ...config, endpoints }));
+  }
 
   await Promise.all(tasks);
+
+  // Pi intentionally uses MOONSHOT_API_KEY for both regional providers. When one
+  // key works in only one region, hide the expected regional auth failure from
+  // the all-provider view while preserving active-provider polling behavior.
+  if (tokens.moonshot && tokens.moonshot === tokens["moonshot-cn"]) {
+    if (results.moonshot && !results.moonshot.error && results["moonshot-cn"]?.error) {
+      results["moonshot-cn"] = null;
+    } else if (results["moonshot-cn"] && !results["moonshot-cn"].error && results.moonshot?.error) {
+      results.moonshot = null;
+    }
+  }
   return results;
 }