pi-freeflow 1.41.0 → 1.42.0

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## 1.42.0
+
+### Minor Changes
+
+- b247ea6: Enable relay pool routing for OVHcloud AI Endpoints to bypass per-IP rate limits during burst and subagent requests. Retire paid `z-ai/glm-5.3-flash` and update the Cline lane to true free-tier models (`cline/nemotron-3.5-super-vl`). Implement dynamic Cline version fetching from Open VSX with disk caching, and background keep-alive auto-probing so saved Cline account tokens never expire.
+
+### Patch Changes
+
+- 2b1f434: Roll Cline pool to the next slot when OpenRouter free models return in-stream 429 errors within HTTP 200 SSE streams.
+- 92532c3: Fix DeepSeek follow-up requests in Pi being rejected when earlier assistant messages have no reasoning content.
+- a6d9834: Retire unserved `cat-jam-free` (persistent upstream 404), correct `mimo-v2.6-flash-free` input modality to text-only (upstream rejects image input), and strip `max_output_tokens` on the OVH lane so translated Responses requests no longer trigger upstream 400 extra arguments errors. Model catalog count updated from 35 to 34 across documentation and tests.
+- debb162: Report client version 1.19.4 to OpenCode, matching the current upstream release. The session-ID format is unchanged: upstream refactored its generator in the same release, and identifiers are still `ses_` followed by 12 hexadecimal timestamp characters and 14 random characters.
+- b5083bd: Stop OVH Qwen models from failing with `400 feature 'extra arguments: {"chat_template_kwargs": …}' is not currently supported`.
+  
+  The host classifies the loopback proxy as a local OpenAI-compatible backend before model compat overrides land, so `Qwen3.x` ids were treated as template-dialect Qwen and every OVH request carried `chat_template_kwargs` (`enable_thinking`, `preserve_thinking`). OVH's OpenAI-compatible surface rejects those fields. The OVH lane now pins `thinkingFormat: "openai"` and clears `qwenPreserveThinking`, and `handleOvhRequest` strips any Qwen template controls that still reach the proxy.
+- 92a818a: Normalize OVH reasoning stream chunks from `delta.reasoning` to standard `delta.reasoning_content` so OMP and OpenAI-compatible clients capture thinking tokens without reporting empty turns. Defensively strip `reasoning_effort` on non-reasoning OVH models (`Meta-Llama-3_3-70B-Instruct` and `Mistral-Small-3.2-24B-Instruct-2506`) to prevent upstream HTTP 400 unsupported feature errors.
+- debb162: Remove MiniMax M3.1 Flash from the free catalog: both free endpoints are gone. OpenCode Zen answers HTTP 410 with a model-level deprecation pointing at `deepseek-v4.1-flash-free`, and the KiloCode free id answers HTTP 404 "does not exist" while the gateway listing keeps only a paid id. Both leave the picker and both stay dead-listed, so a stale cache cannot bring them back. The `minimax-m3.1-flash` short name is removed rather than pointing at a paid model. The catalog is 35 models: 11 from OpenCode Zen, 15 from KiloCode Gateway, 1 from Cline, 8 from OVHcloud AI Endpoints.
+
 ## 1.41.0
 
 ### Minor Changes

package/README.md

@@ -1,6 +1,6 @@
 # pi-freeflow
 
-> 37 free models with up to 1M context. No API keys to manage. Add your own relays to spread requests across more IPs.
+> 34 free models with up to 1M context. No API keys to manage. Add your own relays to spread requests across more IPs.
 
 Thin by design: a model list, a relay proxy, and a log. The host (`pi-ai`) handles thinking, normalization, and provider behavior.
 
@@ -16,7 +16,7 @@ Thin by design: a model list, a relay proxy, and a log. The host (`pi-ai`) handl
 
 | Feature | What it does | Cost |
 | :--- | :--- | :--- |
-| **37 free models** | 12 from OpenCode Zen, 16 from KiloCode Gateway, 1 from Cline, 8 from OVHcloud AI Endpoints, context windows up to 1M. Full list below. | **$0** |
+| **34 free models** | 10 from OpenCode Zen, 15 from KiloCode Gateway, 1 from Cline, 8 from OVHcloud AI Endpoints, context windows up to 1M. Full list below. | **$0** |
 | **Relay pool** | Route requests through your own relays: a self-hosted egress pool (many egress IPs on one small host) or Cloudflare Workers / Deno Deploy / Vercel Edge workers. Traffic spreads across the pool, or stays on one sticky relay. A relay that rate-limits, times out, or drops the connection cools down while healthy ones take its traffic. | **$0** beyond your host or platforms' free tiers |
 | **Automatic fallback** | When every relay is cooling down, requests go direct to upstream instead of failing. | **$0** |
 | **Short model names** | Most models have a slash-free, colon-free alias, plus an optional `:effort` suffix for thinking depth. You type `freeflow/<name>`; the Cline model has no alias and must be typed in full. | **$0** |
@@ -214,24 +214,23 @@ The same command set works identically in OMP and Pi:
 
 ---
 
-### 37 models, one command
+### 34 models, one command
 
 ```bash
 /model → freeflow → pick
 ```
 
