opencode-ufr 0.2.1 → 0.2.3

package/README.md

@@ -60,8 +60,16 @@ ufr stats        # requests, tokens and cost
 ufr keys list    # stored aliases
 ufr keys test    # check your keys against UFR
 ufr login show   # the stored uni login
+ufr disconnect   # remove everything: keys, uni login, config, gateway
 ```
 
+Removing the **unifreiburg** integration in opencode's `/connect` panel does the
+same as `ufr disconnect`: the stored keys and uni login are wiped, the gateway
+stops, and the models disappear from the picker on the next opencode start.
+While opencode runs, the removal is noticed within a minute. If opencode was
+closed when you removed the integration, run `ufr disconnect` once to wipe what
+is left.
+
 ## The built-in VPN
 
 On the campus network (or the VPN you already run) UFR is reached directly and

package/models.json

@@ -1,6 +1,6 @@
 {
   "schema": 1,
-  "updated": "2026-09-28",
+  "updated": "2026-10-02",
   "defaults": {
     "context": 131072,
     "max_output": 16384
@@ -60,7 +60,11 @@
       "context": 256000
     },
     "qwen-3.5-397b-llmlb": {
-      "context": 262144
+      "context": 262144,
+      "price": {
+        "input": 0.1,
+        "output": 0.1
+      }
     },
     "qwen-3.6-27b-llmlb": {
       "context": 262144
@@ -122,7 +126,7 @@
       "vision": true
     },
     "ufr/reasoning-complex": {
-      "context": 262144,
+      "context": 1048576,
       "price": {
         "input": 0.1,
         "output": 0.1
@@ -135,7 +139,12 @@
       "context": 256000
     },
     "ufr/vision-complex": {
-      "context": 262144
+      "context": 1048576,
+      "vision": true,
+      "price": {
+        "input": 0.1,
+        "output": 0.1
+      }
     },
     "ufr/vision-fast": {
       "context": 131044
@@ -201,6 +210,15 @@
         "input": 0.3,
         "output": 0.9
       }
+    },
+    "deepseek-v4.1-flash-llmlb": {
+      "context": 1048576,
+      "vision": true,
+      "price": {
+        "input": 0.1,
+        "output": 0.1
+      },
+      "note": "context 1048576 probed live 2026-10-02 (vLLM ContextWindowExceededError named the limit); prices from the UFR portal (Lokale Modelle)"
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-ufr",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "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/catalog.ts

@@ -1,5 +1,5 @@
 import type { UfrModel } from "../daemon/catalog"
-import { BUNDLED_MODELS, loadModelsFile, loadUfrModels } from "../daemon/catalog-source"
+import { BUNDLED_MODELS, loadBundledModels, loadUfrModels } from "../daemon/catalog-source"
 import { loadConfig } from "../shared/config"
 import type { ModelsFile } from "../shared/models-file"
 import type { CliDeps } from "./index"
@@ -27,8 +27,7 @@ export async function cmdCatalogDiff(d: CliDeps): Promise<number> {
     return 1
   }
   const log = (m: string) => d.io.err(`${m}\n`)
-  const mf = await loadModelsFile({ url: cfg.catalog.url, cachePath: d.paths.modelsCache, etagPath: d.paths.modelsEtag,
-    bundledPath: BUNDLED_MODELS, fetch: d.fetch, log })
+  const mf = await loadBundledModels({ bundledPath: BUNDLED_MODELS })
   const ufr = await loadUfrModels({ baseUrl: cfg.upstream.baseUrl, key, cachePath: d.paths.ufrModelsCache, fetch: d.fetch, log })
   if (ufr.source !== "remote") {
     d.io.err(`cannot read UFR's live model list: ${ufr.error}\n`)

package/src/cli/index.ts

@@ -5,7 +5,7 @@ import { KeyringStore, type SecretStore } from "../shared/secrets"
 import { cmdCatalogDiff } from "./catalog"
 import { cmdConnect } from "./connect"
 import { type Io, terminalIo } from "./io"
-import { cmdKeys, cmdLogin } from "./keys"
+import { cmdDisconnect, cmdKeys, cmdLogin } from "./keys"
 import { cmdStats } from "./stats"
 import { cmdStatus } from "./status"
 import { cmdStop } from "./stop"
