pi-myusage 0.1.0

package/src/adapters/gemini.ts

@@ -0,0 +1,52 @@
+import { fetchJson, HttpError, safeError, urlOnDomain } from "../http.ts";
+import { snapshot, type UsageAdapter, type UsageSnapshot } from "../types.ts";
+
+const MODELS_URL = "https://generativelanguage.googleapis.com/v1beta/models";
+
+interface ModelsResponse {
+  models?: unknown[];
+}
+
+export const geminiAdapter: UsageAdapter = {
+  id: "gemini",
+  label: "Gemini API",
+  canHandle(target) {
+    if (["gemini", "google-ai-studio", "aistudio"].includes(target.providerId.toLowerCase())) return true;
+    return urlOnDomain(target.baseUrl, "generativelanguage.googleapis.com");
+  },
+  async fetch({ target, signal }): Promise<UsageSnapshot> {
+    try {
+      const apiKey = target.credentials?.apiKey;
+      if (!apiKey) return snapshot(this, target, "unauthorized", { error: "No API key" });
+
+      let payload: ModelsResponse;
+      try {
+        payload = await fetchJson<ModelsResponse>(
+          MODELS_URL,
+          { headers: { "x-goog-api-key": apiKey, Accept: "application/json" } },
+          signal,
+        );
+      } catch (error) {
+        if (error instanceof HttpError && (error.status === 401 || error.status === 403)) {
+          return snapshot(this, target, "unauthorized", { error: safeError(error) });
+        }
+        throw error;
+      }
+
+      const count = Array.isArray(payload.models) ? payload.models.length : 0;
+      return snapshot(this, target, "ok", {
+        accounts: [
+          {
+            id: "gemini-key",
+            label: "Gemini API",
+            metrics: [{ kind: "status", id: "gemini-key", label: "Key", value: `valid · ${count} models` }],
+          },
+        ],
+        summary: `Gemini key ok · ${count} models`,
+      });
+    } catch (error) {
+      if (signal.aborted) return snapshot(this, target, "unavailable", { error: "aborted" });
+      return snapshot(this, target, "unavailable", { error: safeError(error) });
+    }
+  },
+};

package/src/adapters/github-copilot.ts

