clauderipple 0.8.8 → 0.8.9

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.8.9 — 2026-10-08
+
+### Fixed
+
+- **New Claude models appear on their own.** The Claude model list was built into ClaudeRipple,
+  so Opus 5.5, Sonnet 5.5 and Haiku 5.5 never showed up. It now comes from Anthropic's model list
+  for your account, refreshed hourly. When a newer model ships in a family you already use (say
+  Opus 5.5 after Opus 5), it is added to your Claude provider on its own. Untick it and it stays
+  unticked.
+
 ## 0.8.8 — 2026-10-07
 
 ### Fixed

package/dist/app/package.json

@@ -1,5 +1,5 @@
 {
   "private": true,
-  "version": "0.8.8",
+  "version": "0.8.9",
   "type": "commonjs"
 }

package/dist/router/src/admin.js

@@ -30,6 +30,7 @@ import { CHATGPT_FALLBACK_MODELS } from "./providers/chatgpt/catalog.js";
 import { measureModel, refusedByPlan } from "./capabilities.js";
 import { catalogEntry } from "./catalog.js";
 import { ClaudeCodeAuthStore, nativeAnthropicHeaders } from "./providers/anthropic.js";
+import { fetchClaudeModels, newClaudeReleases } from "./providers/anthropic-models.js";
 import { codexEnabled, codexHome } from "../../cli/src/codex.js";
 import { openBrowser } from "../../cli/src/browser.js";
 import { caTrusted, currentAppProxy } from "../../cli/src/picker.js";
@@ -171,18 +172,27 @@ export function effortLevelsForModel(cfg, modelId) {
     }
     return undefined;
 }
+// Only for when Anthropic's own list cannot be had (no sign-in yet, offline): the live list is
+// `deps.claudeModels`, and a release after this table is cut appears there by itself (2026-10-08).
 const CLAUDE_MODEL_FALLBACK = [
-    { id: "claude-fable-5-1", name: "Fable 5.1" },
+    { id: "claude-haiku-5-5", name: "Haiku 5.5" },
+    { id: "claude-sonnet-5-5", name: "Sonnet 5.5" },
     { id: "claude-opus-5-5", name: "Opus 5.5" },
+    { id: "claude-fable-5-1", name: "Fable 5.1" },
     { id: "claude-opus-5", name: "Opus 5" },
     { id: "claude-sonnet-5", name: "Sonnet 5" },
-    { id: "claude-haiku-4-5", name: "Haiku 4.5" },
     { id: "claude-fable-5", name: "Fable 5" },
     { id: "claude-opus-4-8", name: "Opus 4.8" },
     { id: "claude-opus-4-7", name: "Opus 4.7" },
-    { id: "claude-opus-4-6", name: "Opus 4.6" },
     { id: "claude-sonnet-4-6", name: "Sonnet 4.6" },
+    { id: "claude-opus-4-6", name: "Opus 4.6" },
+    { id: "claude-haiku-4-5", name: "Haiku 4.5" },
 ];
+/** The account's Claude models, or the table above when Anthropic's list cannot be had. */
+async function claudeModelList(deps) {
+    const live = await deps.claudeModels?.().catch(() => null);
+    return live?.length ? live.map(({ line: _line, createdAt: _createdAt, ...model }) => ({ ...model, name: model.name ?? model.id })) : CLAUDE_MODEL_FALLBACK;
+}
 export function adminPort(cfg) {
     return cfg.admin?.port ?? cfg.listen.port + 1;
 }
