clauderipple 0.8.0 → 0.8.2

package/CHANGELOG.md

@@ -1,5 +1,45 @@
 # 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
+
+- **Codex credits are spent instead of refused.** Once a ChatGPT plan's window read 100%, the
+  router rested the account until the reset, even though OpenAI serves an account with bought
+  credits past its window. An account with credits (or an unlimited balance) now stays in
+  rotation; a real usage-limit refusal still rests it.
+- **Fewer failed Claude app requests in picker mode.** claude.ai closes idle kept-alive
+  connections, and a request written on one as it closed came back as a 502 (about 65 a day
+  here, mostly the app's start-up requests). A GET, HEAD or OPTIONS that meets such a socket is
+  now sent again; a POST is not.
+- **Picker mode on a new Mac.** The ClaudeRipple CA counted as trusted when it was merely in the
+  login keychain, so `picker on` could skip the trust step and leave Claude Desktop unable to
+  load claude.ai. Trust is now read from the user trust settings, and `picker off` removes the
+  certificate either way.
+- **The route band said "router not answering"** on Claude Code 2.1.288, which sends plain
+  `http://` requests through the proxy too and got 405. They are now relayed.
+
+### Docs
+
+- Any ChatGPT plan that includes Codex works (Plus, Pro, Business; Enterprise/Edu with Codex
+  turned on), not just Plus and Pro.
+- `ultra` effort is sent as `max`: the Codex backend refuses `ultra` (measured), and Codex's own
+  ultra is max reasoning plus its sub-agents, which in Claude Code are Claude Code's subagents.
+
 ## 0.8.0 — 2026-10-05
 
 ### Added

package/README.ko.md

@@ -101,7 +101,9 @@ Anthropic이 만든 커넥터가 전부 그대로 동작합니다. 1P에 남는
 
 ### OpenAI API 키가 필요한가요?
 
-필요 없습니다. ChatGPT Plus나 Pro 구독이면 됩니다. 앱에서 로그인하면 되고 API 키는 쓰지 않습니다.
+필요 없습니다. Codex가 포함된 ChatGPT 요금제면 됩니다 — Plus·Pro·Business, 그리고 워크스페이스 관리자가
+Codex를 켜 둔 Enterprise·Edu. 앱에서 로그인하면 되고 API 키는 쓰지 않습니다. 사용량 한도는 요금제 것을 따르며,
+한도를 다 쓰면 구매해 둔 Codex 크레딧으로 이어서 씁니다.
 API 키는 DeepSeek·Kimi·GLM·OpenRouter처럼 다른 프로바이더를 붙일 때만 씁니다.
 
 ### 어떤 모델을 쓸 수 있나요?

package/README.md

@@ -114,8 +114,10 @@ Claude. Most people map one or two names to GPT and leave the rest alone.
 
 ### Do I need an OpenAI API key?
 
-No. A ChatGPT Plus or Pro subscription works — you sign in from the app and no API key
-is involved. API keys are for the other providers (DeepSeek, Kimi, GLM, OpenRouter and
+No. Any ChatGPT plan that includes Codex works — Plus, Pro and Business, and Enterprise or
+Edu where the workspace admin has turned Codex on. You sign in from the app and no API key
+is involved. The plan's usage limits apply; once they are used up, Codex credits you have
+bought carry on. API keys are for the other providers (DeepSeek, Kimi, GLM, OpenRouter and
 anything else with an Anthropic- or OpenAI-compatible endpoint).
 
 ### Which models can I use?

package/dist/app/package.json

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

package/dist/cli/src/picker.js

@@ -152,8 +152,12 @@ export function caTrusted(caPem) {
             const out = powershell(`@(Get-ChildItem Cert:\\CurrentUser\\Root | Where-Object { $_.Subject -eq 'CN=${CA_NAME}' }).Count`);
             return Number(out.trim()) > 0;
         }
-        execFileSync("security", ["find-certificate", "-c", CA_NAME, loginKeychain()], { stdio: "ignore" });
-        return true;
+        // Ask for the trust setting, not the keychain item: the certificate can sit in the login keychain
+        // with no trust (new Mac, 2026-10-06), and a presence check then made `picker on` skip the trust
+        // step while Claude Desktop rejected every claude.ai certificate (ERR_CERT_AUTHORITY_INVALID).
+        // `add-trusted-cert` without -d writes the user trust domain, which this lists one "Cert N: <name>" per line.
+        const out = execFileSync("security", ["dump-trust-settings"], { stdio: ["ignore", "pipe", "ignore"] }).toString();
+        return out.split("\n").some((line) => /^Cert \d+: /.test(line) && line.slice(line.indexOf(": ") + 2).trim() === CA_NAME);
     }
     catch {
         return false;
@@ -175,9 +179,10 @@ export function trustCa(caPem) {
 export function untrustCa(caPem) {
     if (isLinux)
         return nssUntrust();
-    if (!caTrusted(caPem))
-        return false;
+    const trusted = caTrusted(caPem);
     if (isWindows) {
+        if (!trusted)
+            return false;
         try {
             powershell(`Get-ChildItem Cert:\\CurrentUser\\Root | Where-Object { $_.Subject -eq 'CN=${CA_NAME}' } | ForEach-Object { Remove-Item -Path $_.PSPath -Force }`, { stdio: "inherit", interactive: true });
         }
@@ -186,19 +191,22 @@ export function untrustCa(caPem) {
         }
         return true;
     }
-    try {
-        execFileSync("security", ["remove-trusted-cert", caPem], { stdio: "inherit" });
-    }
-    catch {
-        /* trust settings may already be gone */
+    // macOS: an untrusted copy can still be in the keychain, so the item is deleted either way.
+    if (trusted) {
+        try {
+            execFileSync("security", ["remove-trusted-cert", caPem], { stdio: "inherit" });
+        }
+        catch {
+            /* trust settings may already be gone */
+        }
     }
     try {
         execFileSync("security", ["delete-certificate", "-c", CA_NAME, loginKeychain()], { stdio: "ignore" });
+        return true;
     }
     catch {
-        /* ignore */
+        return trusted;
     }
-    return true;
 }
 function readMeta() {
     try {

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

@@ -97,13 +97,36 @@ export function rateLimitsFromHeaders(h) {
     if (!primary)
         return null;
     const secondary = window("secondary");
+    const flag = (k) => {
+        const v = h.get(k)?.toLowerCase();
+        return v === "true" ? true : v === "false" ? false : undefined;
+    };
+    const credits = creditsSnapshot(flag("x-codex-credits-has-credits"), flag("x-codex-credits-unlimited"), h.get("x-codex-credits-balance"), undefined);
     return {
         type: "codex.rate_limits",
         plan_type: h.get("x-codex-plan-type") ?? undefined,
         rate_limits: { primary, secondary: secondary && secondary.window_minutes ? secondary : null },
+        ...(credits ? { credits } : {}),
         at: Date.now(),
     };
 }
+/**
+ * The account's purchased credits, which the backend draws on once a plan window is used up — the
+ * account keeps answering at 100%. Measured 2026-10-06: response headers carry
+ * `x-codex-credits-has-credits: False` / `-unlimited: False` / `-balance: 0` (Python-style
+ * booleans), and `/wham/usage` carries `credits: {has_credits, unlimited, overage_limit_reached,
+ * balance}`. Null when the backend said nothing about credits.
+ */
+function creditsSnapshot(hasCredits, unlimited, balance, overageReached) {
+    if (typeof hasCredits !== "boolean" && typeof unlimited !== "boolean")
+        return null;
+    return {
+        has_credits: hasCredits === true,
+        unlimited: unlimited === true,
+        ...(typeof balance === "string" || typeof balance === "number" ? { balance: String(balance) } : {}),
+        ...(typeof overageReached === "boolean" ? { overage_limit_reached: overageReached } : {}),
+    };
+}
 /**
  * Map the `/wham/usage` JSON body onto the same shape as `rateLimitsFromHeaders`, so `/api/status`
  * and the GUI read one thing whether the snapshot came from response headers or the active call.
@@ -131,10 +154,13 @@ export function rateLimitsFromUsage(body) {
     if (!primary)
         return null;
     const secondary = win(b?.rate_limit?.secondary_window);
+    const c = b?.credits;
+    const credits = c ? creditsSnapshot(c.has_credits, c.unlimited, c.balance, c.overage_limit_reached) : null;
     return {
         type: "codex.rate_limits",
         plan_type: typeof b?.plan_type === "string" ? b.plan_type : undefined,
         rate_limits: { primary, secondary: secondary && secondary.window_minutes ? secondary : null },
+        ...(credits ? { credits } : {}),
         at: Date.now(),
     };
 }
@@ -182,9 +208,14 @@ function windowResetMs(w, now) {
 /**
  * How long an account is out, from a rate-limit snapshot: the latest reset among the windows it
  * has used up, since it is usable only once every full window has reset. Undefined when no window
- * is full — the account is not out, whatever else the snapshot says.
+ * is full — the account is not out, whatever else the snapshot says — and undefined when the
+ * account has credits to spend past the window: the backend keeps serving it, and when the credits
+ * run out it says so with a 429, which rests the account the ordinary way.
  */
-export function exhaustedForMs(snapshot, now = Date.now()) {
+export function exhaustedForMs(snapshot, now = Date.now(), creditsCount = true) {
+    const credits = snapshot?.credits;
+    if (creditsCount && credits && (credits.has_credits === true || credits.unlimited === true) && credits.overage_limit_reached !== true)
+        return undefined;
     const limits = (snapshot?.rate_limits ?? null);
     let out;
     for (const w of [limits?.primary, limits?.secondary]) {
@@ -762,7 +793,8 @@ export class ChatGptAdapter {
             const headerRecord = Object.fromEntries(upstream.headers.entries());
             const snapshot = rateLimitsFromHeaders(upstream.headers);
             const retryHeader = headerRecord["retry-after"] ? retryAfterMs({ "retry-after": headerRecord["retry-after"] }) : undefined;
-            const waitMs = retryHeader ?? exhaustedForMs(snapshot) ?? retryAfterMs(headerRecord);
+            // The account was refused, so whatever credits the headers report did not carry it past the window.
+            const waitMs = retryHeader ?? exhaustedForMs(snapshot, Date.now(), false) ?? retryAfterMs(headerRecord);
             // A refusal here is a rest, never a pool quarantine: "sign in again" is the store's to say
             // (needsReauth, above), and a quarantine would outlive the new token a sign-in brings.
             const verdict = this.pool.penalise(this.name, credential.id, credentialRefused ? 403 : status, waitMs, text);

package/dist/router/src/proxy.js

@@ -47,11 +47,15 @@ const HOP_BY_HOP = new Set(["connection", "keep-alive", "proxy-connection", "tra
 const CLIENT_AUTH = new Set(["authorization", "x-api-key"]);
 /** How much of an upstream error body is kept for the log. */
 const ERROR_HEAD_MAX = 4096;
+/** Methods safe to send twice (RFC 9110 §9.2.2), and so the only ones resent after a stale socket. */
+const IDEMPOTENT = new Set(["GET", "HEAD", "OPTIONS"]);
 /**
  * Claude Code's Remote Control registration uses HTTPS absolute-form proxy requests instead of
  * CONNECT (`POST https://api.anthropic.com/v1/environments/bridge HTTP/1.1`). Convert that legal
  * forward-proxy form to the origin form expected inside a TLS connection. Credentials and the
  * request body remain byte-for-byte client data; proxy-only headers never reach the destination.
+ * Plain `http:` takes the same form and is relayed over TCP: Claude Code 2.1.288 sends its http
+ * requests through HTTPS_PROXY too, loopback included (a mod reading the admin API got our 405).
  */
 export function absoluteProxyRequest(header) {
     const lines = header.toString("latin1").split("\r\n");
@@ -66,9 +70,10 @@ export function absoluteProxyRequest(header) {
     catch {
         return null;
     }
-    if (url.protocol !== "https:" || url.username || url.password || url.hash || !url.hostname)
+    const secure = url.protocol === "https:";
+    if ((!secure && url.protocol !== "http:") || url.username || url.password || url.hash || !url.hostname)
         return null;
-    const port = url.port ? Number(url.port) : 443;
+    const port = url.port ? Number(url.port) : secure ? 443 : 80;
     if (!Number.isInteger(port) || port < 1 || port > 65535)
         return null;
     // URL.hostname keeps brackets around IPv6 literals; net/tls expect the bare address while the
@@ -79,10 +84,10 @@ export function absoluteProxyRequest(header) {
         !/^connection\s*:/i.test(line));
     const authority = url.port ? `${url.hostname}:${url.port}` : url.hostname;
     const path = `${url.pathname || "/"}${url.search}`;
-    // One TLS connection serves one absolute-form request. Reusing it would send the next proxy-form
+    // One upstream connection serves one absolute-form request. Reusing it would send the next proxy-form
     // request target directly to the origin, so explicitly ask both peers to close after the response.
     const rewritten = [`${match[1]} ${path} ${match[3]}`, `Host: ${authority}`, "Connection: close", ...headers].join("\r\n") + "\r\n\r\n";
-    return { host, port, path, head: Buffer.from(rewritten, "latin1") };
+    return { host, port, path, head: Buffer.from(rewritten, "latin1"), tls: secure };
 }
 /**
  * The same header list with one credential swapped for another. Names carried by either credential
@@ -425,7 +430,7 @@ export class Proxy {
             if (method !== "CONNECT" || !target) {
                 const absolute = absoluteProxyRequest(head.subarray(0, end));
                 if (absolute) {
-                    log.info(`ABSOLUTE ${method ?? "?"} https://${absolute.host}:${absolute.port}${absolute.path}`);
+                    log.info(`ABSOLUTE ${method ?? "?"} ${absolute.tls ? "https" : "http"}://${absolute.host}:${absolute.port}${absolute.path}`);
                     this.forwardAbsolute(sock, absolute, rest);
                     return;
                 }
@@ -450,7 +455,9 @@ export class Proxy {
     /** Forward an HTTPS absolute-form request without terminating it through the routing layer. */
     forwardAbsolute(sock, request, rest) {
         const servername = net.isIP(request.host) ? undefined : request.host;
-        const up = (this.deps.tlsConnect ?? tls.connect)({ host: request.host, port: request.port, ...(servername ? { servername } : {}), ALPNProtocols: ["http/1.1"] });
+        const up = request.tls
+            ? (this.deps.tlsConnect ?? tls.connect)({ host: request.host, port: request.port, ...(servername ? { servername } : {}), ALPNProtocols: ["http/1.1"] })
+            : net.connect({ host: request.host, port: request.port });
         const kill = () => {
             sock.destroy();
             up.destroy();
@@ -462,7 +469,7 @@ export class Proxy {
             up.destroy();
         });
         sock.on("error", kill);
-        up.once("secureConnect", () => {
+        up.once(request.tls ? "secureConnect" : "connect", () => {
             up.write(request.head);
             if (rest.length)
                 up.write(rest);
@@ -936,7 +943,7 @@ export class Proxy {
             }
         }
         else if (isApiHost) {
-            target = { protocol: "https:", host: cfg.upstream, port: 443, agent: this.upstreamAgent, extraHeaders: {} };
+            target = { protocol: "https:", host: cfg.upstream, port: this.deps.upstreamPort ?? 443, agent: this.deps.upstreamAgent ?? this.upstreamAgent, extraHeaders: {} };
             tag = `PASS ${typeof model === "string" ? model : "-"}`;
             // Passthrough stays byte-exact unless another model's thinking would get the turn refused.
             if (json && dropForeignThinking(json) > 0)
@@ -1005,7 +1012,11 @@ export class Proxy {
         let upReq;
         /** Credentials already spent on this turn, so a retry cannot pick one of them again. */
         const tried = new Set(penalised ? [penalised.id] : []);
+        /** The headers of the attempt in flight, so a stale-socket resend repeats exactly that attempt. */
+        let lastAttemptHeaders = headers;
+        let staleRetries = 0;
         const send = (attemptHeaders) => {
+            lastAttemptHeaders = attemptHeaders;
             upReq = lib.request({
                 protocol: target.protocol,
                 host: target.host,
@@ -1073,6 +1084,18 @@ export class Proxy {
             }
         });
         const onUpstreamError = (e) => {
+            // A kept-alive socket the upstream had already closed: the reset arrives before any response,
+            // so the request never reached it. claude.ai did this 259 times in four days of picker mode
+            // (2026-10-03..06), each one a 502 on an app request such as `current_user_access`. Send an
+            // idempotent request again on a fresh attempt instead of failing it; a POST is never resent,
+            // since a reset cannot prove the upstream did not act on it.
+            const code = e.code;
+            if (upReq.reusedSocket && (code === "ECONNRESET" || code === "EPIPE") && IDEMPOTENT.has(method) && !clientAborted && !res.headersSent && staleRetries < 2) {
+                staleRetries++;
+                log.info(`STALE ${reqHost}: kept-alive socket was closed (${code}); resending ${method} ${path.slice(0, 60)}`);
+                send(lastAttemptHeaders);
+                return;
+            }
             if (target.host === cfg.upstream)
                 this.deps.health.failure(e);
             // Nothing reached the provider, so this says nothing about the credential — but it does say

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

package/docs/ARCHITECTURE.md

@@ -302,8 +302,22 @@ request went, and a `Pane` holds the request log.
     `/zen/v1/responses`, not the Codex backend): gpt-6-sol, gpt-6-luna,
     gpt-5.6-sol and gpt-5.6-luna all accept `none, low, medium, high, xhigh,
     max` and answer `400 param: reasoning.effort` to both `minimal` and
-    `ultra`. So `ultra` is not a level that API takes on any of them; whether
-    the Codex backend does is still open.
+    `ultra`. So `ultra` is not a level that API takes on any of them. **Settled
+    2026-10-06 on the Codex backend too:** gpt-6.1-sol with `reasoning.effort:
+    "ultra"` answered `400 Invalid value: 'ultra'. Supported values are: 'none',
+    'minimal', 'low', 'medium', 'high', 'xhigh', and 'max'`, while `max` answered
+    200. The catalogue's own description of `ultra` is "Maximum reasoning with
+    automatic task delegation": it is `max` on the wire plus the Codex CLI
+    spawning its own sub-agents, which in Claude Code are Claude Code's
+    subagents. Keep the clamp. (`reasoning.mode` takes `standard`/`pro`, and
+    gpt-6.1-sol refuses `pro`: "not supported with this model".)
+  - **Credits (2026-10-06).** Every Codex response carries
+    `x-codex-credits-has-credits` / `-unlimited` (`True`/`False`) and
+    `-balance`; `/wham/usage` has `credits: {has_credits, unlimited,
+    overage_limit_reached, balance}`. OpenAI's help centre: included usage is
+    spent first, then purchased credits. So a window at 100% with credits left
+    is not an exhausted account — `exhaustedForMs` no longer rests it, and a
+    real 429 still does.
   - **Model catalogue (2026-09-23).** `GET {base}/codex/models?client_version=<v>`
     with the same credentials answers `{ models: [{ slug, display_name,
     visibility: "list"|"hide", context_window, supported_reasoning_levels:
@@ -1097,6 +1111,7 @@ subscription exists in this environment. Files are under `src/`:
 | Windows: the scheduled task inherited the console that started it, so closing the installer window killed the router with `0xC000013A` (Ctrl+C), 2026-09-14 | The task runs a PowerShell launcher that uses `Start-Process -PassThru -Wait`: detached from any console, still tracked so `RestartCount` keeps acting as KeepAlive and the exit code (including the health self-exit 75) propagates. |
 | Windows: `install` registered a logon-triggered task and stopped there, so the router did not exist until the next sign-in — launchd starts at bootstrap (`RunAtLoad`) and the difference was invisible | `install` starts the supervisor itself on both platforms and prints the result. |
 | Windows: trusting the CA failed with "this operation cannot use the UI" — every PowerShell call carried `-NonInteractive`, and the confirmation dialog never appeared, so picker mode stopped with no certificate and no explanation | Certificate trust and removal run WITHOUT `-NonInteractive` (and without `windowsHide`). They are UI operations by design: the OS must be able to show the user what it is being asked to trust. |
+| macOS, new Mac (2026-10-06): picker mode on, router up, and Claude Desktop would not open — every claude.ai load failed `ERR_CERT_AUTHORITY_INVALID`, router logged `tls alert certificate unknown`; `dump-trust-settings` had no entry for the CA. "Trusted" was decided by `find-certificate` (the item is in the login keychain), which says nothing about trust, so `picker on` could skip the trust step and `status` could read an untrusted CA as trusted | On macOS the CA counts as trusted only when the user trust domain (`security dump-trust-settings`) lists it. `picker off` deletes the keychain item even when it carries no trust. |
 | Windows: sign-in failed with `missing_required_parameter` because the OAuth URL was opened via `cmd /c start`, and cmd reads `&` as a command separator — everything after the first parameter was cut off and run as commands (2026-09-14) | Browsers are opened with `Start-Process <url>` as a single quoted argument. Any URL we hand to a shell must survive its metacharacters. |
 | The provider form's "also show in the Claude app picker" box only records `cli.extraModels`; picker mode itself stayed off, nothing was injected, and the user believed the picker was on (Windows x64, 2026-09-14: `config.json` had no `picker` key, no CA, no Config Library) | When that box is ticked while picker mode is off, the form says so under the box and offers to turn picker mode on right after saving. Any control that *looks* like it enables picker mode must either enable it or say what is still missing. |
 | A DeepSeek mapping answered `401` on every real request while the provider form's own "Test connection" stayed green — the test sends the provider's headers alone, live traffic also carried the caller's `authorization` (2026-09-15, Windows) | A routed request carries provider authentication only (§4). The connection test and live traffic must present the same auth set, or the test certifies a path nobody uses. |
@@ -1113,6 +1128,7 @@ subscription exists in this environment. Files are under `src/`:
 | The worker registry was four places that did not know each other — `providers.*.models`, `aliases`, `~/.claude/agents/*.md`, and prose in CLAUDE.md — and every new provider needed all four edited by hand; the one left out was the one that failed (2026-09-19, DeepSeek) | One source: a ticked model *is* a worker. Agent files and marker aliases are generated from `config.json` (§4 "worker definitions"); nothing about a worker is written twice. |
 | ChatGPT prompt-cache hit fell from 93% (2026-09-13) to 9% (2026-09-20) with nothing in our request changing — the backend had started keying the cache on the conversation's identity (`session-id`/`thread-id`/`x-client-request-id`/`client_metadata`), which we never sent; `prompt_cache_key` alone no longer earned a write | The adapter states the conversation's identity the way the Codex CLI does (§4) and echoes `x-codex-turn-state`. The acceptance metric (≥90% on translated providers) is watched per day in `requests.jsonl`; a fall with an unchanged request means the wire changed under us, and the reference to diff against is the real CLI captured through a local proxy, not our own memory of the protocol. |
 | Remote Control registration failed locally with 405 before Anthropic saw it: Claude Code 2.1.275 uses HTTPS absolute-form (`POST https://api.anthropic.com/v1/environments/bridge HTTP/1.1`) rather than CONNECT for registration, polling and heartbeats, while the forward-proxy socket accepted CONNECT only (issue #10, Windows 11) | Accept valid HTTPS absolute-form, strip proxy-only headers, replace Host, rewrite only the target to origin-form, and relay one request over direct TLS outside model routing. Force `Connection: close`: reusing that TLS socket could send a later proxy-form request to the first origin. Parser tests plus a live local TLS origin verify body and credential preservation. |
+| The status mod's band said "router not answering" on every tick while the admin API answered curl (2026-10-06, CLI 2.1.288): the host's `$.http.fetch("http://127.0.0.1:8792/…")` went through `HTTPS_PROXY` as plain-HTTP absolute-form (`GET http://127.0.0.1:8792/… HTTP/1.1`), loopback included, and the proxy socket answered 405 to anything but CONNECT or `https:` absolute-form. Measured with a probe mod under `claude -p --plugin-dir`: 405 with an empty body | `http:` absolute-form is relayed like `https:` (same header rewrite, `Connection: close`) over plain TCP. A live loopback origin test covers it. |
 | Re-running `clauderipple install` as a normal Windows user rewrote the launcher, then `Register-ScheduledTask -Force` could answer `0x80070005 Access is denied` even though the existing per-user task was already correct (issue #9) | Reuse an existing task only when its entire intended definition matches: one PowerShell action and exact arguments, current user, limited interactive logon, one matching logon trigger, restart count/interval, no execution limit, IgnoreNew, and battery policy. A missing, stale or foreign same-named task still takes the normal registration/error path. |
 | OpenCode Go's relay answered `403 {"message":"Error from provider (Console Go): Upstream request failed: …"}` during a few seconds of its own trouble. The 403 was classified as an auth failure, which both cooled the credential for 60s **and** removed it from the retry candidate list, so the router could not retry inside the turn and answered the user with what read as an authentication error. Five times in a day, each cleared by asking again (2026-09-21) | A 403 whose body reports an upstream failure is charged a **zero** cooldown. It is not a statement about the credential, and any wait at all moves the conversation off a key that did nothing and takes its prompt cache with it (§4). With no cooldown the credential stays retryable, so the turn is answered on the next attempt instead of becoming a user-visible failure. The body is the only way to tell this apart from a real 403 (policy, region, blocked model), so it is read for 403 and only 403. |
 | The same relay 403 kept reaching the user after that fix, because it was the wrong layer: DeepSeek runs on `openai-compatible`, whose adapter was **never** retried at all — the in-turn retry lives only in the anthropic-compatible wire path (`nextCredential`), and `credentialsOf` gives a translated provider exactly one credential and no fallback. So a relay hiccup had nowhere to go but the user (2026-09-21, root cause of the day's repeated "authentication failed") | Every translated adapter retries the `fetch` **before** any status or byte is written, so the turn is still replaceable (§4 "the first byte commits the turn"). `fetchWithRetry` retries only `transient` verdicts — connect failures, 5xx, and a 403 reporting a broken upstream — to the ceiling of 10 attempts the CLI itself uses, with a 250ms→2s backoff. A 401/429 is **not** retried: the adapter holds one credential, so asking the key that just refused the identical request again only delays the error. `classify` is reused for the judgement, with `kind === "transient"` narrowing a pool's answer to an adapter's. |
@@ -1121,6 +1137,9 @@ subscription exists in this environment. Files are under `src/`:
 | Re-running the installer — the documented update — replaced the files and left the router running the old code: `install` treats a running router as done, and on Windows and Linux an unchanged supervisor definition is not re-registered, so nothing restarted it until the next login (found 2026-09-28 while building `update`; the tray's own restart covered only the packaged app) | `install` asks a router that is already running for its version and restarts one that differs. Measured in the Windows 11 VM: 0.5.1 running, installer run with 0.6.0 → "restarting it on 0.6.0", status 0.6.0. |
 | 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.0",
+  "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": [