opencode-ufr 0.2.11 → 0.2.12

package/dist/tui.js

@@ -1,10 +1,11 @@
 // @bun
 // src/plugin/tui.staged.build.js
-import { createComponent as _$createComponent } from "@opentui/solid";
 import { insert as _$insert } from "@opentui/solid";
 import { createElement as _$createElement } from "@opentui/solid";
+import { createComponent as _$createComponent } from "@opentui/solid";
+import { memo as _$memo } from "@opentui/solid";
 import { Plugin } from "@opencode/plugin/tui";
-import { createSignal, onCleanup, onMount, Show } from "solid-js";
+import { For, Show, createSignal, onCleanup, onMount } from "solid-js";
 
 // src/shared/fs.ts
 import { mkdir, readFile, rename, rm, writeFile } from "fs/promises";
@@ -96,8 +97,22 @@ var POLL_MS = 1000;
 function fmtTokens(v) {
   return v >= 1000 ? `${(v / 1000).toFixed(1)}k` : String(v);
 }
+function fmtMoney(v) {
+  return `$${v.toFixed(2)}`;
+}
+function keyLine(k, s) {
+  const spend = s.spendToday?.[k.alias] ?? 0;
+  let line = `${k.alias} ${fmtMoney(spend)}/${fmtMoney(s.dailyBudgetUsd ?? 0)}`;
+  if (k.invalid)
+    line += " invalid";
+  else if (k.blockedBy === "budget")
+    line += " budget";
+  else if (k.blockedBy === "rate")
+    line += " rate";
+  return line;
+}
 function RatesLine(props) {
-  const [rates, setRates] = createSignal(null);
+  const [status, setStatus] = createSignal(null);
   let busy = false;
   const poll = async () => {
     if (busy)
@@ -106,11 +121,10 @@ function RatesLine(props) {
     try {
       const res = await daemonRequest(props.paths, (u, i) => fetch(u, i), "/v1/_status");
       if (!res?.ok) {
-        setRates(null);
+        setStatus(null);
         return;
       }
-      const j = await res.json();
-      setRates(j.rates ?? null);
+      setStatus(await res.json());
     } finally {
       busy = false;
     }
@@ -122,19 +136,30 @@ function RatesLine(props) {
   });
   onCleanup(() => clearInterval(timer));
   const label = () => {
-    const r = rates();
+    const r = status()?.rates;
     if (!r)
       return null;
     return `UFR ${r.reqPerSec} req/s \xB7 ${fmtTokens(r.tokensOutPerSec)} tok/s out \xB7 ${fmtTokens(r.tokensInPerSec)} tok/s in`;
   };
   return _$createComponent(Show, {
     get when() {
-      return label();
+      return status();
     },
     get children() {
-      var _el$ = _$createElement("text");
-      _$insert(_el$, label);
-      return _el$;
+      return [_$createComponent(For, {
+        get each() {
+          return status().keys ?? [];
+        },
+        children: (k) => (() => {
+          var _el$2 = _$createElement("text");
+          _$insert(_el$2, () => keyLine(k, status()));
+          return _el$2;
+        })()
+      }), (() => {
+        var _el$ = _$createElement("text");
+        _$insert(_el$, label);
+        return _el$;
+      })()];
     }
   });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-ufr",
-  "version": "0.2.11",
+  "version": "0.2.12",
   "description": "Uni Freiburg (UFR) Open WebUI models in opencode — local gateway with key pool, UFR-aware rate limiting, circuit breaker and fallbacks",
   "license": "MIT",
   "type": "module",

package/src/daemon/keypool.ts

@@ -1,9 +1,18 @@
+import { startOfLocalDay } from "../shared/time"
 import { SlidingWindow } from "./window"
 
 export type KeyInfo = { alias: string; secret: string }
 export type Acquired = { kind: "ok"; alias: string; secret: string; waitMs: number; at: number }
 export type NotAcquired = { kind: "none"; reason: "no_keys" | "all_tried" | "exhausted"; retryAfterMs: number }
-export type KeySnapshot = { alias: string; used: number; cap: number; blockedForMs: number; invalid: boolean }
+export type KeySnapshot = {
+  alias: string
+  used: number
+  cap: number
+  blockedForMs: number
+  /** Why the key is blocked right now: a daily-budget 429 or a bucket 429; null when usable. */
+  blockedBy: "budget" | "rate" | null
+  invalid: boolean
+}
 
 /** A 401 can be transient (portal hiccup, short-lived token rotation): the key
  *  is skipped for this long, then retried — instead of being dead until restart. */
@@ -12,6 +21,8 @@ export const INVALID_KEY_TTL_MS = 10 * 60_000
 type Slot = KeyInfo & {
   window: SlidingWindow
   blockedUntil: number
+  /** What blocked the key: a daily-budget 429 or a bucket 429 (null until one fires). */
+  blockedBy: "budget" | "rate" | null
   /** Until when the key is considered invalid (0 = valid); a transient 401 expires. */
   invalidUntil: number
   recent429: { at: number; model: string }[]
@@ -29,6 +40,7 @@ export class KeyPool {
       ...k,
       window: new SlidingWindow({ cap: o.cap, windowMs: o.windowMs, maxWaitMs: o.maxWaitMs, now: o.now }),
       blockedUntil: 0,
+      blockedBy: null,
       invalidUntil: 0,
       recent429: [],
     }))
@@ -92,10 +104,34 @@ export class KeyPool {
     const acrossModels = new Set(s.recent429.map((e) => e.model)).size >= 2
     if (usedHalf || acrossModels) {
       // UFR frees a slot at first admission + window; rejected calls do not count.
-      s.blockedUntil = Math.max(s.blockedUntil, (s.window.oldest() ?? now) + this.o.windowMs, now + 1_000)
+      const until = Math.max(s.blockedUntil, (s.window.oldest() ?? now) + this.o.windowMs, now + 1_000)
+      // Only the block that actually extends the deadline owns the cause: a rate
+      // block on top of a longer budget block must not relabel it "rate".
+      if (until > s.blockedUntil) {
+        s.blockedUntil = until
+        s.blockedBy = "rate"
+      }
     }
   }
 
+  /**
+   * UFR's daily-budget 429 (the `budget_exceeded` marker) means this key's $ cap
+   * is spent for the day: block it until the next local midnight — UFR's own
+   * reset time is unknown, and midnight is the same assumption the spend-today
+   * stats already make. A bucket 429 carries the identical body (2026-10-07), so
+   * a merely rate-limited key can end up budget-blocked; that only costs until
+   * midnight and is safe. Never shortens an existing block.
+   */
+  onBudgetExhausted(alias: string): void {
+    const s = this.find(alias)
+    if (!s) return
+    const now = this.o.now()
+    // startOfLocalDay(now) at exactly midnight would be now itself — +24h always
+    // lands in the future, so the block can never be already expired.
+    s.blockedUntil = Math.max(s.blockedUntil, startOfLocalDay(now) + 24 * 3_600_000)
+    s.blockedBy = "budget"
+  }
+
   onInvalid(alias: string): void {
     const s = this.find(alias)
     if (s) s.invalidUntil = this.o.now() + INVALID_KEY_TTL_MS
@@ -108,6 +144,10 @@ export class KeyPool {
       used: s.window.inWindow(),
       cap: this.o.cap,
       blockedForMs: Math.max(0, s.blockedUntil - now),
+      // The cause is derived from the current time, not stored state: a block
+      // whose deadline has passed reports as unblocked even if the slot still
+      // carries a stale blockedBy.
+      blockedBy: s.blockedUntil > now ? s.blockedBy : null,
       invalid: s.invalidUntil > now,
     }))
   }