@@ -0,0 +1,137 @@
+import { shortReset } from "../format.ts";
+import { fetchJson, HttpError, safeError } from "../http.ts";
+import { snapshot, type Metric, type UsageAdapter, type UsageSnapshot } from "../types.ts";
+
+const USER_URL = "https://api.github.com/copilot_internal/user";
+
+interface CopilotUserPayload {
+  login?: string;
+  copilot_plan?: string;
+  access_type_sku?: string;
+  features?: string[];
+  quota_reset_date_utc?: string;
+  quota_reset_date?: string;
+  limited_user_reset_date?: string;
+  quota_snapshots?: {
+    premium_interactions?: {
+      unlimited?: boolean;
+      token_based_billing?: boolean;
+      entitlement?: number;
+      remaining?: number;
+      quota_remaining?: number;
+      credits_used?: number;
+      overage_count?: number;
+    } | null;
+  } | null;
+  limited_user_quotas?: { chat?: number } | null;
+  monthly_quotas?: { chat?: number } | null;
+}
+
+function resetIso(payload: CopilotUserPayload): string | undefined {
+  const raw = payload.quota_reset_date_utc ?? payload.quota_reset_date ?? payload.limited_user_reset_date;
+  if (!raw) return undefined;
+  const ms = Date.parse(raw);
+  return Number.isFinite(ms) ? new Date(ms).toISOString() : undefined;
+}
+
+function parseMetrics(payload: CopilotUserPayload): Metric[] {
+  const metrics: Metric[] = [];
+  const reset = resetIso(payload);
+  const resetDetail = reset ? `resets ${shortReset(reset)}` : undefined;
+
+  const premium = payload.quota_snapshots?.premium_interactions;
+  if (premium) {
+    if (premium.unlimited === true) {
+      metrics.push({ kind: "status", id: "copilot-premium", label: "Premium requests", value: "Unlimited" });
+    } else {
+      const entitlement = premium.entitlement;
+      const remaining = premium.remaining ?? premium.quota_remaining;
+      if (typeof entitlement === "number" && typeof remaining === "number") {
+        const overage = Math.max(premium.overage_count ?? 0, Math.max(0, -remaining));
+        const used = premium.credits_used ?? Math.max(0, entitlement - remaining);
+        metrics.push({
+          kind: "usage-limit",
+          id: premium.token_based_billing === true ? "copilot-credits" : "copilot-premium",
+          label: premium.token_based_billing === true ? "AI credits" : "Premium requests",
+          used,
+          limit: entitlement,
+          unit: "requests",
+          ...(resetDetail ? { detail: resetDetail } : {}),
+        });
+        if (overage > 0) {
+          metrics.push({
+            kind: "status",
+            id: "copilot-overage",
+            label: "Additional usage",
+            value: `${overage}`,
+          });
+        }
+      }
+    }
+  } else {
+    const remaining = payload.limited_user_quotas?.chat;
+    const entitlement = payload.monthly_quotas?.chat;
+    if (typeof remaining === "number" && typeof entitlement === "number") {
+      metrics.push({
+        kind: "usage-limit",
+        id: "copilot-chat",
+        label: "Chat requests",
+        used: Math.max(0, entitlement - remaining),
+        limit: entitlement,
+        unit: "requests",
+        ...(resetDetail ? { detail: resetDetail } : {}),
+      });
+    }
+  }
+
+  const plan = payload.copilot_plan ?? payload.access_type_sku;
+  if (plan) metrics.push({ kind: "status", id: "copilot-plan", label: "Plan", value: plan });
+
+  if (payload.features?.length) {
+    const trimmed = payload.features.slice(0, 4).join(", ");
+    metrics.push({
+      kind: "status",
+      id: "copilot-features",
+      label: "Features",
+      value: trimmed + (payload.features.length > 4 ? ", …" : ""),
+    });
+  }
+
+  return metrics;
+}
+
+export const githubCopilotAdapter: UsageAdapter = {
+  id: "github-copilot",
+  label: "GitHub Copilot",
+  canHandle(target) {
+    const pid = target.providerId.toLowerCase();
+    return pid === "github-copilot" || pid === "copilot";
+  },
+  async fetch({ target, signal }): Promise<UsageSnapshot> {
+    try {
+      const apiKey = target.credentials?.apiKey;
+      if (!apiKey) return snapshot(this, target, "unauthorized", { error: "No API key" });
+
+      const payload = await fetchJson<CopilotUserPayload>(
+        USER_URL,
+        { headers: { Authorization: `Bearer ${apiKey}`, Accept: "application/vnd.github+json" } },
+        signal,
+      );
+
+      const metrics = parseMetrics(payload);
+      const plan = payload.copilot_plan ?? payload.access_type_sku;
+      if (!metrics.length || !plan) return snapshot(this, target, "empty");
+
+      return snapshot(this, target, "ok", {
+        accounts: [{ id: payload.login ?? "github-copilot", label: payload.login ?? "Copilot", metrics }],
+        summary: `Copilot · ${plan}`,
+      });
+    } catch (error) {
+      if (signal.aborted) return snapshot(this, target, "unavailable", { error: "aborted" });
+      if (error instanceof HttpError && (error.status === 401 || error.status === 403)) {
+        return snapshot(this, target, "unauthorized", { error: `HTTP ${error.status}` });
+      }
+      return snapshot(this, target, "unavailable", { error: safeError(error) });
+    }
+  },
+};

package/src/adapters/glm.ts

