clauderipple 0.8.1 → 0.8.2

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## 0.8.2 — 2026-10-06
+
+### Fixed
+
+- **Effort works on API-key providers.** A provider with no effort ladder of its own — DeepSeek,
+  Kimi, GLM, MiniMax, Qwen, Groq, Mistral, or any key and URL — stripped the effort you picked and
+  the Claude app showed no effort menu for its models. ClaudeRipple now asks each such model: it
+  sends a level no vendor defines, and if the endpoint refuses it, the levels it does accept become
+  that model's effort menu. An endpoint that accepts anything is left without effort, since it is
+  not reading the field. Providers you already set up are measured a minute after the router
+  starts; nothing needs re-saving.
+- **DeepSeek's API offers low / high / max**, the three levels its thinking mode maps every
+  request onto.
+
 ## 0.8.1 — 2026-10-06
 
 ### Fixed

package/dist/app/package.json

@@ -1,5 +1,5 @@
 {
   "private": true,
-  "version": "0.8.1",
+  "version": "0.8.2",
   "type": "commonjs"
 }

package/dist/router/src/admin.js

@@ -981,6 +981,26 @@ function providerLadder(p) {
         return [...(p.caps?.effortLevels ?? [])];
     return [];
 }
+/**
+ * Whether nothing says what effort this provider's models take, so a request strips it: the case
+ * worth measuring a model for. Read the way the request path reads it. An anthropic-compatible
+ * provider falls back to its preset live (`compatCaps` in proxy.ts) and strips on an empty ladder; the
+ * OpenAI adapter reads only its own `caps`, and `reasoning: "effort"` with no levels passes effort
+ * through as asked. An anthropic-compatible ladder the config states is a decision, even an empty
+ * one. `reasoning: "none"` is not: the provider form writes it for every OpenAI-compatible provider
+ * whose preset has no ladder (Groq, Mistral, a key and a URL), with no control to say otherwise.
+ */
+function effortUndeclared(p) {
+    if (p.type === "anthropic-compatible") {
+        if (p.caps?.effortLevels !== undefined)
+            return false;
+        const preset = p.preset ? PRESETS.find((entry) => entry.id === p.preset) : undefined;
+        return (preset?.effortLevels ?? []).length === 0;
+    }
+    if (p.type === "openai-compatible")
+        return p.caps?.reasoning !== "effort";
+    return false;
+}
 /**
  * Fold measurements into the config on disk.
  *
@@ -1025,6 +1045,37 @@ function applyMeasurements(configFile, results) {
     writeConfigFile(configFile, current);
     return { applied };
 }
+/** Register a measurement job and run it detached; returns the id a caller polls. */
+function startMeasureJob(providerName, models, deps) {
+    sweepMeasureJobs();
+    const jobId = crypto.randomBytes(12).toString("hex");
+    MEASURE_JOBS.set(jobId, { state: "running", done: 0, total: models.length, results: [] });
+    deps.log.info(`admin: measuring ${providerName} (${models.length} model(s)) -> ${jobId.slice(0, 8)}`);
+    void runMeasureJob(jobId, providerName, models, deps);
+    return jobId;
+}
+/**
+ * Measure the models whose effort is still stripped and that nobody has settled, without waiting
+ * for a save in the GUI. A model was measured only when its provider was saved, so a provider set up
+ * before effort discovery — every DeepSeek, Kimi or GLM key on 0.8.1 and earlier — would otherwise
+ * stay without effort until its owner happened to save it again. A model with a ladder (measured,
+ * or typed) is the config's and left alone; so is one whose provider declares a ladder.
+ */
+export function measureUnsettledModels(deps) {
+    let started = 0;
+    for (const [name, provider] of Object.entries(deps.config().providers)) {
+        if (provider.type !== "openai-compatible" && provider.type !== "anthropic-compatible")
+            continue;
+        if (!effortUndeclared(provider))
+            continue;
+        const models = (provider.models ?? []).filter((model) => model.effortLevels === undefined).map((model) => model.id);
+        if (models.length === 0)
+            continue;
+        startMeasureJob(name, models, deps);
+        started++;
+    }
+    return started;
+}
 /** 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);
@@ -1036,6 +1087,9 @@ async function runMeasureJob(jobId, providerName, models, deps) {
         return;
     }
     const ladder = providerLadder(provider);
+    // No ladder from the provider, its preset or the config: find out per model whether it takes
+    // effort at all (`discoverLadder`), rather than leave it stripped.
+    const discover = effortUndeclared(provider);
     const fetchImpl = deps.measureFetch ?? measureFetchWithTimeout;
     const headers = "headers" in provider ? provider.headers : undefined;
     const sessionHeader = "sessionHeader" in provider ? provider.sessionHeader : undefined;
@@ -1047,9 +1101,9 @@ async function runMeasureJob(jobId, providerName, models, deps) {
         const candidates = measureCandidates(provider, id, listed?.wire);
         // A ladder the catalogue states is taken as stated; the wire is still asked, once, because that
         // one request is also what finds a model the plan refuses (403 FreeTierError, DataPolicyError).
-        const stated = ladder.length > 0 ? listed?.effortLevels : undefined;
+        const stated = ladder.length > 0 || discover ? listed?.effortLevels : undefined;
         const known = stated !== undefined;
-        const measured = await measureModel(id, candidates, known ? [] : ladder, { fetch: fetchImpl, ...(sessionHeader ? { sessionHeader } : {}), ...(headers ? { headers } : {}) });
+        const measured = await measureModel(id, candidates, known ? [] : ladder, { fetch: fetchImpl, ...(sessionHeader ? { sessionHeader } : {}), ...(headers ? { headers } : {}) }, { discover: discover && !known });
         if (stated && measured.wire)
             measured.effortLevels = stated;
         job.results.push(measured);
@@ -1341,13 +1395,8 @@ export function startAdmin(deps) {
                     sendJson(res, 400, { error: `provider "${body.provider}" is not openai-compatible or anthropic-compatible` });
                     return;
                 }
-                sweepMeasureJobs();
-                const jobId = crypto.randomBytes(12).toString("hex");
-                const job = { state: "running", done: 0, total: body.models.length, results: [] };
-                MEASURE_JOBS.set(jobId, job);
-                deps.log.info(`admin: measuring ${body.provider} (${body.models.length} model(s)) -> ${jobId.slice(0, 8)}`);
-                void runMeasureJob(jobId, body.provider, body.models, deps);
-                sendJson(res, 202, { jobId, total: job.total });
+                const jobId = startMeasureJob(body.provider, body.models, deps);
+                sendJson(res, 202, { jobId, total: body.models.length });
                 return;
             }
             if (pathname.startsWith("/api/providers/measure/") && method === "GET") {

package/dist/router/src/capabilities.js

@@ -136,12 +136,63 @@ async function candidateLevels(id, candidate, ladder, deps) {
             listed = parseLevels(await response.text());
     }
     catch { /* the endpoint said nothing; fall back to everything known */ }
