opencode-ufr 0.2.11 → 0.2.14

package/dist/tui.js

@@ -1,10 +1,13 @@
 // @bun
 // src/plugin/tui.staged.build.js
-import { createComponent as _$createComponent } from "@opentui/solid";
+import { setProp as _$setProp } from "@opentui/solid";
+import { effect as _$effect } 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 +99,30 @@ 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 = k.budgetSpend ?? s.spendToday?.[k.alias] ?? 0;
+  const limit = k.budgetLimit ?? s.dailyBudgetUsd ?? 0;
+  let line = `${k.alias} ${fmtMoney(spend)}/${fmtMoney(limit)}`;
+  if (k.budgetSpend !== undefined)
+    line += " budget";
+  else if (k.invalid)
+    line += " invalid";
+  else if (k.blockedBy === "budget")
+    line += " budget";
+  else if (k.blockedBy === "rate")
+    line += " rate";
+  if (k.budgetSpend !== undefined && k.invalid)
+    line += " invalid";
+  return line;
+}
+function keyColor(k) {
+  return k.blockedBy === "budget" ? "red" : undefined;
+}
 function RatesLine(props) {
-  const [rates, setRates] = createSignal(null);
+  const [status, setStatus] = createSignal(null);
   let busy = false;
   const poll = async () => {
     if (busy)
@@ -106,11 +131,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 +146,32 @@ 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`;
+    const perMin = (perSec) => Math.round(perSec * 60);
+    return `UFR ${r.requests} req/min \xB7 ${fmtTokens(perMin(r.tokensOutPerSec))} tok/min out \xB7 ${fmtTokens(perMin(r.tokensInPerSec))} tok/min 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()));
+          _$effect((_$p) => _$setProp(_el$2, "fg", keyColor(k), _$p));
+          return _el$2;
+        })()
+      }), (() => {
+        var _el$ = _$createElement("text");
+        _$insert(_el$, label);
+        return _el$;
+      })()];
     }
   });
 }

package/models.json

@@ -1,6 +1,6 @@
 {
   "schema": 1,
-  "updated": "2026-10-05",
+  "updated": "2026-10-07",
   "defaults": {
     "context": 131072,
     "max_output": 16384
@@ -190,6 +190,38 @@
         "cache_write": 3.125
       }
     },
+    "openai/gpt-6-astra-llmlb": {
+      "context": 1050000,
+      "max_output": 128000,
+      "price": {
+        "input": 10,
+        "output": 50,
+        "cache_write": 12.5
+      },
+      "note": "context/max_output from OpenAI's model page (2026-10-07), not probed at UFR; cache_read unknown — billed at full input"
+    },
+    "openai/gpt-6.1-sol-llmlb": {
+      "context": 1050000,
+      "max_output": 128000,
+      "price": {
+        "input": 2,
+        "output": 10,
+        "cache_read": 0.1,
+        "cache_write": 2.5
+      },
+      "note": "context/max_output from OpenAI's model page (2026-10-07), not probed at UFR"
+    },
+    "openai/gpt-6-luna-llmlb": {
+      "context": 1050000,
+      "max_output": 128000,
+      "price": {
+        "input": 0.1,
+        "output": 0.5,
+        "cache_read": 0.01,
+        "cache_write": 0.125
+      },
+      "note": "context/max_output from OpenAI's model page (2026-10-07), not probed at UFR"
+    },
     "openai/gpt-5.3-codex-llmlb": {
       "context": 1000000,
       "price": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-ufr",
-  "version": "0.2.11",
+  "version": "0.2.14",
   "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,21 @@
+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
+  /** Parsed from UFR's budget body, only while budget-blocked and only when UFR named the numbers. */
+  budgetSpend?: number
+  budgetLimit?: number
+  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 +24,11 @@ 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
+  /** Spend/limit parsed from the last budget error, for the display; cleared with the block. */
+  budgetSpend?: number
+  budgetLimit?: number
   /** Until when the key is considered invalid (0 = valid); a transient 401 expires. */
   invalidUntil: number
   recent429: { at: number; model: string }[]
@@ -29,6 +46,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 +110,38 @@ 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 error (the `budget_exceeded` marker 429, or the 400
+   * `ExceededBudget` body since 2026-10-07) 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. When UFR's body named the
+   * numbers, they are kept for the display — and expire with the block.
+   */
+  onBudgetExhausted(alias: string, spend?: number, limit?: number): 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"
+    s.budgetSpend = spend
+    s.budgetLimit = limit
+  }
+
   onInvalid(alias: string): void {
     const s = this.find(alias)
     if (s) s.invalidUntil = this.o.now() + INVALID_KEY_TTL_MS
@@ -108,6 +154,14 @@ 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. The parsed spend/limit are display values of
+      // the block — they must not outlive it either.
+      blockedBy: s.blockedUntil > now ? s.blockedBy : null,
+      ...(s.blockedUntil > now && s.blockedBy === "budget" && s.budgetSpend !== undefined
+        ? { budgetSpend: s.budgetSpend, budgetLimit: s.budgetLimit }
+        : {}),
       invalid: s.invalidUntil > now,
     }))
   }