-Every model specification is reconciled against [models.dev](https://models.dev/), [OpenRouter](https://openrouter.ai/), and OMP's built-in catalog on 2026-10-22: a free and a non-free variant of the same model share the highest published context window, output ceiling, and input modalities across its twins. The catalog follows that published spec even where a free lane enforces a lower runtime cap; the authentic upstream error is surfaced above it. Where the lane itself refuses above a published figure, the served boundary wins (MiniMax M3.1 Flash: published 512,000, served 524,288). (Measured runtime caps: MiMo ~348K, GLM 5.3 Flash ~297K, Laguna S 262K.) Lane-published hard caps stay authoritative where the lane refuses above them: OVH's advertised context windows, the 1,000,000-token Nemotron 3 Ultra ceiling, and Dots3-Note's 393,216 served window (its only provider refused a 460,800 output budget on 2026-10-20).
+Every model specification is reconciled against [models.dev](https://models.dev/), [OpenRouter](https://openrouter.ai/), and OMP's built-in catalog on 2026-10-22: a free and a non-free variant of the same model share the highest published context window, output ceiling, and input modalities across its twins. The catalog follows that published spec even where a free lane enforces a lower runtime cap; the authentic upstream error is surfaced above it. Where the lane itself refuses above a published figure, the served boundary wins (DeepSeek V4.1 Flash: published 384,000, served 393,216). (Measured runtime caps: MiMo ~348K, GLM 5.3 Flash ~297K, Laguna S 262K.) Lane-published hard caps stay authoritative where the lane refuses above them: OVH's advertised context windows, the 1,000,000-token Nemotron 3 Ultra ceiling, and Dots3-Note's 393,216 served window (its only provider refused a 460,800 output budget on 2026-10-20). These tables mirror `src/models.ts`, and the scheduled health check retires a model only after a live model-level 404/410 — so a row that no longer answers is a bug worth filing.
 
 The host catalog carries text and image inputs only. Upstream video and audio support (MiMo: audio + video; GLM 5.3 Flash: video + PDF; Nemotron Super VL and Nano Omni: video) is therefore not selectable from the picker and is not declared in `input`.
 
-#### OpenCode Zen (12 models), Chat Completions API
+#### OpenCode Zen (10 models), Chat Completions API
 
 Good defaults for long coding sessions and agentic work.
 
 | Model ID | Creator / Lab | Context | Max Output | Thinking | Vision |
 | :--- | :--- | :--- | :--- | :--- | :--- |
-| `cat-jam-free` | Cat Jam | **1M** (1.048.576) | **131K** (131.072) | `low … max` | ❌ |
-| `mimo-v2.6-flash-free` | Xiaomi MiMo | **1M** (1.048.576) | **128K** (131.072) | `minimal … xhigh`\* | ✅ |
+| `mimo-v2.6-flash-free` | Xiaomi MiMo | **1M** (1.048.576) | **128K** (131.072) | `minimal … xhigh`\* | ❌ |
 | `nemotron-3.5-lightning-free` | NVIDIA | **1M** (1.000.000) | **235K** (235.929) | `minimal … xhigh` | ❌ |
 | `nemotron-3.5-super-vl-free` | NVIDIA | **1M** (1.048.576) | **235K** (235.929) | `minimal … xhigh` | ✅ |
 | `nemotron-3-ultra-free` | NVIDIA | **1M** (1.000.000) | **182K** (182.520) | `minimal … xhigh` | ❌ |
@@ -240,10 +239,9 @@ Good defaults for long coding sessions and agentic work.
 | `glm-5.3-flash-free` | Zhipu AI | **1M** (1.048.576) | **131K** (131.072) | `low / high / max` | ✅ |
 | `beam-free` | Reflection AI | **1M** (1.048.576) | **131K** (131.072) | `low … max` | ❌ |
 | `deepseek-v4.1-flash-free` | DeepSeek | **1M** (1.048.576) | **393K** (393.216) | `low / high / max` | ✅ |
-| `minimax-m3.1-flash-free` | MiniMax | **1M** (1.000.000) | **512K** (524.288) | `low … max` | ✅ |
 | `flint-40b-free` | Recursive | **262K** (262.144) | **65K** (65.536) | `low … max` | ❌ |
 
-#### KiloCode Gateway (16 models), OpenRouter compatible
+#### KiloCode Gateway (15 models), OpenRouter compatible
 
 Keyless access. Most rows have a short alias (shown with the full ID in parentheses); a row that shows only the full ID has no short form.
 
@@ -260,7 +258,6 @@ Keyless access. Most rows have a short alias (shown with the full ID in parenthe
 | `kilo-auto` (`kilo-auto/free`) | Kilo Gateway Auto | **256K** (256.000) | **10K** (10.000) | `minimal…xhigh`\* | ❌ |
 | `openrouter` (`openrouter/free`) | OpenRouter Free | **200K** (200.000) | **65K** (65.536) | `minimal…xhigh`\* | ✅ |
 | `glyph-cluster` (`stealth/glyph-cluster`) | Stealth preview (lab undisclosed) | **256K** (256.000) | **256K** (256.000) | `minimal…xhigh`\* | ❌ |
-| `minimax/minimax-m3.1-flash:free` | MiniMax | **1M** (1.000.000) | **512K** (524.288) | `low…max`\* | ✅ |
 | `nvidia/nemotron-3.5-super-vl:free` | NVIDIA | **1M** (1.000.000) | **131K** (131.072) | `minimal…xhigh`\* | ✅ |
 | `beam-kilo` (`reflection/beam-free`) | Reflection AI | **1M** (1.048.576) | **131K** (131.072) | `low…max`\* | ❌ |
 | `flint-kilo` (`recursive/flint-v1.0:free`) | Recursive | **262K** (262.144) | **65K** (65.536) | `minimal…xhigh`\* | ❌ |
@@ -278,10 +275,11 @@ Each account can only be saved once: an extra login for an account you already h
 
 | Model ID | Creator / Lab | Context | Max Output | Thinking | Vision |
 | :--- | :--- | :--- | :--- | :--- | :--- |
-| `z-ai/glm-5.3-flash` | Zhipu AI | **1M** (1.048.576) | **131K** (131.072) | `low/high/max` | ✅ |
+| `cline-super-vl` (`cline/nemotron-3.5-super-vl`) | NVIDIA | **1M** (1.000.000) | **131K** (131.072) | `minimal … xhigh` | ✅ |
+
 #### OVHcloud AI Endpoints (8 models), OpenAI compatible
 
-Anonymous access — no account, no key, nothing to sign in to. Direct only (never through the relay pool), because OVH has no per-IP gate for relays to route around. OVH rate-limits anonymous callers per IP, so a burst of parallel subagents can hit `429 API rate limit exceeded`; the model list itself never costs anything.
+Anonymous access — no account, no key, nothing to sign in to. When the relay pool is armed, OVH requests route through your relays to bypass the 2 req/min per-IP limit for burst requests and subagents; otherwise requests route direct.
 
 Pick them with the slash-free short name (the full ID is in parentheses). The lane's rows publish `low`/`medium`/`high`; the 3.6 and 3.8 Qwens add `minimal`, and nothing on this lane offers `xhigh`/`max`.
 All eight talk the normal chat API. Hosts that prefer the responses API work too — the proxy maps that shape to chat and maps the answer back, so tool calls and streamed output behave exactly as they do on the other providers.
@@ -396,7 +394,7 @@ pnpm smoke       # verifies extensions/index.ts loads without crashing
 #### Project structure
 
 ```
-├── models.ts                # 37-model catalog definitions
+├── models.ts                # 34-model catalog definitions
 ├── index.ts                 # extension entry, lifecycle hooks
 ├── catalog.ts               # model catalog cache (24h disk)
 ├── proxy.ts                 # local proxy server (127.0.0.1:28180)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pi-freeflow",
   "type": "module",
-  "version": "1.41.0",
+  "version": "1.42.0",
   "description": "Thin provider for OMP/Pi — model list + dumb relay proxy + log; host pi-ai owns thinking/normalization",
   "main": "extensions/index.ts",
   "types": "src/index.ts",

package/src/catalog.ts

@@ -101,7 +101,8 @@ export const DEAD_MODEL_IDS = new Set<string>([
  "mimo-v2.5-free",
  "stealth/space-bunny-alpha",
  // space-bunny-free: deprecated on the Zen free tier (2026-10-20) — the
- // endpoint answers 410 ModelDeprecated and points at minimax-m3.1-flash-free.
+ // endpoint answers 410 ModelDeprecated and points at minimax-m3.1-flash-free,
+ // which was itself retired on 2026-10-23 (see below).
  "space-bunny-free",
  "qwen/qwen3.8-27b:free",
  "nvidia/nemotron-3.5-content-safety:free",
@@ -159,6 +160,28 @@ export const DEAD_MODEL_IDS = new Set<string>([
  // path and gone from the live Zen listing, four days after it was re-registered
  // from a 2026-10-16 revival. Permanently dead-listed.
  "exo-free",
+ // minimax-m3.1-flash-free: the Zen free endpoint of MiniMax M3.1 Flash was
+ // retired on 2026-10-23 — it answers HTTP 410 with a model-level deprecation
+ // and points at deepseek-v4.1-flash-free. The KiloCode free twin of the same
+ // weights died the same day (see below), so both free endpoints are gone.
+ "minimax-m3.1-flash-free",
+ // minimax/minimax-m3.1-flash:free: the KiloCode free endpoint was retired on
+ // 2026-10-23 too — a direct gateway request answers HTTP 404 "The requested
+ // model 'minimax/minimax-m3.1-flash:free' does not exist" (model_not_found)
+ // on every attempt, and the live /api/gateway/models listing carries only the
+ // PAID minimax/minimax-m3.1-flash. No short alias exists for it: a short name
+ // must never route to a paid model.
+ "minimax/minimax-m3.1-flash:free",
+ // cat-jam-free: retired upstream (2026-10-24) — every request path
+ // (chat non-stream, chat stream, and responses) through the relay pool answers
+ // persistent HTTP 404 "Upstream request failed: Endpoint is unavailable." across
+ // multiple independent runs, while sibling OpenCode models (deepseek, mimo,
+ // nemotron) answer 200 on the same request shapes.
+ "cat-jam-free",
+ // z-ai/glm-5.3-flash: retired from the Cline free catalog (2026-10-24) — paid
+ // model that drains account credits and answers HTTP 402 insufficient_credits.
+ // Replaced with Cline's verified working free tier model.
+ "z-ai/glm-5.3-flash",
 ]);
 /**
  * Free-tier allowlist for anything entering the picker via network or stale disk.
@@ -198,7 +221,7 @@ export function sanitizeCatalogModels(models: RegisteredModel[]): RegisteredMode
 }
 /**
  * In-memory cache of currently active/available free models.
- * Initialized with all 37 verified models for 0ms instant availability.
+ * Initialized with all 35 verified models for 0ms instant availability.
  */
 let aliveCatalog: RegisteredModel[] = ALL_MODELS.map((m) => ({
  ...m,

package/src/cline-accounts.ts

@@ -16,7 +16,8 @@ import { writeFileAtomic } from "./atomic-write.ts";
 import { RELAY_STATE_FILE } from "./config.ts";
 import { logWarn } from "./logger.ts";
 import type { FetchImpl } from "./cline-device-auth.ts";
-import { isWorkosJwt } from "./cline-device-auth.ts";
+import { isWorkosJwt, refreshClineToken, toApiKey } from "./cline-device-auth.ts";
+import { fetchWithSystemCA } from "./system-ca-fetch.ts";
 
 /** Env override for the pool file location (tests/CI sandbox). */
 const CLINE_POOL_FILE_ENV = "PI_FREEFLOW_CLINE_POOL_FILE";
@@ -115,38 +116,183 @@ export function _resetClinePoolCacheForTest(): void {
  cachedMtime = -1;
 }
 
-/** Version this proxy reports as its Cline client build. */
-const CLINE_CLIENT_VERSION = "3.5.54";
+/** Bundled fallback version if dynamic fetch and disk cache are absent. */
+export const BUNDLED_CLINE_VERSION = "4.1.25";
+export const CLINE_CLIENT_VERSION = BUNDLED_CLINE_VERSION;
+
+const CLINE_VERSION_TTL_MS = 24 * 60 * 60 * 1000;
+let liveClineVersion: string | null = null;
+
+function clineVersionCachePath(): string {
+ return path.join(path.dirname(CLINE_POOL_FILE), "pi-freeflow-cline-version.json");
+}
+
+export function _resetLiveClineVersionForTest(): void {
+ liveClineVersion = null;
+}
 
 /**
- * Client headers the Cline API expects. Measured live (2026-09-21): the
- * `cline-free/*` models answer 403 "only available via Cline product surfaces"
- * with a bare bearer, and 200 with this set; every non-prefixed catalog model
- * (e.g. z-ai/glm-5.3-flash) answers 200 either way. Header names and shape
- * mirror reference/cline providers/request-headers.ts
- * (DEFAULT_CLINE_REQUEST_HEADERS) — no credential is derived from them.
- *
- * `X-CLIENT-TYPE` is the Cline desktop app's identity, and it gates the
- * `cline-free/*` id space (measured live 2026-09-22: that prefix answers 403
- * "only available via Cline product surfaces" with a bare bearer, and 200 with
- * this set; every non-prefixed id answers 200 either way). The header is kept
- * because `cline-free/*` ids can still appear in a stale host registration —
- * until 2026-10-13 that prefix covered four models, and
- * `cline-free/muse-spark-1.3-contributor` survived it until 2026-10-22. It also
- * decided the free-model feed at the time: five entries for
- * `cline-sdk` / `cline-cli` / the `VSCode Extension` label against six for
- * `cline-desktop`, the extra one being `cline-free/kimi-k3`. That sixth model
- * is retired upstream and no longer requested. Version and User-Agent stay
- * as-is: the feed served the desktop list with them unchanged.
+ * Resolve effective Cline client version. Precedence:
+ * env override (PI_FREEFLOW_CLINE_VERSION) > in-memory version > fresh disk cache > BUNDLED_CLINE_VERSION.
  */
-const CLINE_CLIENT_HEADERS: Record<string, string> = {
- "HTTP-Referer": "https://cline.bot",
- "X-Title": "Cline",
- "X-IS-MULTIROOT": "false",
- "X-CLIENT-TYPE": "cline-desktop",
- "X-CLIENT-VERSION": CLINE_CLIENT_VERSION,
- "User-Agent": `Cline/${CLINE_CLIENT_VERSION}`,
-};
+export function getClineVersion(): string {
+ const override = process.env.PI_FREEFLOW_CLINE_VERSION?.trim();
+ if (override) return override;
+ if (liveClineVersion) return liveClineVersion;
+ try {
+  const cachePath = clineVersionCachePath();
+  if (fs.existsSync(cachePath)) {
+   const data = JSON.parse(fs.readFileSync(cachePath, "utf8")) as { version?: string; checkedAt?: number };
+   if (typeof data.version === "string" && data.version.trim() && typeof data.checkedAt === "number" && Date.now() - data.checkedAt < CLINE_VERSION_TTL_MS) {
+    liveClineVersion = data.version.trim();
+    return liveClineVersion;
+   }
+  }
+ } catch { }
+ return BUNDLED_CLINE_VERSION;
+}
+
+/**
+ * Client headers the Cline API expects, evaluated dynamically with the current version.
+ */
+export function getClineClientHeaders(): Record<string, string> {
+ const ver = getClineVersion();
+ return {
+  "HTTP-Referer": "https://cline.bot",
+  "X-Title": "Cline",
+  "X-IS-MULTIROOT": "false",
+  "X-CLIENT-TYPE": "cline-desktop",
+  "X-CLIENT-VERSION": ver,
+  "User-Agent": `Cline/${ver}`,
+ };
+}
+
+/**
+ * Proxy object for CLINE_CLIENT_HEADERS providing full backward compatibility.
+ */
+export const CLINE_CLIENT_HEADERS: Record<string, string> = new Proxy({} as Record<string, string>, {
+ get(_target, prop) {
+  return getClineClientHeaders()[prop as string];
+ },
+ has(_target, prop) {
+  return prop in getClineClientHeaders();
+ },
+ ownKeys(_target) {
+  return Object.keys(getClineClientHeaders());
+ },
+ getOwnPropertyDescriptor(_target, prop) {
+  const val = getClineClientHeaders()[prop as string];
+  return val !== undefined ? { value: val, writable: false, enumerable: true, configurable: true } : undefined;
+ },
+});
+
+/**
+ * Refresh the live Cline version from open-vsx or GitHub releases and persist to disk.
+ */
+export async function refreshClineVersion(fetchImpl: FetchImpl = fetchWithSystemCA): Promise<string> {
+ try {
+  const res = await fetchImpl("https://open-vsx.org/api/saoudrizwan/claude-dev", {
+   headers: { "User-Agent": "pi-freeflow" },
+   signal: AbortSignal.timeout(5000),
+  });
+  if (res.ok) {
+   const data = (await res.json()) as { version?: string };
+   if (typeof data.version === "string" && /^\d+\.\d+\.\d+/.test(data.version)) {
+    liveClineVersion = data.version.trim();
+    try {
+     const cachePath = clineVersionCachePath();
+     writeFileAtomic(cachePath, JSON.stringify({ version: liveClineVersion, checkedAt: Date.now() }));
+    } catch { }
+    return liveClineVersion;
+   }
+  }
+ } catch { }
+ return getClineVersion();
+}
+async function defaultClineRefresher(refreshToken: string): Promise<ClineRefreshResult | null> {
+ try {
+  const creds = await refreshClineToken(undefined, refreshToken);
+  return { token: toApiKey(creds.access), refreshToken: creds.refresh, expiresAt: creds.expires };
+ } catch {
+  return null;
+ }
+}
+/**
+ * Background auto-probing & keep-alive for Cline account tokens.
+ * Proactively refreshes tokens nearing expiry (<30 min remaining or expired)
+ * so that saved accounts never lapse into unrecoverable dead grants.
+ * Also performs a lightweight ping to verify the account is active.
+ */
+export async function keepClineTokensAlive(
+ opts: {
+  fetchImpl?: FetchImpl;
+  refreshImpl?: ClineRefresher;
+ } = {},
+): Promise<{ refreshed: number; probed: number }> {
+ const pool = loadPool();
+ if (pool.accounts.length === 0) return { refreshed: 0, probed: 0 };
+ const fetchImpl = opts.fetchImpl ?? fetchWithSystemCA;
+ const refreshImpl = opts.refreshImpl ?? defaultClineRefresher;
+ const now = Date.now();
+ const REFRESH_THRESHOLD_MS = 30 * 60 * 1000;
+ let refreshed = 0;
+ let probed = 0;
+
+ for (const account of pool.accounts) {
+  if (!account.refreshToken) continue;
+  const isExpiringSoon = typeof account.expiresAt === "number" && (account.expiresAt - now < REFRESH_THRESHOLD_MS);
+  const isExpired = typeof account.expiresAt === "number" && account.expiresAt <= now;
+  const needsRefresh = isExpiringSoon || isExpired || isClineTokenStale(account);
+
+  if (needsRefresh) {
+   try {
+    const outcome = await refreshAccountInPlace(account, refreshImpl);
+    if (outcome === true) {
+     refreshed += 1;
+    }
+   } catch {
+    continue;
+   }
+  }
+
+  // Light probe: ping models endpoint with light timeout to keep the session warm
+  try {
+   const token = account.token;
+   const probeRes = await fetchImpl("https://api.cline.bot/api/v1/models", {
+    method: "GET",
+    headers: {
+     ...getClineClientHeaders(),
+     authorization: `Bearer ${token}`,
+    },
+    signal: AbortSignal.timeout(6000),
+   });
+   if (probeRes.ok) {
+    probed += 1;
+   }
+  } catch { }
+ }
+
+ return { refreshed, probed };
+}
+
+export const CLINE_MODEL_PREFIX = "cline/";
+
+/**
+ * Maps a catalog Cline model ID to the exact wire model ID expected by Cline API.
+ */
+export function clineUpstreamModelId(id: string): string {
+ const trimmed = id.trim();
+ if (trimmed === "cline/nemotron-3.5-super-vl") {
+  return "nvidia/nemotron-3.5-super-vl:free";
+ }
+ if (trimmed.startsWith(CLINE_MODEL_PREFIX)) {
+  return trimmed.slice(CLINE_MODEL_PREFIX.length);
+ }
+ if (trimmed.startsWith("cline-free/")) {
+  return trimmed.slice("cline-free/".length);
+ }
+ return trimmed;
+}
 
 /**
  * Free-limit report carried by a Cline 429 body, e.g.
@@ -166,7 +312,19 @@ interface ClineFreeLimit {
  resetAt?: number;
 }
 
-const CLINE_FREE_LIMIT_MARKER = /free limit reached on model/i;
+const CLINE_FREE_LIMIT_MARKER = /(?:free limit reached on model|Daily limit reached for)/i;
+
+/**
+ * Extract epoch reset from X-RateLimit-Reset if present in headers or metadata.
+ * Converts epoch seconds (<1e11) to ms.
+ */
+function parseXRateLimitReset(text: string): number | null {
+ const m = text.match(/X-RateLimit-Reset[\\"\s:]+([0-9.]+)/i);
+ if (!m) return null;
+ const val = Number(m[1]);
+ if (!Number.isFinite(val) || val <= 0) return null;
+ return val < 1e11 ? Math.round(val * 1000) : Math.round(val);
+}
 
 /**
  * Delay stated as `try again in <N>h <N>m`, `<N>m`, or a bare `<N>` (hours).
@@ -191,13 +349,15 @@ function parseResetDelayMs(text: string): number | null {
  */
 export function parseClineFreeLimit(raw: string, now = Date.now()): ClineFreeLimit | null {
  if (typeof raw !== "string" || !CLINE_FREE_LIMIT_MARKER.test(raw)) return null;
- const named = raw.match(/free limit reached on model\s+(\S+)/i);
+ const named = raw.match(/(?:free limit reached on model|Daily limit reached for)\s+([^\\"\s,;]+)/i);
  // The model name ends the sentence, so a trailing "." belongs to the prose.
  const modelId = named ? named[1].replace(/[.,;:]+$/, "") : "";
- const delay = parseResetDelayMs(raw);
+ const epochReset = parseXRateLimitReset(raw);
+ const delay = epochReset !== null ? null : parseResetDelayMs(raw);
+ const resetAt = epochReset !== null ? epochReset : delay !== null ? now + delay : undefined;
  return {
   ...(modelId ? { modelId } : {}),
-  ...(delay !== null ? { resetAt: now + delay } : {}),
+  ...(resetAt !== undefined ? { resetAt } : {}),
  };
 }
 
@@ -894,6 +1054,82 @@ function exhaustedResponse(reason: string, status: number): Response {
  );
 }
 
+/**
+ * For OpenRouter-backed Cline models, Cline sometimes answers HTTP 200
+ * `text/event-stream` where the first event is an in-stream 429 error
+ * (e.g. `stream_initialization_failed` with status 429 / daily limit reached).
+ * Peek the first chunk: if it is an in-stream 429 error, convert it to a 429
+ * Response so rollChat rolls to the next slot; otherwise, reconstruct the
+ * stream with the peeked chunk re-enqueued.
+ */
+async function peekStreamForInStreamError(res: Response): Promise<{ res: Response; inStreamError: boolean; errorText: string }> {
+ const contentType = res.headers.get("content-type") || "";
+ if (!contentType.includes("text/event-stream") || !res.body) {
+  return { res, inStreamError: false, errorText: "" };
+ }
+ try {
+  const reader = res.body.getReader();
+  const { done, value } = await reader.read();
+  if (done || !value || value.byteLength === 0) {
+   return {
+    res: new Response(null, { status: res.status, statusText: res.statusText, headers: res.headers }),
+    inStreamError: false,
+    errorText: "",
+   };
+  }
+  const text = new TextDecoder().decode(value);
+  const isInStream429 = (
+   text.includes('"stream_initialization_failed"') ||
+   text.includes('"error":') ||
+   text.includes('"Rate limit exceeded"') ||
+   text.includes("Daily limit reached")
+  ) && (
+   text.includes("429") ||
+   /status["\s:]+429/i.test(text) ||
+   /Rate limit exceeded/i.test(text) ||
+   /Daily limit reached/i.test(text)
+  );
+
+  if (isInStream429) {
+   try { await reader.cancel(); } catch { }
+   const errRes = new Response(text, {
+    status: 429,
+    headers: { "content-type": "application/json" },
+   });
+   return { res: errRes, inStreamError: true, errorText: text };
+  }
+
+  const reconstructed = new ReadableStream<Uint8Array>({
+   start(controller) {
+    controller.enqueue(value);
+   },
+   async pull(controller) {
+    try {
+     const { done: nextDone, value: nextValue } = await reader.read();
+     if (nextDone) {
+      controller.close();
+     } else if (nextValue) {
+      controller.enqueue(nextValue);
+     }
+    } catch (err) {
+     controller.error(err);
+    }
+   },
+   cancel(reason) {
+    return reader.cancel(reason);
+   },
+  });
+
+  return {
+   res: new Response(reconstructed, { status: res.status, statusText: res.statusText, headers: res.headers }),
+   inStreamError: false,
+   errorText: "",
+  };
+ } catch {
+  return { res, inStreamError: false, errorText: "" };
+ }
+}
+
 /**
  * POST one chat body to the Cline endpoint, rolling across every saved slot.
  * Each attempt sends its slot bearer explicitly; raw tokens never leave this
@@ -1028,6 +1264,14 @@ export async function rollChat(opts: ClineRollOpts): Promise<ClineRollResult> {
   };
   let res = await attempt(account.token);
   if (!res) continue;
+  let inStreamLimitText: string | null = null;
+  if (res.status === 200 && res.headers.get("content-type")?.includes("text/event-stream")) {
+   const peek = await peekStreamForInStreamError(res);
+   res = peek.res;
+   if (peek.inStreamError) {
+    inStreamLimitText = peek.errorText;
+   }
+  }
   let kind = mapClineError(res.status);
   if (kind === "ok" || kind === "client") return await succeed(res, kind);
   // Auth failure on a refreshable slot that has not refreshed yet: one
@@ -1057,7 +1301,7 @@ export async function rollChat(opts: ClineRollOpts): Promise<ClineRollResult> {
   // for the requested model until the stated reset: remember it, so the next
   // turn tries the other logins first.
   if (res.status === 429) {
-   const limit = await freeLimitFrom(res, now);
+   const limit = inStreamLimitText ? parseClineFreeLimit(inStreamLimitText, now) : await freeLimitFrom(res, now);
    if (limit) {
     cappedSlots.add(account.slot);
     if (limit.modelId) limitModelId = limit.modelId;

package/src/config.ts

@@ -75,7 +75,7 @@ export const PORT = resolvePort();
 // OPENCODE_VERSION_FLOOR pins the minimum; OPENCODE_VERSION_FALLBACK is the
 // last-known-good npm version used when the live lookup is stale/offline.
 export const OPENCODE_VERSION_FLOOR = "1.17.0";
-export const OPENCODE_VERSION_FALLBACK = "1.19.0";
+export const OPENCODE_VERSION_FALLBACK = "1.19.4";
 /** Live npm lookup TTL: 6h — within one window the cached UA is reused. */
 export const OPENCODE_VERSION_TTL_MS = 6 * 60 * 60 * 1_000;
 /** Env override: exact `opencode/<version>` UA (or bare version) for tests/pins. */
@@ -239,6 +239,10 @@ export function createOpenCodeId(descending: boolean, timestamp = Date.now()): s
  return time + Array.from(bytes, (byte) => ID_CHARS[byte % 62]).join("");
 }
 
+// Upstream v1.19.4 refactored `SessionID.create` to compose the prefix itself
+// (`schema.make("ses_" + descending())` in packages/schema/src/session-id.ts).
+// The identifier generator is unchanged, so this call is still byte-for-byte
+// equivalent: `ses_` + 12 hex timestamp chars + 14 base62 random chars.
 export function createOpenCodeSessionId(): string {
  return `ses_${createOpenCodeId(true)}`;
 }

package/src/daemon.ts

@@ -31,7 +31,7 @@ import {
  stopLeaseGC,
  touchActivity,
 } from "./lease.ts";
-import { getActiveRequests, startProxy } from "./proxy.ts";
+import { getActiveRequests, startClineKeepAlive, startProxy } from "./proxy.ts";
 import { loadRelayState, setActiveRelayState } from "./relay-state.ts";
 
 /** True when this module was run as the entry script (not imported by tests). */
@@ -122,6 +122,7 @@ async function runDaemon(): Promise<void> {
  touchActivity();
  syncRelayStateFromDisk();
  void seedCatalog();
+ startClineKeepAlive();
 
  // Retire only when zero leases persist past the grace window with nothing
  // in flight — never for request-idleness.

package/src/deploy.ts

@@ -23,8 +23,8 @@ import { randomBytes } from "node:crypto";
  *   auth gate (legacy/manual deploys); built-in deploys always embed one.
  */
 function buildRelayWorkerCore(relayAuth: string): string {
- return String.raw`// Only the 2 upstreams pi-freeflow talks to. Anything else = open proxy abuse.
-const ALLOWED_TARGETS = ["https://opencode.ai", "https://api.kilo.ai"];
+ return String.raw`// Upstreams pi-freeflow talks to. Anything else = open proxy abuse.
+const ALLOWED_TARGETS = ["https://opencode.ai", "https://api.kilo.ai", "https://oai.endpoints.kepler.ai.cloud.ovh.net"];
 const RELAY_AUTH = ${JSON.stringify(relayAuth)};
 const resolveRelayTarget = function(target, relayPath) {
   let targetUrl;

package/src/index.ts

@@ -145,22 +145,44 @@ export function buildProviderConfig(
     contextWindow: m.contextWindow,
     maxTokens: m.maxTokens,
     cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-    compat: m.thinkingFormat
+    compat: {
+     ...(m.thinkingFormat
      ? {
       supportsDeveloperRole: false,
       thinkingFormat: m.thinkingFormat,
      }
      : m.api === "openai-responses"
       ? { sessionAffinityFormat: "openai-nosession" }
-      : m.source === "kilo" || m.source === "cline" || m.source === "ovh"
+      : m.source === "kilo" || m.source === "cline"
        ? {
         supportsDeveloperRole: false,
         supportsReasoningEffort: !!m.thinkingLevelMap,
        }
-       : {
-        supportsDeveloperRole: false,
-        supportsReasoningEffort: true,
-       },
+       // OVH is a plain OpenAI chat endpoint. Without an explicit format the
+       // host sees the loopback proxy URL, classifies the lane as a local
+       // backend and treats `Qwen3.x` ids as template-dialect Qwen, emitting
+       // `chat_template_kwargs` that OVH rejects with
+       // `400 feature 'extra arguments: ...' is not currently supported`.
+       // Pin the format so the host sends `reasoning_effort` instead.
+       : m.source === "ovh"
+        ? {
+         supportsDeveloperRole: false,
+         supportsReasoningEffort: !!m.thinkingLevelMap,
+         thinkingFormat: "openai",
+         // The host derives these two from the loopback base URL before the
+         // spec override lands: `thinkingFormat` is overridden above, but
+         // `qwenPreserveThinking` was already latched on and still emits
+         // `chat_template_kwargs.preserve_thinking`. Clear it explicitly.
+         qwenPreserveThinking: false,
+        }
+        : {
+         supportsDeveloperRole: false,
+         supportsReasoningEffort: true,
+        }),
+     ...(m.requiresReasoningContentOnAssistantMessages !== undefined
+      ? { requiresReasoningContentOnAssistantMessages: m.requiresReasoningContentOnAssistantMessages }
+      : {}),
+    },
    };
   }),
  };

package/src/models.ts

@@ -1,9 +1,9 @@
 /**
  * Static model definitions and upstream routing catalogs for pi-freeflow
  *
- * Defines the 37 verified free models (live-verified 2026-10-22):
- * - 12 OpenCode Zen models (all Chat Completions)
- * - 16 KiloCode Keyless Gateway models (OpenRouter format)
+ * Defines the 34 verified free models (live-verified 2026-10-24):
+ * - 10 OpenCode Zen models (all Chat Completions)
+ * - 15 KiloCode Keyless Gateway models (OpenRouter format)
  * - 1 Cline direct-only model (per-user pool; z-ai/glm-5.3-flash)
  * - 8 OVHcloud AI Endpoints models (keyless, direct-only)
  *
@@ -33,32 +33,6 @@ import type { ModelDef, ThinkingLevelMap, Upstream } from "./types.ts";
  * Endpoint: https://opencode.ai/inference/v1
  */
 export const OPENCODE_MODELS: ModelDef[] = [
- {
-  id: "cat-jam-free",
-  name: "Cat Jam [OpenCode]",
-  reasoning: true,
-  // Confirmed 2026-10-20: the endpoint refuses a 1.05M-token prompt with
-  // "maximum context length is 1048576 tokens", and a 900,337-token needle
-  // probe recalled correctly. The earlier ~250K miss was recall, not
-  // truncation.
-  contextWindow: 1_048_576,
-  maxTokens: 131_072,
-  input: ["text"],
-  // Effort ladder live-probed 2026-10-16: the gateway enumerates
-  // max/xhigh/high/medium/low as the supported set for this model — a probe
-  // with `minimal`, `none`, or a bogus value answers 400 naming exactly
-  // that list, and `max` answers 200 with a populated reasoning stream. So
-  // `max` is a real level here, not a silent clamp.
-  thinkingLevelMap: {
-   off: null,
-   minimal: null,
-   low: "low",
-   medium: "medium",
-   high: "high",
-   xhigh: "xhigh",
-   max: "max",
-  },
- },
  {
   id: "mimo-v2.6-flash-free",
   name: "MiMo V2.6 Flash [OpenCode]",
@@ -70,7 +44,7 @@ export const OPENCODE_MODELS: ModelDef[] = [
   // a caller sees above the lane's cap.
   contextWindow: 1_048_576,
   maxTokens: 131_072,
- input: ["text", "image"],
+  input: ["text"],
   thinkingLevelMap: {
    off: null,
    minimal: "low",
@@ -270,6 +244,7 @@ export const OPENCODE_MODELS: ModelDef[] = [
   id: "deepseek-v4.1-flash-free",
   name: "DeepSeek V4.1 Flash [OpenCode]",
   reasoning: true,
+  requiresReasoningContentOnAssistantMessages: true,
   // 1,048,576, matching both the published twin and the probe: a marker
   // planted mid-prompt is still recalled through prompt_tokens=1,030,800, and
   // the gateway turns an oversized request away with an empty-bodied 400
@@ -298,43 +273,6 @@ export const OPENCODE_MODELS: ModelDef[] = [
    max: "max",
   },
 },
- {
-  // Added 2026-10-22: new free model on the OpenCode Zen lane, live-probed
-  // against the gateway rather than copied from a published row.
-  // Availability: 5/5 probes answered 200 through the fingerprint path
-  // (chat + stream + tool call), so this is a stable listing.
-  // Context: 1,000,000 measured — a needle planted at prompt_tokens 991,641
-  // is recalled, and a request above the window is refused. That makes the
-  // declared figure the lane's own 1M cap, not a published twin value.
-  // maxTokens: the rejection boundary is 524,288 (600,000 is refused with
-  // "does not support max tokens > 524288"), so the exact served ceiling is
-  // the budget. models.dev publishes the rounded 512,000; acceptance is not a
-  // cap, so the boundary wins.
-  // Vision verified live. Effort ladder probed level-by-level: low, medium,
-  // high, xhigh and max each answer 200 with reasoning deltas. `off` answers
-  // 400 and `minimal` is accepted but absent from the published ladder, so
-  // both stay null and the picker never offers them. Chat is the native
-  // shape, so `api` stays unset.
-  // Known caveat, measured on trivial prompts at high effort: the model
-  // sometimes calls the injected fingerprint placeholder tool, which the
-  // cloak strips — the host then sees a tool_calls finish with no visible
-  // calls. The turn still completes; nothing is dropped from a real call.
-  id: "minimax-m3.1-flash-free",
-  name: "MiniMax M3.1 Flash [OpenCode]",
-  reasoning: true,
-  contextWindow: 1_000_000,
-  maxTokens: 524_288,
-  input: ["text", "image"],
-  thinkingLevelMap: {
-   off: null,
-   minimal: null,
-   low: "low",
-   medium: "medium",
-   high: "high",
-   xhigh: "xhigh",
-   max: "max",
-  },
- },
  {
   // Added 2026-10-22. Availability on this lane is bursty: the same day it
   // answered 1 of 19 probes across ~25 minutes and later 8 of 8 over 43
@@ -527,35 +465,6 @@ export const KILO_MODELS: ModelDef[] = [
   thinkingFormat: "openrouter",
   thinkingLevelMap: KILO_REASONING_MAP,
  },
- {
-  // Added 2026-10-22: exact gateway id, tool call + agent loop verified on
-  // both the chat and /v1/responses paths. 1,000,000 / 524,288 is the
-  // gateway `top_provider` pair, and the Zen twin (minimax-m3.1-flash-free)
-  // measured the same 524,288 output boundary — two lanes, one figure, so the
-  // twin reading is corroboration rather than a copy. Conservative twin note:
-  // both entries declare the served boundary; the rounded 512,000 some
-  // datasheets publish is not what either lane enforces.
-  // Reasoning is mandatory upstream: `none` and `off` answer 400 "Reasoning
-  // is mandatory", which is why both rungs stay null. When tools are present
-  // no reasoning deltas are reported at all (silent-thinking tool turns), so
-  // the map's level labels describe the effort sent, not visible thought.
-  id: "minimax/minimax-m3.1-flash:free",
-  name: "MiniMax M3.1 Flash [Kilo]",
-  reasoning: true,
-  contextWindow: 1_000_000,
-  maxTokens: 524_288,
-  input: ["text", "image"],
-  thinkingFormat: "openrouter",
-  thinkingLevelMap: {
-   off: null,
-   minimal: null,
-   low: "low",
-   medium: "medium",
-   high: "high",
-   xhigh: "xhigh",
-   max: "max",
-  },
- },
  {
   // Added 2026-10-22: exact gateway id, tool call + agent loop verified on
   // both the chat and /v1/responses paths.
@@ -654,22 +563,6 @@ export const KILO_MODELS: ModelDef[] = [
  },
 ];
 
-/**
- * Narrow effort map for the Cline model in the catalog (GLM 5.3 Flash) — the
- * reference reasoningOptions list effort values [low, high, max] only (no
- * toggle on GLM); minimal/medium/xhigh are not offered so the host never
- * sends an unsupported level (the proxy forwards effort verbatim).
- */
-const CLINE_FLASH_REASONING_MAP: ThinkingLevelMap = {
- off: null,
- minimal: null,
- low: "low",
- medium: null,
- high: "high",
- xhigh: null,
- max: "max",
-};
-
 /**
  * Cline free models (per-user local pool — https://api.cline.bot).
  * Direct-only: never served through the relay pool. IDs are Cline-native
@@ -684,13 +577,21 @@ const CLINE_FLASH_REASONING_MAP: ThinkingLevelMap = {
  */
 export const CLINE_MODELS: ModelDef[] = [
  {
-  id: "z-ai/glm-5.3-flash",
-  name: "GLM 5.3 Flash [Cline]",
+  id: "cline/nemotron-3.5-super-vl",
+  name: "Nemotron 3.5 Super VL [Cline]",
   reasoning: true,
- contextWindow: 1_048_576,
+  contextWindow: 1_000_000,
   maxTokens: 131_072,
- input: ["text", "image"],
-  thinkingLevelMap: CLINE_FLASH_REASONING_MAP,
+  input: ["text", "image"],
+  thinkingLevelMap: {
+   off: null,
+   minimal: "minimal",
+   low: "low",
+   medium: "medium",
+   high: "high",
+   xhigh: "xhigh",
+   max: null,
+  },
  },
 ];
 
@@ -700,7 +601,7 @@ export const CLINE_MODELS: ModelDef[] = [
  * populated reasoning stream). minimal/medium/xhigh/max were not confirmed,
  * so they map to null and the picker never offers them. `minimal` must be an
  * explicit null, not an omitted key: omitting it leaves the level selectable
- * in the host. Same shape as CLINE_FLASH_REASONING_MAP.
+ * in the host.
  */
 const OVH_REASONING_MAP: ThinkingLevelMap = {
  off: null,
@@ -858,6 +759,9 @@ export function ovhUpstreamModelId(id: string): string {
  * - Muse Spark 1.2 = Meta Superintelligence Labs (not Anthropic Claude) → removed claude-sonnet aliases
  * - Laguna S 2.1 = Poolside (not MiniMax) → removed minimax-m2.1 alias
  * - Hy3 = Tencent Hunyuan (not Alibaba Qwen) → removed qwen3-coder alias
+ * - Both free MiniMax M3.1 Flash endpoints retired on 2026-10-23 (Zen 410,
+ *   Kilo 404 model-not-found) → removed minimax-m3.1-flash alias; a short
+ *   name must never route to the surviving paid id
  */
 export const MODEL_ALIASES: Record<string, string> = {
  "dots-3-note-preview": "dots-studio/dots-3-note-preview:free",
@@ -874,9 +778,6 @@ export const MODEL_ALIASES: Record<string, string> = {
  "longcat": "longcat-2.5-preview-free",
  "beam": "beam-free",
  "deepseek-v4.1-flash": "deepseek-v4.1-flash-free",
- // Added 2026-10-22. "flint" stays on the Zen lane; the Kilo twin gets its
- // own name so neither entry can shadow the other.
- "minimax-m3.1-flash": "minimax-m3.1-flash-free",
  "flint": "flint-40b-free",
  "flint-kilo": "recursive/flint-v1.0:free",
  "beam-kilo": "reflection/beam-free",
@@ -895,6 +796,7 @@ export const MODEL_ALIASES: Record<string, string> = {
 "qwen3.8-27b": "ovh-free/Qwen3.8-27B",
 "mistral-small-3.2": "ovh-free/Mistral-Small-3.2-24B-Instruct-2506",
 "llama-3.3-70b": "ovh-free/Meta-Llama-3_3-70B-Instruct",
+"cline-super-vl": "cline/nemotron-3.5-super-vl",
 };
 
 /**
@@ -934,7 +836,7 @@ export const OVH_MODEL_IDS = new Set<string>([
   .map(([alias]) => alias),
 ]);
 /**
- * Combined list of all 37 static free models (canonical)
+ * Combined list of all 35 static free models (canonical)
  */
 export const ALL_MODELS: ModelDef[] = [...OPENCODE_MODELS, ...KILO_MODELS, ...CLINE_MODELS, ...OVH_MODELS];
 

package/src/proxy.ts

@@ -49,7 +49,7 @@ import {
 import { isDebugEnabled, log } from "./logger.ts";
 import { getModelUpstream, isClineModel, isOvhModel, KILO_MODEL_IDS, MODEL_MAP, ovhUpstreamModelId, resolveCanonicalModelId } from "./models.ts";
 import { ClineAuthError, refreshClineToken, toApiKey } from "./cline-device-auth.ts";
-import { rollChat } from "./cline-accounts.ts";
+import { rollChat, clineUpstreamModelId, keepClineTokensAlive, refreshClineVersion } from "./cline-accounts.ts";
 import { fetchWithSystemCA } from "./system-ca-fetch.ts";
 import {
 	buildFindGlobRestore,
@@ -251,6 +251,27 @@ async function clineRefreshImpl(refreshToken: string): Promise<{ token: string;
  }
 }
 
+let clineKeepAliveTimer: NodeJS.Timeout | null = null;
+const CLINE_KEEP_ALIVE_INTERVAL_MS = 15 * 60 * 1000;
+
+export function startClineKeepAlive(): void {
+ if (clineKeepAliveTimer !== null) return;
+ void keepClineTokensAlive().catch(() => {});
+ void refreshClineVersion().catch(() => {});
+ clineKeepAliveTimer = setInterval(() => {
+  void keepClineTokensAlive().catch(() => {});
+  void refreshClineVersion().catch(() => {});
+ }, CLINE_KEEP_ALIVE_INTERVAL_MS);
+ clineKeepAliveTimer.unref?.();
+}
+
+export function stopClineKeepAlive(): void {
+ if (clineKeepAliveTimer !== null) {
+  clearInterval(clineKeepAliveTimer);
+  clineKeepAliveTimer = null;
+ }
+}
+
 /**
  * Bound on the caller tool names the audit summary carries (the recorder
  * applies the same caps itself; bounding here keeps a hostile body from
@@ -385,6 +406,7 @@ async function handleClineRequest(opts: {
   if (Array.isArray(chatBody.tools)) chatBody.tools = translateToolsForPath(chatBody.tools, "/v1/chat/completions");
   delete chatBody.prompt_cache_key;
  }
+ chatBody.model = clineUpstreamModelId(model);
  // Cline bypasses the fingerprint, but its arguments still malform the same
  // way: capture the caller's own schemas before translation for repair.
  const argSchemas = buildArgRepairSchemas(Array.isArray(parsedBody.tools) ? parsedBody.tools : []);
@@ -699,14 +721,25 @@ async function handleOvhRequest(opts: {
  // Lane quirks, keyed by canonical catalog id so an alias resolves to the same
  // model (the wire id above has already lost its `ovh-free/` prefix).
  const canonicalModelId = resolveCanonicalModelId(requestedModel);
- if (canonicalModelId === OVH_NO_EFFORT_MODEL) {
-  // Measured 2026-10-22: with `reasoning_effort` present this model answers
-  // HTTP 200 whose body is a bare `data: [DONE]` — no deltas, no error — at
-  // max_tokens 4000 and 32000 alike; without the field it streams its own
-  // reasoning plus a proper tool call. Every other OVH model tolerates the
-  // field, so the strip is this model only. The responses-path translation
-  // cannot reintroduce it: chatBodyFromResponsesBody copies a fixed scalar
-  // list that carries no reasoning/effort key.
+ // OVH's OpenAI-compatible surface rejects Qwen chat-template controls
+ // (`400 feature 'extra arguments: {"chat_template_kwargs":…}' is not
+ // currently supported`). The host classifies this loopback proxy as a local
+ // OpenAI-compatible backend, treats `Qwen3.x` models as template-dialect
+ // Qwen and injects them; the lane has no such feature. Strip defensively so
+ // no host version can leak them upstream.
+ delete chatBody.chat_template_kwargs;
+ delete chatBody.enable_thinking;
+delete chatBody.preserve_thinking;
+// OVH's OpenAI-compatible surface rejects Responses-native caps (`400 feature
+// 'extra arguments: {"max_output_tokens":…}' is not currently supported`)
+// when a responses-path request was translated via chatBodyFromResponsesBody.
+// Strip defensively so the cap is not passed as an unknown extra argument.
+delete chatBody.max_output_tokens;
+ const modelDef = MODEL_MAP.get(canonicalModelId) ?? MODEL_MAP.get(requestedModel);
+ if (canonicalModelId === OVH_NO_EFFORT_MODEL || (modelDef && !modelDef.reasoning)) {
+  // Qwen3.8-27B on OVH starves when reasoning_effort is present.
+  // Non-reasoning OVH models (Llama 3.3, Mistral Small) return HTTP 400
+  // "feature 'reasoning_effort for this model' is not currently supported".
   delete chatBody.reasoning_effort;
  }
  if (canonicalModelId === OVH_STRICT_TOOL_CALL_ID_MODEL) {
@@ -736,16 +769,35 @@ async function handleOvhRequest(opts: {
  res.once("close", abortOnClientGone);
  req.once("error", abortOnClientGone);
  let upstreamRes: Response;
+ let servedRelay: string | null = null;
  try {
-  // Keyless, direct (never the relay pool). OVH serves anonymous callers but
-  // rate-limits them, so a 429 here is a real per-IP cap and must NOT carry
-  // the relay-deploy hint — this lane can never ride a relay.
-  upstreamRes = await fetch(OVH_CHAT_URL, {
-   method: "POST",
-   headers: { "Content-Type": "application/json" },
-   body: JSON.stringify(chatBody),
-   signal: controller.signal,
-  });
+  const relayState = getActiveRelayState();
+  const relayPoolOn =
+   relayState.mode !== "off" &&
+   relayState.enabled !== false &&
+   Boolean(relayState.url || (relayState.relays && relayState.relays.length > 0));
+
+  if (relayPoolOn) {
+   upstreamRes = await relayFetch(
+    OVH_CHAT_URL,
+    {
+     method: "POST",
+     headers: { "Content-Type": "application/json" },
+     body: JSON.stringify(chatBody),
+     signal: controller.signal,
+    },
+    reqId,
+    { onServed: (url) => { servedRelay = url; } },
+    (failure) => audit?.attemptFailure({ attempt: failure.attempt, status: failure.status, reason: failure.reason }),
+   );
+  } else {
+   upstreamRes = await fetch(OVH_CHAT_URL, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(chatBody),
+    signal: controller.signal,
+   });
+  }
  } catch (e) {
   log("error", "ovh upstream fetch failed", { error: String(e), model: requestedModel }, reqId);
   if (!res.headersSent) {
@@ -793,17 +845,20 @@ async function handleOvhRequest(opts: {
    connection: "keep-alive",
    "x-accel-buffering": "no",
   });
-  // Fetched direct, never through the relay pool: attributing an OVH-side
-  // stream failure to an unrelated relay would mark a healthy relay failed.
+  // Fetched via relay pool or direct fallback.
   pipeUpstreamStream(
    Readable.fromWeb(upstreamRes.body as unknown as WebReadableStream),
    res,
    req,
    reqId,
-   "direct",
-   findGlob.renamedFindToGlob || findGlob.renamed !== undefined || argSchemas.size > 0
-    ? { callerHadTools: true, argSchemas, findGlob, pathname: "/v1/chat/completions" }
-    : undefined,
+   servedRelay ?? "direct",
+   {
+    callerHadTools: Array.isArray(parsedBody.tools) && parsedBody.tools.length > 0,
+    argSchemas,
+    findGlob,
+    pathname: "/v1/chat/completions",
+    normalizeReasoning: true,
+   },
    { upstreamContentType: upstreamRes.headers.get("content-type"), audit: audit?.active ? audit : undefined },
   );
   return;
@@ -1018,8 +1073,8 @@ export function isRelayEligibleModel(model: unknown): boolean {
  if (typeof model !== "string") return false;
  if (model.trim() === "") return true;
  const canonical = resolveCanonicalModelId(model.trim());
- if (isClineModel(canonical) || isOvhModel(canonical)) return false;
- return MODEL_MAP.has(canonical) || KILO_MODEL_IDS.has(canonical) || isFreeCatalogId(canonical);
+ if (isClineModel(canonical)) return false;
+ return MODEL_MAP.has(canonical) || KILO_MODEL_IDS.has(canonical) || isFreeCatalogId(canonical) || isOvhModel(canonical);
 }
 
 /**
@@ -1433,7 +1488,10 @@ export function handleControlRequest(
   res.writeHead(200, { "content-type": "application/json" });
   res.end(JSON.stringify({ ok: true }));
   setTimeout(() => {
-   try { closeServer(); } catch { }
+   try {
+    stopClineKeepAlive();
+    closeServer();
+   } catch { }
    if (shutdownShouldExit) process.exit(0);
   }, 50);
   return true;

package/src/stream-pipe.ts

@@ -314,6 +314,8 @@ export interface StreamCloakOptions {
  pathname: string;
  /** Caller tool schemas for argument repair; undefined/empty means byte-identical. */
  argSchemas?: ReadonlyMap<string, Record<string, unknown>>;
+ /** Normalize delta.reasoning to delta.reasoning_content for OpenAI/OMP compatibility. */
+ normalizeReasoning?: boolean;
 }
 
 /** Per-stream drop tracking (delta events carry no name, only an index/id). */
@@ -498,6 +500,7 @@ export function shouldBypassStreamCloak(cloak?: StreamCloakOptions): boolean {
  if (!cloak.callerHadTools && cloak.injected !== undefined) return false;
  // A repairable schema means fragmented arguments must be buffered.
  if (cloak.argSchemas !== undefined && cloak.argSchemas.size > 0) return false;
+ if (cloak.normalizeReasoning === true) return false;
  return true;
 }
 
@@ -843,7 +846,12 @@ function rewriteChatBlock(
    if (c.finish_reason || c.text || c.logprobs) allDeltasEmpty = false;
    continue;
   }
-  const d = delta as Record<string, unknown>;
+ const d = delta as Record<string, unknown>;
+ if (cloak.normalizeReasoning && typeof d.reasoning === "string" && typeof d.reasoning_content !== "string") {
+  d.reasoning_content = d.reasoning;
+  changed = true;
+  allDeltasEmpty = false;
+ }
   // Terminal chunk for this choice: re-emit every buffered tool call's whole
   // argument packet, repaired, at its host index. The fragments never went
   // out, so this is the first and only time the client sees them. Runs

package/src/types.ts

@@ -28,6 +28,7 @@ export interface ModelDef {
  input?: ModelInputType[];
  thinkingFormat?: "openrouter";
  thinkingLevelMap?: ThinkingLevelMap;
+ requiresReasoningContentOnAssistantMessages?: boolean;
 }
 
 export type RegisteredModel = ModelDef & {
@@ -119,6 +120,7 @@ export interface ProviderModelCost {
 export interface ProviderModelCompat {
  supportsDeveloperRole?: boolean;
  supportsReasoningEffort?: boolean;
+ requiresReasoningContentOnAssistantMessages?: boolean;
  thinkingFormat?: "openrouter" | string;
  sessionAffinityFormat?: "openai-nosession" | string;
  [key: string]: unknown;