@@ -0,0 +1,120 @@
+import { fetchJson, HttpError, safeError, urlOnDomain } from "../http.ts";
+import { windowsSummary, type QuotaWindowMetric } from "../format.ts";
+import { snapshot, type Metric, type UsageAdapter, type UsageSnapshot } from "../types.ts";
+
+const BIGMODEL_ORIGIN = "https://open.bigmodel.cn";
+const ZAI_ORIGIN = "https://api.z.ai";
+const QUOTA_PATH = "/api/monitor/usage/quota/limit";
+
+const GLM_IDS = new Set(["glm", "zhipu", "bigmodel", "zai", "zai-coding-cn", "glm-v2max"]);
+
+interface QuotaLimit {
+  type?: string;
+  percentage?: number;
+  unit?: number;
+  number?: number;
+  nextResetTime?: number;
+  currentValue?: number;
+  usage?: number;
+  remaining?: number;
+}
+
+interface QuotaLimitResponse {
+  success?: boolean;
+  data?: { level?: string; limits?: QuotaLimit[] };
+}
+
+export function glmWindowLabel(unit: number | undefined, quantity: number | undefined): { label: string; order: number } {
+  const q = quantity ?? 1;
+  if (unit === 3) return q === 5 ? { label: "5h", order: 0 } : { label: `${q}h`, order: 2 };
+  if (unit === 6) return q === 1 ? { label: "7d", order: 1 } : { label: `${q}w`, order: 3 };
+  return { label: `u${unit ?? "?"}·${q}`, order: 4 };
+}
+
+export function resetIso(nextResetTime: number | undefined): string | undefined {
+  if (nextResetTime === undefined || !Number.isFinite(nextResetTime)) return undefined;
+  const millis = nextResetTime < 10_000_000_000 ? nextResetTime * 1000 : nextResetTime;
+  const date = new Date(millis);
+  return Number.isFinite(date.getTime()) ? date.toISOString() : undefined;
+}
+
+export const glmAdapter: UsageAdapter = {
+  id: "glm",
+  label: "GLM / Zhipu",
+
+  canHandle(target) {
+    const pid = target.providerId.toLowerCase();
+    return (
+      GLM_IDS.has(pid) ||
+      (!target.baseUrl && pid.startsWith("glm-")) ||
+      urlOnDomain(target.baseUrl, "bigmodel.cn") ||
+      urlOnDomain(target.baseUrl, "z.ai")
+    );
+  },
+
+  async fetch({ target, signal }): Promise<UsageSnapshot> {
+    try {
+      const apiKey = target.credentials?.apiKey;
+      if (!apiKey) return snapshot(this, target, "unauthorized", { error: "No API key" });
+
+      const origin = urlOnDomain(target.baseUrl, "z.ai") ? ZAI_ORIGIN : BIGMODEL_ORIGIN;
+      const payload = await fetchJson<QuotaLimitResponse>(
+        `${origin}${QUOTA_PATH}`,
+        { headers: { Authorization: apiKey, Accept: "application/json" } },
+        signal,
+      );
+
+      const limits = payload.success ? (payload.data?.limits ?? []) : [];
+      if (!limits.length) return snapshot(this, target, "empty");
+
+      const metrics: Metric[] = [];
+      const planLevel = payload.data?.level ? payload.data.level.toUpperCase() : "Coding Plan";
+
+      const classified = limits
+        .filter((limit) => limit.type === "TOKENS_LIMIT")
+        .map((limit) => ({ limit, ...glmWindowLabel(limit.unit, limit.number) }))
+        .sort((a, b) => a.order - b.order);
+      for (const { limit, label } of classified) {
+        const used = Math.max(0, Math.min(100, limit.percentage ?? 0));
+        const resetAt = resetIso(limit.nextResetTime);
+        metrics.push({
+          kind: "quota-window",
+          id: `glm-${label}`,
+          label: `GLM ${label}`,
+          remainingFraction: (100 - used) / 100,
+          ...(resetAt ? { resetAt } : {}),
+        });
+      }
+
+      const mcp = limits.find((limit) => limit.type === "TIME_LIMIT");
+      if (mcp && mcp.usage !== undefined && mcp.usage > 0) {
+        const remaining = mcp.remaining ?? mcp.usage - (mcp.currentValue ?? 0);
+        metrics.push({
+          kind: "quota-window",
+          id: "glm-mcp",
+          label: "MCP Monthly",
+          remainingFraction: Math.max(0, Math.min(1, remaining / mcp.usage)),
+          detail: `${mcp.currentValue ?? 0}/${mcp.usage}`,
+        });
+      }
+
+      if (!metrics.length) return snapshot(this, target, "empty");
+      metrics.push({ kind: "status", id: "glm-plan-level", label: "Plan", value: planLevel });
+
+      const windows = metrics.filter(
+        (metric): metric is QuotaWindowMetric => metric.kind === "quota-window" && metric.id !== "glm-mcp",
+      );
+      const summary = windowsSummary(windows) ?? `GLM · ${planLevel}`;
+      return snapshot(this, target, "ok", {
+        accounts: [{ id: "glm-coding-plan", label: `GLM ${planLevel}`, metrics }],
+        summary,
+      });
+    } catch (error) {
+      if (signal.aborted) return snapshot(this, target, "unavailable", { error: "aborted" });
+      if (error instanceof HttpError && (error.status === 401 || error.status === 403)) {
+        return snapshot(this, target, "unauthorized", { error: `HTTP ${error.status}` });
+      }
+      return snapshot(this, target, "unavailable", { error: safeError(error) });
+    }
+  },
+};