-    const wanted = listed.length > 0 ? listed : [...ladder, ...KNOWN_EFFORTS];
-    const seen = new Set(wanted);
-    // Canonical order first so the GUI reads weakest to strongest, then anything newly named.
-    return [...KNOWN_EFFORTS.filter((level) => seen.has(level)), ...wanted.filter((level) => !KNOWN_EFFORTS.includes(level))]
+    return canonicalOrder(listed.length > 0 ? listed : [...ladder, ...KNOWN_EFFORTS]);
+}
+/** Canonical order first so the GUI reads weakest to strongest, then anything newly named. */
+function canonicalOrder(levels) {
+    const seen = new Set(levels);
+    return [...KNOWN_EFFORTS.filter((level) => seen.has(level)), ...levels.filter((level) => !KNOWN_EFFORTS.includes(level))]
         .filter((level, index, all) => all.indexOf(level) === index);
 }
+/**
+ * Whether a model with no declared ladder takes reasoning effort at all, and which levels.
+ *
+ * A provider set up from a key and a URL declares no ladder, and without one every effort the user
+ * picked was stripped and the app showed no effort menu — for DeepSeek's API, which takes effort,
+ * among others. Whether a model takes effort is not knowable from its id, and "the endpoint
+ * accepted the field" is not proof either: an endpoint that ignores unknown fields accepts any
+ * value. So a value no vendor defines is sent first:
+ *
+ * - accepted → the field is not read; no effort (`[]`).
+ * - refused (400/422) → the field is validated. The levels the refusal names, else every known one,
+ *   are sent one at a time, and the accepted ones are the ladder. DeepSeek refuses with the list
+ *   `none … max` and accepts each (measured 2026-10-06).
+ * - anything else (429, 5xx, network) → nothing is concluded (`undefined`), so a later save measures
+ *   again. Likewise when a level could not be settled, or no level was accepted while one could not
+ *   be asked: a partial ladder from a hiccup would read as the model's own.
+ */
+async function discoverLadder(id, candidate, deps) {
+    const url = endpointFor(candidate.wire, candidate.url);
+    let probe;
+    try {
+        probe = await deps.fetch(url, { method: "POST", headers: requestHeaders(candidate, deps), body: requestBody(candidate.wire, id, NOT_A_LEVEL) });
+    }
+    catch {
+        return undefined;
+    }
+    if (probe.ok)
+        return [];
+    if (!refusedLevel(probe.status))
+        return undefined;
+    const listed = parseLevels(await probe.text().catch(() => ""));
+    const accepted = [];
+    let unsettled = false;
+    for (const level of canonicalOrder(listed.length > 0 ? listed : KNOWN_EFFORTS)) {
+        let response;
+        try {
+            response = await deps.fetch(url, { method: "POST", headers: requestHeaders(candidate, deps), body: requestBody(candidate.wire, id, level) });
+        }
+        catch {
+            unsettled = true;
+            continue;
+        }
+        if (response.ok)
+            accepted.push(level);
+        else if (!refusedLevel(response.status))
+            unsettled = true;
+    }
+    return unsettled ? undefined : accepted;
+}
 /** The levels an endpoint listed in its complaint, or nothing when it did not list any. */
 export function parseLevels(message) {
     const listed = /supported values:\s*\[([^\]]+)\]/i.exec(message)?.[1] ?? /expected one of\s+(.+?)(?:\s+at line\b|$)/i.exec(message)?.[1];