package/src/daemon/router.ts

@@ -238,11 +238,22 @@ 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" } })
+      case "budget_exhausted":
+        // UFR named this key over budget (400 ExceededBudget, 2026-10-07): block
+        // it until midnight and hand the raw 400 back — the relay is a raw pipe.
+        this.d.keys.onBudgetExhausted(k.alias, r.spend, r.limit)
+        this.d.breakers.get(group).onOtherFailure()
+        this.record(t0, group, k.alias, r.status, null, 1, "upstream_budget_exhausted", true)
+        return new Response(r.body, { status: r.status, headers: { "content-type": "application/json" } })
       case "auth_invalid":
         this.d.keys.onInvalid(k.alias)
         this.d.breakers.get(group).onOtherFailure()
@@ -318,8 +329,23 @@ 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. When UFR's
+          // budget bodies named the numbers, show per-key spend — the reset time
+          // is still unknown here (the probe, not the error body, knows it).
+          const blocked = keys.snapshot().filter((s) => s.blockedBy === "budget")
+          if (blocked.length > 0) {
+            const withSpend = blocked.filter((s) => s.budgetSpend !== undefined)
+            return fail(429, "key_pool_exhausted",
+              withSpend.length > 0
+                ? `UFR key(s) over budget: ${withSpend.map((s) => `${s.alias} $${s.budgetSpend!.toFixed(2)}`).join(", ")} (limit $${(withSpend[0]!.budgetLimit ?? 0).toFixed(2)}) — reset time unknown, probing`
+                : "a UFR key has exhausted its daily budget (resets at local midnight)",
+              k.retryAfterMs)
+          }
           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)