package/src/adapters/kimi.ts

@@ -0,0 +1,183 @@
+import { windowsSummary, type QuotaWindowMetric } from "../format.ts";
+import { fetchJson, HttpError, safeError, urlOrigin, urlOnDomain } from "../http.ts";
+import { snapshot, type Metric, type UsageAdapter, type UsageSnapshot } from "../types.ts";
+
+const CODING_USAGES_URL = "https://api.kimi.com/coding/v1/usages";
+
+const KIMI_IDS = new Set(["kimi", "kimi-coding", "moonshotai", "moonshotai-cn", "moonshot"]);
+
+interface KimiQuotaDetail {
+  limit?: string | number;
+  used?: string | number;
+  remaining?: string | number;
+  resetTime?: string;
+}
+
+interface KimiUsagesResponse {
+  usage?: KimiQuotaDetail;
+  limits?: Array<{ window?: { duration?: number; timeUnit?: string }; detail?: KimiQuotaDetail }>;
+}
+
+interface MoonshotBalanceResponse {
+  balance_infos?: Array<{ currency?: string; total_balance?: string }>;
+}
+
+function clamp01(value: number): number {
+  return Math.max(0, Math.min(1, value));
+}
+
+function parseFraction(detail: KimiQuotaDetail | undefined): number | undefined {
+  if (!detail) return undefined;
+  const lim = Number(detail.limit);
+  const rem = Number(detail.remaining);
+  if (Number.isFinite(rem) && Number.isFinite(lim) && lim > 0) return clamp01(rem / lim);
+  const used = Number(detail.used);
+  if (Number.isFinite(used) && Number.isFinite(lim) && lim > 0) return clamp01((lim - used) / lim);
+  return undefined;
+}
+
+function isoTime(value: string | undefined): string | undefined {
+  if (!value) return undefined;
+  const millis = Date.parse(value);
+  return Number.isFinite(millis) ? new Date(millis).toISOString() : undefined;
+}
+
+function quotaExhaustedMessage(body: string): string | undefined {
+  try {
+    const data = JSON.parse(body) as {
+      code?: string;
+      message?: string;
+      details?: Array<{ debug?: { reason?: string; localizedMessage?: { message?: string } } }>;
+    };
+    const detail = data.details?.[0]?.debug;
+    if (data.code === "resource_exhausted" || detail?.reason === "REASON_QUOTA_EXCEEDED") {
+      return detail?.localizedMessage?.message ?? data.message ?? "Quota exhausted";
+    }
+  } catch {
+    return undefined;
+  }
+  return undefined;
+}
+
+export const kimiAdapter: UsageAdapter = {
+  id: "kimi",
+  label: "Kimi / Moonshot",
+
+  canHandle(target) {
+    const pid = target.providerId.toLowerCase();
+    return (
+      KIMI_IDS.has(pid) ||
+      urlOnDomain(target.baseUrl, "api.kimi.com") ||
+      urlOnDomain(target.baseUrl, "moonshot.cn") ||
+      urlOnDomain(target.baseUrl, "moonshot.ai")
+    );
+  },
+
+  async fetch({ target, signal }): Promise<UsageSnapshot> {
+    try {
+      const apiKey = target.credentials?.apiKey;
+      if (!apiKey) return snapshot(this, target, "unauthorized", { error: "No API key" });
+
+      const pid = target.providerId.toLowerCase();
+      const codingPlan =
+        urlOnDomain(target.baseUrl, "api.kimi.com") || pid.includes("coding") || apiKey.startsWith("eyJ");
+
+      if (codingPlan) {
+        const payload = await fetchJson<KimiUsagesResponse>(
+          CODING_USAGES_URL,
+          { headers: { Authorization: `Bearer ${apiKey}`, Accept: "application/json" } },
+          signal,
+        );
+
+        const metrics: Metric[] = [];
+        const fiveHour = payload.limits?.find(
+          (limit) => limit.window?.duration === 300 && limit.window?.timeUnit === "TIME_UNIT_MINUTE",
+        )?.detail;
+        const fiveHourFraction = parseFraction(fiveHour);
+        const fiveHourReset = isoTime(fiveHour?.resetTime);
+        if (fiveHourFraction !== undefined) {
+          metrics.push({
+            kind: "quota-window",
+            id: "kimi-5h",
+            label: "Kimi 5h",
+            remainingFraction: fiveHourFraction,
+            ...(fiveHourReset ? { resetAt: fiveHourReset } : {}),
+          });
+        }
+        const weeklyFraction = parseFraction(payload.usage);
+        const weeklyReset = isoTime(payload.usage?.resetTime);
+        if (weeklyFraction !== undefined) {
+          metrics.push({
+            kind: "quota-window",
+            id: "kimi-weekly",
+            label: "Kimi Weekly",
+            remainingFraction: weeklyFraction,
+            ...(weeklyReset ? { resetAt: weeklyReset } : {}),
+          });
+        }
+        if (!metrics.length) return snapshot(this, target, "empty");
+        const windows = metrics.filter(
+          (metric): metric is QuotaWindowMetric => metric.kind === "quota-window",
+        );
+        return snapshot(this, target, "ok", {
+          accounts: [{ id: "kimi-coding", label: "Kimi Coding", metrics }],
+          summary: windowsSummary(windows),
+        });
+      }
+
+      const origin =
+        urlOrigin(target.baseUrl) ?? (pid.endsWith("-cn") ? "https://api.moonshot.cn" : "https://api.moonshot.ai");
+      const payload = await fetchJson<MoonshotBalanceResponse>(
+        `${origin}/v1/users/me/balance`,
+        { headers: { Authorization: `Bearer ${apiKey}`, Accept: "application/json" } },
+        signal,
+      );
+
+      const accounts = (payload.balance_infos ?? []).map((info, index) => ({
+        id: `kimi-${info.currency ?? index}`,
+        label: info.currency === "CNY" ? "Account (CNY)" : `Account (${info.currency ?? "?"})`,
+        metrics:
+          info.total_balance !== undefined
+            ? [
+                {
+                  kind: "balance" as const,
+                  id: "total",
+                  label: "Balance",
+                  amount: Number(info.total_balance) || 0,
+                  currency: info.currency ?? "CNY",
+                },
+              ]
+            : [],
+      }));
+      const primary = accounts[0]?.metrics[0];
+      if (!primary) return snapshot(this, target, "empty");
+      return snapshot(this, target, "ok", {
+        accounts,
+        summary:
+          primary.kind === "balance"
+            ? `${primary.currency === "CNY" ? "¥" : "$"}${primary.amount.toFixed(2)} · Kimi`
+            : undefined,
+      });
+    } catch (error) {
+      if (signal.aborted) return snapshot(this, target, "unavailable", { error: "aborted" });
+      if (error instanceof HttpError && (error.status === 401 || error.status === 403)) {
+        return snapshot(this, target, "unauthorized", { error: `HTTP ${error.status}` });
+      }
+      if (error instanceof HttpError && error.status === 429) {
+        const message = quotaExhaustedMessage(error.body);
+        if (message) {
+          return snapshot(this, target, "empty", {
+            accounts: [
+              {
+                id: "kimi-coding",
+                label: "Kimi Coding",
+                metrics: [{ kind: "status", id: "kimi-quota", label: "Quota", value: message }],
+              },
+            ],
+          });
+        }
+      }
+      return snapshot(this, target, "unavailable", { error: safeError(error) });
+    }
+  },
+};

