opencode-auth-load-balancer 0.9.1 → 0.10.0

package/tui/auth-load-balancer-scoring.ts

@@ -48,6 +48,14 @@ export interface ScoreWindow {
   resetAt: number
 }
 
+/** Codex credits, which keep an account serving once its plan windows are exhausted. */
+export interface ScoreCredits {
+  hasCredits: boolean
+  unlimited: boolean
+  /** The credit spending cap is hit: the balance cannot be spent. */
+  limitReached?: boolean
+}
+
 /**
  * The slice of an account the scoring reads. The server's full `PoolAccount` and the
  * TUI's parsed-pool account both satisfy this (the TUI normalizes its looser JSON into
@@ -58,6 +66,7 @@ export interface ScoreAccount {
     hourly: ScoreWindow | null
     weekly: ScoreWindow | null
   }
+  credits?: ScoreCredits
   cooldownUntil: number
   disabledReason: string | null
 }
@@ -200,7 +209,30 @@ export function isExhausted(
   return maxUtil(account, now) >= cfg.exhaustedAt
 }
 
-/** Available = not disabled, not in cooldown, and not exhausted. */
+/**
+ * Whether credits keep the account serving past exhausted plan windows. Same test as
+ * Codex itself (`unlimited || has_credits`, the backend then bills the credits), unless
+ * the account's credit spending cap is hit.
+ */
+export function hasCreditHeadroom(account: ScoreAccount): boolean {
+  const credits = account.credits
+  return (
+    !!credits &&
+    !credits.limitReached &&
+    (credits.unlimited || credits.hasCredits)
+  )
+}
+
+/** Plan headroom, or credits to spend once the plan is exhausted. */
+export function hasHeadroom(
+  account: ScoreAccount,
+  cfg: ScoreConfig,
+  now: number,
+): boolean {
+  return !isExhausted(account, cfg, now) || hasCreditHeadroom(account)
+}
+
+/** Available = not disabled, not in cooldown, and with plan or credit headroom. */
 export function isAvailable(
   account: ScoreAccount,
   cfg: ScoreConfig,
@@ -208,8 +240,7 @@ export function isAvailable(
 ): boolean {
   if (account.disabledReason) return false
   if (account.cooldownUntil > now) return false
-  if (isExhausted(account, cfg, now)) return false
-  return true
+  return hasHeadroom(account, cfg, now)
 }
 
 /**
@@ -325,20 +356,28 @@ export function scoreAccount(
  * Sort comparator shared by `src/status.ts` and the TUI sidebar ranking pipeline, so the
  * dashboard's *ordering* rule can never silently drift from what the server displays —
  * the same single-source guarantee `scoreAccount` provides for the *formula*. Both
- * pipelines map each account into `{ available, score, weeklyUtil }` (the per-pipeline
- * `weeklyUtil` field is computed locally — `src/status.ts` uses the raw stored value to
- * keep tie-breaking deterministic for cooling-down accounts, the TUI uses `utilOf` to
- * discard a window that already reset) and pass that shape here:
+ * pipelines map each account into `{ available, onCredits, score, weeklyUtil }` (the
+ * per-pipeline `weeklyUtil` field is computed locally — `src/status.ts` uses the raw
+ * stored value to keep tie-breaking deterministic for cooling-down accounts, the TUI uses
+ * `utilOf` to discard a window that already reset) and pass that shape here:
  *
  *   - available accounts come first (they're the only ones the scheduler will pick);
- *   - among available accounts, higher `score` wins (matches `selectAccount`'s pick);
+ *   - among available accounts, plan headroom comes before serving on credits alone
+ *     (`onCredits`: credits cost money), then higher `score` wins (matches
+ *     `selectAccount`'s pick);
  *   - among unavailable accounts, lower `weeklyUtil` wins — the "least bad cooling-down
  *     account" surfaces first so a forced fall-through stays predictable.
  */
 export function compareRanked<
-  T extends { available: boolean; score: number; weeklyUtil: number },
+  T extends {
+    available: boolean
+    onCredits: boolean
+    score: number
+    weeklyUtil: number
+  },
 >(x: T, y: T): number {
   if (x.available !== y.available) return x.available ? -1 : 1
-  if (x.available) return y.score - x.score
-  return x.weeklyUtil - y.weeklyUtil
+  if (!x.available) return x.weeklyUtil - y.weeklyUtil
+  if (x.onCredits !== y.onCredits) return x.onCredits ? 1 : -1
+  return y.score - x.score
 }

package/tui/auth-load-balancer-tui.logic.ts

@@ -18,6 +18,7 @@ import {
   isExhausted,
   loadScoreConfig,
   type ScoreAccount,
+  type ScoreCredits,
   type ScoreWindow,
 } from './auth-load-balancer-scoring'
 
@@ -51,11 +52,18 @@ export interface UsageWindow {
   utilization?: number
   resetAt?: number
 }
+export interface UsageCredits {
+  hasCredits?: boolean
+  unlimited?: boolean
+  balance?: number
+  limitReached?: boolean
+}
 export interface PoolAccount {
   id: string
   providerID: string
   label: string
   usage?: { weekly?: UsageWindow | null; hourly?: UsageWindow | null } | null
+  credits?: UsageCredits | null
   cooldownUntil?: number
   /** tier name → epoch ms until that model tier's cap resets (tier requests steer around the account until then). */
   modelCooldownsUntil?: Record<string, number> | null
@@ -445,17 +453,56 @@ export function toScoreWindow(
       }
     : null
 }
+/** The raw credits when both flags are booleans (as the server's store requires), else undefined. */
+function creditsOf(
+  a: PoolAccount,
+): (ScoreCredits & { balance?: number }) | undefined {
+  const c = a.credits
+  if (
+    !isPlainRecordValue(c) ||
+    typeof c?.hasCredits !== 'boolean' ||
+    typeof c.unlimited !== 'boolean'
+  )
+    return undefined
+  return {
+    hasCredits: c.hasCredits,
+    unlimited: c.unlimited,
+    ...(isFiniteNumber(c.balance) ? { balance: c.balance } : {}),
+    ...(c.limitReached === true ? { limitReached: true } : {}),
+  }
+}
+
 export function toScore(a: PoolAccount): ScoreAccount {
+  const credits = creditsOf(a)
   return {
     usage: {
       hourly: toScoreWindow(a.usage?.hourly),
       weekly: toScoreWindow(a.usage?.weekly),
     },
+    ...(credits ? { credits } : {}),
     cooldownUntil: isFiniteNumber(a.cooldownUntil) ? a.cooldownUntil : 0,
     disabledReason: a.disabledReason ?? null,
   }
 }
 
+/**
+ * The credits an exhausted account has left: `credits 12.5`, `credits
+ * unlimited`, `credits available` (no amount reported), `no credits`,
+ * `credit limit reached` (a spending cap stops them); '' when the provider
+ * never reported credits. NOTE: copy of `src/status.ts`'s `creditsText` (the
+ * TUI runtime cannot import `src/`).
+ */
+export function creditsText(a: PoolAccount): string {
+  const credits = creditsOf(a)
+  if (!credits) return ''
+  if (credits.limitReached) return 'credit limit reached'
+  if (credits.unlimited) return 'credits unlimited'
+  if (!credits.hasCredits) return 'no credits'
+  return credits.balance === undefined
+    ? 'credits available'
+    : `credits ${Math.round(credits.balance * 100) / 100}`
+}
+
 /**
  * The account the CURRENT opencode session is pinned to for a provider — i.e.
  * what THIS session is actually using — read from the pool's session map. The
@@ -565,13 +612,14 @@ export function stateOf(
   sa: ScoreAccount,
   tiers: [string, number][],
   now: number,
+  credits = '',
 ): string {
   if (sa.disabledReason)
     return sa.disabledReason === MANUAL_DISABLED_REASON
       ? 'disabled'
       : 're-login'
   if (sa.cooldownUntil > now) return `cooldown ${until(sa.cooldownUntil, now)}`
-  if (isExhausted(sa, cfg, now)) return 'full'
+  if (isExhausted(sa, cfg, now)) return credits ? `full · ${credits}` : 'full'
   // A model-tier limit keeps the account usable (other models + downgrade),
   // so it annotates rather than sidelines — mirrors src/status.ts.
   if (tiers.length > 0)

package/tui/auth-load-balancer-tui.view.tsx

@@ -27,6 +27,7 @@ import {
   compareRanked,
   displayUtil,
   isAvailable,
+  isExhausted,
   scoreAccount,
   utilOf,
 } from './auth-load-balancer-scoring'
@@ -37,6 +38,7 @@ import {
   clearReloginTargetInPool,
   compareAscii,
   credentialTag,
+  creditsText,
   deleteFromPool,
   discardSyncIntent,
   hasLostLogin,
@@ -279,6 +281,7 @@ function SidebarPanel(props: {
             a,
             sa,
             available,
+            onCredits: available && isExhausted(sa, cfg, now),
             score: available
               ? scoreAccount(sa, cfg, now)
               : Number.NEGATIVE_INFINITY,
@@ -308,7 +311,10 @@ function SidebarPanel(props: {
           // Raw reads are finiteness-guarded inside tierResets: a hand-edited
           // `1e999` entry (Infinity via JSON.parse) would otherwise render its
           // tier annotation forever until the server heals the file.
-          state: [stateOf(sa, tierResets(a, now), now), ...rowWarnings(a, now)]
+          state: [
+            stateOf(sa, tierResets(a, now), now, creditsText(a)),
+            ...rowWarnings(a, now),
+          ]
             .filter(Boolean)
             .join(' · '),
           manuallyDisabled: a.disabledReason === MANUAL_DISABLED_REASON,