opencode-ufr 0.2.12 → 0.2.14

package/dist/tui.js

@@ -1,5 +1,7 @@
 // @bun
 // src/plugin/tui.staged.build.js
+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";
@@ -101,16 +103,24 @@ 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)
+  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 [status, setStatus] = createSignal(null);
   let busy = false;
@@ -139,7 +149,8 @@ function RatesLine(props) {
     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() {
@@ -153,6 +164,7 @@ function RatesLine(props) {
         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;
         })()
       }), (() => {

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.12",
+  "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

@@ -11,6 +11,9 @@ export type KeySnapshot = {
   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
 }
 
@@ -23,6 +26,9 @@ type Slot = KeyInfo & {
   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 }[]
@@ -115,14 +121,16 @@ export class KeyPool {
   }
 
   /**
-   * 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.
+   * 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): void {
+  onBudgetExhausted(alias: string, spend?: number, limit?: number): void {
     const s = this.find(alias)
     if (!s) return
     const now = this.o.now()
@@ -130,6 +138,8 @@ export class KeyPool {
     // 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 {
@@ -146,8 +156,12 @@ export class KeyPool {
       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.
+      // 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

@@ -247,6 +247,13 @@ export class Router {
         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()
@@ -324,12 +331,20 @@ export class Router {
           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")
+          // 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",
-            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`,
+            `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
@@ -404,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,12 +1,15 @@
 /**
+ * @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 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),
+ * 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"
@@ -17,6 +20,7 @@ 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
@@ -31,6 +35,10 @@ type KeyStatus = {
   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. */
@@ -56,19 +64,33 @@ function fmtMoney(v: number): string {
 /**
  * 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
+ * `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 {
-  const spend = s.spendToday?.[k.alias] ?? 0
-  let line = `${k.alias} ${fmtMoney(spend)}/${fmtMoney(s.dailyBudgetUsd ?? 0)}`
-  if (k.invalid) line += " invalid"
+  // 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 [status, setStatus] = createSignal<Status | null>(null)
   let busy = false
@@ -95,11 +117,19 @@ function RatesLine(props: { paths: Paths }) {
   const label = () => {
     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={status()}>
-      <For each={status()!.keys ?? []}>{(k) => <text>{keyLine(k, status()!)}</text>}</For>
+      <For each={status()!.keys ?? []}>
+        {(k) => (
+          <text fg={keyColor(k)}>{keyLine(k, status()!)}</text>
+        )}
+      </For>
       <text>{label()}</text>
     </Show>
   )