opencode-usage-report 0.1.0 → 0.3.0

package/README.md

@@ -6,8 +6,10 @@
 
 An [opencode](https://opencode.ai) plugin that adds a `/usage` command (and a
 `usage_report` tool) showing the quota windows (5-hour, weekly, monthly) of your
-inference subscriptions — currently **Kimi Code** (`kimi-for-coding`) and
-**OpenCode Go** (`opencode-go`). It fetches from each provider's API, caches
+inference subscriptions — currently **Kimi Code** (both regional plans:
+`kimi-code-plan-global` on kimi.ai and `kimi-code-plan-cn` on kimi.com),
+**OpenCode Go** (`opencode-go`), **GitHub Copilot** (`github-copilot`) and
+**ChatGPT** (`openai`). It fetches from each provider's API, caches
 results on disk, and can fall back to a local estimate when the API is
 unreachable. It also emits background low-quota warnings in the TUI.
 
@@ -31,7 +33,7 @@ Add the plugin to `opencode.json` / `opencode.jsonc` and restart opencode:
 
 ```jsonc
 {
-  "plugin": ["./path/to/opencode-usage-report"] // or an npm spec
+  "plugin": ["opencode-usage-report"],
 }
 ```
 
@@ -41,20 +43,33 @@ options in the tuple form:
 
 ```jsonc
 {
-  "plugin": [["./path/to/opencode-usage-report", { "thresholdPercent": 75 }]]
+  "plugin": [["opencode-usage-report", { "thresholdPercent": 75 }]],
 }
 ```
 
 ### TUI sidebar panel
 
-Add the TUI module to `tui.json` and restart opencode:
+Add the plugin to `tui.json` and restart opencode:
 
 ```jsonc
 {
-  "plugin": ["file:///abs/path/to/opencode-usage-report/src/tui.tsx"]
+  "plugin": ["opencode-usage-report"],
 }
 ```
 
+Use the bare package name — opencode resolves the `./tui` entrypoint from the
+package `exports` on its own. (`opencode-usage-report/tui` is **not** a valid
+spec and will silently not load.)
+
+For local development, point the configs at the source instead:
+
+```jsonc
+// opencode.json
+{ "plugin": ["file:///abs/path/to/opencode-usage-report/src/index.ts"] }
+// tui.json
+{ "plugin": ["file:///abs/path/to/opencode-usage-report/src/tui.tsx"] }
+```
+
 The panel renders under opencode's native Context block in the session sidebar
 (order 150) and shows a colored progress bar per quota window, `NN%`, and a
 live reset countdown — refreshed every 60s, on `session.idle`, and on demand via
@@ -65,13 +80,16 @@ and local estimates `(est)`.
 TUI options (tuple form): `providers`, `cacheTtlSeconds`, `thresholdPercent`,
 `refreshIntervalSeconds` (default `60`), `barWidth` (default `14`).
 
-
 ## Commands
 
-- `/usage` — show every configured provider's quota windows.
-- `/usage kimi-for-coding` — filter to a single provider. The argument must match a
-  registered provider id **exactly** (`kimi-for-coding` or `opencode-go`); an
-  unknown id (e.g. `/usage kimi`) returns a helpful error listing the known ids.
+- `/usage` — show every configured provider's quota windows. Providers without a
+  resolved credential are skipped in this view.
+- `/usage kimi-code-plan-global` — filter to a single provider. The argument must
+  match a registered provider id **exactly** (`kimi-code-plan-global`,
+  `kimi-code-plan-cn`, `opencode-go`, `github-copilot` or `openai`); an unknown
+  id (e.g. `/usage kimi`)
+  returns a helpful error listing the known ids. An explicitly requested
+  provider with no credential is reported as an error row.
 - `/usage --json` — emit the raw `ProviderReport[]` JSON.
 - `/usage --refresh` — bypass the on-disk cache and fetch live.
 
@@ -80,12 +98,12 @@ tool can also be invoked directly by an agent.
 
 ## Options
 
-| Option             | Type       | Default | Meaning                                                        |
-| ------------------ | ---------- | ------- | -------------------------------------------------------------- |
-| `thresholdPercent` | `number`   | `80`    | Warn when a window is at/above this percent used.              |
-| `cacheTtlSeconds`  | `number`   | `120`   | How long a cached API result is considered fresh.              |
-| `providers`        | `string[] \| null` | `null` | Providers to report; `null` = every registered adapter. |
-| `fallback`         | `boolean`  | `true`  | Use a local estimate when the API fails and no cache exists.   |
+| Option             | Type               | Default | Meaning                                                      |
+| ------------------ | ------------------ | ------- | ------------------------------------------------------------ |
+| `thresholdPercent` | `number`           | `80`    | Warn when a window is at/above this percent used.            |
+| `cacheTtlSeconds`  | `number`           | `120`   | How long a cached API result is considered fresh.            |
+| `providers`        | `string[] \| null` | `null`  | Providers to report; `null` = every registered adapter.      |
+| `fallback`         | `boolean`          | `true`  | Use a local estimate when the API fails and no cache exists. |
 
 Malformed option values are ignored and the defaults are kept.
 
@@ -100,12 +118,21 @@ per window until that window resets; it re-arms after usage drops below
 
 ## Data sources & privacy
 
-- Credential resolution order: `OPENCODE_USAGE_<ID>_KEY` env override, then
+- Credential resolution order: `OPENCODE_USAGE_<ID>_KEY` env override (optionally
+  paired with `OPENCODE_USAGE_<ID>_ACCOUNT_ID`, e.g.
+  `OPENCODE_USAGE_OPENAI_ACCOUNT_ID`, to supply the ChatGPT account id), then
   `~/.local/share/opencode/auth.json` (`type: "api"` `.key`, or `type: "oauth"`
-  `.access`). `$OPENCODE_DATA_HOME` overrides the data directory.
-- APIs: `https://api.kimi.com/coding/v1/usages` and
+  `.access`, falling back to `.refresh` for GitHub Copilot). For ChatGPT the
+  oauth entry's `.accountId` is read automatically. `$OPENCODE_DATA_HOME`
+  overrides the data directory.
+- APIs: `https://api.kimi.ai/coding/v1/usages` (global plan),
+  `https://api.kimi.com/coding/v1/usages` (China plan),
   `https://opencode.ai/zen/go/v1/usage` (custom `User-Agent` is required by the
-  latter).
+  latter), `https://api.github.com/copilot_internal/user` (GitHub Copilot) and
+  `https://chatgpt.com/backend-api/wham/usage` (ChatGPT).
+- Auth: run `opencode auth login` and pick **GitHub Copilot** or **OpenAI
+  ChatGPT**. ChatGPT additionally needs the account id that login writes to
+  `auth.json`; the plugin reads it automatically.
 - Cache and state live in `<data-home>/usage-report/` (TTL cache, session id,
   warn state).
 - Local fallback reads `opencode.db` read-only.