package/src/adapters/minimax.ts

@@ -0,0 +1,185 @@
+import { windowsSummary, type QuotaWindowMetric } from "../format.ts";
+import { fetchJson, HttpError, safeError, urlOnDomain } from "../http.ts";
+import { snapshot, type Metric, type UsageAccount, type UsageAdapter, type UsageSnapshot } from "../types.ts";
+
+interface MiniMaxRemainsResponse {
+  base_resp?: { status_code?: number };
+  model_remains?: unknown[];
+}
+
+interface MiniMaxBalanceResponse {
+  base_resp?: { status_code?: number };
+  available_amount?: string;
+  cash_balance?: string;
+  voucher_balance?: string;
+  credit_balance?: string;
+  owed_amount?: string;
+}
+
+type Row = Record<string, unknown>;
+
+const DECIMAL_AMOUNT = /^-?(?:0|[1-9]\d*)(?:\.\d+)?$/;
+
+const WINDOW_FIELDS = [
+  {
+    id: "interval",
+    label: "Rolling",
+    count: "current_interval_usage_count",
+    total: "current_interval_total_count",
+    percent: "current_interval_remaining_percent",
+    status: "current_interval_status",
+    end: "end_time",
+  },
+  {
+    id: "weekly",
+    label: "Weekly",
+    count: "current_weekly_usage_count",
+    total: "current_weekly_total_count",
+    percent: "current_weekly_remaining_percent",
+    status: "current_weekly_status",
+    end: "weekly_end_time",
+  },
+] as const;
+
+function intVal(value: unknown): number | undefined {
+  if (value === undefined || value === null) return undefined;
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : undefined;
+}
+
+function percentVal(value: unknown): number | undefined {
+  if (value === undefined || value === null) return undefined;
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 100 ? value : undefined;
+}
+
+export function resolveRemaining(reported: number, total: number, percent: number | undefined): number | undefined {
+  if (total <= 0 || reported > total) return undefined;
+  let remaining = reported;
+  if (percent !== undefined) {
+    const asRemaining = (reported / total) * 100;
+    const asUsed = ((total - reported) / total) * 100;
+    const remainingDistance = Math.abs(asRemaining - percent);
+    const usedDistance = Math.abs(asUsed - percent);
+    if (Math.min(remainingDistance, usedDistance) > 1) return undefined;
+    if (usedDistance < remainingDistance) remaining = total - reported;
+  }
+  return remaining;
+}
+
+function windowMetric(
+  row: Row,
+  fields: (typeof WINDOW_FIELDS)[number],
+  id: string,
+  label: string,
+): Metric | undefined {
+  const status = intVal(row[fields.status]);
+  if (status !== undefined && ![1, 2, 3].includes(status)) return undefined;
+  const end = intVal(row[fields.end]);
+  if (end === undefined || end <= 0) return undefined;
+  const resetAt = new Date(end).toISOString();
+  if (status === 3) return { kind: "quota-window", id, label, remainingFraction: 1, resetAt };
+  const percent = percentVal(row[fields.percent]);
+  const total = intVal(row[fields.total]) ?? 0;
+  const count = intVal(row[fields.count]);
+  if (total === 0) {
+    if (percent === undefined || (count !== undefined && count !== 0)) return undefined;
+    return { kind: "quota-window", id, label, remainingFraction: Math.min(1, percent / 100), resetAt };
+  }
+  if (count === undefined) return undefined;
+  const remaining = resolveRemaining(count, total, percent);
+  if (remaining === undefined) return undefined;
+  return { kind: "quota-window", id, label, remainingFraction: Math.max(0, Math.min(1, remaining / total)), resetAt };
+}
+
+function balanceMetric(id: string, label: string, value: string | undefined, currency: string): Metric | undefined {
+  if (value === undefined || !DECIMAL_AMOUNT.test(value)) return undefined;
+  return { kind: "balance", id, label, amount: Number(value), currency };
+}
+
+export const minimaxAdapter: UsageAdapter = {
+  id: "minimax",
+  label: "MiniMax",
+
+  canHandle(target) {
+    const pid = target.providerId.toLowerCase();
+    return (
+      pid === "minimax" ||
+      pid === "minimax-cn" ||
+      urlOnDomain(target.baseUrl, "minimax.io") ||
+      urlOnDomain(target.baseUrl, "minimaxi.com")
+    );
+  },
+
+  async fetch({ target, signal }): Promise<UsageSnapshot> {
+    try {
+      const apiKey = target.credentials?.apiKey;
+      if (!apiKey) return snapshot(this, target, "unauthorized", { error: "No API key" });
+
+      const cn = urlOnDomain(target.baseUrl, "minimaxi.com") || target.providerId.toLowerCase() === "minimax-cn";
+      const root = cn ? "https://api.minimaxi.com" : "https://api.minimax.io";
+      const currency = cn ? "CNY" : "USD";
+
+      if (apiKey.startsWith("eyJ")) {
+        const payload = await fetchJson<MiniMaxRemainsResponse>(
+          `${root}/v1/token_plan/remains`,
+          { headers: { Authorization: `Bearer ${apiKey}`, Accept: "application/json" } },
+          signal,
+        );
+        if (payload.base_resp?.status_code !== 0) {
+          throw new Error("MiniMax usage response did not report success");
+        }
+
+        const accounts: UsageAccount[] = [];
+        for (const [index, raw] of (payload.model_remains ?? []).entries()) {
+          if (!raw || typeof raw !== "object" || Array.isArray(raw)) continue;
+          const row = raw as Row;
+          const modelName =
+            typeof row.model_name === "string" && row.model_name ? row.model_name : `Quota ${index + 1}`;
+          const metrics = WINDOW_FIELDS.map((fields) =>
+            windowMetric(row, fields, `minimax-${index}-${fields.id}`, `${modelName} ${fields.label}`),
+          ).filter((metric): metric is Metric => metric !== undefined);
+          if (metrics.length) accounts.push({ id: `minimax-${index}`, label: modelName, metrics });
+        }
+        if (!accounts.length) return snapshot(this, target, "empty");
+        const windows = accounts[0].metrics.filter(
+          (metric): metric is QuotaWindowMetric => metric.kind === "quota-window",
+        );
+        return snapshot(this, target, "ok", {
+          accounts,
+          summary: windowsSummary(windows),
+        });
+      }
+
+      const payload = await fetchJson<MiniMaxBalanceResponse>(
+        `${root}/account/query_balance`,
+        { headers: { Authorization: `Bearer ${apiKey}`, Accept: "application/json" } },
+        signal,
+      );
+      if (payload.base_resp?.status_code !== 0) {
+        throw new Error("MiniMax usage response did not report success");
+      }
+
+      const metrics = [
+        balanceMetric("available", "Available balance", payload.available_amount, currency),
+        balanceMetric("cash", "Cash balance", payload.cash_balance, currency),
+        balanceMetric("voucher", "Voucher balance", payload.voucher_balance, currency),
+        balanceMetric("credit", "Credit balance", payload.credit_balance, currency),
+        balanceMetric("owed", "Owed amount", payload.owed_amount, currency),
+      ].filter((metric): metric is Metric => metric !== undefined);
+      if (!metrics.length) return snapshot(this, target, "empty");
+      const primary = metrics[0];
+      return snapshot(this, target, "ok", {
+        accounts: [{ id: "minimax", label: `MiniMax (${currency})`, metrics }],
+        summary:
+          primary.kind === "balance"
+            ? `${currency === "CNY" ? "¥" : "$"}${primary.amount.toFixed(2)} · MiniMax`
+            : undefined,
+      });
+    } catch (error) {
+      if (signal.aborted) return snapshot(this, target, "unavailable", { error: "aborted" });
+      if (error instanceof HttpError && (error.status === 401 || error.status === 403)) {
+        return snapshot(this, target, "unauthorized", { error: `HTTP ${error.status}` });
+      }
+      return snapshot(this, target, "unavailable", { error: safeError(error) });
+    }
+  },
+};