opencode-ufr 0.2.8 → 0.2.9

package/README.md

@@ -23,7 +23,7 @@ opencode plugin add opencode-ufr     # registers the plugin
 
 (or add `"plugins": ["opencode-ufr"]` to your `opencode.json` manually.)
 
-## Updating
+## Install
 
 opencode installs the plugin once into its cache and does not look for a newer
 version while that copy exists — restarting opencode alone keeps the old one.
@@ -34,7 +34,7 @@ and stop that server:
 ```bash
 bun add -g opencode-ufr@latest                      # update the `ufr` CLI
 rm -rf ~/.cache/opencode/npm/opencode-ufr@latest    # opencode's cached plugin copy
-pkill -f "opencode serve --service"                 # opencode's background server
+/restart in opencode eintippen                      # opencode's background server
 ```
 
 The next opencode start installs the latest version and replaces the old
@@ -207,10 +207,20 @@ the GitHub release after a maintainer approves the staged version with 2FA.
 
 ## Model data
 
-The gateway fetches `models.json` from this repository every 6 hours —
-context windows, prices, vision/tool flags, alias spellings and fallback
-order that UFR's own API doesn't expose or gets wrong. Fixes reach every
-user without a release.
+`models.json` ships with every release — context windows, prices,
+vision/tool flags, alias spellings and fallback order that UFR's own API
+doesn't expose or gets wrong. Fixes reach users with the next plugin update.
+
+Context windows are measured, not guessed: the `probe contexts` workflow
+(weekly, on demand, and after every release tag) sends one oversized — and
+therefore free, since UFR rejects it before pricing — request per model and
+commits the exact limit the server names back to `models.json` on main. Run
+it yourself with a stored key:
+
+```bash
+ufr context-probe            # report: measured context vs. models.json
+ufr context-probe --write    # also patch your local models.json
+```
 
 To contribute a measurement (a price, a context window, a missing alias),
 open a PR against `models.json` with the source of the measurement in a

package/models.json

@@ -1,6 +1,6 @@
 {
   "schema": 1,
-  "updated": "2026-10-02",
+  "updated": "2026-10-05",
   "defaults": {
     "context": 131072,
     "max_output": 16384
@@ -60,11 +60,12 @@
       "context": 256000
     },
     "qwen-3.5-397b-llmlb": {
-      "context": 262144,
+      "context": 1048576,
       "price": {
         "input": 0.1,
         "output": 0.1
-      }
+      },
+      "note": "context 1048576 probed live 2026-10-05 (probe-all-contexts)"
     },
     "qwen-3.6-27b-llmlb": {
       "context": 262144
@@ -139,12 +140,13 @@
       "context": 256000
     },
     "ufr/vision-complex": {
-      "context": 1048576,
+      "context": 262144,
       "vision": true,
       "price": {
         "input": 0.1,
         "output": 0.1
-      }
+      },
+      "note": "context 262144 probed live 2026-10-05 (probe-all-contexts)"
     },
     "ufr/vision-fast": {
       "context": 131044
@@ -219,6 +221,10 @@
         "output": 0.1
       },
       "note": "context 1048576 probed live 2026-10-02 (vLLM ContextWindowExceededError named the limit); prices from the UFR portal (Lokale Modelle)"