@@ -638,7 +648,9 @@ function claudeAuthStore(deps) {
     return new ClaudeCodeAuthStore(undefined, { home: homeDir(), ...(deps.observedClaudeCodeAuth ? { observed: deps.observedClaudeCodeAuth } : {}) });
 }
 async function probeAnthropicApiKey(apiKey, probeFetch = fetchWithTimeout) {
-    const models = CLAUDE_MODEL_FALLBACK;
+    // The key's own model list where it answers; a key that cannot list is still tested below.
+    const listed = await fetchClaudeModels("https://api.anthropic.com", { "x-api-key": apiKey }, probeFetch).catch(() => []);
+    const models = listed.length ? listed.map(({ line: _line, createdAt: _createdAt, ...model }) => model) : CLAUDE_MODEL_FALLBACK;
     const label = "messages endpoint";
     try {
         const response = await probeFetch("https://api.anthropic.com/v1/messages", {
@@ -661,14 +673,14 @@ async function probeAnthropicApiKey(apiKey, probeFetch = fetchWithTimeout) {
         return { ok: false, auth: "unreachable", models, error: `${label}: ${errorText(e)}` };
     }
 }
-function probeClaudeCodeAuth(deps) {
+async function probeClaudeCodeAuth(deps) {
     const source = claudeAuthStore(deps).describeSource();
     // Our own accounts are reported separately: a Claude Desktop session can outrank them, and without
     // this the screen would answer a finished sign-in with the source it was already showing.
     const accounts = listClaudeAccounts(homeDir());
     const hasUsableAccount = accounts.some((account) => !account.needsReauth && account.expiresAt > Date.now());
     const signedIn = accounts.length > 0 ? "oauth" : readClaudeAuthFile(homeDir())?.source ?? null;
-    return { ok: source !== null || hasUsableAccount, auth: source !== null || hasUsableAccount ? "ok" : "missing", source, signedIn, accountCount: accounts.length, models: CLAUDE_MODEL_FALLBACK };
+    return { ok: source !== null || hasUsableAccount, auth: source !== null || hasUsableAccount ? "ok" : "missing", source, signedIn, accountCount: accounts.length, models: await claudeModelList(deps) };
 }
 /** The reasoning levels a `GET /v1beta/models` entry says the model takes, or none to offer. */
 function googleEffortLevels(entry) {
@@ -1089,6 +1101,55 @@ export function measureUnsettledModels(deps) {
     }
     return started;
 }
+/**
+ * Declare each Claude release the account has gained on every native Anthropic provider that
+ * declares an older model of the same family (`newClaudeReleases`). The declared list was whatever
+ * was ticked when the provider was saved, so Opus 5.5, Sonnet 5.5 and Haiku 5.5 stayed off it for
+ * weeks while Claude Code had them (2026-10-08). A model offered once is remembered in
+ * `claude-models-offered.json` and never offered again, so unticking a new model sticks.
+ * Returns the `provider/model` ids it declared.
+ */
+export async function adoptNewClaudeModels(deps) {
+    const live = await deps.claudeModels?.().catch(() => null);
+    if (!live?.length)
+        return [];
+    const stateFile = path.join(homeDir(), "claude-models-offered.json");
+    let offered = new Set();
+    try {
+        const saved = JSON.parse(fs.readFileSync(stateFile, "utf8"));
+        if (Array.isArray(saved.offered))
+            offered = new Set(saved.offered.filter((id) => typeof id === "string"));
+    }
+    catch { /* first run: nothing offered yet */ }
+    let current;
+    try {
+        current = JSON.parse(fs.readFileSync(deps.configFile, "utf8"));
+    }
+    catch (e) {
+        deps.log.warn(`admin: claude models not adopted: could not read config: ${errorText(e)}`);
+        return [];
+    }
+    const added = [];
+    for (const [name, provider] of Object.entries(current.providers)) {
+        if (provider.type !== "anthropic" || !provider.models?.length)
+            continue;
+        for (const model of newClaudeReleases(live, provider.models.map((entry) => entry.id), offered)) {
+            provider.models.push({ id: model.id, name: model.name ?? model.id });
+            added.push(`${name}/${model.id}`);
+        }
+    }
+    if (added.length) {
+        const errors = validate(current);
+        if (errors.length > 0) {
+            deps.log.warn(`admin: claude models not adopted: config did not validate: ${errors[0]}`);
+            return [];
+        }
+        writeConfigFile(deps.configFile, current);
+        deps.log.info(`admin: declared new Claude model(s): ${added.join(", ")}`);
+    }
+    fs.writeFileSync(stateFile, JSON.stringify({ offered: [...new Set([...offered, ...live.map((model) => model.id)])].sort() }, null, 2) + "\n");
+    return added;
+}
 /** Run one provider measurement job to completion. Detached: the request that started it has already answered. */
 async function runMeasureJob(jobId, providerName, models, deps) {
     const job = MEASURE_JOBS.get(jobId);
@@ -1145,7 +1206,7 @@ async function runMeasureJob(jobId, providerName, models, deps) {
         MEASURE_JOBS.set(jobId, { ...job, state: "failed", error: errorText(e), finishedAt: Date.now() });
     }
 }
-function pickerModels(deps) {
+async function pickerModels(deps) {
     const last = deps.picker?.().last;
     if (last && typeof last === "object" && Array.isArray(last.surfaces)) {
         const entries = last.surfaces
@@ -1171,7 +1232,7 @@ function pickerModels(deps) {
         if (models.length > 0)
             return { models, source: "picker" };
     }
-    return { models: CLAUDE_MODEL_FALLBACK, source: "fallback" };
+    return { models: await claudeModelList(deps), source: "fallback" };
 }
 function tailLines(file, n) {
     if (!fs.existsSync(file))
@@ -1293,7 +1354,7 @@ export function startAdmin(deps) {
                 return;
             }
             if (pathname === "/api/claude-models" && method === "GET") {
-                sendJson(res, 200, pickerModels(deps));
+                sendJson(res, 200, await pickerModels(deps));
                 return;
             }
             if (pathname === "/api/effort-levels" && method === "GET") {
@@ -1324,7 +1385,7 @@ export function startAdmin(deps) {
                 const probe = parsed;
                 if (probe.type === "anthropic") {
                     if (probe.auth === "claude-code") {
-                        sendJson(res, 200, probeClaudeCodeAuth(deps));
+                        sendJson(res, 200, await probeClaudeCodeAuth(deps));
                         return;
                     }
                     if (probe.auth === "api-key") {

package/dist/router/src/index.js

@@ -14,7 +14,7 @@ import { CertStore } from "./certs.js";
 import { Logger } from "./log.js";
 import { UpstreamHealth, EXIT_UPSTREAM_UNREACHABLE } from "./health.js";
 import { Proxy } from "./proxy.js";
-import { measureUnsettledModels, startAdmin } from "./admin.js";
+import { adoptNewClaudeModels, measureUnsettledModels, startAdmin } from "./admin.js";
 import { loadModelCatalog } from "./catalog.js";
 import { RequestLog } from "./requestlog.js";
 import { OpenAiIngress } from "./ingress/server.js";
@@ -164,6 +164,7 @@ proxy
         picker: () => ({ enabled: !!store.get().picker?.enabled, hosts: terminateHosts(store.get()).slice(1), last: proxy.lastPickerInjection }),
         observedClaudeCodeAuth,
         claudeUsage: () => proxy.claudeUsage.snapshot(),
+        claudeModels: () => proxy.claudeModels.list(),
         image: (req, signal) => proxy.generateImage(req, signal),
         modelCatalog: () => loadModelCatalog(),
         shutdown: () => beginDrain("shutdown requested"),
@@ -174,6 +175,11 @@ proxy
     // A minute in, once start-up traffic has settled: a few one-token requests per model whose
     // effort nobody has measured yet, so effort works without the owner re-saving the provider.
     setTimeout(() => measureUnsettledModels(adminDeps), 60_000).unref();
+    // Claude releases reach the declared models without a ClaudeRipple release: checked a minute in,
+    // then every six hours (the catalogue itself is cached for an hour).
+    const adopt = () => void adoptNewClaudeModels(adminDeps).catch((e) => log.warn(`claude models: ${e.message}`));
+    setTimeout(adopt, 60_000).unref();
+    setInterval(adopt, 6 * 60 * 60_000).unref();
 })
     .catch((e) => {
     log.error(`listen failed: ${e.message}`);

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

@@ -0,0 +1,125 @@
+const EFFORT_ORDER = ["low", "medium", "high", "xhigh", "max"];
+/**
+ * The active models in a `/v1/models` body. A dated id (`claude-haiku-4-5-20251001`) is folded to
+ * its alias, which the API takes as well and which is the id the rest of ClaudeRipple and Claude
+ * Code's own aliases use.
+ */
+export function claudeModelsFromBody(body) {
+    const data = body?.data;
+    if (!Array.isArray(data))
+        return [];
+    const out = [];
+    for (const raw of data) {
+        if (!raw || typeof raw !== "object")
+            continue;
+        const m = raw;
+        if (typeof m.id !== "string" || !m.id.startsWith("claude-"))
+            continue;
+        if (m.lifecycle !== undefined && m.lifecycle !== "active")
+            continue;
+        const id = m.id.replace(/-\d{8}$/, "");
+        if (out.some((entry) => entry.id === id))
+            continue;
+        const name = typeof m.display_name === "string" ? m.display_name.replace(/^Claude\s+/, "") : id;
+        const effort = m.capabilities?.effort;
+        const supported = (key) => {
+            const value = effort?.[key];
+            return typeof value === "object" && value !== null && value.supported === true;
+        };
+        const entry = { id, name };
+        // Haiku 4.5 reports the effort block with every level unsupported: it takes no effort at all.
+        if (effort && typeof effort === "object")
+            entry.effortLevels = effort.supported === true ? EFFORT_ORDER.filter(supported) : [];
+        if (typeof m.max_input_tokens === "number" && m.max_input_tokens > 0)
+            entry.contextWindow = m.max_input_tokens;
+        if (typeof m.line === "string")
+            entry.line = m.line;
+        const created = typeof m.created_at === "string" ? Date.parse(m.created_at) : NaN;
+        if (Number.isFinite(created))
+            entry.createdAt = created;
+        out.push(entry);
+    }
+    return out;
+}
+/**
+ * The account's model list, fetched at most once per `ttlMs` (an hour by default: Anthropic ships a
+ * model every few weeks). A failed lookup keeps the last good list, and null means none was ever
+ * had, so a caller falls back to its own.
+ */
+export class ClaudeModelCatalog {
+    last = null;
+    fetchedAt = Number.NEGATIVE_INFINITY;
+    inFlight = null;
+    source;
+    opts;
+    constructor(source, opts) {
+        this.source = source;
+        this.opts = opts;
+    }
+    list() {
+        const now = (this.opts.now ?? Date.now)();
+        if (now - this.fetchedAt < (this.opts.ttlMs ?? 60 * 60_000))
+            return Promise.resolve(this.last);
+        this.inFlight ??= this.fetch().finally(() => {
+            this.fetchedAt = (this.opts.now ?? Date.now)();
+            this.inFlight = null;
+        });
+        return this.inFlight;
+    }
+    async fetch() {
+        let credential;
+        try {
+            credential = (await this.source.credentials())[0];
+        }
+        catch (e) {
+            this.opts.warn?.(`claude models: no credentials: ${e.message}`);
+            return this.last;
+        }
+        if (!credential)
+            return this.last;
+        try {
+            const models = await fetchClaudeModels(`https://${this.opts.upstream()}`, credential.headers, this.opts.fetch, this.opts.timeoutMs);
+            if (models.length)
+                this.last = models;
+        }
+        catch (e) {
+            this.opts.warn?.(`claude models: ${e.message}`);
+        }
+        return this.last;
+    }
+}
+/** One `GET /v1/models` with the given credentials. Throws on anything but a usable answer. */
+export async function fetchClaudeModels(origin, headers, fetchImpl = fetch, timeoutMs = 8000) {
+    const res = await fetchImpl(`${origin}/v1/models?limit=100`, {
+        method: "GET",
+        headers: { "anthropic-version": "2023-06-01", ...headers, accept: "application/json" },
+        signal: AbortSignal.timeout(timeoutMs),
+    });
+    // The status alone: the body of an auth failure is not worth the risk of echoing.
+    if (!res.ok)
+        throw new Error(`HTTP ${res.status}`);
+    return claudeModelsFromBody(await res.json());
+}
+/**
+ * The models to add to a provider's declared list: each one released after the newest model it
+ * already declares in the same family, and not offered before. A family the provider does not
+ * declare at all is left out — someone who unticked every Sonnet did not ask for the next one — and
+ * so is anything in `offered`, so a model unticked after it arrived does not come back.
+ */
+export function newClaudeReleases(live, declared, offered) {
+    const byId = new Map(live.map((model) => [model.id, model]));
+    const newest = new Map();
+    for (const id of declared) {
+        const model = byId.get(id.replace(/-\d{8}$/, ""));
+        if (!model?.line || model.createdAt === undefined)
+            continue;
+        newest.set(model.line, Math.max(newest.get(model.line) ?? Number.NEGATIVE_INFINITY, model.createdAt));
+    }
+    const declaredIds = new Set(declared.map((id) => id.replace(/-\d{8}$/, "")));
+    return live.filter((model) => {
+        if (declaredIds.has(model.id) || offered.has(model.id) || !model.line || model.createdAt === undefined)
+            return false;
+        const floor = newest.get(model.line);
+        return floor !== undefined && model.createdAt > floor;
+    });
+}

package/dist/router/src/proxy.js

@@ -37,6 +37,7 @@ import { effortLevelsForModel } from "./admin.js";
 import { ResponseUsageTap } from "./requestlog.js";
 import { credentialHeaderValues, redactErrorText, redactHeaders } from "./redact.js";
 import { ClaudeAccountAuthPool } from "./providers/anthropic-account-pool.js";
+import { ClaudeModelCatalog } from "./providers/anthropic-models.js";
 import { ClaudeUsage } from "./providers/anthropic-usage.js";
 import { dropForeignThinking } from "./thinking.js";
 const MAX_BODY = 64 * 1024 * 1024;
@@ -188,6 +189,8 @@ export class Proxy {
     claudeAccounts;
     /** Each Claude subscription account's usage, for the admin status (never a token). */
     claudeUsage;
+    /** The Claude models the signed-in account can use, from Anthropic's own list. */
+    claudeModels;
     deps;
     /**
      * Cooldowns, quarantines and conversation stickiness for provider credentials. In memory: a
@@ -357,6 +360,10 @@ export class Proxy {
             upstream: () => this.deps.config().upstream,
             warn: (message) => deps.log.warn(message),
         });
+        this.claudeModels = new ClaudeModelCatalog(this.claudeAccounts, {
+            upstream: () => this.deps.config().upstream,
+            warn: (message) => deps.log.warn(message),
+        });
         this.httpServer = http.createServer({ maxHeaderSize: 64 * 1024 }, (req, res) => {
             void this.handle(req, res);
         });

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.8";
+export const VERSION = "0.8.9";

package/dist/ui/app.js

@@ -1795,7 +1795,10 @@ function openAnthropicProviderForm(options) {
         response.error ? el("div", { class: "small", text: response.error.replace(/^no-credits:\s*/, "") }) : null,
       ].filter(Boolean));
       if (Array.isArray(response.models) && response.models.length) {
-        foundModels = response.models;
+        // Anthropic's own list, so a release shows up here without a ClaudeRipple update. A saved
+        // model the list no longer carries stays visible and ticked rather than dropped on save.
+        const listed = new Set(response.models.map((model) => model.id));
+        foundModels = [...response.models, ...modelsOf(existing).filter((model) => !listed.has(model.id))];
         selected = new Set(existing ? modelsOf(existing).map((model) => model.id) : foundModels.map((model) => model.id));
         renderModels();
       }
@@ -1803,6 +1806,9 @@ function openAnthropicProviderForm(options) {
     finally { if (formActive) probeButton.disabled = false; }
   }
   probeButton.addEventListener("click", () => void runProbe());
+  // The Claude login needs nothing typed, so fetch the account's model list as soon as the form
+  // opens: a saved provider otherwise showed only what was ticked when it was first saved.
+  if (auth.value === "claude-code") setTimeout(() => void runProbe(), 0);
   const modeHint = hint("");
   function syncModeHint() { modeHint.textContent = auth.value === "claude-code" && accountPool ? t("providers.anthropicPoolRouting") : t("providers.anthropicIngressOnly"); }
   auth.addEventListener("change", syncModeHint);

package/dist/ui/presets-fallback.js

@@ -3,15 +3,18 @@
 // Used only while the router is starting up or an older router does not yet expose
 // /api/presets and /api/claude-models. The API response replaces these lists.
 const FALLBACK_CLAUDE_MODELS = [
+  { id: "claude-haiku-5-5", name: "Haiku 5.5" },
+  { id: "claude-sonnet-5-5", name: "Sonnet 5.5" },
+  { id: "claude-opus-5-5", name: "Opus 5.5" },
   { id: "claude-fable-5-1", name: "Fable 5.1" },
   { id: "claude-opus-5", name: "Opus 5" },
   { id: "claude-sonnet-5", name: "Sonnet 5" },
-  { id: "claude-haiku-4-5", name: "Haiku 4.5" },
   { id: "claude-fable-5", name: "Fable 5" },
   { id: "claude-opus-4-8", name: "Opus 4.8" },
   { id: "claude-opus-4-7", name: "Opus 4.7" },
-  { id: "claude-opus-4-6", name: "Opus 4.6" },
   { id: "claude-sonnet-4-6", name: "Sonnet 4.6" },
+  { id: "claude-opus-4-6", name: "Opus 4.6" },
+  { id: "claude-haiku-4-5", name: "Haiku 4.5" },
 ];
 
 const CHATGPT_MODELS = [

package/docs/ARCHITECTURE.md

@@ -208,6 +208,18 @@ request went, and a `Pane` holds the request log.
 
 ## 4. Provider adapters
 
+- **The Claude model list is Anthropic's own (2026-10-08).** The native `anthropic`
+  provider's models came from a constant in admin.ts, so each release after it was cut
+  was missing from the provider form, the mapping table and the declared list until a
+  ClaudeRipple release caught up — Opus 5.5 (Sep 21), Sonnet 5.5 (Sep 28) and Haiku 5.5
+  (Oct 7) all were, while Claude Code itself had them. `GET /v1/models` answers the Claude
+  Code login (the observed headers) as well as an API key, newest first, with each model's
+  effort ladder, context window and lifecycle (measured: 14 active models). The router
+  caches it for an hour (`ClaudeModelCatalog`); the constant is only the fallback when no
+  sign-in answers. A release is also **declared** on its own, every six hours: added to a
+  native provider that already declares an older model of the same family, and remembered
+  in `claude-models-offered.json` so a model unticked afterwards is not added again.
+
 - **Declared models route themselves (2026-09-19).** A provider's `models` list —
   filled by the probe from the vendor's `/models`, ticked in the GUI — now decides
   routing when no rule matched: a model exactly one provider carries goes there,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clauderipple",
-  "version": "0.8.8",
+  "version": "0.8.9",
   "description": "Use GPT (any ChatGPT plan with Codex), DeepSeek and 400+ other models in the Claude Desktop Code tab and Claude Code while staying signed in to your Claude subscription — no third-party gateway mode. Several ChatGPT accounts that take over when one runs out, in Codex too.",
   "license": "GPL-3.0-only",
   "workspaces": [