@askalf/dario 6.0.1 → 6.0.3

package/README.md

@@ -177,7 +177,7 @@ That is a **chain**, read left to right, and each provider takes the first entry
 
 A single-entry chain is one-way and means what it always meant, so an existing config is unaffected. Failover is entirely opt-in: without `--pool-fallback`, a drained pool still returns its honest 429/503.
 
-The Claude entry must be a real `claude-*` model id. "Not a GPT model" is not the same as "the pool can serve it", and swapping in a typo would trade a recoverable 429 for an unrecoverable 404 — so an entry that doesn't look like an Anthropic model is ignored and the error surfaces honestly.
+The Claude entry has to be a model the pool can actually serve. "Not a GPT model" is not the same thing, and swapping in a typo would trade a recoverable 429 for an unrecoverable 404 — so each entry is checked positively against the live model catalog and skipped if it fails, letting the real error surface. Canonical ids (`claude-sonnet-5`), long-context variants (`claude-sonnet-5[1m]`), catalog shorthands (`opus`, `sonnet1m`) and explicit provider prefixes (`claude:opus`, `anthropic:sonnet`) all qualify.
 
 Only a **429 or 5xx** fails over. A 400 surfaces to you, because a bad request that fails over just reproduces itself on the other provider and buries the real cause.
 
@@ -303,7 +303,7 @@ The split isn't live, but it was announced once on short notice and could return
 
 | Signal | Status |
 |---|---|