+    },
+    "kolibri-1-llmlb": {
+      "context": 262144,
+      "note": "context 262144 probed live 2026-10-05 (probe-all-contexts)"
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-ufr",
-  "version": "0.2.8",
+  "version": "0.2.9",
   "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/cli/context-probe.ts

@@ -0,0 +1,96 @@
+import { BUNDLED_MODELS, loadBundledModels } from "../daemon/catalog-source"
+import { applyProbeResults, formatProbeReport, probeAllContexts } from "../daemon/probe-all"
+import { VpnManager } from "../daemon/vpn/manager"
+import { loadConfig } from "../shared/config"
+import { VPN_PASS, VPN_USER } from "../shared/secrets"
+import type { CliDeps } from "./index"
+
+/**
+ * ufr context-probe — measure every UFR model's context limit with one of the
+ * stored keys. Rejected probes are free and don't consume the key's bucket;
+ * the report flags values that drifted from models.json. `--write` patches
+ * the local models.json copy (the repo copy when run from a checkout).
+ *
+ * `--vpn` routes the probes through the built-in Fortinet tunnel with the
+ * stored uni login (vpn-login/vpn-pass) — for off campus machines without
+ * their own VPN connection.
+ */
+export async function cmdContextProbe(d: CliDeps, args: string[]): Promise<number> {
+  const write = args.includes("--write")
+  const viaVpn = args.includes("--vpn")
+  const cfg = await loadConfig(d.paths.configFile)
+  const alias = cfg.keys[0]
+  if (!alias) {
+    d.io.err("no stored key — run `ufr connect` first\n")
+    return 2
+  }
+  const key = await d.secrets.get(alias)
+  if (!key) {
+    d.io.err(`key "${alias}" is configured but missing from the keyring\n`)
+    return 2
+  }
+  let fetch = d.fetch
+  let vpn: { stop(): Promise<void> } | null = null
+  if (viaVpn) {
+    const [user, pass] = await Promise.all([d.secrets.get(VPN_USER), d.secrets.get(VPN_PASS)])
+    if (!user || !pass) {
+      d.io.err("no stored uni login — run `ufr login` or `ufr connect --login …` first\n")
+      return 2
+    }
+    const manager = new VpnManager({
+      gateway: cfg.vpn.gateway,
+      upstreamHost: new URL(cfg.upstream.baseUrl).hostname,
+      baseUrl: cfg.upstream.baseUrl,
+      credentials: { user, pass },
+      mode: "always",
+      log: (m) => d.io.out(`${m}\n`),
+      fetch: d.fetch,
+    })
+    vpn = manager
+    fetch = manager.transport().fetch
+  }
+  const { file } = await loadBundledModels({})
+  d.io.out(`probing ${cfg.keys.length} key(s) via "${alias}"${viaVpn ? " through the built-in VPN" : ""} — rejected probes are free, this takes a few minutes\n`)
+  try {
+    const rows = await probeAllContexts({
+      baseUrl: cfg.upstream.baseUrl,
+      key,
+      fetch,
+      file,
+      log: (m) => d.io.out(`${m}\n`),
+    })
+    d.io.out("\n" + formatProbeReport(rows) + "\n")
+    return await report(d, file, rows, write)
+  } finally {
+    if (vpn) await vpn.stop()
+  }
+}
+
+async function report(
+  d: CliDeps,
+  file: Awaited<ReturnType<typeof loadBundledModels>>["file"],
+  rows: Awaited<ReturnType<typeof probeAllContexts>>,
+  write: boolean,
+): Promise<number> {
+  if (write) {
+    const date = new Date().toISOString().slice(0, 10)
+    const { file: updated, changed } = applyProbeResults(file, rows, date)
+    if (changed.length === 0) {
+      d.io.out("\nmodels.json is already current — nothing written\n")
+    } else {
+      await Bun.write(BUNDLED_MODELS, JSON.stringify(updated, null, 2) + "\n")
+      d.io.out(`\n${BUNDLED_MODELS} updated (${changed.length}):\n`)
+      for (const c of changed) d.io.out(`  ${c.id}: ${c.from ?? "—"} -> ${c.to}\n`)
+      d.io.out("\nIf this is a repo checkout: commit models.json (PR welcome per README).\n")
+      d.io.out("On an installed copy this patches your local file until the next plugin/CLI update;\n")
+      d.io.out("upstream fixes reach everyone through models.json PRs and releases.\n")
+    }
+  } else {
+    const needsUpdate = rows.filter((r) => r.how === "error-named" && r.probed !== null && r.probed !== r.known)
+    if (needsUpdate.length > 0) {
+      d.io.out("\nrun `ufr context-probe --write` to patch your local models.json, or PR the values upstream\n")
+      return 1
+    }
+  }
+  return 0
+}

package/src/cli/index.ts

@@ -4,6 +4,7 @@ import { type Paths, resolvePaths } from "../shared/paths"
 import { KeyringStore, type SecretStore } from "../shared/secrets"
 import { cmdCatalogDiff } from "./catalog"
 import { cmdConnect } from "./connect"
+import { cmdContextProbe } from "./context-probe"
 import { type Io, terminalIo } from "./io"
 import { cmdDisconnect, cmdKeys, cmdLogin } from "./keys"
 import { cmdStats } from "./stats"
@@ -32,6 +33,11 @@ const HELP = `ufr — opencode-ufr gateway
   ufr status                       gateway, keys, limits, breakers, spend today
   ufr stats [--days N]             requests, tokens and cost (default: today)
   ufr catalog diff                 UFR's model list vs. models.json
+  ufr context-probe [--write] [--vpn]
+                                   measure every model's context limit live
+                                   (rejected probes are free; --write patches
+                                   the local models.json; --vpn routes the
+                                   probes through the built-in tunnel)
   ufr stop                         stop the gateway (opencode starts it again)
 
 UFR needs the uni VPN off campus: https://wiki.uni-freiburg.de/rz/doku.php?id=vpn
@@ -78,6 +84,8 @@ export async function main(argv: string[], partial: Partial<CliDeps> = {}): Prom
         if (rest[0] === "diff") return await cmdCatalogDiff(d)
         d.io.err("usage: ufr catalog diff\n")
         return 2
+      case "context-probe":
+        return await cmdContextProbe(d, rest)
       case "stop":
         return await cmdStop(d)
       case undefined:

package/src/daemon/probe-all.ts

@@ -0,0 +1,190 @@
+/**
+ * Probe the context limit of every model UFR serves, reusing probe.ts's
+ * oversized-request trick: one request above a model's known context makes
+ * the server name the exact limit ("maximum context length is N tokens").
+ *
+ * Cost profile matters here: a REJECTED request is refused before any tokens
+ * are priced (measured 2026-10-05: 740 ms, x-process-time 0), so probing a
+ * model whose recorded context is still right costs nothing and does not
+ * count against the 20/min key bucket. Money is only spent when a probe rung
+ * is ACCEPTED (context grew since the last measurement) or a paid model is
+ * probed on an accepted rung — which is why paid models are skipped unless
+ * asked for.
+ */
+
+import type { ModelsFile } from "../shared/models-file"
+import type { FetchLike } from "./catalog-source"
+import { parseUfrModels } from "./catalog"
+import { fillerForTokens, parseLimitFromBody } from "./probe"
+
+/** No UFR model is known to exceed this; probing higher only risks an accepted (paid) rung. */
+export const PROBE_CEILING = 1_600_000
+
+export type ProbeHow =
+  | "error-named" // the server named the exact limit — the trustworthy result
+  | "accepted-floor" // every rung up to `probed` was accepted — `probed` is a lower bound only
+  | "rejected-unnamed" // rejected, but the body named no limit
+  | "http-error" // something other than 400/413/429 — not a context answer
+  | "skipped-paid" // external model, probing costs money
+  | "skipped-hidden" // on models.json's exclude list (not user-facing)
+
+export type ProbeRow = {
+  id: string
+  tier: "free" | "paid"
+  known: number | null // value in models.json, null = no entry
+  probed: number | null
+  how: ProbeHow
+  detail?: string
+}
+
+export type ProbeAllDeps = {
+  baseUrl: string
+  key: string
+  fetch: FetchLike
+  file: ModelsFile // known values + exclude list
+  includePaid?: boolean
+  /** Pause between models — the per-key bucket is 20/min across ALL models. */
+  paceMs?: number
+  log: (m: string) => void
+  now?: () => number
+  sleep?: (ms: number) => Promise<void>
+}
+
+const sleep = (ms: number) => new Promise<void>((r) => setTimeout(r, ms))
+
+/** Rungs for one model. Known context → just above it (cheapest reject, minimal
+ *  server tokenization). Unknown → one oversized rung: a rejection is free and
+ *  names the exact limit, and acceptance only happens for contexts above 1.5M,
+ *  which no UFR model has — so a ladder would only ever spend money on accepted
+ *  rungs without adding information. */
+export function sizesFor(known: number | null): number[] {
+  if (known !== null) {
+    const out = [known + 64]
+    for (let s = 2 * known + 64; s <= PROBE_CEILING && out.length < 3; s *= 2) out.push(s)
+    return out
+  }
+  return [1_500_000]
+}
+
+async function probeOne(o: ProbeAllDeps, id: string, known: number | null): Promise<ProbeRow> {
+  const doSleep = o.sleep ?? sleep
+  const floor = { value: 0 }
+  let last = { status: 0, body: "" }
+  for (const size of sizesFor(known)) {
+    for (let tries = 0; ; tries++) {
+      let res: Response
+      try {
+        res = await o.fetch(`${o.baseUrl}/chat/completions`, {
+          method: "POST",
+          headers: { Authorization: `Bearer ${o.key}`, "Content-Type": "application/json" },
+          body: JSON.stringify({
+            model: id,
+            max_tokens: 1,
+            messages: [{ role: "user", content: fillerForTokens(size) + "\n\nReply with exactly: OK" }],
+          }),
+          signal: AbortSignal.timeout(180_000),
+          redirect: "manual",
+        })
+      } catch (e) {
+        return { id, tier: "free", known, probed: floor.value || null,
+          how: floor.value ? "accepted-floor" : "http-error", detail: `transport: ${(e as Error).message}` }
+      }
+      if (res.ok) {
+        const j = (await res.json().catch(() => null)) as { usage?: { prompt_tokens?: number } } | null
+        floor.value = j?.usage?.prompt_tokens ?? size
+        break // accepted — try the next rung
+      }
+      const text = await res.text().catch(() => "")
+      if (res.status === 429 && tries < 2) {
+        o.log(`  ${id}: 429 at ${size} tokens — backing off 20 s`)
+        await doSleep(20_000)
+        continue // bucket, not a context answer — retry the same rung
+      }
+      last = { status: res.status, body: text }
+      if (res.status === 400 || res.status === 413) {
+        const named = parseLimitFromBody(text)
+        if (named) return { id, tier: "free", known, probed: named, how: "error-named" }
+        return { id, tier: "free", known, probed: floor.value || null,
+          how: floor.value ? "accepted-floor" : "rejected-unnamed", detail: text.slice(0, 200) }
+      }
+      return { id, tier: "free", known, probed: floor.value || null,
+        how: floor.value ? "accepted-floor" : "http-error", detail: `HTTP ${res.status}: ${text.slice(0, 200)}` }
+    }
+  }
+  return { id, tier: "free", known, probed: floor.value || null, how: "accepted-floor",
+    detail: last.status ? `last: HTTP ${last.status}` : undefined }
+}
+
+export async function probeAllContexts(o: ProbeAllDeps): Promise<ProbeRow[]> {
+  const res = await o.fetch(`${o.baseUrl}/models`, {
+    headers: { Authorization: `Bearer ${o.key}` },
+    signal: AbortSignal.timeout(20_000),
+    redirect: "manual",
+  })
+  if (!res.ok) throw new Error(`UFR /api/models: HTTP ${res.status}`)
+  const ufr = parseUfrModels(await res.json())
+  const excluded = new Set(o.file.exclude)
+  const rows: ProbeRow[] = []
+  for (const m of ufr) {
+    if (excluded.has(m.id)) {
+      rows.push({ id: m.id, tier: m.tier, known: o.file.models[m.id]?.context ?? null, probed: null, how: "skipped-hidden" })
+      continue
+    }
+    if (m.tier === "paid" && !o.includePaid) {
+      rows.push({ id: m.id, tier: "paid", known: o.file.models[m.id]?.context ?? null, probed: null, how: "skipped-paid" })
+      continue
+    }
+    rows.push(await probeOne(o, m.id, o.file.models[m.id]?.context ?? null))
+    await (o.sleep ?? sleep)(o.paceMs ?? 3_000) // stay under the 20/min key bucket
+  }
+  return rows
+}
+
+/** Human-readable report; `status` flags what a models.json update would change. */
+export function formatProbeReport(rows: ProbeRow[]): string {
+  const pad = (s: string, n: number) => (s.length >= n ? s : s + " ".repeat(n - s.length))
+  const lines = [
+    pad("model", 38) + pad("context", 12) + pad("how", 17) + pad("models.json", 12) + "status",
+    "-".repeat(94),
+  ]
+  let mismatches = 0
+  for (const r of rows) {
+    const context = r.probed === null ? "—" : r.probed.toLocaleString("en-US")
+    const status =
+      r.how === "error-named" && r.probed !== null
+        ? r.known === null ? "NEW — needs models.json entry" : r.probed === r.known ? "ok" : `MISMATCH (was ${r.known.toLocaleString("en-US")})`
+        : r.how
+    if (status.startsWith("NEW") || status.startsWith("MISMATCH")) mismatches++
+    lines.push(pad(r.id, 38) + pad(context, 12) + pad(r.how, 17) + pad(r.known === null ? "—" : r.known.toLocaleString("en-US"), 12) + status)
+  }
+  lines.push("-".repeat(94))
+  lines.push(`${rows.length} models, ${mismatches} needing a models.json update`)
+  return lines.join("\n")
+}
+
+/**
+ * Applies error-named results to a ModelsFile copy. Only `error-named` is
+ * exact; accepted floors are bounds and must not overwrite curated values.
+ * Existing notes are kept — a context measurement is appended, a previous
+ * context-probe note is replaced.
+ */
+export function applyProbeResults(
+  file: ModelsFile,
+  rows: ProbeRow[],
+  date: string,
+): { file: ModelsFile; changed: { id: string; from: number | null; to: number }[] } {
+  const out: ModelsFile = JSON.parse(JSON.stringify(file))
+  out.updated = date
+  const changed: { id: string; from: number | null; to: number }[] = []
+  for (const r of rows) {
+    if (r.how !== "error-named" || r.probed === null) continue
+    const e = (out.models[r.id] ??= {})
+    const from = e.context ?? null
+    if (from === r.probed) continue
+    e.context = r.probed
+    const probeNote = `context ${r.probed} probed live ${date} (probe-all-contexts)`
+    e.note = e.note?.includes("probed live") ? probeNote : e.note ? `${e.note} | ${probeNote}` : probeNote
+    changed.push({ id: r.id, from, to: r.probed })
+  }
+  return { file: out, changed }
+}

package/src/daemon/probe.ts

@@ -26,7 +26,7 @@ export function parseLimitFromBody(body: string): number | null {
 }
 
 /** Prompt filler: ~4.5 chars per token for prose-like text. */
-function fillerForTokens(tokens: number): string {
+export function fillerForTokens(tokens: number): string {
   return "The quick brown fox jumps over the lazy dog. ".repeat(Math.ceil((tokens * 4.5) / 45))
 }