@@ -129,13 +156,17 @@ Reference endpoints for future adapters (not built in v1):
 - **Claude**: `api.anthropic.com/api/oauth/usage` (requires
   `anthropic-beta: oauth-2025-04-20`, the claude-code User-Agent, and
   `~/.claude/.credentials.json`).
-- **Codex**: the ChatGPT backend usage endpoint.
 
 ## Development
 
 ```sh
+npm run lint                      # oxlint
+npm run lint:fix                  # oxlint --fix
+npm run format                    # oxfmt (write in place)
+npm run format:check              # oxfmt --check
 npm test                          # vitest, no network
 npm run typecheck                 # tsc --noEmit
+npm run check                     # lint + format:check + typecheck + test
 npm run smoke -- --yes-live       # manual live check (real keys; opt-in)
 ```
 

package/package.json

@@ -1,60 +1,68 @@
 {
   "name": "opencode-usage-report",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "opencode plugin: /usage command showing subscription quota windows for configured providers",
+  "keywords": [
+    "kimi",
+    "opencode",
+    "opencode-plugin",
+    "quota",
+    "rate-limit",
+    "tui",
+    "usage"
+  ],
+  "homepage": "https://github.com/kaanchinar/opencode-usage-report#readme",
+  "bugs": {
+    "url": "https://github.com/kaanchinar/opencode-usage-report/issues"
+  },
+  "license": "MIT",
   "author": "Kaan Chinar",
-  "type": "module",
-  "main": "src/index.ts",
-  "exports": {
-    ".": "./src/index.ts",
-    "./tui": "./src/tui.tsx"
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kaanchinar/opencode-usage-report.git"
   },
   "files": [
     "src",
     "README.md"
   ],
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/kaanchinar/opencode-usage-report.git"
+  "type": "module",
+  "main": "src/index.ts",
+  "exports": {
+    ".": "./src/index.ts",
+    "./tui": "./src/tui.tsx"
   },
-  "bugs": {
-    "url": "https://github.com/kaanchinar/opencode-usage-report/issues"
+  "publishConfig": {
+    "access": "public"
   },
-  "homepage": "https://github.com/kaanchinar/opencode-usage-report#readme",
-  "keywords": [
-    "opencode",
-    "opencode-plugin",
-    "usage",
-    "quota",
-    "rate-limit",
-    "kimi",
-    "tui"
-  ],
   "scripts": {
-    "test": "vitest run",
+    "lint": "oxlint",
+    "lint:fix": "oxlint --fix",
+    "format": "oxfmt",
+    "format:check": "oxfmt --check",
     "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
     "smoke": "tsx scripts/live-smoke.ts",
-    "prepublishOnly": "npm run typecheck && npm test"
-  },
-  "peerDependencies": {
-    "@opencode-ai/plugin": "*",
-    "@opentui/core": ">=0.5.11",
-    "@opentui/solid": ">=0.5.11",
-    "solid-js": ">=1.9.0"
+    "check": "npm run lint && npm run format:check && npm run typecheck && npm test",
+    "prepublishOnly": "npm run lint && npm run format:check && npm run typecheck && npm test"
   },
   "devDependencies": {
     "@opencode-ai/plugin": "^1.0.0",
     "@opentui/core": "^0.5.11",
     "@opentui/keymap": "^0.5.11",
     "@opentui/solid": "^0.5.11",
-    "@types/node": "^22.0.0",
+    "@types/node": "^26.6.2",
+    "oxfmt": "^0.70.0",
+    "oxlint": "^1.85.0",
     "solid-js": "1.9.12",
     "tsx": "^4.19.0",
-    "typescript": "^5.6.0",
-    "vitest": "^3.0.0"
+    "typescript": "^7.0.2",
+    "vitest": "^5.0.1"
   },
-  "license": "MIT",
-  "publishConfig": {
-    "access": "public"
+  "peerDependencies": {
+    "@opencode-ai/plugin": "*",
+    "@opentui/core": ">=0.5.11",
+    "@opentui/solid": ">=0.5.11",
+    "solid-js": ">=1.9.0"
   }
 }

package/src/auth.ts

@@ -1,12 +1,21 @@
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
-import type { Credential } from "./types.js";
-import { dataHome } from "./paths.js";
+import type { Credential } from "./types";
+import { dataHome } from "./paths";
 
-/** "kimi-for-coding" -> "OPENCODE_USAGE_KIMI_FOR_CODING_KEY" (non-alphanumerics become "_", uppercased). */
+/** "kimi-code-plan-global" -> "OPENCODE_USAGE_KIMI_CODE_PLAN_GLOBAL_KEY" (non-alphanumerics become "_", uppercased). */
 export function envVarName(providerId: string): string {
+  return providerEnvVarName(providerId, "KEY");
+}
+
+/** "openai" -> "OPENCODE_USAGE_OPENAI_ACCOUNT_ID" (same normalization as envVarName). */
+export function accountIdEnvVarName(providerId: string): string {
+  return providerEnvVarName(providerId, "ACCOUNT_ID");
+}
+
+function providerEnvVarName(providerId: string, suffix: string): string {
   const normalized = providerId.replace(/[^a-zA-Z0-9]/g, "_").toUpperCase();
-  return `OPENCODE_USAGE_${normalized}_KEY`;
+  return `OPENCODE_USAGE_${normalized}_${suffix}`;
 }
 
 /**
@@ -23,7 +32,10 @@ export function resolveCredential(
 
     const override = env[envVarName(providerId)];
     if (typeof override === "string" && override.trim() !== "") {
-      return { type: "api", key: override };
+      const accountId = env[accountIdEnvVarName(providerId)];
+      return typeof accountId === "string" && accountId.trim() !== ""
+        ? { type: "api", key: override, accountId }
+        : { type: "api", key: override };
     }
 
     const dir = opts.dataHomeDir ?? dataHome(env);
@@ -40,10 +52,21 @@ export function resolveCredential(
       return typeof key === "string" && key !== "" ? { type: "api", key } : null;
     }
     if (record.type === "oauth") {
+      // Prefer the access token. opencode stores the GitHub Copilot token in
+      // `refresh` (there is no access token), so fall back to it there only;
+      // other oauth providers keep the access-only behavior.
       const access = record.access;
-      return typeof access === "string" && access !== ""
-        ? { type: "oauth", key: access }
-        : null;
+      let key = typeof access === "string" && access !== "" ? access : null;
+      if (key === null && providerId === "github-copilot") {
+        const refresh = record.refresh;
+        if (typeof refresh === "string" && refresh !== "") key = refresh;
+      }
+      if (key === null) return null;
+
+      const accountId = record.accountId;
+      return typeof accountId === "string" && accountId !== ""
+        ? { type: "oauth", key, accountId }
+        : { type: "oauth", key };
     }
     return null;
   } catch {

package/src/cache.ts

@@ -1,8 +1,8 @@
 import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import { randomUUID } from "node:crypto";
 import { join } from "node:path";
-import type { AdapterResult } from "./types.js";
-import { pluginStateDir } from "./paths.js";
+import type { AdapterResult } from "./types";
+import { pluginStateDir } from "./paths";
 
 export interface CacheEntry {
   fetchedAt: string;

package/src/fallback.ts

@@ -1,6 +1,6 @@
 import { existsSync } from "node:fs";
-import type { AdapterResult, UsageWindow } from "./types.js";
-import { dbPath } from "./paths.js";
+import type { AdapterResult, UsageWindow } from "./types";
+import { dbPath } from "./paths";
 
 const HOUR_MS = 60 * 60 * 1000;
 const DAY_MS = 24 * HOUR_MS;

package/src/index.ts

@@ -1,15 +1,17 @@
 import type { Plugin } from "@opencode-ai/plugin";
 import { tool } from "@opencode-ai/plugin";
-import { DEFAULT_OPTIONS, collectReports } from "./report.js";
-import { renderJson, renderText } from "./render.js";
-import { checkWarnings } from "./warn.js";
-import { toNumber } from "./normalize.js";
-import type { PluginOptions } from "./types.js";
+import { DEFAULT_OPTIONS, collectReports } from "./report";
+import { renderJson, renderText } from "./render";
+import { checkWarnings } from "./warn";
+import { toNumber } from "./normalize";
+import { adapters } from "./providers/index";
+import type { PluginOptions } from "./types";
 
 const WARN_THROTTLE_MS = 10 * 60 * 1000;
 
 const TOOL_DESCRIPTION =
-  "Show subscription usage/quota windows (5h, weekly, monthly) for configured inference providers (kimi-for-coding, opencode-go)";
+  "Show subscription usage/quota windows (5h, weekly, monthly) for configured inference providers " +
+  `(${adapters.map((adapter) => adapter.id).join(", ")})`;
 
 const COMMAND_TEMPLATE =
   "Call the usage_report tool with these arguments: $ARGUMENTS and present the result verbatim.";

package/src/normalize.ts

@@ -1,4 +1,4 @@
-import type { UsageWindow, WindowKind } from "./types.js";
+import type { UsageWindow, WindowKind } from "./types";
 
 /** Accepts a number or a numeric string; anything else (including NaN/Infinity) yields null. */
 export function toNumber(v: unknown): number | null {

package/src/providers/chatgpt.ts

@@ -0,0 +1,194 @@
+import type {
+  AdapterResult,
+  Credential,
+  FetchOptions,
+  ProviderAdapter,
+  UsageWindow,
+  WindowKind,
+} from "../types";
+import { AdapterError } from "../types";
+import { toISODate, toNumber } from "../normalize";
+import { redact } from "../auth";
+
+const VERSION = "0.3.0";
+const USER_AGENT = "opencode-usage-report/" + VERSION;
+const ENDPOINT = "https://chatgpt.com/backend-api/wham/usage";
+
+function asRecord(v: unknown): Record<string, unknown> | null {
+  return v !== null && typeof v === "object" && !Array.isArray(v)
+    ? (v as Record<string, unknown>)
+    : null;
+}
+
+/** "foo_bar-baz" -> "Foo Bar Baz". */
+function titleCase(v: string): string {
+  return v
+    .split(/[\s_-]+/)
+    .filter((word) => word !== "")
+    .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+    .join(" ");
+}
+
+/** Maps a ChatGPT plan string to a friendly label. Pure so it can be unit-tested directly. */
+export function chatgptPlan(plan: unknown): string {
+  if (typeof plan === "string" && plan.trim() !== "") {
+    const p = plan.toLowerCase();
+    if (p === "free") return "ChatGPT Free";
+    if (p === "go") return "ChatGPT Go";
+    if (p === "plus") return "ChatGPT Plus";
+    if (p === "pro") return "ChatGPT Pro";
+    if (p === "team") return "ChatGPT Team";
+    if (p === "business") return "ChatGPT Business";
+    if (p === "enterprise") return "ChatGPT Enterprise";
+    return titleCase(plan);
+  }
+  return "ChatGPT";
+}
+
+/** Maps a window length (seconds) to its kind and label. */
+function windowKind(seconds: number | null): { kind: WindowKind; label: string } {
+  if (seconds === 18000) return { kind: "5h", label: "5-hour" };
+  if (seconds === 86400) return { kind: "daily", label: "Daily" };
+  if (seconds === 604800) return { kind: "weekly", label: "Weekly" };
+  if (seconds === 2592000) return { kind: "monthly", label: "Monthly" };
+  return { kind: "other", label: "Other" };
+}
+
+/** Reads the body once as text and best-effort parses JSON, so error and success paths share it. */
+async function readBody(res: Response): Promise<{ text: string; json: unknown }> {
+  const text = await res.text().catch(() => "");
+  let json: unknown = null;
+  try {
+    json = JSON.parse(text);
+  } catch {
+    json = null;
+  }
+  return { text, json };
+}
+
+async function attempt(cred: Credential, accountId: string, opts: FetchOptions): Promise<Response> {
+  return fetch(ENDPOINT, {
+    method: "GET",
+    headers: {
+      Authorization: "Bearer " + cred.key,
+      "ChatGPT-Account-Id": accountId,
+      Accept: "application/json",
+      "User-Agent": USER_AGENT,
+    },
+    signal: AbortSignal.timeout(opts.timeoutMs),
+  });
+}
+
+/** Exactly one retry on a network throw or 5xx; 4xx is returned immediately (never retried). */
+async function request(cred: Credential, accountId: string, opts: FetchOptions): Promise<Response> {
+  try {
+    const first = await attempt(cred, accountId, opts);
+    if (first.status < 500) return first;
+  } catch {
+    // fall through to the single retry
+  }
+
+  try {
+    return await attempt(cred, accountId, opts);
+  } catch (err) {
+    throw new AdapterError(
+      "network",
+      redact(
+        `ChatGPT request failed: ${err instanceof Error ? err.message : String(err)}`,
+        cred.key,
+      ),
+    );
+  }
+}
+
+async function handleError(res: Response, cred: Credential): Promise<never> {
+  const { text } = await readBody(res);
+
+  if (res.status === 401) {
+    throw new AdapterError("auth", redact("invalid ChatGPT login", cred.key));
+  }
+  if (res.status === 403) {
+    throw new AdapterError("no-plan", redact("ChatGPT is not enabled for this account", cred.key));
+  }
+  if (res.status === 429) {
+    throw new AdapterError("rate-limited", redact("ChatGPT rate limit reached", cred.key));
+  }
+  if (res.status >= 500) {
+    throw new AdapterError("network", redact(`ChatGPT server error ${res.status}`, cred.key));
+  }
+  throw new AdapterError(
+    "bad-response",
+    redact(`ChatGPT unexpected status ${res.status}: ${text.slice(0, 200)}`, cred.key),
+  );
+}
+
+export const chatgptAdapter: ProviderAdapter = {
+  id: "openai",
+  displayName: "ChatGPT",
+  async fetch(cred: Credential, opts: FetchOptions): Promise<AdapterResult> {
+    if (typeof cred.accountId !== "string" || cred.accountId === "") {
+      throw new AdapterError("auth", "ChatGPT account id missing (re-run: opencode auth login)");
+    }
+
+    const res = await request(cred, cred.accountId, opts);
+    if (!res.ok) return handleError(res, cred);
+
+    const { json } = await readBody(res);
+    const body = asRecord(json);
+    const rateLimit = body ? asRecord(body.rate_limit) : null;
+    if (!rateLimit) {
+      throw new AdapterError(
+        "bad-response",
+        redact("ChatGPT response missing rate_limit", cred.key),
+      );
+    }
+
+    const limitReached = rateLimit.limit_reached === true || rateLimit.allowed === false;
+    const windows: UsageWindow[] = [];
+    for (const raw of [rateLimit.primary_window, rateLimit.secondary_window]) {
+      const window = asRecord(raw);
+      if (!window) continue;
+      const { kind, label } = windowKind(toNumber(window.limit_window_seconds));
+      const used = toNumber(window.used_percent);
+      windows.push({
+        kind,
+        label,
+        usedPercent: used !== null ? Math.min(100, Math.max(0, Math.round(used * 10) / 10)) : null,
+        used: null,
+        limit: null,
+        remaining: null,
+        resetsAt: toISODate(window.reset_at),
+        status: limitReached ? "rate-limited" : "ok",
+      });
+    }
+
+    if (windows.length === 0) {
+      throw new AdapterError(
+        "bad-response",
+        redact("ChatGPT response missing usage windows", cred.key),
+      );
+    }
+
+    const extras: Record<string, string> = {};
+    extras["Plan"] = chatgptPlan(body?.plan_type);
+
+    const credits = body ? asRecord(body.credits) : null;
+    if (credits) {
+      if (credits.unlimited === true) {
+        extras["Credits"] = "unlimited";
+      } else {
+        const balance = toNumber(credits.balance);
+        if (balance !== null) {
+          extras["Credits"] = `$${balance.toFixed(2)}`;
+        } else if (
+          credits.has_credits === true &&
+          (credits.balance === null || credits.balance === undefined)
+        ) {
+          extras["Credits"] = "available";
+        }
+      }
+    }
+
+    return { windows, extras };
+  },
+};

package/src/providers/copilot.ts

@@ -0,0 +1,234 @@
+import type {
+  AdapterResult,
+  Credential,
+  FetchOptions,
+  ProviderAdapter,
+  UsageWindow,
+} from "../types";
+import { AdapterError } from "../types";
+import { toISODate, toNumber } from "../normalize";
+import { redact } from "../auth";
+
+const VERSION = "0.3.0";
+const USER_AGENT = "opencode-usage-report/" + VERSION;
+const ENDPOINT = "https://api.github.com/copilot_internal/user";
+
+/** Snapshot keys in display order, paired with their human-readable labels. */
+const SNAPSHOTS: Array<{ key: string; label: string }> = [
+  { key: "chat", label: "Chat" },
+  { key: "completions", label: "Completions" },
+  { key: "premium_interactions", label: "Premium interactions" },
+];
+
+function asRecord(v: unknown): Record<string, unknown> | null {
+  return v !== null && typeof v === "object" && !Array.isArray(v)
+    ? (v as Record<string, unknown>)
+    : null;
+}
+
+/** "foo_bar-baz" -> "Foo Bar Baz". */
+function titleCase(v: string): string {
+  return v
+    .split(/[\s_-]+/)
+    .filter((word) => word !== "")
+    .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+    .join(" ");
+}
+
+/**
+ * Maps a Copilot SKU (preferred) or plan string to a friendly tier label.
+ * Pure so it can be unit-tested directly.
+ */
+export function copilotTier(sku: unknown, plan: unknown): string {
+  if (typeof sku === "string") {
+    const s = sku.toLowerCase();
+    if (s === "free_educational_quota") return "Copilot Student";
+    if (s === "free" || s.startsWith("free")) return "Copilot Free";
+    if (s.includes("pro_plus") || s.includes("pro+")) return "Copilot Pro+";
+    if (s.includes("max")) return "Copilot Max";
+    if (s.includes("business")) return "Copilot Business";
+    if (s.includes("enterprise")) return "Copilot Enterprise";
+    if (s.includes("pro")) return "Copilot Pro";
+  }
+  if (typeof plan === "string" && plan.trim() !== "") {
+    const p = plan.toLowerCase();
+    if (p === "individual") return "Copilot Individual";
+    if (p === "business") return "Copilot Business";
+    if (p === "enterprise") return "Copilot Enterprise";
+    return titleCase(plan);
+  }
+  return "Copilot";
+}
+
+/** Reads the body once as text and best-effort parses JSON, so error and success paths share it. */
+async function readBody(res: Response): Promise<{ text: string; json: unknown }> {
+  const text = await res.text().catch(() => "");
+  let json: unknown = null;
+  try {
+    json = JSON.parse(text);
+  } catch {
+    json = null;
+  }
+  return { text, json };
+}
+
+async function attempt(cred: Credential, opts: FetchOptions): Promise<Response> {
+  return fetch(ENDPOINT, {
+    method: "GET",
+    headers: {
+      Authorization: "Bearer " + cred.key,
+      Accept: "application/json",
+      "User-Agent": USER_AGENT,
+    },
+    signal: AbortSignal.timeout(opts.timeoutMs),
+  });
+}
+
+/** Exactly one retry on a network throw or 5xx; 4xx is returned immediately (never retried). */
+async function request(cred: Credential, opts: FetchOptions): Promise<Response> {
+  try {
+    const first = await attempt(cred, opts);
+    if (first.status < 500) return first;
+  } catch {
+    // fall through to the single retry
+  }
+
+  try {
+    return await attempt(cred, opts);
+  } catch (err) {
+    throw new AdapterError(
+      "network",
+      redact(
+        `GitHub Copilot request failed: ${err instanceof Error ? err.message : String(err)}`,
+        cred.key,
+      ),
+    );
+  }
+}
+
+async function handleError(res: Response, cred: Credential): Promise<never> {
+  const { text } = await readBody(res);
+
+  if (res.status === 401 || res.status === 404) {
+    throw new AdapterError(
+      "auth",
+      redact("GitHub Copilot login invalid or not available for this account", cred.key),
+    );
+  }
+  if (res.status === 403) {
+    throw new AdapterError(
+      "no-plan",
+      redact("GitHub Copilot is not enabled for this account", cred.key),
+    );
+  }
+  if (res.status === 429) {
+    throw new AdapterError("rate-limited", redact("GitHub Copilot rate limit reached", cred.key));
+  }
+  if (res.status >= 500) {
+    throw new AdapterError(
+      "network",
+      redact(`GitHub Copilot server error ${res.status}`, cred.key),
+    );
+  }
+  throw new AdapterError(
+    "bad-response",
+    redact(`GitHub Copilot unexpected status ${res.status}: ${text.slice(0, 200)}`, cred.key),
+  );
+}
+
+export const copilotAdapter: ProviderAdapter = {
+  id: "github-copilot",
+  displayName: "GitHub Copilot",
+  async fetch(cred: Credential, opts: FetchOptions): Promise<AdapterResult> {
+    const res = await request(cred, opts);
+    if (!res.ok) return handleError(res, cred);
+
+    const { json } = await readBody(res);
+    const body = asRecord(json);
+    if (!body) {
+      throw new AdapterError(
+        "bad-response",
+        redact("GitHub Copilot response was not an object", cred.key),
+      );
+    }
+
+    const snapshots = asRecord(body.quota_snapshots) ?? {};
+    const reset = toISODate(body.quota_reset_date);
+    const tokenBasedBilling = body.token_based_billing === true;
+
+    const windows: UsageWindow[] = [];
+    const extras: Record<string, string> = {};
+    let unlimitedCount = 0;
+
+    for (const { key, label } of SNAPSHOTS) {
+      const snapshot = asRecord(snapshots[key]);
+      if (!snapshot) continue;
+
+      if (snapshot.unlimited === true) {
+        unlimitedCount += 1;
+        extras[label] = "unlimited";
+        continue;
+      }
+
+      const entitlement = toNumber(snapshot.entitlement);
+      const quotaRemaining = toNumber(snapshot.quota_remaining);
+      if (snapshot.has_quota === false || (entitlement === null && quotaRemaining === null)) {
+        continue;
+      }
+
+      const limit = toNumber(snapshot.entitlement ?? snapshot.quota_remaining);
+      const remaining = toNumber(snapshot.remaining ?? snapshot.quota_remaining);
+      const used = limit !== null && remaining !== null ? Math.max(0, limit - remaining) : null;
+
+      const percentRemaining = toNumber(snapshot.percent_remaining);
+      let usedPercent: number | null = null;
+      if (percentRemaining !== null) {
+        usedPercent = Math.min(100, Math.max(0, Math.round((100 - percentRemaining) * 10) / 10));
+      } else if (used !== null && limit !== null && limit > 0) {
+        usedPercent = Math.min(100, Math.max(0, Math.round((used / limit) * 1000) / 10));
+      }
+
+      const windowLabel =
+        key === "premium_interactions"
+          ? tokenBasedBilling
+            ? "Monthly credits"
+            : "Monthly premium requests"
+          : key === "chat"
+            ? "Chat (monthly)"
+            : "Completions (monthly)";
+
+      windows.push({
+        kind: "monthly",
+        label: windowLabel,
+        usedPercent,
+        used,
+        limit,
+        remaining,
+        resetsAt: reset,
+        status: remaining !== null && remaining <= 0 ? "rate-limited" : "ok",
+      });
+    }
+
+    extras["Plan"] = copilotTier(body.access_type_sku, body.copilot_plan);
+
+    // Billing extras come from the premium-interactions snapshot (the billed one).
+    const premium = asRecord(snapshots["premium_interactions"]);
+    const overage = premium ? toNumber(premium.overage_entitlement) : null;
+    if (tokenBasedBilling && overage !== null && overage > 0) {
+      extras["Additional usage budget"] = `$${(overage / 100).toFixed(2)}`;
+    }
+    const creditsUsed = premium ? toNumber(premium.credits_used) : null;
+    if (creditsUsed !== null && creditsUsed > 0) {
+      extras["Credits used"] = `${creditsUsed} credits ($${(creditsUsed / 100).toFixed(2)})`;
+    }
+
+    if (windows.length === 0 && unlimitedCount === 0) {
+      throw new AdapterError(
+        "bad-response",
+        redact("GitHub Copilot response missing quota snapshots", cred.key),
+      );
+    }
+
+    return { windows, extras };
+  },
+};

package/src/providers/index.ts

@@ -1,5 +1,15 @@
-import type { ProviderAdapter } from "../types.js";
-import { kimiAdapter } from "./kimi.js";
-import { opencodeGoAdapter } from "./opencode-go.js";
-export const adapters: ProviderAdapter[] = [kimiAdapter, opencodeGoAdapter];
-export function getAdapter(id: string): ProviderAdapter | undefined { return adapters.find(a => a.id === id); }
+import type { ProviderAdapter } from "../types";
+import { kimiCnAdapter, kimiGlobalAdapter } from "./kimi";
+import { opencodeGoAdapter } from "./opencode-go";
+import { copilotAdapter } from "./copilot";
+import { chatgptAdapter } from "./chatgpt";
+export const adapters: ProviderAdapter[] = [
+  kimiGlobalAdapter,
+  kimiCnAdapter,
+  opencodeGoAdapter,
+  copilotAdapter,
+  chatgptAdapter,
+];
+export function getAdapter(id: string): ProviderAdapter | undefined {
+  return adapters.find((a) => a.id === id);
+}

package/src/providers/kimi.ts

@@ -4,16 +4,27 @@ import type {
   FetchOptions,
   ProviderAdapter,
   UsageWindow,
-} from "../types.js";
-import { AdapterError } from "../types.js";
-import { pick, ratioToPercent, toISODate, toNumber, windowFromCounts } from "../normalize.js";
-import { redact } from "../auth.js";
-
-const VERSION = "0.1.0";
-const ENDPOINT = "https://api.kimi.com/coding/v1/usages";
+} from "../types";
+import { AdapterError } from "../types";
+import { pick, ratioToPercent, toISODate, toNumber, windowFromCounts } from "../normalize";
+import { redact } from "../auth";
+
+const VERSION = "0.3.0";
+
+/**
+ * Kimi Code is split by region in opencode/models.dev: the global plan lives on
+ * api.kimi.ai and the mainland-China plan on api.kimi.com. Both expose the same
+ * `GET <base>/usages` contract, so one factory builds both adapters.
+ */
+export interface KimiAdapterConfig {
+  id: string;
+  displayName: string;
+  /** API base including the version segment, e.g. "https://api.kimi.ai/coding/v1". */
+  baseUrl: string;
+}
 
-function request(cred: Credential, opts: FetchOptions): Promise<Response> {
-  return fetch(ENDPOINT, {
+function request(cred: Credential, opts: FetchOptions, endpoint: string): Promise<Response> {
+  return fetch(endpoint, {
     method: "GET",
     headers: {
       Authorization: "Bearer " + cred.key,
@@ -25,11 +36,15 @@ function request(cred: Credential, opts: FetchOptions): Promise<Response> {
 }
 
 /** One retry on network throw or 5xx; 4xx and 2xx return immediately. */
-async function fetchWithRetry(cred: Credential, opts: FetchOptions): Promise<Response> {
+async function fetchWithRetry(
+  cred: Credential,
+  opts: FetchOptions,
+  endpoint: string,
+): Promise<Response> {
   let lastError: unknown = null;
   for (let attempt = 0; attempt < 2; attempt++) {
     try {
-      const res = await request(cred, opts);
+      const res = await request(cred, opts, endpoint);
       if (res.status >= 500) {
         lastError = new Error(`HTTP ${res.status}`);
         continue;
@@ -56,11 +71,7 @@ function findLimitDetail(limits: unknown, durationMinutes: number): unknown {
   return undefined;
 }
 
-function ratioWindow(
-  kind: UsageWindow["kind"],
-  label: string,
-  value: unknown,
-): UsageWindow {
+function ratioWindow(kind: UsageWindow["kind"], label: string, value: unknown): UsageWindow {
   const ratio = toNumber(pick(value, "used_ratio", "usedRatio"));
   return {
     kind,
@@ -157,42 +168,59 @@ function parse(body: Record<string, unknown>, cred: Credential): AdapterResult {
   return { windows, extras };
 }
 
-export const kimiAdapter: ProviderAdapter = {
-  id: "kimi-for-coding",
-  displayName: "Kimi Code",
-  async fetch(cred: Credential, opts: FetchOptions): Promise<AdapterResult> {
-    const res = await fetchWithRetry(cred, opts);
+export function createKimiAdapter(config: KimiAdapterConfig): ProviderAdapter {
+  const endpoint = `${config.baseUrl}/usages`;
+  return {
+    id: config.id,
+    displayName: config.displayName,
+    async fetch(cred: Credential, opts: FetchOptions): Promise<AdapterResult> {
+      const res = await fetchWithRetry(cred, opts, endpoint);
 
-    if (res.status === 401) {
-      throw new AdapterError("auth", redact("invalid Kimi API key", cred.key));
-    }
-    if (res.status === 429) {
-      throw new AdapterError("rate-limited", redact("Kimi API rate limit exceeded", cred.key));
-    }
-    if (res.status < 200 || res.status >= 300) {
-      throw new AdapterError(
-        "bad-response",
-        redact(`Kimi API returned HTTP ${res.status}`, cred.key),
-      );
-    }
+      if (res.status === 401) {
+        throw new AdapterError("auth", redact("invalid Kimi API key", cred.key));
+      }
+      if (res.status === 429) {
+        throw new AdapterError("rate-limited", redact("Kimi API rate limit exceeded", cred.key));
+      }
+      if (res.status < 200 || res.status >= 300) {
+        throw new AdapterError(
+          "bad-response",
+          redact(`Kimi API returned HTTP ${res.status}`, cred.key),
+        );
+      }
 
-    let body: unknown;
-    try {
-      body = await res.json();
-    } catch {
-      throw new AdapterError(
-        "bad-response",
-        redact("Kimi API returned a non-JSON response", cred.key),
-      );
-    }
+      let body: unknown;
+      try {
+        body = await res.json();
+      } catch {
+        throw new AdapterError(
+          "bad-response",
+          redact("Kimi API returned a non-JSON response", cred.key),
+        );
+      }
 
-    if (body === null || typeof body !== "object" || Array.isArray(body)) {
-      throw new AdapterError(
-        "bad-response",
-        redact("Kimi API returned an unexpected response shape", cred.key),
-      );
-    }
+      if (body === null || typeof body !== "object" || Array.isArray(body)) {
+        throw new AdapterError(
+          "bad-response",
+          redact("Kimi API returned an unexpected response shape", cred.key),
+        );
+      }
+
+      return parse(body as Record<string, unknown>, cred);
+    },
+  };
+}
 
-    return parse(body as Record<string, unknown>, cred);
-  },
-};
+/** Kimi For Coding (kimi.ai) — the global `kimi-code-plan-global` provider. */
+export const kimiGlobalAdapter: ProviderAdapter = createKimiAdapter({
+  id: "kimi-code-plan-global",
+  displayName: "Kimi Code (kimi.ai)",
+  baseUrl: "https://api.kimi.ai/coding/v1",
+});
+
+/** Kimi For Coding (kimi.com) — the mainland-China `kimi-code-plan-cn` provider. */
+export const kimiCnAdapter: ProviderAdapter = createKimiAdapter({
+  id: "kimi-code-plan-cn",
+  displayName: "Kimi Code (kimi.com)",
+  baseUrl: "https://api.kimi.com/coding/v1",
+});

package/src/providers/opencode-go.ts

@@ -6,12 +6,12 @@ import type {
   UsageWindow,
   WindowKind,
   WindowStatus,
-} from "../types.js";
-import { AdapterError } from "../types.js";
-import { toISODate, toNumber } from "../normalize.js";
-import { redact } from "../auth.js";
+} from "../types";
+import { AdapterError } from "../types";
+import { toISODate, toNumber } from "../normalize";
+import { redact } from "../auth";
 
-const VERSION = "0.1.0";
+const VERSION = "0.3.0";
 const USER_AGENT = "opencode-usage-report/" + VERSION;
 const ENDPOINT = "https://opencode.ai/zen/go/v1/usage";
 
@@ -139,7 +139,10 @@ export const opencodeGoAdapter: ProviderAdapter = {
     const body = asRecord(json);
     const usage = body ? asRecord(body.usage) : null;
     if (!usage) {
-      throw new AdapterError("bad-response", redact("OpenCode Go response missing usage", cred.key));
+      throw new AdapterError(
+        "bad-response",
+        redact("OpenCode Go response missing usage", cred.key),
+      );
     }
 
     const windows: UsageWindow[] = [];

package/src/render.ts

@@ -1,4 +1,4 @@
-import type { ProviderReport, UsageWindow } from "./types.js";
+import type { ProviderReport, UsageWindow } from "./types";
 
 const WEEKDAYS = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
 const MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
@@ -38,7 +38,7 @@ function header(report: ProviderReport, now: Date): string {
   return `${report.displayName} (${parts.join(", ")})`;
 }
 
-function windowLine(report: ProviderReport, w: UsageWindow, now: Date): string {
+function windowLine(report: ProviderReport, w: UsageWindow, now: Date, labelWidth: number): string {
   // Local estimates always carry the `~` marker, even when only absolutes are
   // known (percent is null): a bare em dash would hide that the row is estimated.
   const isEstimate = report.source === "local-estimate";
@@ -48,10 +48,11 @@ function windowLine(report: ProviderReport, w: UsageWindow, now: Date): string {
       : isEstimate
         ? "~estimate"
         : "—";
-  let line = `  ${w.label.padEnd(LABEL_WIDTH)}${percent.padEnd(PERCENT_WIDTH)}`;
+  let line = `  ${w.label.padEnd(labelWidth)}${percent.padEnd(PERCENT_WIDTH)}`;
 
   if (w.used !== null && w.limit !== null) {
-    line += `${formatNumber(w.used)} / ${formatNumber(w.limit)} reqs`.padEnd(ABSOLUTES_WIDTH);
+    const unit = /credit/i.test(w.label) ? "credits" : "reqs";
+    line += `${formatNumber(w.used)} / ${formatNumber(w.limit)} ${unit}`.padEnd(ABSOLUTES_WIDTH);
   }
   if (w.resetsAt !== null) {
     const reset = formatReset(w.resetsAt, now);
@@ -63,13 +64,17 @@ function windowLine(report: ProviderReport, w: UsageWindow, now: Date): string {
 /** Renders provider reports as a human-readable text table (spec §3.8). */
 export function renderText(reports: ProviderReport[], opts?: { now?: Date }): string {
   const now = opts?.now ?? new Date();
+  const labelWidth = Math.max(
+    LABEL_WIDTH,
+    ...reports.flatMap((report) => report.windows.map((w) => w.label.length + 1)),
+  );
   const blocks = reports.map((report) => {
     if (report.source === "error") {
       return `⚠ ${report.displayName}: ${report.error ?? "unknown error"}`;
     }
     const lines = [header(report, now)];
     for (const w of report.windows) {
-      lines.push(windowLine(report, w, now));
+      lines.push(windowLine(report, w, now, labelWidth));
     }
     for (const [key, value] of Object.entries(report.extras)) {
       lines.push(`  ${key}: ${value}`);

package/src/report.ts

@@ -1,9 +1,9 @@
-import type { PluginOptions, ProviderAdapter, ProviderReport } from "./types.js";
-import { adapters, getAdapter } from "./providers/index.js";
-import { redact, resolveCredential } from "./auth.js";
-import { ensureSessionId, readCache, writeCache } from "./cache.js";
-import type { CacheEntry } from "./cache.js";
-import { localEstimate } from "./fallback.js";
+import type { PluginOptions, ProviderAdapter, ProviderReport } from "./types";
+import { adapters, getAdapter } from "./providers/index";
+import { redact, resolveCredential } from "./auth";
+import { ensureSessionId, readCache, writeCache } from "./cache";
+import type { CacheEntry } from "./cache";
+import { localEstimate } from "./fallback";
 
 export const DEFAULT_OPTIONS: PluginOptions = {
   thresholdPercent: 80,
@@ -69,9 +69,14 @@ async function collectOne(
   options: PluginOptions,
   refresh: boolean,
   env: NodeJS.ProcessEnv,
-): Promise<ProviderReport> {
+  explicit: boolean,
+): Promise<ProviderReport | null> {
   const cred = resolveCredential(id, { env });
-  if (cred === null) return errorReport(id, adapter.displayName, "no credential found");
+  if (cred === null) {
+    // The default view lists only providers that are actually configured; a
+    // provider the user asked for by name still reports the missing credential.
+    return explicit ? errorReport(id, adapter.displayName, "no credential found") : null;
+  }
 
   if (!refresh) {
     const cached = await readCache(id, options.cacheTtlSeconds, env);
@@ -97,7 +102,10 @@ async function collectOne(
       error: null,
     };
   } catch (err) {
-    failure = redact(err instanceof Error ? err.message : String(err), cred.key);
+    failure = redact(
+      redact(err instanceof Error ? err.message : String(err), cred.key),
+      cred.accountId ?? null,
+    );
   }
 
   const cached = await readCache(id, options.cacheTtlSeconds, env);
@@ -126,19 +134,19 @@ async function collectOne(
 
 /**
  * Collects normalized usage reports for the requested providers (default: every
- * registered adapter). Never throws: each provider is isolated and failures
- * surface as `source: "error"` rows.
+ * configured adapter; unconfigured ones are skipped unless requested by name).
+ * Never throws: each provider is isolated and failures surface as
+ * `source: "error"` rows.
  */
 export async function collectReports(opts: CollectReportsOptions = {}): Promise<ProviderReport[]> {
-  const options: PluginOptions = { ...DEFAULT_OPTIONS, ...(opts.options ?? {}) };
+  const options: PluginOptions = { ...DEFAULT_OPTIONS, ...opts.options };
   const env = opts.env ?? process.env;
   const refresh = opts.refresh === true;
 
   // An empty filter is treated like "no filter": report every registered adapter.
-  const ids =
-    firstNonEmpty(opts.providers) ??
-    firstNonEmpty(options.providers) ??
-    adapters.map((adapter) => adapter.id);
+  const requested = firstNonEmpty(opts.providers) ?? firstNonEmpty(options.providers);
+  const ids = requested ?? adapters.map((adapter) => adapter.id);
+  const explicit = requested !== null;
   const reports: ProviderReport[] = [];
 
   for (const id of ids) {
@@ -150,7 +158,8 @@ export async function collectReports(opts: CollectReportsOptions = {}): Promise<
     }
 
     try {
-      reports.push(await collectOne(id, adapter, options, refresh, env));
+      const report = await collectOne(id, adapter, options, refresh, env, explicit);
+      if (report !== null) reports.push(report);
     } catch {
       // Last-resort isolation: never let one provider break the whole report.
       reports.push(errorReport(id, adapter.displayName, "internal error while collecting usage"));

package/src/tui-format.ts

@@ -2,7 +2,7 @@
  * Pure formatting helpers for the TUI sidebar usage panel. No JSX, no Solid
  * imports (the only module dependency is the shared `DEFAULT_OPTIONS`).
  */
-import { DEFAULT_OPTIONS } from "./report.js";
+import { DEFAULT_OPTIONS } from "./report";
 
 export type ToneName = "success" | "warning" | "error" | "textMuted";
 
@@ -109,10 +109,10 @@ export function percentText(w: {
   const usedIsNumber = typeof used === "number" && Number.isFinite(used);
   const limitIsNumber = typeof limit === "number" && Number.isFinite(limit);
   if (usedIsNumber && limitIsNumber) {
-    return `${used.toLocaleString()}/${limit.toLocaleString()}`;
+    return `${used.toLocaleString("en-US")}/${limit.toLocaleString("en-US")}`;
   }
   if (usedIsNumber) {
-    return `~${used.toLocaleString()}`;
+    return `~${used.toLocaleString("en-US")}`;
   }
   return "—";
 }
@@ -160,9 +160,7 @@ function toFiniteNumber(value: unknown): number | null {
  * `barWidth` is floored and clamped to 4..40; `refreshIntervalSeconds` is
  * rounded and clamped to 5..3600 so the timer can never hot-loop or overflow.
  */
-export function coerceTuiOptions(
-  raw: Record<string, unknown> | undefined,
-): ResolvedTuiOptions {
+export function coerceTuiOptions(raw: Record<string, unknown> | undefined): ResolvedTuiOptions {
   const opts: ResolvedTuiOptions = {
     cacheTtlSeconds: DEFAULT_OPTIONS.cacheTtlSeconds,
     thresholdPercent: DEFAULT_OPTIONS.thresholdPercent,

package/src/tui.tsx

@@ -6,16 +6,9 @@ import type {
   TuiSlotPlugin,
 } from "@opencode-ai/plugin/tui";
 import { For, createSignal } from "solid-js";
-import { DEFAULT_OPTIONS, collectReports } from "./report.js";
-import {
-  bar,
-  coerceTuiOptions,
-  countdown,
-  percentText,
-  toneFor,
-  windowLabel,
-} from "./tui-format.js";
-import type { ProviderReport, WindowKind } from "./types.js";
+import { DEFAULT_OPTIONS, collectReports } from "./report";
+import { bar, coerceTuiOptions, countdown, percentText, toneFor, windowLabel } from "./tui-format";
+import type { ProviderReport, WindowKind } from "./types";
 
 type Theme = TuiPluginApi["theme"]["current"];
 type ThemeColor = Theme["text"];
@@ -55,8 +48,7 @@ function clip(value: string, max = 60): string {
 
 /** Pads a label to a fixed width, truncating (with a trailing space) when long. */
 function alignLabel(label: string): string {
-  const text =
-    label.length > NAMED_WIDTH ? label.slice(0, NAMED_WIDTH - 1) + " " : label;
+  const text = label.length > NAMED_WIDTH ? label.slice(0, NAMED_WIDTH - 1) + " " : label;
   return text.padEnd(NAMED_WIDTH);
 }
 
@@ -94,16 +86,12 @@ function buildLines(
 
     if (report.source === "error") {
       lines.push({
-        segments: [
-          { text: clip(report.error ?? "unknown error"), fg: theme.error },
-        ],
+        segments: [{ text: clip(report.error ?? "unknown error"), fg: theme.error }],
       });
       continue;
     }
 
-    const windows = [...report.windows].sort(
-      (a, b) => windowRank(a.kind) - windowRank(b.kind),
-    );
+    const windows = report.windows.toSorted((a, b) => windowRank(a.kind) - windowRank(b.kind));
     for (const w of windows) {
       const tone = toneFor(w.usedPercent, w.status);
       const row: Segment[] = [
@@ -121,9 +109,7 @@ function buildLines(
 
     for (const [key, value] of Object.entries(report.extras)) {
       lines.push({
-        segments: [
-          { text: clip(`${key}: ${value}`, EXTRAS_MAX_LENGTH), fg: theme.textMuted },
-        ],
+        segments: [{ text: clip(`${key}: ${value}`, EXTRAS_MAX_LENGTH), fg: theme.textMuted }],
       });
     }
   }
@@ -198,9 +184,7 @@ export const tui: TuiPlugin = async (api, rawOptions) => {
           },
         },
       ],
-      bindings: [
-        { key: "ctrl+shift+u", cmd: "usage.refresh", desc: "Refresh usage panel" },
-      ],
+      bindings: [{ key: "ctrl+shift+u", cmd: "usage.refresh", desc: "Refresh usage panel" }],
     }),
   );
 
@@ -215,7 +199,14 @@ export const tui: TuiPlugin = async (api, rawOptions) => {
               <b>Usage</b>
             </text>
             <For
-              each={buildLines(theme, reports(), busy(), error(), new Date(tick()), options.barWidth)}
+              each={buildLines(
+                theme,
+                reports(),
+                busy(),
+                error(),
+                new Date(tick()),
+                options.barWidth,
+              )}
             >
               {(line) => (
                 <text>

package/src/types.ts

@@ -28,6 +28,8 @@ export interface ProviderReport {
 export interface Credential {
   type: "api" | "oauth";
   key: string;
+  /** Provider account id, when the auth entry carries one (e.g. ChatGPT). */
+  accountId?: string;
 }
 export interface AdapterResult {
   windows: UsageWindow[];
@@ -50,7 +52,10 @@ export interface PluginOptions {
 
 export type AdapterErrorKind = "auth" | "no-plan" | "rate-limited" | "network" | "bad-response";
 export class AdapterError extends Error {
-  constructor(public kind: AdapterErrorKind, message: string) {
+  constructor(
+    public kind: AdapterErrorKind,
+    message: string,
+  ) {
     super(message);
     this.name = "AdapterError";
   }

package/src/warn.ts

@@ -1,8 +1,8 @@
 import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-import type { ProviderReport, UsageWindow } from "./types.js";
-import { pluginStateDir } from "./paths.js";
-import { formatReset } from "./render.js";
+import type { ProviderReport, UsageWindow } from "./types";
+import { pluginStateDir } from "./paths";
+import { formatReset } from "./render";
 
 export interface WarnHit {
   provider: string;
@@ -72,7 +72,8 @@ export async function checkWarnings(
     for (const w of report.windows) {
       const key = `${report.provider}/${w.kind}`;
       const crossed =
-        (w.usedPercent !== null && w.usedPercent >= thresholdPercent) || HITS_WINDOW_STATUSES.has(w.status);
+        (w.usedPercent !== null && w.usedPercent >= thresholdPercent) ||
+        HITS_WINDOW_STATUSES.has(w.status);
 
       if (crossed) {
         const prev = state[key];