package/src/daemon/router.ts

@@ -238,8 +238,12 @@ export class Router {
         return Response.json(json)
       }
       case "rate_limited":
+        // Same body as a bucket 429 — the `budget_exceeded` marker is the only
+        // tell (text/plain, 2026-09-28); a merely rate-limited key that carries
+        // it is budget-blocked until midnight, which is safe.
+        if (r.body.includes("budget_exceeded")) this.d.keys.onBudgetExhausted(k.alias)
+        else this.d.keys.onRateLimited(k.alias, group)
         // A wall on the exact model the script asked for — honest breaker signal.
-        this.d.keys.onRateLimited(k.alias, group)
         this.d.breakers.get(group).onRateLimited()
         this.record(t0, group, k.alias, 429, null, 1, "upstream_rate_limited", true)
         return new Response(r.body, { status: 429, headers: { "content-type": "application/json" } })
@@ -318,8 +322,15 @@ export class Router {
         if (k.reason === "exhausted") {
           breakers.get(model).onOtherFailure() // model's probe (if any) got no outcome
           if (rateLimitedHere) giveUp(model) // the wall counts toward the breaker threshold even here
+          // The two messages tell the user very different remedies: wait a minute
+          // vs. wait for midnight. The pool alone cannot tell why a key is
+          // blocked, so read it off the snapshot's budget marker.
+          const budgeted = keys.snapshot().some((s) => s.blockedBy === "budget")
           return fail(429, "key_pool_exhausted",
-            `every UFR key is at its limit of ${config.limits.keyRpm} requests per ${config.limits.keyWindowS} s`, k.retryAfterMs)
+            budgeted
+              ? "a UFR key has exhausted its daily budget (resets at local midnight)"
+              : `every UFR key is at its limit of ${config.limits.keyRpm} requests per ${config.limits.keyWindowS} s`,
+            k.retryAfterMs)
         }
         // all_tried: every usable key already failed on this model
         if (rateLimitedHere) giveUp(model)
