clauderipple 0.8.10 → 0.9.0

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/chatgpt/index.js

@@ -8,6 +8,7 @@ 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, latestCodexVersion, parseCodexCatalog } from "./catalog.js";
 import fs from "node:fs";
@@ -1037,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");
@@ -1141,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());
@@ -1154,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

@@ -539,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() {

package/dist/router/src/proxy.js

@@ -18,7 +18,7 @@ import https from "node:https";
 import net from "node:net";
 import tls from "node:tls";
 import zlib from "node:zlib";
-import { UpstreamHealth } from "./health.js";
+import { ProviderHealth, providerExhaustion, UpstreamHealth } from "./health.js";
 import { BOOTSTRAP_PATH, injectBootstrap } from "./bootstrap.js";
 import { THREAD_UNSUPPORTED, effortOf, resolve, rewriteBody, stripThreadFields, threadDecision, unroutableReason } from "./routing.js";
 import { defaultAgentDir, withAgentAliases } from "./agents.js";
@@ -32,7 +32,7 @@ import { OpenAiCompatibleAdapter } from "./providers/openai/index.js";
 import { GoogleAdapter } from "./providers/google/index.js";
 import { conversationKey } from "./providers/chatgpt/translate.js";
 import { providerFor, searchProviderFor, terminateHosts } from "./config.js";
-import { injectPickerModels, isBootstrapPath } from "./picker.js";
+import { chatPickerModels, injectPickerModels, isBootstrapPath } from "./picker.js";
 import { effortLevelsForModel } from "./admin.js";
 import { ResponseUsageTap } from "./requestlog.js";
 import { credentialHeaderValues, redactErrorText, redactHeaders } from "./redact.js";
@@ -198,6 +198,7 @@ export class Proxy {
      * its quarantine again on the first request.
      */
     pool = new CredentialPool();
+    providerHealth = new ProviderHealth();
     /** Latest rate-limit snapshot reported by any chatgpt provider (for the admin GUI). */
     get chatgptRateLimits() {
         const out = {};
@@ -784,6 +785,8 @@ export class Proxy {
                     // The adapter reports each account's outcome to the shared pool itself, so a slot pointing
                     // here fails over once every account is out (chooseTarget asks the adapter).
                     const o = await this.chatgpt(route.provider, provider).handle(req, res, path, json, route.model, effortOf(json));
+                    if (!path.startsWith("/v1/messages/count_tokens"))
+                        this.providerHealth.observe(route.provider, o.status, o.exhaustion);
                     finish(String(o.status), o.bytes, o.note, o.status >= 400, { ...(o.usage ? { usage: o.usage } : {}), ...(o.stopReason ? { stopReason: o.stopReason } : {}) });
                 }
                 catch (e) {
@@ -813,6 +816,8 @@ export class Proxy {
                 try {
                     const o = await this.openai(route.provider, provider).handle(req, res, path, json, route.model, routeEffort);
                     this.recordOutcome(route.provider, o.status);
+                    if (!path.startsWith("/v1/messages/count_tokens"))
+                        this.providerHealth.observe(route.provider, o.status, o.exhaustion);
                     finish(String(o.status), o.bytes, o.note, o.status >= 400, { ...(o.usage ? { usage: o.usage } : {}), ...(o.stopReason ? { stopReason: o.stopReason } : {}) });
                 }
                 catch (e) {
@@ -845,6 +850,8 @@ export class Proxy {
                 try {
                     const o = await this.google(route.provider, provider).handle(req, res, path, json, route.model, routeEffort);
                     this.recordOutcome(route.provider, o.status);
+                    if (!path.startsWith("/v1/messages/count_tokens"))
+                        this.providerHealth.observe(route.provider, o.status, o.exhaustion);
                     finish(String(o.status), o.bytes, o.note, o.status >= 400, { ...(o.usage ? { usage: o.usage } : {}), ...(o.stopReason ? { stopReason: o.stopReason } : {}) });
                 }
                 catch (e) {
@@ -1274,7 +1281,7 @@ export class Proxy {
                     else if (status === 200 && isPickerBootstrap) {
                         try {
                             const j = JSON.parse(out.toString("utf8"));
-                            const r = injectPickerModels(j, cfg.cli.extraModels, cfg.cli.autoCompactWindow, (model) => effortLevelsForModel(cfg, model));
+                            const r = injectPickerModels(j, chatPickerModels(cfg), cfg.cli.autoCompactWindow, (model) => effortLevelsForModel(cfg, model));
                             if (r.surfaces.length > 0) {
                                 this.lastPickerInjection = { at: new Date().toISOString(), ...r };
                                 out = Buffer.from(JSON.stringify(j));
@@ -1337,6 +1344,10 @@ export class Proxy {
                 observedUsage = observed.usage;
                 observedStopReason = observed.stopReason;
                 res.end();
+                const errorBody = status >= 400 ? decodeBodyToText(Buffer.concat(errorHead), upRes.headers["content-encoding"]) : "";
+                if (route && path.startsWith("/v1/messages") && !path.startsWith("/v1/messages/count_tokens")) {
+                    this.providerHealth.observe(route.provider, status, providerExhaustion(status, errorBody, retryAfterMs(upRes.headers)));
+                }
                 const note = status >= 400 ? `upstream ${status}: ${errorSnippet(Buffer.concat(errorHead), upRes.headers["content-encoding"], [...errorSecrets], upRes.headers["content-type"])}` : undefined;
                 // Anthropic forgets a conversation's server-side thread after a few idle minutes, and the CLI
                 // answers the 404 by replaying the whole conversation, which hits the prompt cache. From CLI

package/dist/router/src/version.js

@@ -5,4 +5,4 @@
 // from the manifests. Until 0.1.1 the router and the CLI each carried their own literal, and both
 // still said "0.1.0" in the 0.1.1 release: after an update nobody could tell which router was
 // running, and the tray app had nothing to compare (2026-09-15, reported from a Windows install).
-export const VERSION = "0.8.10";
+export const VERSION = "0.9.0";