-| Source | **~29k** lines of TypeScript across **58** files — auditable in a weekend (v5 removed shim; the pool is the one code path) |
+| Source | **~29k** lines of TypeScript across **59** files — auditable in a weekend (v5 removed shim; the pool is the one code path) |
 | Dependencies | **0 runtime.** Verify: `npm ls --production` |
 | Provenance | Every release [SLSA-attested](https://www.npmjs.com/package/@askalf/dario) via GitHub Actions + Sigstore |
 | Scanning | [CodeQL](https://github.com/askalf/dario/actions/workflows/codeql.yml) on every push and weekly |

package/dist/claude-model.d.ts

@@ -0,0 +1,12 @@
+/** Maps a bare name to a canonical id, or returns it unchanged. */
+export type ModelResolver = (model: string) => string;
+/**
+ * The canonical id the Claude pool would serve `model` as, or null when it
+ * cannot serve it. `bases` is the catalog base set — `getCachedBases()` at a
+ * call site, a fixture in a test. `resolve` is the alias pipeline; the default
+ * knows only catalog family shorthands, so pass the proxy's full resolver
+ * (operator aliases + pinned aliases) where one exists.
+ */
+export declare function resolveClaudeServable(model: string, bases?: readonly string[], resolve?: ModelResolver): string | null;
+/** Whether the Claude pool can serve `model`. See resolveClaudeServable. */
+export declare function isClaudeServableModel(model: string, bases?: readonly string[], resolve?: ModelResolver): boolean;

package/dist/claude-model.js

@@ -0,0 +1,70 @@
+/**
+ * "Can the Claude pool actually serve this model name?" — the positive test
+ * the reverse half of failover needs, and WHAT it resolves to.
+ *
+ * Chain selection used to answer this by elimination: anything absent from the
+ * Codex slugs was handed to the Claude pool. That is not a capability test, it
+ * is a default, and it is wrong for every name that belongs to neither
+ * provider. `--pool-fallback=gpt-5.6-sol,gpt-4o` on a rate-limited
+ * subscription re-pointed the request at Anthropic as `gpt-4o` and turned a
+ * 429 into a 400 — and a typo'd slug (`claude-sonnet-6`, `gtp-5.6-sol`) did
+ * the same, silently, because a misspelling is also "absent from the slugs".
+ * A discovery outage makes it worse: `getCodexModelSlugs` degrades to an EMPTY
+ * set, at which point elimination calls EVERY chain entry Claude-servable.
+ *
+ * So the rule is positive, in two steps that mirror the request path:
+ *
+ *   1. RESOLVE the entry the way a request model is resolved — an explicit
+ *      `claude:` / `anthropic:` prefix is stripped, then operator
+ *      `--model-alias` values, pinned aliases (`opus48`) and catalog family
+ *      shorthands (`opus`, `sonnet1m`) map to a canonical id. The caller
+ *      supplies that resolver so classification and forwarding cannot
+ *      disagree.
+ *   2. VALIDATE the resolved id against the catalog base set. A `claude-`
+ *      prefix on its own proves nothing — `claude-sonnet-6` has the prefix and
+ *      does not exist — so the id (sans `[1m]`) must be a base the pool can
+ *      forward. An explicit provider prefix can force the route; it cannot
+ *      make an unknown model servable.
+ *
+ * The RESOLVED id is what the caller swaps into the body. The swap happens
+ * after the proxy's own alias pass, so returning the entry as written would
+ * send an alias upstream raw and Anthropic would 400 it.
+ *
+ * Pure over the base set it is handed, so the whole selection stays testable
+ * without a socket. `bases` defaults to the baked catalog, never to empty: a
+ * cold catalog must still admit real ids, and must still refuse typos.
+ */
+import { BAKED_BASE_MODELS, resolveAliasAgainst } from './model-catalog.js';
+/** Provider prefixes that force the Claude path (mirrors proxy.ts's PROVIDER_PREFIXES). */
+const CLAUDE_PREFIXES = new Set(['claude', 'anthropic']);
+/**
+ * The canonical id the Claude pool would serve `model` as, or null when it
+ * cannot serve it. `bases` is the catalog base set — `getCachedBases()` at a
+ * call site, a fixture in a test. `resolve` is the alias pipeline; the default
+ * knows only catalog family shorthands, so pass the proxy's full resolver
+ * (operator aliases + pinned aliases) where one exists.
+ */
+export function resolveClaudeServable(model, bases = BAKED_BASE_MODELS, resolve) {
+    let m = model.trim().toLowerCase();
+    if (!m)
+        return null;
+    const idx = m.indexOf(':');
+    if (idx > 0) {
+        const prefix = m.slice(0, idx);
+        // A recognized non-Claude prefix is a definite NO, not a fall-through to
+        // the name test below — `openai:claude-sonnet-5` is the operator pointing
+        // somewhere else on purpose.
+        if (!CLAUDE_PREFIXES.has(prefix))
+            return null;
+        m = m.slice(idx + 1);
+        if (!m)
+            return null;
+    }
+    const resolved = (resolve ? resolve(m) : (resolveAliasAgainst(m, bases) ?? m)).trim().toLowerCase();
+    const base = resolved.endsWith('[1m]') ? resolved.slice(0, -4) : resolved;
+    return bases.some((b) => b.toLowerCase() === base) ? resolved : null;
+}
+/** Whether the Claude pool can serve `model`. See resolveClaudeServable. */
+export function isClaudeServableModel(model, bases = BAKED_BASE_MODELS, resolve) {
+    return resolveClaudeServable(model, bases, resolve) !== null;
+}

package/dist/codex-backend.d.ts

@@ -23,6 +23,7 @@
  */
 import type { IncomingMessage, ServerResponse } from 'node:http';
 import type { CodexAccountCredentials } from './codex-accounts.js';
+import { type ModelResolver } from './claude-model.js';
 export declare const CODEX_BACKEND_BASE_URL: string;
 /**
  * Client version sent on the model-discovery call. The backend REQUIRES the
@@ -85,7 +86,7 @@ export declare function isCodexModel(model: string, slugs: readonly string[]): b
  * written before this release behave identically.
  */
 export declare function pickCodexFallback(models: readonly string[], slugs: readonly string[]): string | null;
-export declare function pickClaudeFallback(models: readonly string[], slugs: readonly string[]): string | null;
+export declare function pickClaudeFallback(models: readonly string[], slugs: readonly string[], bases?: readonly string[], resolve?: ModelResolver): string | null;
 /**
  * Pull `chatgpt_account_id` out of the id_token's `https://api.openai.com/auth`
  * claim. Payload only — this is reading our own token for a routing header, not

package/dist/codex-backend.js

@@ -1,4 +1,6 @@
 import { anthropicToResponsesRequest, createResponsesSSEParser, formatResponsesAnthropicSSE, createAnthropicMessageAssembler, responsesStreamToAnthropicSSE, } from './anthropic-responses-translate.js';
+import { resolveClaudeServable } from './claude-model.js';
+import { BAKED_BASE_MODELS } from './model-catalog.js';
 export const CODEX_BACKEND_BASE_URL = process.env.DARIO_CODEX_BASE_URL || 'https://chatgpt.com/backend-api/codex';
 /** Originator string the codex CLI identifies itself with. */
 const CODEX_ORIGINATOR = 'codex_cli_rs';
@@ -109,21 +111,36 @@ export function isCodexModel(model, slugs) {
 export function pickCodexFallback(models, slugs) {
     return models.find(m => isCodexModel(m, slugs)) ?? null;
 }
-export function pickClaudeFallback(models, slugs) {
+export function pickClaudeFallback(models, slugs, bases = BAKED_BASE_MODELS, resolve) {
     // "Not a codex slug" is NOT the same as "the Claude pool can serve it". A
     // typo, a retired model, or an entry meant for some third provider would all
     // pass that test, and the request would be swapped to a model Anthropic 404s
     // on — trading a recoverable 429 for an unrecoverable 404, which is strictly
     // worse than not failing over at all.
     //
-    // So require it to look like an Anthropic model. Every model the pool serves
-    // is `claude-*`; anything else means the chain has no Claude entry and the
-    // codex error surfaces honestly. Failing CLOSED is the right direction here.
+    // v6.0.0 shipped this as `/^claude/i`, which was the right DIRECTION (fail
+    // closed) and the wrong TEST. It rejected `anthropic:opus`, where the operator
+    // named the provider explicitly, and every catalog shorthand (`opus`,
+    // `sonnet1m`) — so a legitimate chain entry silently never failed over, which
+    // is the same class of quiet wrongness it was written to prevent. It also did
+    // nothing about the case where discovery degrades and `slugs` arrives EMPTY,
+    // at which point elimination calls every entry Claude-servable.
     //
-    // Known limitation: a `--model-alias` that resolves to a Claude model is not
-    // accepted, because aliases resolve later in the request path than this. Name
-    // the real model id in the chain.
-    return models.find(m => !isCodexModel(m, slugs) && /^claude/i.test(m)) ?? null;
+    // `isClaudeServableModel` is the positive capability test instead, resolved
+    // against the live catalog, so aliases work and the limitation the old comment
+    // documented as accepted is simply gone.
+    //
+    // Returns the RESOLVED canonical id, not the entry as written: the caller
+    // swaps it into the body after the proxy's own alias pass has already run,
+    // so an alias returned raw would reach Anthropic unresolved and 400.
+    for (const m of models) {
+        if (isCodexModel(m, slugs))
+            continue;
+        const resolved = resolveClaudeServable(m, bases, resolve);
+        if (resolved)
+            return resolved;
+    }
+    return null;
 }
 /**
  * Pull `chatgpt_account_id` out of the id_token's `https://api.openai.com/auth`
@@ -718,7 +735,7 @@ export async function forwardToCodex(req, res, body, creds, corsOrigin, security
             }
             catch { /* already closed */ }
         }
-        report(502, null, false, '');
+        report(502, null, clientWantsStream, model);
         return true;
     }
     finally {

package/dist/proxy.js

@@ -1863,6 +1863,42 @@ export async function startProxy(opts = {}) {
         const hasNextOption = openaiBackend !== null && shape === 'openai';
         return await forwardToCodex(req, res, fallbackBody, creds, corsOrigin, { ...SECURITY_HEADERS, 'x-dario-pool-fallback': fallbackModel }, upstreamTimeoutMs, verbose, shape, fetch, hasNextOption);
     };
+    /**
+     * Mid-flight 429, no peer account left to retry — the pool is genuinely
+     * exhausted mid-request, not just at selection. Tries every fallback in
+     * order (subscription, then api-key backend) and returns true once one has
+     * written the response; false means nothing could serve it and the caller
+     * writes its own honest 429.
+     *
+     * A SINGLE function for BOTH mid-flight 429 sites in the request handler
+     * (the non-passthrough recovery-loop path and the general/passthrough
+     * path), by design. Those two sites used to carry independent, hand-copied
+     * versions of this logic, and v6.0.0 wired the fallback into only ONE of
+     * them. The other kept returning the raw upstream 429 — and that unwired
+     * site is the one reached by every non-passthrough request, i.e. everything
+     * except a literal Claude Code CLI session, forge's SDK Engine included.
+     * That is what left the whole fleet unable to fail over during the live
+     * outage on 2026-08-30 while `dario doctor` reported failover armed.
+     *
+     * One function reachable from both call sites is what makes that class of
+     * bug structurally impossible to reintroduce: a future third call site gets
+     * this by construction, not by remembering to copy six lines correctly.
+     */
+    const attemptPoolFallbackOn429 = async (req, res, body, isOpenAI) => {
+        if (await tryCodexPoolFallback(req, res, body, poolFallbackModels, isOpenAI ? 'openai' : 'anthropic', 'pool exhausted mid-flight (429, no peer)')) {
+            return true;
+        }
+        if (isOpenAI && poolFallbackModel && openaiBackend) {
+            const fallbackBody = buildPoolFallbackBody(body, poolFallbackModel);
+            if (fallbackBody) {
+                console.log(`[dario] #${requestCount} pool exhausted mid-flight (429, no peer) → ${openaiBackend.name} as ${poolFallbackModel}`);
+                requestCount++;
+                await forwardToOpenAI(req, res, fallbackBody, openaiBackend, corsOrigin, { ...SECURITY_HEADERS, 'x-dario-pool-fallback': poolFallbackModel }, upstreamTimeoutMs, verbose);
+                return true;
+            }
+        }
+        return false;
+    };
     const server = createServer(async (req, res) => {
         if (req.method === 'OPTIONS') {
             res.writeHead(204, CORS_HEADERS);
@@ -2706,7 +2742,12 @@ export async function startProxy(opts = {}) {
                         // and pick the request back up on the Claude path below. Before
                         // this, a rate-limited ChatGPT plan was terminal for a gpt-bound
                         // request even with an idle Claude pool sitting right beside it.
-                        const claudeTarget = pickClaudeFallback(poolFallbackModels, codexModels);
+                        // Resolve chain entries exactly as a request model is resolved —
+                        // operator --model-alias first, then pinned + catalog aliases — so
+                        // `backup` or `opus48` in the chain works the way it does on a
+                        // request, and the classifier validates the id that would actually
+                        // be forwarded.
+                        const claudeTarget = pickClaudeFallback(poolFallbackModels, codexModels, getCachedBases(), (m) => resolveClaudeAlias(applyModelAlias(m, modelAliases) ?? m));
                         const canDefer = claudeTarget !== null && pool.size > 0 && !upstreamApiKey;
                         const codexReq = requestCount;
                         const served = await forwardToCodex(req, res, body, codexCreds, corsOrigin, SECURITY_HEADERS, upstreamTimeoutMs, verbose, isOpenAI ? 'openai' : 'anthropic', fetch, canDefer, 
@@ -3585,6 +3626,19 @@ export async function startProxy(opts = {}) {
                                 continue dispatchLoop;
                             }
                         }
+                        // Pool-exhausted fallback, mid-flight: no peer left to fail over
+                        // to. THE BUG (live incident, 2026-08-30) and its independent
+                        // rediscovery: this branch — reached by every non-passthrough
+                        // request, i.e. everything except a literal Claude Code CLI session
+                        // — never called the fallback wired into the OTHER, structurally
+                        // near-identical 429 site below. #1153 fixed it here with its own
+                        // inline copy; that copy is collapsed into the single shared
+                        // attemptPoolFallbackOn429 below, so the file goes back to having
+                        // exactly ONE copy of this logic instead of two near-identical ones
+                        // — which is the exact shape of bug this incident already was.
+                        if (await attemptPoolFallbackOn429(req, res, body, isOpenAI)) {
+                            return;
+                        }
                         const enriched = enrich429(peekedBody, upstream.headers);
                         const responseHeaders = {
                             'Content-Type': 'application/json',
@@ -3675,25 +3729,14 @@ export async function startProxy(opts = {}) {
                             continue dispatchLoop;
                         }
                     }
-                    // Pool-exhausted fallback: no peer left to fail over to. For an
-                    // OpenAI-shape request with the fallback armed, re-point the
-                    // client's own body at the openai-compat backend instead of
-                    // surfacing the 429. `body` still holds the client's OpenAI-shape
-                    // bytes — the Anthropic translation went into finalBody, never
-                    // back into body. Marked via x-dario-pool-fallback, same as the
-                    // selection-time path.
-                    if (await tryCodexPoolFallback(req, res, body, poolFallbackModels, isOpenAI ? 'openai' : 'anthropic', 'pool exhausted mid-flight (429, no peer)')) {
+                    // Pool-exhausted fallback: no peer left to fail over to. `body`
+                    // still holds the client's own bytes as received — the Anthropic
+                    // translation (OpenAI-shape clients) went into finalBody, never back
+                    // into body. See attemptPoolFallbackOn429's doc comment for why this
+                    // is one shared function rather than an inline copy.
+                    if (await attemptPoolFallbackOn429(req, res, body, isOpenAI)) {
                         return;
                     }
-                    if (isOpenAI && poolFallbackModel && openaiBackend) {
-                        const fallbackBody = buildPoolFallbackBody(body, poolFallbackModel);
-                        if (fallbackBody) {
-                            console.log(`[dario] #${requestCount} pool exhausted mid-flight (429, no peer) — /v1/chat/completions → ${openaiBackend.name} as ${poolFallbackModel}`);
-                            requestCount++;
-                            await forwardToOpenAI(req, res, fallbackBody, openaiBackend, corsOrigin, { ...SECURITY_HEADERS, 'x-dario-pool-fallback': poolFallbackModel }, upstreamTimeoutMs, verbose);
-                            return;
-                        }
-                    }
                     const errBody = await upstream.text().catch(() => '');
                     const enriched = enrich429(errBody, upstream.headers);
                     const responseHeaders = {

package/docs/multi-account-pool.md

@@ -59,7 +59,7 @@ Neither subscription hitting its ceiling can take the deployment down on its own
 Deliberate limits:
 
 - **Only a 429 or 5xx fails over.** A 400 surfaces to the client. A bad request that fails over just reproduces itself on the other provider and buries the real cause.
-- **The Claude entry must be a real `claude-*` id.** "Not a codex slug" would also match a typo or a model meant for a third provider, and swapping that in trades a recoverable 429 for an unrecoverable 404. Anything that doesn't look like an Anthropic model is ignored — failing closed. A `--model-alias` is not accepted here; name the real id.
+- **The Claude entry is validated positively, against the live catalog.** "Not a codex slug" would also match a typo, or a model meant for a third provider, and swapping that in trades a recoverable 429 for an unrecoverable 404. Worse, when model discovery degrades the codex slug list arrives EMPTY, at which point elimination would call *every* entry Claude-servable. So each entry is tested for what it is rather than what it isn't: canonical ids, `[1m]` variants, catalog shorthands (`opus`, `sonnet1m`) and explicit `claude:` / `anthropic:` prefixes all qualify; anything else is skipped and the real error surfaces.
 - **The api-key backend is still OpenAI-shape only.** There is no Messages translation on that route. A Codex account has one, which is why it is preferred.
 - **Never silent.** Every substituted response carries `x-dario-pool-fallback: <model>`. A quietly swapped model is exactly the surprise this project exists to avoid.
 - **Empty pool still errors.** A pool with zero accounts is a setup mistake (`dario login` never ran); that returns the usual 503 rather than silently re-billing every request to another provider.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@askalf/dario",
-  "version": "6.0.1",
+  "version": "6.0.3",
   "description": "Use your Claude Pro/Max subscription in any tool — Cursor, Cline, Aider, the Agent SDK, your scripts — at subscription pricing, not per-token API bills. One local Anthropic + OpenAI-compatible endpoint.",
   "type": "module",
   "bin": {