@@ -25,6 +25,8 @@ const HELP = `ufr — opencode-ufr gateway
                                    [--keys "<k1>,<k2>"] (comma/newline separated,
                                    whitespace filtered), optional uni login for the
                                    built-in VPN [--login <u> --password <p>]
+  ufr disconnect                   remove everything: stored keys, uni login,
+                                   config and the running gateway
   ufr keys list | remove <alias> | test [alias]   manage stored keys
   ufr login show | remove          the uni login for the built-in VPN
   ufr status                       gateway, keys, limits, breakers, spend today
@@ -55,6 +57,8 @@ export async function main(argv: string[], partial: Partial<CliDeps> = {}): Prom
     switch (cmd) {
       case "connect":
         return await cmdConnect(d, rest)
+      case "disconnect":
+        return await cmdDisconnect(d)
       case "keys":
         return await cmdKeys(d, rest)
       case "login":

package/src/cli/keys.ts

@@ -1,6 +1,6 @@
 import { loadConfig, saveConfig } from "../shared/config"
 import type { Paths } from "../shared/paths"
-import { VPN_PASS, VPN_USER } from "../shared/secrets"
+import { VPN_PASS, VPN_USER, type SecretStore } from "../shared/secrets"
 import { daemonRequest } from "./daemon-client"
 import type { FetchLike } from "../daemon/catalog-source"
 import type { CliDeps } from "./index"
@@ -29,6 +29,41 @@ export async function applyKeyChange(d: { paths: Paths; fetch: FetchLike; log: (
     : "could not stop the gateway — run `ufr stop` so it picks up the new keys")
 }
 
+export type DisconnectResult = { removed: string[]; loginRemoved: boolean }
+
+/**
+ * Provider-removal cleanup: delete every stored key alias and the uni login
+ * from the keyring, clear config.keys, and stop an idle gateway (it reads its
+ * keys at start, so a later start serves nothing). Idempotent.
+ */
+export async function disconnectAll(d: {
+  paths: Paths
+  secrets: SecretStore
+  fetch: FetchLike
+  log: (m: string) => void
+}): Promise<DisconnectResult> {
+  const cfg = await loadConfig(d.paths.configFile)
+  const removed: string[] = []
+  for (const alias of cfg.keys) {
+    if (await d.secrets.delete(alias)) removed.push(alias)
+  }
+  const userRemoved = await d.secrets.delete(VPN_USER)
+  const passRemoved = await d.secrets.delete(VPN_PASS)
+  const loginRemoved = userRemoved || passRemoved
+  cfg.keys = []
+  await saveConfig(d.paths.configFile, cfg)
+  await applyKeyChange(d)
+  return { removed, loginRemoved }
+}
+
+export async function cmdDisconnect(d: CliDeps): Promise<number> {
+  const r = await disconnectAll({ paths: d.paths, secrets: d.secrets, fetch: d.fetch, log: (m) => d.io.out(m + "\n") })
+  d.io.out(r.removed.length > 0 ? `removed from keyring: ${r.removed.join(", ")}\n` : "nothing was stored\n")
+  if (r.loginRemoved) d.io.out("removed the uni login\n")
+  d.io.out("done — reconnect any time with `ufr connect` or /connect in opencode\n")
+  return 0
+}
+
 export async function cmdKeys(d: CliDeps, args: string[]): Promise<number> {
   const [sub, ...rest] = args
   const cfg = await loadConfig(d.paths.configFile)

package/src/daemon/catalog-source.ts

@@ -1,48 +1,22 @@
 import { fileURLToPath } from "node:url"
-import { readJson, readText, writeFileAtomic } from "../shared/fs"
+import { readJson, writeFileAtomic } from "../shared/fs"
 import { type ModelsFile, validateModelsFile } from "../shared/models-file"
 import { VPN_MESSAGE, isVpnPage } from "../shared/vpn"
 import { type UfrModel, parseUfrModels } from "./catalog"
 
 export type FetchLike = (url: string, init?: RequestInit) => Promise<Response>
-export type ModelsSource = "remote" | "cache" | "bundled"
+export type ModelsSource = "bundled"
 
 export const BUNDLED_MODELS = fileURLToPath(new URL("../../models.json", import.meta.url))
 
-/** models.json: remote (ETag) → last good cache → copy shipped in the package. */
-export async function loadModelsFile(o: {
-  url: string
-  cachePath: string
-  etagPath: string
+/**
+ * The fixes file ships with the package (models.json in the release) — no
+ * remote pull. Model data updates arrive with plugin updates; UFR's live
+ * model list supplies everything else.
+ */
+export async function loadBundledModels(o: {
   bundledPath?: string
-  fetch: FetchLike
-  log: (m: string) => void
 }): Promise<{ file: ModelsFile; source: ModelsSource }> {
-  const cached = await readJson(o.cachePath)
-  const etag = cached ? (await readText(o.etagPath))?.trim() : undefined
-  try {
-    const res = await o.fetch(o.url, {
-      headers: etag ? { "If-None-Match": etag } : {},
-      signal: AbortSignal.timeout(15_000),
-    })
-    if (res.status === 304 && cached) return { file: validateModelsFile(cached), source: "remote" }
-    if (!res.ok) throw new Error(`HTTP ${res.status}`)
-    const text = await res.text()
-    const file = validateModelsFile(JSON.parse(text)) // validate before it can replace a good cache
-    await writeFileAtomic(o.cachePath, text)
-    const tag = res.headers.get("etag")
-    if (tag) await writeFileAtomic(o.etagPath, tag)
-    return { file, source: "remote" }
-  } catch (e) {
-    o.log(`models.json: remote copy unavailable or invalid (${(e as Error).message}) — using the ${cached ? "cached" : "bundled"} copy`)
-  }
-  if (cached) {
-    try {
-      return { file: validateModelsFile(cached), source: "cache" }
-    } catch (e) {
-      o.log(`models.json: cached copy invalid (${(e as Error).message})`)
-    }
-  }
   const bundled: unknown = JSON.parse(await Bun.file(o.bundledPath ?? BUNDLED_MODELS).text())
   return { file: validateModelsFile(bundled), source: "bundled" }
 }

package/src/daemon/catalog.ts

@@ -46,19 +46,23 @@ function toPrice(p: Price | undefined): ModelPrice | null {
   return { input: p.input, output: p.output, cacheRead: p.cache_read ?? p.input, cacheWrite: p.cache_write ?? p.input }
 }
 
-export function buildCatalog(ufr: UfrModel[], file: ModelsFile, opts: { allowPaid: boolean }): Catalog {
+export function buildCatalog(ufr: UfrModel[], file: ModelsFile, opts: { allowPaid: boolean; probes?: Record<string, { context: number; at: number }> }): Catalog {
   const warnings: string[] = []
   const exclude = new Set(file.exclude)
+  const probes = opts.probes ?? {}
   const models = new Map<string, Model>()
   for (const u of ufr) {
     const e = file.models[u.id]
+    // precedence: models.json entry (measured, ships with releases) > auto-probe > defaults
+    const probed = probes[u.id]?.context
+    const context = e?.context ?? probed ?? file.defaults.context
     models.set(u.id, {
       id: u.id,
       name: u.name,
       tier: u.tier,
       vision: e?.vision ?? u.vision,
       tools: e?.tools ?? true,
-      context: e?.context ?? file.defaults.context,
+      context,
       maxOutput: e?.max_output ?? file.defaults.max_output,
       price: toPrice(e?.price),
       hasEntry: e !== undefined,

package/src/daemon/daemon.ts

@@ -11,8 +11,11 @@ import { startOfLocalDay } from "../shared/time"
 import { VERSION } from "../shared/version"
 import { type BreakerState, BreakerRegistry } from "./breaker"
 import { type Catalog, EMPTY_CATALOG, buildCatalog, listModels } from "./catalog"
-import { type FetchLike, type ModelsSource, loadModelsFile, loadUfrModels } from "./catalog-source"
+import { type FetchLike, type ModelsSource, loadBundledModels, loadUfrModels } from "./catalog-source"
+import type { ModelsFile } from "../shared/models-file"
 import { type KeyInfo, KeyPool, type KeySnapshot } from "./keypool"
+import { loadProbes, probeContextLimit, saveProbe } from "./probe"
+import { type UfrModel } from "./catalog"
 import { Router } from "./router"
 import { startServer } from "./server"
 import { Stats } from "./stats"
@@ -58,6 +61,8 @@ export type DaemonOptions = {
   idleCheckMs?: number
   /** Backoff after UFR's model list failed to load (VPN down, UFR unreachable); the last delay repeats. */
   catalogRetryMs?: number[]
+  /** Auto-probe the context limit of unknown models (default: on). */
+  probes?: boolean
   onStopped?: () => void
 }
 
@@ -243,7 +248,7 @@ export async function startDaemon(o: DaemonOptions): Promise<RunningDaemon> {
     const timers: ReturnType<typeof setInterval>[] = []
     let stopping = false
     // UFR's model list failed (VPN not up yet, UFR unreachable): retry with backoff
-    // (60 s → 120 s → 300 s → 900 s, then every 900 s; no step longer than refreshHours)
+    // (60 s → 120 s → 300 s → 900 s, then every 900 s)
     // so connecting the VPN later needs no daemon restart.
     const retryMs = o.catalogRetryMs ?? [60_000, 120_000, 300_000, 900_000]
     let retryTimer: ReturnType<typeof setTimeout> | null = null
@@ -259,7 +264,7 @@ export async function startDaemon(o: DaemonOptions): Promise<RunningDaemon> {
     }
     const scheduleCatalogRetry = () => {
       if (stopping || retryTimer) return
-      const delay = Math.min(retryMs[Math.min(retries, retryMs.length - 1)]!, config.catalog.refreshHours * 3_600_000)
+      const delay = Math.min(retryMs[Math.min(retries, retryMs.length - 1)]!, 900_000)
       retries++
       retryTimer = setTimeout(() => {
         retryTimer = null
@@ -273,12 +278,50 @@ export async function startDaemon(o: DaemonOptions): Promise<RunningDaemon> {
     const reach: StatusJson["upstream"] = { ok: null, message: "", at: 0 }
     let catalog: Catalog = EMPTY_CATALOG
     let catalogInfo: Omit<StatusJson["catalog"], "models" | "warnings"> = { source: "none", ufrSource: "none", loadedAt: 0 }
+    let probeStore = loadProbes((k) => db.getKv(k))
+    let probing = false
+    /** Measure models UFR serves but models.json does not describe (one at a time, off the hot path). */
+    const scheduleProbes = async (ufrModels: UfrModel[], file: ModelsFile): Promise<void> => {
+      if (probing || keyInfos.length === 0 || o.probes === false) return
+      const unknown = ufrModels
+        .map((u) => u.id)
+        .filter((id) => file.models[id] === undefined && probeStore[id] === undefined)
+      if (unknown.length === 0) return
+      probing = true
+      try {
+        for (const id of unknown.slice(0, 2)) {
+          if (stopping) break
+          const result = await probeContextLimit({
+            model: id,
+            baseUrl: config.upstream.baseUrl,
+            key: keyInfos[0]!.secret,
+            transport,
+            log,
+          })
+          if (result) {
+            if (stopping) break
+            saveProbe(probeStore, id, result, (k, v) => {
+              if (stopping) return
+              try { db.setKv(k, v) } catch { /* db already closed */ }
+            })
+            log(`context probe ${id}: ${result.context} tokens (${result.how})`)
+          }
+        }
+        if (unknown.length > 0) {
+          const mf2 = await loadBundledModels({ bundledPath: o.bundledModelsPath })
+          catalog = buildCatalog(ufrModels, mf2.file, { allowPaid: config.allowPaid, probes: probeStore })
+          catalogInfo = { ...catalogInfo, loadedAt: now() }
+        }
+      } finally {
+        probing = false
+      }
+    }
     const refreshCatalog = async () => {
-      const mf = await loadModelsFile({ url: config.catalog.url, cachePath: p.modelsCache, etagPath: p.modelsEtag,
-        bundledPath: o.bundledModelsPath, fetch: f, log })
+      // fixes ship with the package; UFR's live list is fetched through the transport (vpn-aware)
+      const mf = await loadBundledModels({ bundledPath: o.bundledModelsPath })
       const ufr = await loadUfrModels({ baseUrl: config.upstream.baseUrl, key: keyInfos[0]?.secret ?? null,
         cachePath: p.ufrModelsCache, fetch: (u, i) => transport.fetch(u, i), log })
-      catalog = buildCatalog(ufr.models, mf.file, { allowPaid: config.allowPaid })
+      catalog = buildCatalog(ufr.models, mf.file, { allowPaid: config.allowPaid, probes: probeStore })
       catalogInfo = { source: mf.source, ufrSource: ufr.source, loadedAt: now() }
       if (ufr.error) Object.assign(reach, { ok: false, message: ufr.error, at: now() })
       else if (reach.ok !== true) Object.assign(reach, { ok: true, message: "", at: now() })
@@ -286,6 +329,7 @@ export async function startDaemon(o: DaemonOptions): Promise<RunningDaemon> {
       // Keys are read once at start: without one a retry can never succeed.
       if (ufr.error && keyInfos.length > 0) scheduleCatalogRetry()
       else clearCatalogRetry()
+      void scheduleProbes(ufr.models, mf.file).catch(() => {}) // must not outlive a shutdown
     }
     await refreshCatalog()
 
@@ -375,8 +419,9 @@ export async function startDaemon(o: DaemonOptions): Promise<RunningDaemon> {
     await writeFileAtomic(p.daemonFile, JSON.stringify({ port, pid: process.pid, version: VERSION, startedAt }) + "\n", 0o600)
 
     timers.push(setInterval(() => {
+      // pick up new UFR models periodically (the fixes file only changes with a plugin update)
       refreshCatalog().catch((e) => log(`catalog refresh failed: ${(e as Error).message}`))
-    }, config.catalog.refreshHours * 3_600_000))
+    }, 6 * 3_600_000))
     timers.push(setInterval(() => db.setKv("breakers", JSON.stringify(breakers.snapshot())), 30_000))
     timers.push(setInterval(() => db.prune(now() - 90 * 86_400_000), 86_400_000))
     if (o.exitOnIdle !== false) {

package/src/daemon/probe.ts

@@ -0,0 +1,113 @@
+/**
+ * Auto-probe for models UFR serves but models.json does not describe yet:
+ * one oversized request makes vLLM name its real context limit in the error
+ * ("This model's maximum context length is N tokens"). Results are stored in
+ * the stats DB and survive restarts — new models measure themselves, no
+ * patches needed.
+ */
+
+import type { FetchLike } from "./catalog-source"
+
+const LIMIT_RES = [
+  /context length is (\d+)/i,
+  /maximum context length[^\d]{0,40}(\d+)/i,
+  /context window[^\d]{0,30}(\d+)/i,
+]
+
+export function parseLimitFromBody(body: string): number | null {
+  for (const re of LIMIT_RES) {
+    const m = re.exec(body)
+    if (m) {
+      const n = Number(m[1])
+      if (Number.isFinite(n) && n >= 1024) return n
+    }
+  }
+  return null
+}
+
+/** Prompt filler: ~4.5 chars per token for prose-like text. */
+function fillerForTokens(tokens: number): string {
+  return "The quick brown fox jumps over the lazy dog. ".repeat(Math.ceil((tokens * 4.5) / 45))
+}
+
+export type ProbeResult = { context: number; how: "error-named" | "accepted-floor" } | null
+
+/**
+ * Ladder probe: sizes in tokens. The first error either names the limit
+ * (done) or marks the ceiling; the last success sets the floor.
+ */
+export async function probeContextLimit(o: {
+  model: string
+  baseUrl: string
+  key: string
+  transport: { name: string; fetch(url: string, init?: RequestInit): Promise<Response> }
+  sizes?: number[] // token counts to try, in order
+  log: (m: string) => void
+}): Promise<ProbeResult> {
+  const sizes = o.sizes ?? [300_000, 600_000, 1_048_000, 1_500_000]
+  let floor = 0
+  for (const tokens of sizes) {
+    const body = JSON.stringify({
+      model: o.model,
+      max_tokens: 1,
+      messages: [{ role: "user", content: fillerForTokens(tokens) + "\n\nReply with exactly: OK" }],
+    })
+    let res: Response
+    try {
+      res = await o.transport.fetch(`${o.baseUrl}/chat/completions`, {
+        method: "POST",
+        headers: { Authorization: `Bearer ${o.key}`, "Content-Type": "application/json" },
+        body,
+        signal: AbortSignal.timeout(180_000),
+        redirect: "manual",
+      })
+    } catch (e) {
+      o.log(`context probe ${o.model}: transport error at ${tokens} tokens (${(e as Error).message})`)
+      return floor > 0 ? { context: floor, how: "accepted-floor" } : null
+    }
+    if (res.ok) {
+      const j = (await res.json().catch(() => null)) as { usage?: { prompt_tokens?: number } } | null
+      floor = j?.usage?.prompt_tokens ?? tokens
+      continue // accepted: try the next rung
+    }
+    const text = await res.text().catch(() => "")
+    const named = parseLimitFromBody(text)
+    if (named) {
+      o.log(`context probe ${o.model}: the server names the limit: ${named} tokens`)
+      return { context: named, how: "error-named" }
+    }
+    if (res.status === 400 || res.status === 413) {
+      o.log(`context probe ${o.model}: rejected at ${tokens} tokens without naming a limit`)
+      return floor > 0 ? { context: floor, how: "accepted-floor" } : null
+    }
+    // rate limit / auth / anything else: not a context answer, retry later
+    o.log(`context probe ${o.model}: HTTP ${res.status} — will retry later`)
+    return null
+  }
+  return floor > 0 ? { context: floor, how: "accepted-floor" } : null
+}
+
+export const PROBE_KV_KEY = "ctxprobes"
+
+type ProbeStore = Record<string, { context: number; at: number }>
+
+export function loadProbes(getKv: (k: string) => string | null): ProbeStore {
+  try {
+    const raw = getKv(PROBE_KV_KEY)
+    const parsed = raw ? JSON.parse(raw) : null
+    return parsed && typeof parsed === "object" ? (parsed as ProbeStore) : {}
+  } catch {
+    return {}
+  }
+}
+
+export function saveProbe(
+  store: ProbeStore,
+  model: string,
+  result: ProbeResult,
+  setKv: (k: string, v: string) => void,
+): void {
+  if (!result) return
+  store[model] = { context: result.context, at: Date.now() }
+  setKv(PROBE_KV_KEY, JSON.stringify(store))
+}

package/src/daemon/vpn/tcp.ts

@@ -49,6 +49,8 @@ const DEFAULT_MSS = 1360 // fits a 1400-byte tunnel MTU with IP+TCP headers
 const DEFAULT_RTO_MS = 500
 const DEFAULT_MAX_RETRANSMITS = 6
 const RECV_WINDOW = 65535
+const CWND_START = 4 // segments in flight before the first ACK (slow start)
+const CWND_MAX = 64
 
 export function freshLocalPort(): number {
   return 32768 + Math.floor(Math.random() * 20000)
@@ -65,8 +67,11 @@ export class TcpConn {
   private rcvNext = 0 // next byte we expect from the peer (RCV.NXT)
   private peerWindow = 0
   private peerMss = 536
-  private outQueue: QueueEntry[] = []
+  private outQueue: QueueEntry[] = [] // not yet sent
+  private flightQueue: QueueEntry[] = [] // sent, not yet acked (retransmit source)
   private earlyQueue: Uint8Array[] = [] // application data written while syn-sent
+  private cwnd = CWND_START // congestion window in segments (slow start)
+  private dupAcks = 0
   private finQueued = false
   private finSent = false
   private closeFired = false
@@ -145,7 +150,7 @@ export class TcpConn {
   }
 
   get buffered(): number {
-    return this.outQueue.reduce((n, e) => n + e.bytes.length, 0)
+    return this.outQueue.reduce((n, e) => n + e.bytes.length, 0) + this.flightBytes()
   }
 
   // -- inbound -------------------------------------------------------------
@@ -219,7 +224,6 @@ export class TcpConn {
       return
     }
 
-    if (this.finQueued && !this.outQueue.some((e) => e.len > 0) && this.unacked === 0) this.maybeSendFin()
     this.flush()
   }
 
@@ -239,17 +243,16 @@ export class TcpConn {
     const seg: TcpSegment = { header, payload, options }
     const bytes = buildDatagram({ src: this.info.local, dst: this.info.remote, segment: seg })
     this.sendPkt(bytes)
-    if (queueLen > 0) this.outQueue.push({ seq: this.seq, len: queueLen, bytes })
+    if (queueLen > 0) this.flightQueue.push({ seq: this.seq, len: queueLen, bytes }) // sent: tracks in flight
   }
 
   private flush(): void {
-    let inFlight = this.unacked
+    let inFlight = this.flightBytes()
     let sent = false
+    const limit = Math.min(Math.max(this.peerWindow, 1), this.cwnd * this.effMss())
     while (this.outQueue.length > 0) {
       const e = this.outQueue[0]!
-      if (e.len > 0) break // SYN/FIN marker: only retransmits move it
-      const window = Math.max(this.peerWindow, 1)
-      if (inFlight + e.bytes.length > window) break
+      if (inFlight + e.bytes.length > limit) break
       const header = {
         srcPort: this.info.localPort,
         dstPort: this.info.remotePort,
@@ -262,15 +265,23 @@ export class TcpConn {
       this.sendPkt(buildDatagram({ src: this.info.local, dst: this.info.remote, segment: { header, payload: e.bytes } }))
       inFlight += e.bytes.length
       sent = true
-      this.outQueue.shift()
+      this.flightQueue.push(this.outQueue.shift()!)
     }
     if (sent) this.armRto()
     if (this.finQueued && this.buffered === 0) this.maybeSendFin()
     if (this.buffered === 0) this.events.onDrain?.(this)
   }
 
+  private effMss(): number {
+    return Math.min(this.peerMss, this.opts.mss ?? DEFAULT_MSS)
+  }
+
+  private flightBytes(): number {
+    return this.flightQueue.reduce((n, e) => n + e.bytes.length, 0)
+  }
+
   private maybeSendFin(): void {
-    if (this.finSent || this.outQueue.some((e) => e.len > 0)) return // FIN already in flight
+    if (this.finSent || this.flightQueue.some((e) => e.len > 0)) return // FIN already in flight
     this.finSent = true
     this.sendSegment({ flags: FIN | ACK }, new Uint8Array(0), 1)
     this.seq = (this.seq + 1) >>> 0
@@ -297,17 +308,29 @@ export class TcpConn {
     if (window > 0) this.peerWindow = window
     const unacked = this.unacked
     const newly = (ack - this.acked) >>> 0
-    if (newly === 0 || newly > unacked) return // stale or covering more than we sent
+    if (newly === 0 || newly > unacked) {
+      // duplicate ACK: the peer is missing something after `acked`
+      if (unacked > 0 && ++this.dupAcks >= 3) {
+        this.dupAcks = 0
+        this.cwnd = Math.max(Math.floor(this.cwnd / 2), CWND_START) // multiplicative decrease
+        const first = this.flightQueue[0]!
+        if (first) this.sendPkt(first.bytes) // fast retransmit, no RTO wait
+      }
+      return
+    }
+    this.dupAcks = 0
+    // slow start: one segment of window per acked segment, bounded by the peer window
+    this.cwnd = Math.min(Math.ceil(this.cwnd + newly / this.effMss()), CWND_MAX)
     this.acked = ack
     this.retransmits = 0
     this.rto = this.opts.rtoMs ?? DEFAULT_RTO_MS
-    // drop fully acknowledged queue entries
-    while (this.outQueue.length > 0) {
-      const e = this.outQueue[0]!
+    // drop fully acknowledged entries from the flight queue
+    while (this.flightQueue.length > 0) {
+      const e = this.flightQueue[0]!
       if ((e.seq + e.len) >>> 0 > ack || (e.len === 0 && e.seq + e.bytes.length > ack)) break
-      this.outQueue.shift()
+      this.flightQueue.shift()
     }
-    if (this.outQueue.length === 0 && this.unacked === 0) {
+    if (this.flightQueue.length === 0 && this.unacked === 0) {
       if (this.timer) { clearTimeout(this.timer); this.timer = null }
     }
     if (this.state === "fin-wait-1" && this.unacked === 0) this.state = "fin-wait-2"
@@ -335,8 +358,13 @@ export class TcpConn {
       return
     }
     this.rto = Math.min(this.rto * 2, 5_000)
-    const first = this.outQueue[0]!
-    this.sendPkt(first.bytes) // go-back-N: resend oldest unacked segment
+    this.cwnd = CWND_START // collapse the window: the burst was too much
+    this.dupAcks = 0
+    // true go-back-N: resend EVERY unacked segment, not just the first —
+    // a burst can lose several at once, one-per-RTO would never recover
+    for (const e of this.flightQueue) {
+      this.sendPkt(e.bytes)
+    }
     this.armRto()
   }
 

package/src/plugin/connect.ts

@@ -9,7 +9,7 @@
 
 import { applyConnect, splitKeys } from "../shared/connect"
 import type { Paths } from "../shared/paths"
-import { applyKeyChange } from "../cli/keys"
+import { applyKeyChange, disconnectAll } from "../cli/keys"
 
 export const UFR_INTEGRATION_ID = "unifreiburg"
 
@@ -18,6 +18,11 @@ export type ConnectDeps = {
   paths: Paths
   secrets: { get(alias: string): Promise<string | null>; set(alias: string, value: string): Promise<void>; delete(alias: string): Promise<boolean> }
   log: (m: string) => void
+  /** (Re-)registers the provider with opencode — called on first connect and after a removal+reconnect.
+   *  Returns false when the registration did not succeed (e.g. no models yet); the watcher retries. */
+  register?: () => Promise<boolean | void> | boolean | void
+  /** Whether setup() already registered the provider (it does when a connection exists at startup). */
+  providerRegistered?: boolean
 }
 
 type CredentialValue = { type?: string; key?: string; configuration?: Record<string, unknown> } | undefined
@@ -73,28 +78,52 @@ export async function registerConnect(d: ConnectDeps): Promise<ConnectRegistrati
     })
   })
 
-  // Apply a submitted credential once, then watch for changes.
+  // Apply a submitted credential once, then watch for changes. Phases:
+  // "registered" (provider live), "unregistered" (no provider yet), and
+  // "disconnected" (the connection was removed in opencode — everything
+  // wiped; a later connection re-applies and re-registers).
+  type Phase = "registered" | "unregistered" | "disconnected"
+  let phase: Phase = d.providerRegistered ? "registered" : "unregistered"
   let lastApplied = ""
   const applyOnce = async (): Promise<boolean> => {
     try {
       const connection = await ctx.integration.connection.active(UFR_INTEGRATION_ID)
-      if (!connection) return false
+      if (!connection) {
+        if (phase === "registered") {
+          phase = "disconnected"
+          lastApplied = ""
+          const r = await disconnectAll({ paths: d.paths, secrets: d.secrets, fetch: (u, i) => fetch(u, i), log: d.log })
+          d.log(`unifreiburg removed in opencode — wiped from keyring: ${r.removed.length > 0 ? r.removed.join(", ") : "nothing"}${r.loginRemoved ? " + uni login" : ""}`)
+          return true // the disconnect cleaned something up — a state change
+        }
+        return false
+      }
       const cred = (await ctx.integration.connection.resolve(connection)) as CredentialValue
       const sig = JSON.stringify(cred?.configuration ?? {}) + "|" + (cred?.key ?? "")
-      if (sig === lastApplied) return false
-      lastApplied = sig
-      const input = credentialToInput(cred)
-      if (!input) {
-        d.log("/connect credential has no keys — nothing applied")
-        return false
+      let changed = false
+      if (sig !== lastApplied) {
+        lastApplied = sig
+        const input = credentialToInput(cred)
+        if (!input) {
+          d.log("/connect credential has no keys — nothing applied")
+          return false
+        }
+        const r = await applyConnect(input, { paths: d.paths, secrets: d.secrets, log: d.log })
+        if (r.errors.length > 0) {
+          for (const e of r.errors) d.log(`/connect: ${e}`)
+          lastApplied = "" // retry on the next poll
+          return false
+        }
+        if (r.changed) await applyKeyChange({ paths: d.paths, fetch: (u, i) => fetch(u, i), log: d.log })
+        changed = true
       }
-      const r = await applyConnect(input, { paths: d.paths, secrets: d.secrets, log: d.log })
-      if (r.errors.length > 0) {
-        for (const e of r.errors) d.log(`/connect: ${e}`)
-        return false
+      if (phase !== "registered") {
+        // first connect mid-session, or a reconnect after a removal
+        const ok = await d.register?.()
+        if (ok !== false) phase = "registered" // false = registration failed — retry on the next poll
+        changed = true
       }
-      await applyKeyChange({ paths: d.paths, fetch: (u, i) => fetch(u, i), log: d.log })
-      return true
+      return changed
     } catch (e) {
       d.log(`/connect apply failed: ${(e as Error).message}`)
       return false

package/src/plugin/index.ts

@@ -1,10 +1,11 @@
 import { fileURLToPath } from "node:url"
 import type { OpencodeStamp } from "../daemon/catalog"
+import { daemonRequest } from "../cli/daemon-client"
 import { type Paths, resolvePaths } from "../shared/paths"
 import { KeyringStore } from "../shared/secrets"
 import { VERSION } from "../shared/version"
 import { type Conn, ensureDaemon, spawnDaemon } from "./ensure-daemon"
-import { registerConnect } from "./connect"
+import { registerConnect, UFR_INTEGRATION_ID } from "./connect"
 import { toModelInfo } from "./model-info"
 
 const DAEMON_ENTRY = fileURLToPath(new URL("../daemon/main.ts", import.meta.url))
@@ -17,13 +18,69 @@ async function connect(paths: Paths): Promise<Conn> {
   return ensureDaemon({ paths, version: VERSION, spawn: () => spawnDaemon(DAEMON_ENTRY, paths.stateDir) })
 }
 
-async function heartbeat(conn: Conn, paths: Paths): Promise<void> {
-  const ok = await fetch(`http://127.0.0.1:${conn.port}/v1/_client/heartbeat`, {
-    method: "POST",
+/** Whether this opencode exposes the integration API (needed to see connection state). */
+function hasIntegration(ctx: any): boolean {
+  return typeof ctx?.integration?.connection?.active === "function"
+}
+
+/** Starts the daemon if needed, fetches its models and registers the provider with opencode. */
+async function registerProvider(
+  ctx: any,
+  providerId: string,
+  providerName: string,
+  paths: Paths,
+): Promise<boolean> {
+  let conn: Conn
+  try {
+    conn = await connect(paths)
+  } catch (e) {
+    log(`${(e as Error).message} — run \`ufr status\``)
+    return false
+  }
+  const list = await fetch(`http://127.0.0.1:${conn.port}/v1/models`, {
     headers: { Authorization: `Bearer ${conn.token}` },
-    signal: AbortSignal.timeout(5_000),
+    signal: AbortSignal.timeout(10_000),
+  })
+    .then(async (r) => (r.ok ? ((await r.json()) as { data: { id: string; opencode: OpencodeStamp }[] }).data : []))
+    .catch(() => [])
+  if (list.length === 0) {
+    // Never register an empty provider: it breaks the whole model picker.
+    log("no models available — run `ufr setup`, connect to the uni VPN, then `ufr status` for details")
+    return false
+  }
+  if (typeof ctx?.provider?.transform !== "function") {
+    log("this opencode version has no ctx.provider.transform — cannot register the provider")
+    return false
+  }
+  const models = list.map((m) => toModelInfo(providerId, m.id, m.opencode))
+  await ctx.provider.transform((editor: any) => {
+    editor.add({
+      info: {
+        id: providerId,
+        name: providerName,
+        activation: "enabled",
+        package: "@opencode/ai/providers/openai-compatible",
+        settings: { baseURL: `http://127.0.0.1:${conn.port}/v1`, apiKey: conn.token },
+      },
+      models,
+    })
   })
-    .then((r) => r.ok)
+  log(`registered ${providerId} with ${models.length} models`)
+  return true
+}
+
+/**
+ * Keeps the daemon alive while the provider is connected. When the connection
+ * was removed in opencode, the daemon must stay down — the watcher wipes the
+ * keys and opencode no longer offers the provider.
+ */
+export async function heartbeat(ctx: any, paths: Paths): Promise<void> {
+  if (hasIntegration(ctx)) {
+    const active = await ctx.integration.connection.active(UFR_INTEGRATION_ID).catch(() => undefined)
+    if (!active) return
+  }
+  const ok = await daemonRequest(paths, (u, i) => fetch(u, i), "/v1/_client/heartbeat", "POST")
+    .then((r) => r?.ok ?? false)
     .catch(() => false)
   // Port and token are stable, so a restarted daemon serves the provider we already registered.
   if (!ok) await connect(paths).catch((e) => log(`gateway restart failed: ${(e as Error).message}`))
@@ -37,53 +94,38 @@ export default {
     const providerName = typeof options.providerName === "string" ? options.providerName : "Uni Freiburg"
     const paths = resolvePaths()
 
-    let conn: Conn
-    try {
-      conn = await connect(paths)
-    } catch (e) {
-      log(`${(e as Error).message} — run \`ufr status\``)
-      return
-    }
-    const list = await fetch(`http://127.0.0.1:${conn.port}/v1/models`, {
-      headers: { Authorization: `Bearer ${conn.token}` },
-      signal: AbortSignal.timeout(10_000),
-    })
-      .then(async (r) => (r.ok ? ((await r.json()) as { data: { id: string; opencode: OpencodeStamp }[] }).data : []))
-      .catch(() => [])
-    if (list.length === 0) {
-      // Never register an empty provider: it breaks the whole model picker.
-      log("no models available — run `ufr setup`, connect to the uni VPN, then `ufr status` for details")
-      return
-    }
-    if (typeof ctx?.provider?.transform !== "function") {
-      log("this opencode version has no ctx.provider.transform — cannot register the provider")
-      return
+    let registered = false
+    const registerProviderFn = async (): Promise<boolean> => {
+      if (registered) return true
+      registered = await registerProvider(ctx, providerId, providerName, paths)
+      return registered
     }
-    const models = list.map((m) => toModelInfo(providerId, m.id, m.opencode))
-    await ctx.provider.transform((editor: any) => {
-      editor.add({
-        info: {
-          id: providerId,
-          name: providerName,
-          activation: "enabled",
-          package: "@opencode/ai/providers/openai-compatible",
-          settings: { baseURL: `http://127.0.0.1:${conn.port}/v1`, apiKey: conn.token },
-        },
-        models,
-      })
-    })
-    log(`registered ${providerId} with ${models.length} models`)
-    // /connect integration: uni login (optional) form on the unifreiburg entry
+
+    // /connect integration first: it is the only way to connect when no
+    // provider is registered yet, so it must exist even while disconnected.
     const stopConnect = await registerConnect({
       ctx,
       paths,
       secrets: new KeyringStore(),
       log,
+      register: registerProviderFn,
+      providerRegistered: false,
     }).catch((e) => {
       log(`/connect integration failed: ${(e as Error).message}`)
       return { stop: () => {}, applyNow: async () => false }
     })
-    const beat = setInterval(() => void heartbeat(conn, paths), 60_000)
+
+    // The provider is registered only while the integration is connected:
+    // removing it in opencode must remove the models too.
+    if (!hasIntegration(ctx)) {
+      await registerProviderFn() // old opencode without the integration API — register as before
+    } else {
+      const connection = await ctx.integration.connection.active(UFR_INTEGRATION_ID).catch(() => undefined)
+      if (connection) await registerProviderFn()
+      else log(`${providerId} not connected — open /connect in opencode to set it up`)
+    }
+
+    const beat = setInterval(() => void heartbeat(ctx, paths), 60_000)
     ;(beat as { unref?: () => void }).unref?.()
     return () => {
       clearInterval(beat)

package/src/shared/config.ts

@@ -19,7 +19,6 @@ export type Config = {
   breaker: { tripThreshold: number; ladderS: number[]; probeTimeoutS: number }
   allowPaid: boolean
   dailyBudgetUsd: number
-  catalog: { url: string; refreshHours: number }
   idleShutdownMin: number
 }
 
@@ -44,7 +43,6 @@ export const DEFAULTS: Config = {
   breaker: { tripThreshold: 3, ladderS: [30, 120, 300, 900, 1800, 3600], probeTimeoutS: 120 },
   allowPaid: false,
   dailyBudgetUsd: 20,
-  catalog: { url: "https://raw.githubusercontent.com/FinleyLaempe/opencode-ufr/main/models.json", refreshHours: 6 },
   idleShutdownMin: 5,
 }
 
@@ -72,8 +70,6 @@ const RULES: Record<string, Rule> = {
   "breaker.probeTimeoutS": "int>=1",
   allowPaid: "bool",
   dailyBudgetUsd: "num>=0",
-  "catalog.url": "str",
-  "catalog.refreshHours": "int>=1",
   idleShutdownMin: "int>=1",
 }
 
@@ -88,7 +84,6 @@ const MAX: Record<string, number> = {
   "limits.poolMaxWaitS": 86_400,
   "breaker.ladderS": 86_400,
   "breaker.probeTimeoutS": 86_400,
-  "catalog.refreshHours": 168,
   idleShutdownMin: 1_440,
 }
 

package/src/shared/connect.ts

@@ -43,6 +43,8 @@ export type ConnectApplied = {
   aliases: { alias: string; key: string }[]
   removedAliases: string[]
   loginStored: boolean
+  /** False when the submission was byte-identical to what is already stored — no gateway restart needed. */
+  changed: boolean
   errors: string[]
 }
 
@@ -60,15 +62,16 @@ export async function applyConnect(
   const keys = splitKeys(input.keys)
   if (keys.length === 0) {
     errors.push("no keys given")
-    return { aliases: [], removedAliases: [], loginStored: false, errors }
+    return { aliases: [], removedAliases: [], loginStored: false, changed: false, errors }
   }
   if (input.login && !EMAIL_RE.test(input.login.trim())) {
     errors.push(`"${input.login}" does not look like a uni login`)
-    return { aliases: [], removedAliases: [], loginStored: false, errors }
+    return { aliases: [], removedAliases: [], loginStored: false, changed: false, errors }
   }
 
   const cfg = await loadConfig(o.paths.configFile)
   const custom = cfg.keys.filter((k) => !/^key\d+$/.test(k))
+  const beforeKeys = cfg.keys.join("\n")
 
   // replace the managed key1…keyN aliases
   const removedAliases: string[] = []
@@ -80,15 +83,21 @@ export async function applyConnect(
     }
   }
   const aliases: { alias: string; key: string }[] = []
+  let changed = beforeKeys !== [...custom, ...wanted].join("\n") || removedAliases.length > 0
   for (let i = 0; i < keys.length; i++) {
     const alias = wanted[i]!
+    if ((await o.secrets.get(alias)) !== keys[i]!) changed = true
     await o.secrets.set(alias, keys[i]!)
     aliases.push({ alias, key: keys[i]! })
   }
 
   let loginStored = false
   if (input.login?.trim()) {
-    await o.secrets.set(VPN_USER, input.login.trim())
+    const login = input.login.trim()
+    if ((await o.secrets.get(VPN_USER)) !== login || (input.password && (await o.secrets.get(VPN_PASS)) !== input.password)) {
+      changed = true
+    }
+    await o.secrets.set(VPN_USER, login)
     if (input.password) await o.secrets.set(VPN_PASS, input.password)
     loginStored = true
   }
@@ -96,5 +105,5 @@ export async function applyConnect(
   cfg.keys = [...custom, ...wanted]
   await saveConfig(o.paths.configFile, cfg)
   log(`connect applied: ${aliases.length} key(s), login ${loginStored ? "stored" : "unchanged"}`)
-  return { aliases, removedAliases, loginStored, errors }
+  return { aliases, removedAliases, loginStored, changed, errors }
 }

package/src/shared/paths.ts

@@ -12,8 +12,6 @@ export type Paths = {
   lockFile: string
   logFile: string
   statsDb: string
-  modelsCache: string
-  modelsEtag: string
   ufrModelsCache: string
 }
 
@@ -55,8 +53,6 @@ export function resolvePaths(
     lockFile: join(stateDir, "daemon.lock"),
     logFile: join(stateDir, "daemon.log"),
     statsDb: join(dataDir, "stats.db"),
-    modelsCache: join(cacheDir, "models.json"),
-    modelsEtag: join(cacheDir, "models.etag"),
     ufrModelsCache: join(cacheDir, "ufr-models.json"),
   }
 }