@@ -181,8 +232,11 @@ async function measureLadder(id, candidate, ladder, deps) {
  * was refused before the path mattered, so reporting anything but "auth" would send the user to
  * check the wire when the problem is the credential. When no candidate answers, the result carries
  * the last status and body as `error` and no `wire`.
+ *
+ * `discover` is for a model with no ladder from anywhere: an empty `ladder` then means "find out"
+ * (`discoverLadder`) rather than "do not measure effort".
  */
-export async function measureModel(id, candidates, ladder, deps) {
+export async function measureModel(id, candidates, ladder, deps, options = {}) {
     if (candidates.length === 0)
         return { id, error: "no candidate wire to try" };
     let failure = "no candidate wire answered";
@@ -204,8 +258,12 @@ export async function measureModel(id, candidates, ladder, deps) {
             return { id, error: refusedByPlan(detail) ? `not-entitled: ${detail}` : "auth" };
         }
         if (response.ok) {
-            if (ladder.length === 0)
-                return { id, wire: candidate.wire };
+            if (ladder.length === 0) {
+                if (!options.discover)
+                    return { id, wire: candidate.wire };
+                const discovered = await discoverLadder(id, candidate, deps);
+                return { id, wire: candidate.wire, ...(discovered !== undefined ? { effortLevels: discovered } : {}) };
+            }
             return { id, wire: candidate.wire, effortLevels: await measureLadder(id, candidate, ladder, deps) };
         }
         failure = `${response.status} ${snippet(await response.text())}`.trim();

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 { startAdmin } from "./admin.js";
+import { measureUnsettledModels, startAdmin } from "./admin.js";
 import { loadModelCatalog } from "./catalog.js";
 import { RequestLog } from "./requestlog.js";
 import { OpenAiIngress } from "./ingress/server.js";
@@ -138,7 +138,7 @@ proxy
     // Quota only arrives on GPT response headers, so a quiet day left the status 11 hours stale
     // (2026-09-20). Ask once now, after listen(), and never wait for the answer.
     proxy.chatgptRefreshAll();
-    const admin = await startAdmin({
+    const adminDeps = {
         config: () => store.get(),
         configFile: configPath(),
         log: log,
@@ -167,9 +167,13 @@ proxy
         image: (req, signal) => proxy.generateImage(req, signal),
         modelCatalog: () => loadModelCatalog(),
         shutdown: () => beginDrain("shutdown requested"),
-    });
+    };
+    const admin = await startAdmin(adminDeps);
     log.info(`clauderipple admin GUI on http://127.0.0.1:${admin.port}/`);
     setImmediate(premintLeaves);
+    // 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();
 })
     .catch((e) => {
     log.error(`listen failed: ${e.message}`);

package/dist/router/src/presets.js

@@ -14,9 +14,12 @@ export const PRESETS = [
             { id: "deepseek-v4-pro", name: "DeepSeek V4 Pro" },
             { id: "deepseek-flash", name: "DeepSeek Flash" },
         ],
-        // https://api-docs.deepseek.com/guides/anthropic_api/ documents thinking and output_config.effort,
-        // but no accepted effort-level set for its Anthropic endpoint; strip effort rather than guess.
-        effortLevels: [],
+        // https://api-docs.deepseek.com/guides/thinking_mode/ maps every requested effort onto three:
+        // minimal/low → low, medium/high/xhigh → high, max/ultra → max (thinking on, high, by default).
+        // Measured 2026-10-06 on this endpoint: `output_config.effort` is validated (an unknown value is
+        // 422 "expected one of none … max") and low/high/max answer 200 on deepseek-v4-pro and
+        // deepseek-flash. Offering the three real levels keeps the menu from showing steps that collapse.
+        effortLevels: ["low", "high", "max"],
         thinking: "enabled",
         // Measured 2026-09-17, not documented: a `web_search_20250305` tool sent to this endpoint came
         // back with server_tool_use, a web_search_tool_result holding ten hits, and

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

package/docs/ARCHITECTURE.md

@@ -1138,6 +1138,7 @@ subscription exists in this environment. Files are under `src/`:
 | The tray's Electron (~270MB) was fetched into the installed package's own `node_modules`, and `npm install -g` of any other version deleted it with the old files (measured 2026-09-28): every update silently took the tray away, and on Windows a running tray held `electron.exe` inside the folder npm had to replace | Electron lives in `<home>/tray-runtime`, outside anything an update replaces. Both install scripts move one found in the old place there before installing (Windows first stops a tray running from it, and starts it again after setup) — checked on macOS and in the VM with a locked `electron.exe`. |
 | Adding a provider in the settings window restored three OpenCode effort ladders realigned by hand five hours earlier, so the app's effort menus for DeepSeek and GLM never narrowed (2026-10-02 23:13, found 10-05). `PUT /api/config` takes the whole config, and the screen built it from the copy it loaded at open and never re-read; the router itself also writes `config.json` (a measurement's results), so any of those was undone by the next unrelated save | Every GUI save fetches the router's config first and applies its own change to that. A provider form, which holds per-model fields (wire, ladder, window) from when it opened and has no control for them, takes a saved model's values from the router's copy. The provider and client screens re-read the config whenever they load. |
 | In picker mode, claude.ai requests failed as `502 … ECONNRESET` in under a second — 259 times in four days (2026-10-03..06), mostly `current_user_access`, `desktop/features` and `event_logging`. The kept-alive upstream socket had been closed by claude.ai as the next request was written on it, and Node does not resend | A GET/HEAD/OPTIONS whose reused socket resets before any response is sent again (twice at most), logged `STALE`. A POST is never resent: a reset does not prove the upstream did not act on it. Not yet shown to be the cause of the Windows "chat history loads forever" report (DC, 2026-10-06). |
+| An API-key provider with no declared effort ladder — DeepSeek, Kimi, GLM, MiniMax, Qwen, Groq, Mistral, a key and a URL — stripped every effort the user picked (`effort high→removed`) and the Claude app showed no effort menu for its models (DC reports, 2026-10-06). Declaring nothing was meant as "do not guess", but DeepSeek's API, for one, validates `output_config.effort` and maps it onto low/high/max | When nothing declares a ladder (no config ladder, no preset ladder, OpenAI-compatible `reasoning` not `effort` — the form writes `none` by default), a measurement sends a level no vendor defines first: accepted means the field is ignored (no effort, `[]`); refused means it is validated, and the levels the refusal names (else every known one) are sent one by one and the accepted ones become the model's ladder. A 429/5xx concludes nothing. The router runs this a minute after start for unsettled models, so existing providers need no re-save. The DeepSeek preset now declares low/high/max from its docs. |
 | ChatGPT accounts that had bought Codex credits were rested by the router the moment a window read 100%, though OpenAI serves them from credits past the window | `exhaustedForMs` ignores a full window while `credits.has_credits` or `unlimited` holds (and `overage_limit_reached` does not); an actual 429 still rests the account until the window resets. |
 
 ## 6. Blocked paths (measured, do not retry)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clauderipple",
-  "version": "0.8.1",
+  "version": "0.8.2",
   "description": "Use GPT (ChatGPT Plus/Pro), 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": [