clauderipple 0.8.9 → 0.9.0

package/dist/router/src/mod-settings.js

@@ -0,0 +1,119 @@
+// Persistence and normalization have one source each: the router's locked store
+// and the mod's pure schema (no claude-code runtime dependency).
+import fs from "node:fs";
+import path from "node:path";
+import { homeDir } from "./config.js";
+import { withFileLock, writeJsonAtomic } from "./locked-file.js";
+import { MOD_SETTINGS_SCHEMA_VERSION, hadRetiredRouting, normalizeSettings } from "../../mod/hooks/settings.js";
+export const MAX_MOD_SETTINGS_BYTES = 64 * 1024;
+export class ModSettingsInputError extends Error {
+    status;
+    constructor(message, status = 400) { super(message); this.status = status; }
+}
+function object(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function revision(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+/**
+ * A field that holds a credential: its last word is key, token, secret, password or the like
+ * (`apiKey`, `access_token`, `typesafeKey`). The last word decides, so a count such as
+ * `keepWarmMinTokens` — a setting the mod has — is not mistaken for one.
+ */
+function isSecretName(key) {
+    const last = key.split(/[^A-Za-z0-9]+|(?<=[a-z0-9])(?=[A-Z])/).filter(Boolean).at(-1)?.toLowerCase() ?? "";
+    return ["key", "apikey", "token", "secret", "password", "passwd", "authorization", "credential", "credentials", "bearer"].includes(last);
+}
+/** Iterative traversal also checks objects nested in arrays, without a recursion limit. */
+function hasSecretKey(settings) {
+    const pending = [settings];
+    while (pending.length) {
+        const value = pending.pop();
+        if (Array.isArray(value))
+            pending.push(...value);
+        else if (object(value)) {
+            for (const [key, child] of Object.entries(value)) {
+                if (isSecretName(key))
+                    return true;
+                pending.push(child);
+            }
+        }
+    }
+    return false;
+}
+export function validateSettings(settings) {
+    if (!object(settings))
+        throw new ModSettingsInputError("settings must be a JSON object");
+    if (Buffer.byteLength(JSON.stringify(settings), "utf8") > MAX_MOD_SETTINGS_BYTES)
+        throw new ModSettingsInputError("settings exceeds 64 KiB", 413);
+    if (hasSecretKey(settings))
+        throw new ModSettingsInputError("settings must not contain credential fields (key, token, secret, password)");
+}
+export function readModSettings(home = homeDir()) {
+    let text;
+    try {
+        text = fs.readFileSync(path.join(home, "mod-settings.json"), "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return { settings: normalizeSettings(null), revision: 0, stored: false };
+        throw error;
+    }
+    // Corruption is not an empty store: fail rather than silently overwrite it.
+    const stored = JSON.parse(text);
+    if (!object(stored) || !revision(stored.revision) || stored.revision < 1)
+        throw new Error("invalid mod settings store");
+    validateSettings(stored.settings);
+    // Auto and field rules are gone: the dashboard says so once, until the next save drops them.
+    return { settings: normalizeSettings(stored.settings), revision: stored.revision, stored: true, ...(hadRetiredRouting(stored.settings) ? { legacy: true } : {}) };
+}
+/** Reject old writers before normalization/fill can erase evidence of their format. */
+export function validateSettingsSchema(body) {
+    if (!object(body))
+        throw new ModSettingsInputError("body must be a JSON object");
+    if (body.schemaVersion !== MOD_SETTINGS_SCHEMA_VERSION)
+        throw new ModSettingsInputError("settings schema unsupported; reload ClaudeRipple before saving", 426);
+}
+/** Exact previous bytes, not the normalized read view; backup failure aborts the write. */
+function backupModSettings(file, previousRevision) {
+    const backup = `${file}.bak-${previousRevision}`;
+    fs.copyFileSync(file, backup);
+    fs.chmodSync(backup, 0o600);
+    const fd = fs.openSync(backup, "r");
+    try {
+        fs.fsyncSync(fd);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+    const backups = fs.readdirSync(path.dirname(file)).filter(name => /^mod-settings\.json\.bak-\d+$/.test(name))
+        .sort((a, b) => Number(b.split("-").at(-1)) - Number(a.split("-").at(-1)));
+    for (const name of backups.slice(10))
+        fs.unlinkSync(path.join(path.dirname(file), name));
+}
+/** Compare-and-swap and revision increment share the account stores' cross-process lock. */
+export function writeModSettings(body, home = homeDir()) {
+    if (!object(body))
+        throw new ModSettingsInputError("body must be a JSON object");
+    validateSettingsSchema(body);
+    validateSettings(body.settings);
+    if (body.revision !== undefined && !revision(body.revision))
+        throw new ModSettingsInputError("revision must be a non-negative safe integer");
+    const settings = normalizeSettings(body.settings);
+    validateSettings(settings);
+    const expected = body.revision;
+    const file = path.join(home, "mod-settings.json");
+    return withFileLock(file, () => {
+        const current = readModSettings(home);
+        if (expected !== undefined && expected !== current.revision)
+            return { stale: true, current };
+        if (current.revision === Number.MAX_SAFE_INTEGER)
+            throw new Error("mod settings revision exhausted");
+        const next = { settings, revision: current.revision + 1, stored: true };
+        if (current.stored)
+            backupModSettings(file, current.revision);
+        writeJsonAtomic(file, next);
+        return { stale: false, current: next };
+    });
+}

package/dist/router/src/model-policy.js

@@ -0,0 +1,6 @@
+// OpenCode Zen's presets.ts note documents jev's /systemone-only judging shape:
+// it cannot answer an ordinary chat/Responses/Messages turn. Keep it configurable
+// for judges, but never advertise it as a chat model or generate a worker for it.
+export function isJudgeOnlyModel(modelId) {
+    return modelId.toLowerCase().startsWith("jev");
+}

package/dist/router/src/model-scores.js

@@ -0,0 +1,159 @@
+// AA benchmark scores are metadata only: this module never changes routing or calls providers.
+import fs from "node:fs/promises";
+import path from "node:path";
+import { homeDir } from "./config.js";
+import { declaredBy, resolve } from "./routing.js";
+import { isJudgeOnlyModel } from "./model-policy.js";
+export const AA_DATA_URL = "https://raw.githubusercontent.com/PBJ-2/clauderipple/data/aa-models.json";
+const ATTRIBUTION = "Data: Artificial Analysis (artificialanalysis.ai)";
+const TTL_MS = 24 * 60 * 60_000;
+const RETRY_MS = 60 * 60_000;
+/** Namespace, @effort and Claude snapshot date are transport spelling, not AA base identity. */
+export function normalizeAaBase(model) {
+    return model.toLowerCase().split("/").at(-1).replace(/@[a-z]+$/, "").replace(/-\d{8}$/, "").replace(/[._]/g, "-");
+}
+/** AA minimal/non-reasoning have no equivalent in the picker's five-level ladder. Do not mislabel. */
+export function mapAaEffort(effort) {
+    return effort === "minimal" || effort === "non-reasoning" ? null : effort;
+}
+/** Only the fields consumed here are validated; full dataset schema belongs to the producer. */
+export function parseScoreDataset(raw) {
+    if (!raw || typeof raw !== "object")
+        throw new Error("invalid AA dataset");
+    const d = raw;
+    if (d.source !== "https://artificialanalysis.ai" || d.attribution !== ATTRIBUTION || typeof d.generatedAt !== "string" || !Number.isFinite(Date.parse(d.generatedAt)) || !Array.isArray(d.models))
+        throw new Error("invalid AA dataset envelope");
+    const models = [];
+    const slugs = new Set();
+    for (const value of d.models) {
+        if (!value || typeof value !== "object")
+            throw new Error("invalid AA model");
+        const m = value;
+        const validNumber = (n) => n === null || (typeof n === "number" && Number.isFinite(n));
+        if (typeof m.slug !== "string" || !m.slug || slugs.has(m.slug) || typeof m.base !== "string" || !m.base || ![null, "low", "medium", "high", "xhigh", "max", "minimal", "non-reasoning"].includes(m.effort) || !validNumber(m.intelligence) || !validNumber(m.costPerTask))
+            throw new Error("invalid AA model score");
+        slugs.add(m.slug);
+        models.push({ slug: m.slug, base: m.base, effort: m.effort, intelligence: m.intelligence, costPerTask: m.costPerTask });
+    }
+    return { attribution: ATTRIBUTION, generatedAt: d.generatedAt, models };
+}
+/** Fetch at most daily, single-flight; offline keeps the last good disk/memory copy and retries hourly. */
+export class ModelScoreCatalog {
+    dataset = null;
+    until = 0;
+    loaded = false;
+    pending = null;
+    options;
+    constructor(options = {}) { this.options = options; }
+    async get() {
+        if (this.pending)
+            return this.pending;
+        if (this.loaded && this.until > this.now())
+            return this.dataset;
+        this.pending = this.refresh();
+        try {
+            return await this.pending;
+        }
+        finally {
+            this.pending = null;
+        }
+    }
+    now() { return (this.options.now ?? Date.now)(); }
+    warn(message) { (this.options.warn ?? console.warn)(`AA model scores: ${message}`); }
+    async refresh() {
+        const file = path.join(this.options.home ?? homeDir(), "aa-models.json");
+        if (!this.loaded) {
+            this.loaded = true;
+            try {
+                this.dataset = parseScoreDataset(JSON.parse(await fs.readFile(file, "utf8")));
+                // Disk mtime records retrieval, not AA's measurement/publication time. Honour TTL on restart.
+                const fetched = (await fs.stat(file)).mtimeMs;
+                if (fetched <= this.now())
+                    this.until = fetched + TTL_MS;
+            }
+            catch (e) {
+                if (!(e instanceof Error && "code" in e && e.code === "ENOENT"))
+                    this.warn(`cache unreadable: ${String(e)}`);
+            }
+        }
+        if (this.until > this.now())
+            return this.dataset;
+        let raw;
+        try {
+            const response = await (this.options.fetch ?? fetch)(AA_DATA_URL, { headers: { accept: "application/json" }, signal: AbortSignal.timeout(5_000) });
+            if (!response.ok)
+                throw new Error(`HTTP ${response.status}`);
+            raw = await response.json();
+            this.dataset = parseScoreDataset(raw);
+            this.until = this.now() + TTL_MS;
+        }
+        catch (e) {
+            this.until = this.now() + RETRY_MS;
+            this.warn(`refresh failed; using ${this.dataset ? "cached scores" : "unmatched models"}: ${String(e)}`);
+            return this.dataset;
+        }
+        const tmp = `${file}.tmp-${process.pid}`;
+        try {
+            await fs.mkdir(path.dirname(file), { recursive: true });
+            await fs.writeFile(tmp, JSON.stringify(raw, null, 2) + "\n");
+            await fs.rename(tmp, file);
+        }
+        catch (e) {
+            this.warn(`could not persist cache: ${String(e)}`);
+            await fs.rm(tmp, { force: true }).catch(error => this.warn(`could not remove temporary cache: ${String(error)}`));
+        }
+        return this.dataset;
+    }
+}
+/**
+ * Enumerate finite configured ids, not hypothetical ids a prefix could accept. Use resolve() so
+ * explicit routes/direct precedence and ambiguous owners behave exactly like inference. Native
+ * Anthropic declarations remain visible (they are routable via OpenAI ingress, not Messages).
+ * Marker aliases contribute their target ids; a slot contributes its resolved target, not the
+ * Claude source label. Deduplicate by (provider, model); ambiguous declarations without an
+ * explicit rule are not routable and are excluded.
+ */
+export function buildModelScores(cfg, dataset) {
+    const targets = new Map();
+    const add = (model, provider) => {
+        if (cfg.providers[provider] && !isJudgeOnlyModel(model))
+            targets.set(`${provider}\0${model}`, { model, provider });
+    };
+    const declared = new Set(Object.values(cfg.providers).flatMap(p => (p.models ?? []).map(m => m.id)));
+    const candidates = new Set([...declared, ...Object.values(cfg.aliases), ...cfg.cli.extraModels.map(m => m.model), ...Object.values(cfg.cli.models ?? {}), ...Object.keys(cfg.routes)]);
+    // Fallbacks are explicit provider/model targets even when they are absent from declared lists.
+    for (const route of Object.values(cfg.routes)) {
+        for (const fallback of route.fallbacks ?? []) {
+            const provider = cfg.providers[fallback.provider];
+            if (provider && (provider.type !== "anthropic" || provider.accountPool))
+                add(fallback.model, fallback.provider);
+        }
+    }
+    for (const candidate of candidates) {
+        const result = resolve(candidate, {}, cfg);
+        if (result) {
+            add(result.model, result.provider);
+            continue;
+        }
+        // Native ingress has a separate resolver; do not pretend ambiguous translated models route.
+        const owners = declaredBy(candidate, cfg);
+        if (owners.length === 1 && cfg.providers[owners[0]].type === "anthropic")
+            add(candidate.replace(/@[a-z]+$/, ""), owners[0]);
+    }
+    const groups = new Map();
+    for (const variant of dataset?.models ?? []) {
+        const group = groups.get(variant.base) ?? [];
+        group.push(variant);
+        groups.set(variant.base, group);
+    }
+    const models = [...targets.values()].sort((a, b) => a.model.localeCompare(b.model) || a.provider.localeCompare(b.provider)).map(target => {
+        const aaBase = normalizeAaBase(target.model);
+        const found = groups.get(aaBase) ?? [];
+        return {
+            ...target, aaBase,
+            variants: [...found].sort((a, b) => a.slug.localeCompare(b.slug)).map(v => ({ effort: mapAaEffort(v.effort), intelligence: v.intelligence, costPerTask: v.costPerTask })),
+            matched: found.length > 0,
+        };
+    });
+    return { attribution: dataset?.attribution ?? ATTRIBUTION, generatedAt: dataset?.generatedAt ?? null, models };
+}

package/dist/router/src/picker.js

@@ -9,7 +9,9 @@
 // entry as a template and override the identifying fields. Surfaces are matched by id
 // heuristically (anything that is not the claude.ai chat surface); the ids we saw are
 // logged once so the heuristic can be tightened.
+import { resolve } from "./routing.js";
 import { clampEffort } from "./compat.js";
+import { isJudgeOnlyModel } from "./model-policy.js";
 export const BOOTSTRAP_PATHS = ["/edge-api/bootstrap", "/api/bootstrap"];
 export function isBootstrapPath(path) {
     return BOOTSTRAP_PATHS.some((p) => path === p || path.startsWith(p + "/") || path.startsWith(p + "?"));
@@ -48,12 +50,17 @@ function narrowThinking(entry, levels) {
     const preferred = clampEffort("high", kept.map((option) => option.id));
     entry.thinking = { ...thinking, effort_options: kept.map(({ recommended: _recommended, ...option }) => (option.id === preferred ? { ...option, recommended: true } : option)) };
 }
+/** Resolve aliases/routes before advertising an entry; a chat-looking alias can target a judge. */
+export function chatPickerModels(cfg) {
+    return cfg.cli.extraModels.filter(entry => !isJudgeOnlyModel(entry.model) && !isJudgeOnlyModel(resolve(entry.model, {}, cfg)?.model ?? cfg.aliases[entry.model.split("@")[0]] ?? ""));
+}
 /**
  * Mutates `json` in place; returns what was done for logging. `effortFor` names the levels a model
  * takes (by its id without an `@effort` suffix); undefined leaves the template's menu as it is.
  */
 export function injectPickerModels(json, extra, contextWindow, effortFor) {
     const result = { injected: 0, surfaces: [] };
+    extra = extra.filter(e => !isJudgeOnlyModel(e.model));
     const msc = json.model_selector_config;
     if (!Array.isArray(msc) || extra.length === 0)
         return result;

package/dist/router/src/providers/anthropic-account-pool.js

@@ -1,5 +1,5 @@
-// Runtime view of Claude subscription accounts: current Claude Code/Desktop login first, followed by
-// ClaudeRipple-owned OAuth accounts. Stored grants are refreshed just before expiry and projected as
+// Runtime view of Claude subscription accounts: current Claude Code/Desktop login first (unless the
+// user marked a stored account preferred, which then leads), followed by ClaudeRipple-owned OAuth accounts. Stored grants are refreshed just before expiry and projected as
 // ordinary proxy credentials, so the shared CredentialPool supplies affinity, cooldown and retry.
 import crypto from "node:crypto";
 import { redactErrorText } from "../redact.js";
@@ -115,12 +115,18 @@ export class ClaudeAccountAuthPool {
             // first migration write, omit that duplicate instead of trying the same token twice.
             if (currentToken && account.token === currentToken)
                 continue;
-            out.push({
+            const credential = {
                 id: credentialId(account.id, account.token, account.refreshToken),
                 ownerId: account.id,
                 label: account.label,
                 headers: nativeAnthropicHeaders({ type: "anthropic", auth: "claude-code" }, { accessToken: account.token, expiresAt: account.expiresAt }),
-            });
+            };
+            // The pool tries credentials in this order, so the account the user chose goes ahead of the
+            // current login. A conversation already held by another account stays there (its cache).
+            if (account.preferred)
+                out.unshift(credential);
+            else
+                out.push(credential);
         }
         return out;
     }

package/dist/router/src/providers/anthropic-accounts.js

@@ -27,7 +27,8 @@ function validAccount(value) {
         && typeof a.label === "string" && a.label.length > 0
         && (a.subjectHash === undefined || (typeof a.subjectHash === "string" && /^[0-9a-f]{64}$/.test(a.subjectHash)))
         && (a.email === undefined || typeof a.email === "string")
-        && (a.needsReauth === undefined || typeof a.needsReauth === "boolean");
+        && (a.needsReauth === undefined || typeof a.needsReauth === "boolean")
+        && (a.preferred === undefined || typeof a.preferred === "boolean");
 }
 function parseClaudeAccountsFile(home) {
     try {
@@ -178,6 +179,29 @@ export function renameClaudeAccount(home, id, label) {
         return true;
     });
 }
+/**
+ * Make one stored account the first one tried, or with `null` hand first place back to the current
+ * Claude login. False when the id names no stored account.
+ */
+export function setPreferredClaudeAccount(home, id) {
+    return withAccountLock(home, () => {
+        const accounts = readClaudeOAuthAccountsForMutation(home);
+        if (id !== null && !accounts.some((account) => account.id === id))
+            return false;
+        let changed = false;
+        const next = accounts.map((account) => {
+            const want = account.id === id;
+            if ((account.preferred === true) === want)
+                return account;
+            changed = true;
+            const { preferred: _, ...rest } = account;
+            return want ? { ...rest, preferred: true } : rest;
+        });
+        if (changed)
+            writeClaudeAccountsFile(home, next);
+        return true;
+    });
+}
 export function removeClaudeAccount(home, id) {
     return withAccountLock(home, () => {
         const accounts = readClaudeOAuthAccountsForMutation(home);
@@ -209,6 +233,7 @@ export function summarize(account) {
         ...(account.email ? { email: account.email } : {}),
         expiresAt: account.expiresAt,
         needsReauth: account.needsReauth === true,
+        preferred: account.preferred === true,
     };
 }
 export function listClaudeAccounts(home) {

package/dist/router/src/providers/chatgpt/catalog.js

@@ -11,8 +11,13 @@
 import fs from "node:fs";
 import path from "node:path";
 import { codexHome } from "../../../../cli/src/codex.js";
-/** The client_version floor: below this the backend hides models ClaudeRipple already supports. */
-export const CODEX_CLIENT_VERSION_FLOOR = "0.155.0";
+/**
+ * The client_version floor: below this the backend hides models ClaudeRipple already supports.
+ * 0.158.0 omits gpt-6.1-sol and 0.159.0 lists it (measured 2026-10-10). A floor always trails the
+ * next release, so the newest published Codex version is asked for as well (`latestCodexVersion`):
+ * a Windows user with no Codex CLI was asking with this floor and never saw 6.1 Sol (issue #50).
+ */
+export const CODEX_CLIENT_VERSION_FLOOR = "0.159.0";
 /**
  * Copied from the Codex catalog 2026-09-23, used only when the live catalog cannot be read. The
  * catalog lists `ultra` on astra, sol and 5.6 terra/sol and not on either Luna — the reverse of a
@@ -78,20 +83,46 @@ function compareVersions(a, b) {
 /**
  * The version to ask the catalogue with: the installed Codex CLI's, from the cache it writes
  * (`<codexHome>/models_cache.json`, honouring `CODEX_HOME`), but never below the floor — an older
- * CLI must not cost us the models the newer backend would list. Missing or unreadable file, or a
- * version that is not numeric, answers the floor.
+ * CLI must not cost us the models the newer backend would list. `latest` (the newest published
+ * Codex) wins when it is higher still. Missing or unreadable file, or a version that is not
+ * numeric, answers the floor.
  */
-export function codexClientVersion(home = codexHome()) {
-    let cached;
+export function codexClientVersion(home = codexHome(), latest) {
+    let best = CODEX_CLIENT_VERSION_FLOOR;
+    const consider = (value) => {
+        if (typeof value !== "string" || !/^\d+(\.\d+)*/.test(value))
+            return;
+        // "0.155.1-nightly.3" is 0.155.1 as far as the backend's filter is concerned.
+        const core = value.split("-")[0];
+        if (compareVersions(core, best) > 0)
+            best = core;
+    };
     try {
-        cached = JSON.parse(fs.readFileSync(path.join(home, "models_cache.json"), "utf8")).client_version;
+        consider(JSON.parse(fs.readFileSync(path.join(home, "models_cache.json"), "utf8")).client_version);
     }
-    catch {
-        return CODEX_CLIENT_VERSION_FLOOR;
+    catch { /* no Codex CLI here */ }
+    consider(latest);
+    return best;
+}
+const NPM_LATEST = "https://registry.npmjs.org/@openai/codex/latest";
+const LATEST_TTL_MS = 24 * 60 * 60_000;
+const LATEST_RETRY_MS = 60 * 60_000;
+let latestCache = null;
+/**
+ * The newest published Codex CLI version, from the npm registry, kept a day; null when the
+ * registry cannot be read, which is then not asked again for an hour. Never throws.
+ */
+export async function latestCodexVersion(fetchImpl = fetch, now = Date.now()) {
+    if (latestCache && latestCache.until > now)
+        return latestCache.version;
+    let version = null;
+    try {
+        const res = await fetchImpl(NPM_LATEST, { headers: { accept: "application/json" }, signal: AbortSignal.timeout(3_000) });
+        const value = res.ok ? (await res.json()).version : undefined;
+        if (typeof value === "string" && /^\d+\.\d+\.\d+/.test(value))
+            version = value;
     }
-    if (typeof cached !== "string" || !/^\d+(\.\d+)*/.test(cached))
-        return CODEX_CLIENT_VERSION_FLOOR;
-    // "0.155.1-nightly.3" is 0.155.1 as far as the backend's filter is concerned.
-    const core = cached.split("-")[0];
-    return compareVersions(core, CODEX_CLIENT_VERSION_FLOOR) > 0 ? core : CODEX_CLIENT_VERSION_FLOOR;
+    catch { /* offline or blocked: the floor and the local CLI still answer */ }
+    latestCache = { version, until: now + (version ? LATEST_TTL_MS : LATEST_RETRY_MS) };
+    return version;
 }

package/dist/router/src/providers/chatgpt/index.js

@@ -8,8 +8,9 @@ import { SseParser } from "./sse.js";
 import { fetchWithRetry } from "../retry.js";
 import { looksLikeAuth } from "../openai/index.js";
 import { StreamMapper, conversationKey, estimateTokens, formatSse, serverToolNames, toResponsesRequest, toolNameRestoreMap } from "./translate.js";
+import { providerExhaustion } from "../../health.js";
 import { credentialHeaderValues, redactErrorText } from "../../redact.js";
-import { codexClientVersion, parseCodexCatalog } from "./catalog.js";
+import { codexClientVersion, latestCodexVersion, parseCodexCatalog } from "./catalog.js";
 import fs from "node:fs";
 import path from "node:path";
 import { homeDir } from "../../config.js";
@@ -635,11 +636,12 @@ export class ChatGptAdapter {
             this.log.warn(`chatgpt ${this.name}: model-catalog fetch skipped: ${tokens.message}`);
             return null;
         }
+        const version = codexClientVersion(undefined, await latestCodexVersion());
         const ac = new AbortController();
         const timer = setTimeout(() => ac.abort(), MODELS_TIMEOUT_MS);
         let res;
         try {
-            res = await fetch(`${(this.cfg.url ?? DEFAULT_BASE).replace(/\/$/, "")}${MODELS_PATH}?client_version=${encodeURIComponent(codexClientVersion())}`, {
+            res = await fetch(`${(this.cfg.url ?? DEFAULT_BASE).replace(/\/$/, "")}${MODELS_PATH}?client_version=${encodeURIComponent(version)}`, {
                 method: "GET",
                 headers: {
                     authorization: `Bearer ${tokens.accessToken}`,
@@ -1036,7 +1038,9 @@ export class ChatGptAdapter {
                     this.dump(sent.status, json, upstreamReq, sent.text);
             }
             res.writeHead(err.status, { "content-type": "application/json", ...(retryAfterSeconds ? { "retry-after": String(retryAfterSeconds) } : {}) }).end(err.body);
-            return { status: err.status, bytes: err.body.length, note };
+            return { status: err.status, bytes: err.body.length, note,
+                ...(sent.kind === "refused" ? { exhaustion: providerExhaustion(sent.status, sent.text, sent.retryAfterSeconds === undefined ? undefined : sent.retryAfterSeconds * 1000) } : {}),
+            };
         }
         const { upstream, credential } = sent;
         const nextTurnState = upstream.headers.get("x-codex-turn-state");
@@ -1140,6 +1144,7 @@ export class ChatGptAdapter {
         }
         const failure = mapper.failure;
         const failedStatus = failure?.type === "invalid_request_error" ? 400 : failure?.type === "overloaded_error" ? 529 : failure?.type === "rate_limit_error" ? 429 : 502;
+        const exhaustion = failure ? providerExhaustion(429, `${failure.code ?? ""} ${failure.message}`, retryAfterMs(Object.fromEntries(upstream.headers))) : undefined;
         if (!wantStream || (failure && !res.headersSent)) {
             // A failed turn is an error here too, not a 200 carrying whatever arrived before it failed.
             const msg = failure ? anthropicError(failedStatus, failure.type, failure.message).body : JSON.stringify(mapper.message());
@@ -1153,6 +1158,7 @@ export class ChatGptAdapter {
         return {
             // A stream has already sent 200; the record still says the turn failed.
             status: failure ? failedStatus : 200,
+            exhaustion,
             bytes,
             note: failure
                 ? `${wantStream ? "mid-stream " : ""}${failure.type}: ${failure.message} (in=${u.input_tokens} cached=${u.cache_read_input_tokens} out=${u.output_tokens})`

package/dist/router/src/providers/chatgpt/translate.js

@@ -114,16 +114,20 @@ const UNSUPPORTED_REGEX = /\(\?[=!<]|\\[0-9]/;
 export function unsupportedPattern(p) {
     return UNSUPPORTED_REGEX.test(p);
 }
-function scrubSchema(node) {
+/** Drops the patterns above anywhere in a schema; `removed.count` says how many went. */
+export function scrubSchema(node, removed) {
     if (Array.isArray(node))
-        return node.map(scrubSchema);
+        return node.map((item) => scrubSchema(item, removed));
     if (typeof node !== "object" || node === null)
         return node;
     const out = {};
     for (const [k, v] of Object.entries(node)) {
-        if (k === "pattern" && typeof v === "string" && unsupportedPattern(v))
+        if (k === "pattern" && typeof v === "string" && unsupportedPattern(v)) {
+            if (removed)
+                removed.count++;
             continue;
-        out[k] = scrubSchema(v);
+        }
+        out[k] = scrubSchema(v, removed);
     }
     return out;
 }
@@ -535,7 +539,7 @@ export class StreamMapper {
         const type = contextOverflow ? "invalid_request_error" : code === "server_is_overloaded" ? "overloaded_error" : code === "rate_limit_exceeded" || code === "usage_limit_reached" ? "rate_limit_error" : "api_error";
         if (contextOverflow)
             message = `prompt is too long: ${message}`;
-        this.failure = { type, message };
+        this.failure = { type, message, ...(code ? { code } : {}) };
         return [...this.start(), ...this.closeBlock(), { event: "error", data: { type: "error", error: { type, message } } }];
     }
     /** Non-streaming body once finished. */

package/dist/router/src/providers/google/index.js

@@ -14,6 +14,7 @@
 // vendor sent. The antigravity path picks the account the conversation is sticky to and moves to the
 // next one only on a refusal that has not reached the client (§4 Credential pools).
 import http from "node:http";
+import { providerExhaustion } from "../../health.js";
 import { CredentialPool, retryAfterMs } from "../../pool.js";
 import { credentialHeaderValues, redactErrorText } from "../../redact.js";
 import { SseParser } from "../chatgpt/sse.js";
@@ -320,7 +321,7 @@ export class GoogleAdapter {
             this.log.warn(`google ${this.name}: upstream ${upstream.status} for ${model}: ${safeText.slice(0, 400)}`);
             res.off("close", onClose);
             res.writeHead(out.status, { "content-type": "application/json", "content-length": String(Buffer.byteLength(out.body)) }).end(out.body);
-            return { status: out.status, bytes: Buffer.byteLength(out.body), note: `upstream ${upstream.status}` };
+            return { status: out.status, bytes: Buffer.byteLength(out.body), note: `upstream ${upstream.status}`, exhaustion: providerExhaustion(upstream.status, text, retryAfterMs(Object.fromEntries(upstream.headers)) ?? googleRetryDelayMs(text)) };
         }
         return this.streamBack(res, upstream, transport, json, model, wantStream, key, startInput, controller, onClose);
     }
@@ -384,7 +385,9 @@ export class GoogleAdapter {
                 note = `upstream ${sent.status}`;
             }
             res.writeHead(err.status, { "content-type": "application/json", ...(retryAfterSeconds ? { "retry-after": String(retryAfterSeconds) } : {}) }).end(err.body);
-            return { status: err.status, bytes: Buffer.byteLength(err.body), note };
+            return { status: err.status, bytes: Buffer.byteLength(err.body), note,
+                ...(sent.kind === "refused" ? { exhaustion: providerExhaustion(sent.status, sent.text, sent.retryAfterSeconds === undefined ? undefined : sent.retryAfterSeconds * 1000) } : {}),
+            };
         }
         return this.streamBack(res, sent.upstream, transport, json, model, wantStream, key, startInput, controller, onClose);
     }
@@ -484,6 +487,7 @@ export class GoogleAdapter {
         const usage = mapper.usage;
         return {
             status: failure ? failedStatus : 200,
+            exhaustion: failure ? providerExhaustion(429, failure.message, retryAfterMs(Object.fromEntries(upstream.headers))) : undefined,
             bytes,
             note: failure
                 ? `${wantStream ? "mid-stream " : ""}${failure.type}: ${failure.message} (in=${usage.input_tokens} cached=${usage.cache_read_input_tokens} out=${usage.output_tokens})`

package/dist/router/src/providers/openai/index.js

@@ -2,6 +2,8 @@
 // Responses SSE out, translated back to Anthropic Messages. It never synthesizes
 // cache figures; the request log reflects cached tokens only when the vendor sends them.
 import http from "node:http";
+import { providerExhaustion } from "../../health.js";
+import { retryAfterMs } from "../../pool.js";
 import { credentialHeaderValues, redactErrorText } from "../../redact.js";
 import { SseParser } from "../chatgpt/sse.js";
 import { fetchWithRetry } from "../retry.js";
@@ -146,7 +148,7 @@ export class OpenAiCompatibleAdapter {
             this.log.warn(`openai ${this.name}: upstream ${upstream.status} for ${model}: ${safeText.slice(0, 400)}`);
             res.off("close", onClose);
             res.writeHead(out.status, { "content-type": "application/json", "content-length": String(Buffer.byteLength(out.body)) }).end(out.body);
-            return { status: out.status, bytes: Buffer.byteLength(out.body), note: `upstream ${upstream.status}` };
+            return { status: out.status, bytes: Buffer.byteLength(out.body), note: `upstream ${upstream.status}`, exhaustion: providerExhaustion(upstream.status, text, retryAfterMs(Object.fromEntries(upstream.headers))) };
         }
         const wantStream = json.stream === true;
         const mapper = new OpenAiStreamMapper(model, startInput, toolNameRestoreMap(json));
@@ -226,6 +228,7 @@ export class OpenAiCompatibleAdapter {
         return {
             // A stream has already sent 200; the record still says the turn failed.
             status: failure ? failedStatus : 200,
+            exhaustion: failure ? providerExhaustion(429, `${failure.code ?? ""} ${failure.message}`, retryAfterMs(Object.fromEntries(upstream.headers))) : undefined,
             bytes,
             note: failure
                 ? `${wantStream ? "mid-stream " : ""}${failure.type}: ${failure.message} (in=${usage.input_tokens} cached=${usage.cache_read_input_tokens} out=${usage.output_tokens})`

package/dist/router/src/providers/openai/translate.js

@@ -550,7 +550,7 @@ export class OpenAiStreamMapper {
         // `overloaded_error` is the one mid-stream error Claude Code retries on its own (CLI 2.1.278
         // matches `"type":"overloaded_error"` in the message); `api_error` ends the turn for good.
         const type = code === "rate_limit_exceeded" ? "rate_limit_error" : code === "server_is_overloaded" ? "overloaded_error" : "api_error";
-        this.failure = { type, message };
+        this.failure = { type, message, ...(code ? { code } : {}) };
         return [...this.start(), ...this.closeBlock(), { event: "error", data: { type: "error", error: { type, message } } }];
     }
     message() {