+            `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 +402,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)
@@ -388,6 +419,15 @@ export class Router {
             }
           }
           continue
+        case "budget_exhausted":
+          // A daily-budget error (400 ExceededBudget, 2026-10-07) is key-specific:
+          // do NOT giveUp(model) — the breaker must not wall a model every other
+          // key can still answer — and do not advance the model either: the next
+          // acquire picks an untried key, and once every key is budget-blocked
+          // acquire reports exhausted, which surfaces the budget message below.
+          breakers.get(model).onOtherFailure() // a budget 400 is no wall evidence
+          keys.onBudgetExhausted(k.alias, r.spend, r.limit)
+          continue
         case "auth_invalid":
           keys.onInvalid(k.alias)
           continue

package/src/daemon/upstream.ts

@@ -4,6 +4,7 @@ import type { Transport } from "./transport"
 export type UpstreamResult =
   | { kind: "ok"; response: Response }
   | { kind: "rate_limited"; status: number; body: string }
+  | { kind: "budget_exhausted"; status: number; body: string; spend?: number; limit?: number }
   | { kind: "context_overflow"; status: number; body: string }
   | { kind: "auth_invalid"; status: number; body: string }
   | { kind: "unreachable"; message: string }
@@ -11,6 +12,9 @@ export type UpstreamResult =
 
 const CONTEXT_RE = /maximum context length|max input tokens|context length|context window|too many tokens|prompt is too long/i
 
+/** UFR's budget body names the numbers: `... Spend=24.0425389, Budget=20.0`. */
+const BUDGET_RE = /Spend=([0-9.]+),\s*Budget=([0-9.]+)/
+
 /** One call to UFR. Throws only if the caller's own signal aborted. */
 export async function callUpstream(o: {
   transport: Transport
@@ -72,6 +76,14 @@ export async function callUpstream(o: {
   }
   if (res.ok) return { kind: "ok", response: res }
   const body = await res.text()
+  // The daily-budget error carries the `ExceededBudget` marker in its detail
+  // (400 application/json since 2026-10-07, previously a 429 marker). It must
+  // win over the generic error fallthrough on any status, and over context
+  // overflow — a budget body never names a context limit.
+  if (body.includes("ExceededBudget")) {
+    const m = BUDGET_RE.exec(body)
+    return { kind: "budget_exhausted", status: res.status, body, spend: m?.[1] ? Number(m[1]) : undefined, limit: m?.[2] ? Number(m[2]) : undefined }
+  }
   if (res.status === 429) return { kind: "rate_limited", status: 429, body }
   if (res.status === 401 || res.status === 403) return { kind: "auth_invalid", status: res.status, body }
   if ((res.status === 400 || res.status === 413) && CONTEXT_RE.test(body)) return { kind: "context_overflow", status: res.status, body }

package/src/plugin/tui.tsx

@@ -1,27 +1,54 @@
 /**
+ * @jsxImportSource @opentui/solid
+ *
  * TUI contribution: live gateway throughput in opencode's sidebar. Loaded by
  * 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 or the real spend from
+ * UFR's budget error, daily budget in USD, why it is blocked) above the
+ * per-minute rates line (raw counts of 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"
 
 /** The rates block of GET /v1/_status (see StatusJson in daemon.ts). */
 type Rates = {
   windowMs: number
+  /** Raw window counts — a 60 s window, so these ARE the per-minute numbers. */
   requests: number
   reqPerSec: number
   tokensInPerSec: number
   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
+  /** Real spend/limit parsed from UFR's ExceededBudget error; present only
+   *  while a budget block with parsed data is active (see keypool.ts). */
+  budgetSpend?: number
+  budgetLimit?: number
+}
+
+/** 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 +56,43 @@ 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 blocked by
+ * the real ExceededBudget error shows UFR's parsed numbers instead of today's
+ * estimate: `k1 $24.04/$20.00 budget` — spend data is the more actionable info,
+ * so it wins over the `invalid` suffix (which is then just appended). 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 {
+  // Parsed budget numbers come straight from UFR's error body; the fallback is
+  // today's local spend estimate against the configured daily budget.
+  const spend = k.budgetSpend ?? s.spendToday?.[k.alias] ?? 0
+  const limit = k.budgetLimit ?? s.dailyBudgetUsd ?? 0
+  let line = `${k.alias} ${fmtMoney(spend)}/${fmtMoney(limit)}`
+  if (k.budgetSpend !== undefined) line += " budget"
+  else if (k.invalid) line += " invalid"
+  else if (k.blockedBy === "budget") line += " budget"
+  else if (k.blockedBy === "rate") line += " rate"
+  // Spend data outranks the transient-invalid suffix, but invalid stays visible.
+  if (k.budgetSpend !== undefined && k.invalid) line += " invalid"
+  return line
+}
+
+/** Budget-exhausted keys render red; everything else keeps the default color. */
+function keyColor(k: KeyStatus): string | undefined {
+  return k.blockedBy === "budget" ? "red" : undefined
+}
+
 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 +100,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 +115,21 @@ 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`
+    // The daemon's rates window is exactly 60 s, so the raw request count IS
+    // req/min; the per-second token numbers ×60 give the same window counts
+    // (daemon.ts rounds them, invisible at fmtTokens precision).
+    const perMin = (perSec: number) => Math.round(perSec * 60)
+    return `UFR ${r.requests} req/min · ${fmtTokens(perMin(r.tokensOutPerSec))} tok/min out · ${fmtTokens(perMin(r.tokensInPerSec))} tok/min in`
   }
   return (
-    <Show when={label()}>
+    <Show when={status()}>
+      <For each={status()!.keys ?? []}>
+        {(k) => (
+          <text fg={keyColor(k)}>{keyLine(k, status()!)}</text>
+        )}
+      </For>
       <text>{label()}</text>
     </Show>
   )