@monotykamary/pi-better-openai 0.1.40 → 0.1.42

package/README.md

@@ -26,6 +26,7 @@ Usage display, image generation, and live voice require pi's `openai-codex` OAut
 2. Verify subscription usage with `/openai-usage`, or open `/openai-settings` and check **Diagnostics**.
 3. The extension reads auth from pi's agent auth store, normally `~/.pi/agent/auth.json`. Do not copy, paste, or commit values from this file.
 4. If `PI_CODING_AGENT_DIR` is set, the auth store, global extension config, and global generated-image directory use that agent directory instead of `~/.pi/agent`. A leading `~/` is expanded to your home directory.
+5. When [pi-multiprovider](https://github.com/monotykamary/pi-multiprovider) 0.4.0+ pools several `openai-codex` accounts, the session's active account (chosen with `/switch-account`) is resolved first for usage display, image generation, web search, and live voice; the usage widget refreshes on every switch. Without that extension, credential resolution is unchanged.
 
 ## Features
 

package/index.ts

@@ -14,9 +14,17 @@ import {
 } from "@earendil-works/pi-tui";
 import { registerOpenAICodexModels } from "./src/codex-models.ts";
 import { CONFIG_BASENAME, STATUS_KEY } from "./src/identity.ts";
+import {
+  CODEX_PROVIDER_ID,
+  isMultiproviderService,
+  MULTIPROVIDER_SERVICE_EVENT,
+  setActiveMultiproviderService,
+  type MultiproviderService,
+} from "./src/multiprovider.ts";
 import {
   formatTokens,
   redactDiagnosticValue,
+  sanitizeDiagnosticError,
   sanitizeStatusText,
   truncateToWidth,
   visibleWidth,
@@ -54,7 +62,19 @@ import {
   formatUsageSnapshot,
   parseUsageSnapshot,
   readCodexAuth,
+  requestCodexUsage,
+  type UsageSnapshot,
 } from "./src/usage.ts";
+import {
+  buildBankedResetConfirmation,
+  consumeBankedReset,
+  formatBankedResetChoice,
+  formatConsumeOutcome,
+  newRedeemRequestId,
+  requestBankedResetCredits,
+  selectBankedResetCredit,
+  type BankedResetCredits,
+} from "./src/resets.ts";
 import { registerOpenAIImage, _imageTest } from "./src/image.ts";
 import { registerOpenAIWebSearch, _websearchTest } from "./src/websearch.ts";
 import { registerOpenAILive } from "./src/live/index.ts";
@@ -114,6 +134,7 @@ class DynamicBorder {
 const COMMAND = "fast";
 const OPENAI_STATUS_COMMAND = "openai-usage";
 const OPENAI_SETTINGS_COMMAND = "openai-settings";
+const OPENAI_RESETS_COMMAND = "openai-resets";
 const FLAG = "fast";
 const PET_EMPTY_VALUE = "not selected";
 const SERVICE_TIER = "priority";
@@ -227,6 +248,32 @@ export default function betterOpenAI(pi: ExtensionAPI): void {
   let cachedSessionName: string | undefined;
   const usageController = new UsageController(config, updateFooter);
   const petController = new PetFooterController(config, updateFooter, () => footerInstalled);
+  let multiproviderService: MultiproviderService | undefined;
+  let unsubscribeMultiprovider: (() => void) | undefined;
+  let multiproviderRefreshCtx: ExtensionContext | undefined;
+
+  // Follow pi-multiprovider's active pooled account for openai-codex. The
+  // event re-fires with the same stable object at load and session start; the
+  // identity check keeps the change subscription attached exactly once. When
+  // the extension is absent, nothing here activates and credential resolution
+  // keeps its standalone behavior.
+  if (typeof pi.events?.on === "function") {
+    pi.events.on(MULTIPROVIDER_SERVICE_EVENT, (value) => {
+      if (!isMultiproviderService(value) || value === multiproviderService) return;
+      unsubscribeMultiprovider?.();
+      multiproviderService = value;
+      setActiveMultiproviderService(value);
+      unsubscribeMultiprovider = value.onActiveAccountChanged(CODEX_PROVIDER_ID, (event) => {
+        void usageController.refresh(event.ctx, undefined, { force: true });
+        updateFooter(event.ctx);
+      });
+      const ctx = multiproviderRefreshCtx;
+      if (ctx) {
+        void usageController.refresh(ctx, undefined, { force: true });
+        updateFooter(ctx);
+      }
+    });
+  }
 
   function refresh(ctx: ExtensionContext): ResolvedConfig {
     cachedConfig = resolveConfig(ctx.cwd || process.cwd());
@@ -350,6 +397,71 @@ export default function betterOpenAI(pi: ExtensionAPI): void {
     ].join("\n");
   }
 
+  async function redeemBankedReset(ctx: ExtensionContext): Promise<void> {
+    if (!hasTerminalUI(ctx)) {
+      ctx.ui.notify("/openai-resets requires an interactive TUI session.", "warning");
+      return;
+    }
+    const timeoutSignal = AbortSignal.timeout(15_000);
+    const signal = ctx.signal ? AbortSignal.any([ctx.signal, timeoutSignal]) : timeoutSignal;
+    let credits: BankedResetCredits | undefined;
+    let snapshot: UsageSnapshot | undefined;
+    try {
+      const [creditResult, usageResult] = await Promise.all([
+        requestBankedResetCredits(ctx, signal),
+        requestCodexUsage(ctx, signal).catch(() => undefined),
+      ]);
+      credits = creditResult;
+      snapshot = usageResult ? parseUsageSnapshot(usageResult, ctx.model?.id) : undefined;
+    } catch (error) {
+      ctx.ui.notify(
+        `Banked reset lookup failed: ${sanitizeDiagnosticError(
+          error instanceof Error ? error.message : String(error),
+        )}`,
+        "error",
+      );
+      return;
+    }
+    if (!credits || credits.availableCount <= 0) {
+      ctx.ui.notify("No banked Codex resets are available for this account.", "info");
+      return;
+    }
+    const available = credits.credits.filter((credit) => credit.status === "available");
+    let selected = selectBankedResetCredit(credits.credits);
+    if (available.length > 1 && selected) {
+      const options = available.map((credit, index) => formatBankedResetChoice(credit, index));
+      const chosen = await ctx.ui.select("Redeem which banked reset?", options);
+      if (chosen === undefined) {
+        ctx.ui.notify("Banked reset redemption cancelled.", "info");
+        return;
+      }
+      selected = available[Math.max(0, options.indexOf(chosen))];
+    }
+    const confirmation = buildBankedResetConfirmation({
+      credit: selected,
+      availableCount: credits.availableCount,
+      snapshot,
+    });
+    if (!(await ctx.ui.confirm(confirmation.title, confirmation.message))) {
+      ctx.ui.notify("Banked reset redemption cancelled.", "info");
+      return;
+    }
+    try {
+      const result = await consumeBankedReset(ctx, selected?.id, newRedeemRequestId(), signal);
+      const outcome = formatConsumeOutcome(result);
+      ctx.ui.notify(outcome.message, outcome.level);
+      void usageController.refresh(ctx, ctx.model?.id, { force: true });
+      updateFooter(ctx);
+    } catch (error) {
+      ctx.ui.notify(
+        `Banked reset redemption failed: ${sanitizeDiagnosticError(
+          error instanceof Error ? error.message : String(error),
+        )}`,
+        "error",
+      );
+    }
+  }
+
   pi.registerCommand(COMMAND, {
     description: "Toggle OpenAI fast mode",
     handler: async (args, ctx) => {
@@ -366,6 +478,13 @@ export default function betterOpenAI(pi: ExtensionAPI): void {
     },
   });
 
+  pi.registerCommand(OPENAI_RESETS_COMMAND, {
+    description: "Inspect and redeem Codex banked rate-limit resets",
+    handler: async (_args, ctx) => {
+      await redeemBankedReset(ctx);
+    },
+  });
+
   function buildPetSettingsItems(cfg: ResolvedConfig): SettingsPickerItem[] {
     return settingsItemsFromDescriptors(PET_SETTING_DESCRIPTORS, cfg, {
       "pets.slug": {
@@ -1261,6 +1380,7 @@ export default function betterOpenAI(pi: ExtensionAPI): void {
   pi.on("session_start", (_event, ctx) => {
     invalidateContextUsage();
     invalidateSessionName();
+    multiproviderRefreshCtx = ctx;
     const nextConfig = refresh(ctx);
     fastController.initializeForSession(ctx, nextConfig, pi.getFlag(FLAG) === true);
     if (
@@ -1347,6 +1467,7 @@ export default function betterOpenAI(pi: ExtensionAPI): void {
   pi.on("session_shutdown", () => {
     invalidateContextUsage();
     invalidateSessionName();
+    multiproviderRefreshCtx = undefined;
     usageController.shutdown();
     petController.shutdown();
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monotykamary/pi-better-openai",
-  "version": "0.1.40",
+  "version": "0.1.42",
   "description": "Improve OpenAI in pi with fast mode, usage stats, realtime voice, image generation, and footer polish.",
   "keywords": [
     "fast",

package/src/codex-auth.ts

@@ -1,6 +1,7 @@
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { CODEX_PROVIDER_ID, getActiveMultiproviderService } from "./multiprovider.ts";
 import { piAgentDir } from "./paths.ts";
 
 export const AUTH_FILE = join(piAgentDir(), "auth.json");
@@ -10,8 +11,13 @@ export type CodexCredentials = {
   accountId: string;
 };
 
+export type CodexCredentialsContext = Pick<
+  ExtensionContext,
+  "modelRegistry" | "model" | "sessionManager"
+>;
+
 export type CodexCredentialsWithSource = CodexCredentials & {
-  source: "modelRegistry" | "authFile";
+  source: "multiprovider" | "modelRegistry" | "authFile";
 };
 
 function waitForSignal<T>(operation: Promise<T>, signal?: AbortSignal): Promise<T> {
@@ -118,11 +124,28 @@ export function readCodexAuth(): CodexCredentials | undefined {
 }
 
 export async function getCodexCredentials(
-  ctx?: Pick<ExtensionContext, "modelRegistry">,
+  ctx?: CodexCredentialsContext,
   signal?: AbortSignal,
 ): Promise<CodexCredentialsWithSource | undefined> {
   if (signal?.aborted) throw signal.reason ?? new Error("Operation was aborted.");
-  const registryRequest = ctx?.modelRegistry?.getApiKeyForProvider("openai-codex");
+  // A pooled account pinned for this session (pi-multiprovider /switch-account)
+  // wins over pi's own credential: subscription usage is per-account.
+  const multiprovider = getActiveMultiproviderService();
+  if (multiprovider && ctx) {
+    try {
+      const resolved = await waitForSignal(
+        multiprovider.resolveActiveAccountAuth(CODEX_PROVIDER_ID, ctx, signal),
+        signal,
+      );
+      const accountId = resolved ? extractAccountIdFromJwt(resolved.accessToken) : undefined;
+      if (resolved && accountId) {
+        return { accessToken: resolved.accessToken, accountId, source: "multiprovider" };
+      }
+    } catch {
+      // Fall back to pi-owned credential resolution.
+    }
+  }
+  const registryRequest = ctx?.modelRegistry?.getApiKeyForProvider(CODEX_PROVIDER_ID);
   const registryToken = registryRequest
     ? await waitForSignal(
         registryRequest.catch(() => undefined),

package/src/config.ts

@@ -58,6 +58,7 @@ export type UsageConfig = {
   refreshIntervalMs?: number;
   showOnlyOnSubscriptionModels?: boolean;
   showResetTimes?: boolean;
+  showBankedResets?: boolean;
 };
 
 export type FooterConfig = {
@@ -140,6 +141,7 @@ export const DEFAULT_USAGE_CONFIG: Required<UsageConfig> = {
   refreshIntervalMs: 60_000,
   showOnlyOnSubscriptionModels: true,
   showResetTimes: true,
+  showBankedResets: true,
 };
 
 export const DEFAULT_FOOTER_CONFIG: Required<FooterConfig> = {
@@ -296,6 +298,16 @@ export const USAGE_SETTING_DESCRIPTORS: readonly SettingsOptionDescriptor[] = [
     description: "Include compact reset countdowns and local reset times.",
     parse: booleanSetting,
   },
+  {
+    id: "usage.showBankedResets",
+    section: "usage",
+    key: "showBankedResets",
+    label: "Banked reset count",
+    currentValue: (cfg) => String(cfg.usage.showBankedResets),
+    values: ["true", "false"],
+    description: "Show the available banked Codex reset count in the usage status line.",
+    parse: booleanSetting,
+  },
 ];
 
 export const IMAGE_SETTING_DESCRIPTORS: readonly SettingsOptionDescriptor[] = [
@@ -629,6 +641,8 @@ export function readConfig(path: string): ConfigFile | undefined {
       config.usage.showOnlyOnSubscriptionModels = parsed.usage.showOnlyOnSubscriptionModels;
     if (typeof parsed.usage.showResetTimes === "boolean")
       config.usage.showResetTimes = parsed.usage.showResetTimes;
+    if (typeof parsed.usage.showBankedResets === "boolean")
+      config.usage.showBankedResets = parsed.usage.showBankedResets;
   }
   if (
     isRecord(parsed.footer) &&

package/src/multiprovider.ts

@@ -0,0 +1,66 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+// Soft bridge to pi-multiprovider. When that extension is installed it emits
+// this event with a service object; without it everything here stays inert and
+// credential resolution keeps its standalone behavior.
+export const MULTIPROVIDER_SERVICE_EVENT = "pi-multiprovider:service";
+export const CODEX_PROVIDER_ID = "openai-codex";
+
+export type MultiproviderActiveAccount = {
+  id: string;
+  label: string;
+  authKind: string;
+};
+
+export type MultiproviderAccountAuth = {
+  accessToken: string;
+  label: string;
+  source?: string;
+};
+
+export type MultiproviderAccountChangedEvent = {
+  providerId: string;
+  account: MultiproviderActiveAccount | undefined;
+  ctx: ExtensionContext;
+};
+
+export type MultiproviderServiceContext = Pick<
+  ExtensionContext,
+  "modelRegistry" | "model" | "sessionManager"
+>;
+
+export type MultiproviderService = {
+  getActiveAccount(
+    providerId: string,
+    ctx: MultiproviderServiceContext,
+  ): Promise<MultiproviderActiveAccount | undefined>;
+  resolveActiveAccountAuth(
+    providerId: string,
+    ctx: MultiproviderServiceContext,
+    signal?: AbortSignal,
+  ): Promise<MultiproviderAccountAuth | undefined>;
+  onActiveAccountChanged(
+    providerId: string,
+    callback: (event: MultiproviderAccountChangedEvent) => void,
+  ): () => void;
+};
+
+export function isMultiproviderService(value: unknown): value is MultiproviderService {
+  if (typeof value !== "object" || value === null) return false;
+  const candidate = value as Partial<MultiproviderService>;
+  return (
+    typeof candidate.getActiveAccount === "function" &&
+    typeof candidate.resolveActiveAccountAuth === "function" &&
+    typeof candidate.onActiveAccountChanged === "function"
+  );
+}
+
+let activeService: MultiproviderService | undefined;
+
+export function setActiveMultiproviderService(service: MultiproviderService | undefined): void {
+  activeService = service;
+}
+
+export function getActiveMultiproviderService(): MultiproviderService | undefined {
+  return activeService;
+}

package/src/resets.ts

@@ -0,0 +1,249 @@
+import { randomUUID } from "node:crypto";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { getCodexCredentials } from "./codex-auth.ts";
+import { formatPercent, type UsageSnapshot } from "./usage.ts";
+
+export const RESET_CREDITS_URL = "https://chatgpt.com/backend-api/wham/rate-limit-reset-credits";
+export const CONSUME_RESET_URL =
+  "https://chatgpt.com/backend-api/wham/rate-limit-reset-credits/consume";
+
+export type BankedResetStatus = "available" | "redeeming" | "redeemed" | "unknown";
+
+export type BankedResetCredit = {
+  id: string;
+  resetType: string | null;
+  status: BankedResetStatus;
+  grantedAtMs: number | null;
+  expiresAtMs: number | null;
+  title: string | null;
+  description: string | null;
+};
+
+export type BankedResetCredits = {
+  availableCount: number;
+  applicableCount: number | null;
+  credits: BankedResetCredit[];
+};
+
+export type ConsumeBankedResetCode =
+  | "reset"
+  | "nothing_to_reset"
+  | "no_credit"
+  | "already_redeemed";
+
+export type ConsumeBankedResetResult = {
+  code: ConsumeBankedResetCode;
+  windowsReset: number | null;
+};
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function isAbortSignal(value: unknown): value is AbortSignal {
+  return typeof value === "object" && value !== null && "aborted" in value;
+}
+
+function asOptionalInt(value: unknown): number | null {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : null;
+}
+
+function readText(value: unknown): string | null {
+  return typeof value === "string" && value.trim() ? value : null;
+}
+
+function parseTimestampMs(value: unknown): number | null {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value > 100_000_000_000 ? value : value * 1000;
+  }
+  if (typeof value === "string" && value.trim()) {
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? parsed : null;
+  }
+  return null;
+}
+
+function parseCreditRow(row: unknown): BankedResetCredit | undefined {
+  if (!isRecord(row)) return undefined;
+  const id = typeof row.id === "string" && row.id ? row.id : undefined;
+  if (!id) return undefined;
+  const statusValue = row.status;
+  const status: BankedResetStatus =
+    statusValue === "available" || statusValue === "redeeming" || statusValue === "redeemed"
+      ? statusValue
+      : "unknown";
+  return {
+    id,
+    resetType: readText(row.reset_type),
+    status,
+    grantedAtMs: parseTimestampMs(row.granted_at),
+    expiresAtMs: parseTimestampMs(row.expires_at),
+    title: readText(row.title),
+    description: readText(row.description),
+  };
+}
+
+export function parseBankedResetCredits(payload: unknown): BankedResetCredits {
+  if (!isRecord(payload)) return { availableCount: 0, applicableCount: null, credits: [] };
+  const rows = Array.isArray(payload.credits) ? payload.credits : [];
+  const credits = rows
+    .map(parseCreditRow)
+    .filter((credit): credit is BankedResetCredit => credit !== undefined);
+  const applicableRaw = payload.applicable_available_count;
+  return {
+    availableCount: asOptionalInt(payload.available_count) ?? 0,
+    applicableCount: applicableRaw === undefined ? null : asOptionalInt(applicableRaw),
+    credits,
+  };
+}
+
+export function parseConsumeBankedResetResult(payload: unknown): ConsumeBankedResetResult {
+  if (!isRecord(payload)) throw new Error("Codex reset response was malformed.");
+  const code = payload.code;
+  if (
+    code !== "reset" &&
+    code !== "nothing_to_reset" &&
+    code !== "no_credit" &&
+    code !== "already_redeemed"
+  )
+    throw new Error("Unexpected Codex reset response code.");
+  return { code, windowsReset: asOptionalInt(payload.windows_reset) };
+}
+
+export function availableBankedResetCredits(
+  credits: readonly BankedResetCredit[],
+): BankedResetCredit[] {
+  return credits.filter((credit) => credit.status === "available");
+}
+
+// Soonest-expiring available credit first: banked resets expire, so spend the
+// one closest to expiry. Credits without an expiry sort last.
+export function selectBankedResetCredit(
+  credits: readonly BankedResetCredit[],
+): BankedResetCredit | undefined {
+  return [...availableBankedResetCredits(credits)].sort((a, b) => {
+    const aExpiry = a.expiresAtMs ?? Number.POSITIVE_INFINITY;
+    const bExpiry = b.expiresAtMs ?? Number.POSITIVE_INFINITY;
+    if (aExpiry !== bExpiry) return aExpiry - bExpiry;
+    return (a.grantedAtMs ?? 0) - (b.grantedAtMs ?? 0);
+  })[0];
+}
+
+function formatResetTimestamp(ms: number | null): string {
+  if (ms === null) return "unknown";
+  return new Date(ms).toLocaleString(undefined, {
+    month: "short",
+    day: "numeric",
+    hour: "numeric",
+    minute: "2-digit",
+  });
+}
+
+export function formatBankedResetChoice(credit: BankedResetCredit, index: number): string {
+  const title = credit.title ?? "Codex banked reset";
+  const expires =
+    credit.expiresAtMs === null
+      ? "no expiry"
+      : `expires ${formatResetTimestamp(credit.expiresAtMs)}`;
+  return `${index + 1}. ${title} · ${expires}`;
+}
+
+export function formatConsumeOutcome(result: ConsumeBankedResetResult): {
+  message: string;
+  level: "info" | "warning";
+} {
+  switch (result.code) {
+    case "reset":
+      return {
+        message: `Banked reset redeemed${result.windowsReset === null ? "" : ` — ${result.windowsReset} usage window${result.windowsReset === 1 ? "" : "s"} refreshed`}.`,
+        level: "info",
+      };
+    case "nothing_to_reset":
+      return {
+        message: "Nothing to reset — Codex reported no eligible usage window.",
+        level: "warning",
+      };
+    case "no_credit":
+      return { message: "No banked Codex resets remain available.", level: "warning" };
+    case "already_redeemed":
+      return { message: "That banked reset was already redeemed.", level: "warning" };
+  }
+}
+
+export function buildBankedResetConfirmation(options: {
+  credit?: BankedResetCredit;
+  availableCount: number;
+  snapshot?: Pick<UsageSnapshot, "fiveHourLeftPercent" | "sevenDayLeftPercent">;
+}): { title: string; message: string } {
+  const credit = options.credit;
+  const lines: string[] = [credit?.title ?? "Codex banked rate-limit reset"];
+  if (credit?.description) lines.push(credit.description);
+  lines.push("");
+  if (credit?.grantedAtMs != null)
+    lines.push(`Granted: ${formatResetTimestamp(credit.grantedAtMs)}`);
+  lines.push(`Expires: ${formatResetTimestamp(credit?.expiresAtMs ?? null)}`);
+  lines.push(`Available: ${options.availableCount}`);
+  const windows: string[] = [];
+  if (options.snapshot?.fiveHourLeftPercent != null)
+    windows.push(`5h ${formatPercent(options.snapshot.fiveHourLeftPercent)} left`);
+  if (options.snapshot?.sevenDayLeftPercent != null)
+    windows.push(`7d ${formatPercent(options.snapshot.sevenDayLeftPercent)} left`);
+  if (windows.length > 0) lines.push(`Current usage: ${windows.join(" · ")}`);
+  lines.push("");
+  lines.push(
+    "This resets your 5-hour and weekly Codex usage windows immediately and cannot be undone.",
+  );
+  return { title: "Redeem banked Codex reset?", message: lines.join("\n") };
+}
+
+export async function requestBankedResetCredits(
+  ctxOrSignal?: ExtensionContext | AbortSignal,
+  signal?: AbortSignal,
+): Promise<BankedResetCredits | undefined> {
+  const ctx = isAbortSignal(ctxOrSignal) ? undefined : ctxOrSignal;
+  const requestSignal = isAbortSignal(ctxOrSignal) ? ctxOrSignal : signal;
+  const credentials = await getCodexCredentials(ctx, requestSignal);
+  if (!credentials) return undefined;
+  const response = await fetch(RESET_CREDITS_URL, {
+    headers: {
+      accept: "*/*",
+      authorization: `Bearer ${credentials.accessToken}`,
+      "chatgpt-account-id": credentials.accountId,
+    },
+    signal: requestSignal,
+  });
+  if (!response.ok) throw new Error(`Codex reset credit request failed (${response.status})`);
+  return parseBankedResetCredits(await response.json());
+}
+
+export async function consumeBankedReset(
+  ctx: ExtensionContext | undefined,
+  creditId: string | undefined,
+  redeemRequestId: string,
+  signal?: AbortSignal,
+): Promise<ConsumeBankedResetResult> {
+  const credentials = await getCodexCredentials(ctx, signal);
+  if (!credentials)
+    throw new Error("OpenAI Codex authentication is unavailable. Run /login first.");
+  const response = await fetch(CONSUME_RESET_URL, {
+    method: "POST",
+    headers: {
+      accept: "*/*",
+      authorization: `Bearer ${credentials.accessToken}`,
+      "chatgpt-account-id": credentials.accountId,
+      "content-type": "application/json",
+    },
+    body: JSON.stringify(
+      creditId
+        ? { credit_id: creditId, redeem_request_id: redeemRequestId }
+        : { redeem_request_id: redeemRequestId },
+    ),
+    signal,
+  });
+  if (!response.ok) throw new Error(`Codex reset consume request failed (${response.status})`);
+  return parseConsumeBankedResetResult(await response.json());
+}
+
+export function newRedeemRequestId(): string {
+  return randomUUID();
+}

package/src/usage-controller.ts

@@ -113,6 +113,7 @@ export class UsageController {
       `Last successful update: ${this.usageUpdatedAt ? new Date(this.usageUpdatedAt).toLocaleTimeString() : "never"}`,
       `Last error: ${this.usageError ?? "none"}`,
       `Refresh interval: ${cfg.usage.refreshIntervalMs}ms`,
+      `Banked resets: ${this.usageSnapshot?.bankedResets ?? "n/a"}`,
       `Endpoint: https://chatgpt.com/backend-api/wham/usage`,
     ].join("\n");
   }

package/src/usage.ts

@@ -19,6 +19,7 @@ export type RateLimitBucket = {
 export type CodexUsageResponse = {
   rate_limit?: RateLimitBucket | null;
   additional_rate_limits?: Record<string, unknown> | unknown[] | null;
+  rate_limit_reset_credits?: { available_count?: number | null } | null;
 };
 
 export type UsageSnapshot = {
@@ -29,6 +30,7 @@ export type UsageSnapshot = {
   fiveHourResetInSeconds: number | null;
   sevenDayResetInSeconds: number | null;
   isLimited: boolean;
+  bankedResets: number | null;
 };
 
 export type UsageScope = "default" | "spark";
@@ -82,6 +84,11 @@ function usedToLeftPercent(value: number | null | undefined): number | null {
   return clampPercent(100 - value);
 }
 
+function readBankedResetCount(data: CodexUsageResponse): number | null {
+  const raw = asObject(data.rate_limit_reset_credits)?.available_count;
+  return typeof raw === "number" && Number.isInteger(raw) && raw >= 0 ? raw : null;
+}
+
 export function formatResetCountdown(seconds: number | null): string | null {
   if (typeof seconds !== "number" || !Number.isFinite(seconds)) return null;
   const total = Math.max(0, Math.round(seconds));
@@ -236,6 +243,7 @@ export function parseUsageSnapshot(
     fiveHourResetInSeconds: weeklyOnly ? null : getResetSeconds(primaryWindow, now),
     sevenDayResetInSeconds: getResetSeconds(weeklyOnly ? primaryWindow : secondaryWindow, now),
     isLimited: bucket?.limit_reached === true || bucket?.allowed === false,
+    bankedResets: readBankedResetCount(data),
   };
 }
 
@@ -247,7 +255,7 @@ export function formatPercent(value: number | null): string {
 
 export function formatUsageSnapshot(
   snapshot: UsageSnapshot,
-  options: { showResetTimes: boolean },
+  options: { showResetTimes: boolean; showBankedResets?: boolean },
   now = Date.now(),
 ): string {
   const windows = [
@@ -283,7 +291,14 @@ export function formatUsageSnapshot(
         )
         .filter((value): value is string => value !== null)
     : [];
-  return `Usage: ${usage}${resets.length ? ` · ${resets.join(" · ")}` : ""}`;
+  const banked =
+    options.showBankedResets === false ? null : formatBankedResetsSuffix(snapshot.bankedResets);
+  return `Usage: ${usage}${resets.length ? ` · ${resets.join(" · ")}` : ""}${banked ? ` · ${banked}` : ""}`;
+}
+
+export function formatBankedResetsSuffix(count: number | null): string | null {
+  if (typeof count !== "number" || !Number.isInteger(count) || count <= 0) return null;
+  return `${count} banked reset${count === 1 ? "" : "s"}`;
 }
 
 function remainingResetSeconds(