@@ -376,7 +387,12 @@ export class Router {
           this.d.onUpstream?.(true, "")
           return { ok: true, response: r.response, model, keyAlias: k.alias, attempts, upstreamAbort: upstreamAbort ?? undefined }
         case "rate_limited":
-          keys.onRateLimited(k.alias, model)
+          // UFR's daily-budget 429 and its bucket 429 share one body — the
+          // `budget_exceeded` marker is the only tell (text/plain, 2026-09-28).
+          // A bucket 429 carrying it budget-blocks a merely rate-limited key:
+          // acceptable, that clears at midnight too.
+          if (r.body.includes("budget_exceeded")) keys.onBudgetExhausted(k.alias)
+          else keys.onRateLimited(k.alias, model)
           rateLimitedHere = true
           if (tried.size >= Math.min(2, keys.size)) {
             giveUp(model)

package/src/plugin/tui.tsx

@@ -3,13 +3,14 @@
  * opencode's CLI because package.json exports "./tui" — the server plugin
  * (index.ts) needs no changes for this to load.
  *
- * Polls GET /v1/_status every second and appends one line to the right
- * panel: req/s and tok/s over the gateway's rolling 60 s window. Status
- * polls don't reset the daemon's idle timer (see server.ts), so leaving the
- * panel open never keeps the gateway alive.
+ * Polls GET /v1/_status every second and appends lines to the right panel:
+ * one compact line per pool key (alias, $ spent today, daily budget in USD,
+ * why it is blocked) above the req/s and tok/s line over the gateway's rolling 60 s
+ * window. Status polls don't reset the daemon's idle timer (see server.ts),
+ * so leaving the panel open never keeps the gateway alive.
  */
 import { Plugin } from "@opencode/plugin/tui"
-import { createSignal, onCleanup, onMount, Show } from "solid-js"
+import { For, Show, createSignal, onCleanup, onMount } from "solid-js"
 import { daemonRequest } from "../shared/daemon-client"
 import { resolvePaths, type Paths } from "../shared/paths"
 
@@ -22,6 +23,24 @@ type Rates = {
   tokensOutPerSec: number
 }
 
+/** Per-key line of GET /v1/_status (KeySnapshot in keypool.ts). */
+type KeyStatus = {
+  alias: string
+  used: number
+  cap: number
+  blockedForMs: number
+  blockedBy: "budget" | "rate" | null
+  invalid: boolean
+}
+
+/** GET /v1/_status — only the fields the sidebar consumes. */
+type Status = {
+  rates?: Rates
+  keys?: KeyStatus[]
+  spendToday?: Record<string, number>
+  dailyBudgetUsd?: number
+}
+
 const POLL_MS = 1_000
 
 /** 6743 → "6.7k" — prompt traffic through opencode dwarfs output. */
@@ -29,8 +48,29 @@ function fmtTokens(v: number): string {
   return v >= 1000 ? `${(v / 1000).toFixed(1)}k` : String(v)
 }
 
+/** 0.4166 → "$0.42" — money is always shown with 2 decimals. */
+function fmtMoney(v: number): string {
+  return `$${v.toFixed(2)}`
+}
+
+/**
+ * One compact line per pool key: `k1 $0.42/$20.00`, with the reason appended when
+ * the key is unusable — `budget` (daily cap hit, resets at local midnight),
+ * `rate` (bucket 429 cool-down) or `invalid` (transient 401). A key with no
+ * entry in spendToday renders as $0.00; healthy keys render too, the user
+ * asked to see every key.
+ */
+function keyLine(k: KeyStatus, s: Status): string {
+  const spend = s.spendToday?.[k.alias] ?? 0
+  let line = `${k.alias} ${fmtMoney(spend)}/${fmtMoney(s.dailyBudgetUsd ?? 0)}`
+  if (k.invalid) line += " invalid"
+  else if (k.blockedBy === "budget") line += " budget"
+  else if (k.blockedBy === "rate") line += " rate"
+  return line
+}
+
 function RatesLine(props: { paths: Paths }) {
-  const [rates, setRates] = createSignal<Rates | null>(null)
+  const [status, setStatus] = createSignal<Status | null>(null)
   let busy = false
   const poll = async () => {
     if (busy) return
@@ -38,11 +78,10 @@ function RatesLine(props: { paths: Paths }) {
     try {
       const res = await daemonRequest(props.paths, (u, i) => fetch(u, i), "/v1/_status")
       if (!res?.ok) {
-        setRates(null) // daemon down, restarting or new token — the line hides
+        setStatus(null) // daemon down, restarting or new token — the lines hide
         return
       }
-      const j = (await res.json()) as { rates?: Rates }
-      setRates(j.rates ?? null)
+      setStatus((await res.json()) as Status)
     } finally {
       busy = false
     }
@@ -54,12 +93,13 @@ function RatesLine(props: { paths: Paths }) {
   })
   onCleanup(() => clearInterval(timer))
   const label = () => {
-    const r = rates()
+    const r = status()?.rates
     if (!r) return null
     return `UFR ${r.reqPerSec} req/s · ${fmtTokens(r.tokensOutPerSec)} tok/s out · ${fmtTokens(r.tokensInPerSec)} tok/s in`
   }
   return (
-    <Show when={label()}>
+    <Show when={status()}>
+      <For each={status()!.keys ?? []}>{(k) => <text>{keyLine(k, status()!)}</text>}</For>
       <text>{label()}</text>
     </Show>
   )