@askalf/dario 6.0.2 → 6.0.4

package/dist/claude-model.js

@@ -19,7 +19,9 @@
  *      `--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.
+ *      disagree. The prefix rule applies to the alias TARGET too, since an
+ *      operator alias is written the way a request model is written — see
+ *      stripClaudePrefix.
  *   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
@@ -37,6 +39,23 @@
 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']);
+/**
+ * Strip a Claude-side provider prefix, or refuse the name outright.
+ *
+ * Null on any prefix that isn't `claude:`/`anthropic:` — a recognized
+ * non-Claude prefix is a definite NO, not a fall-through to the name test
+ * (`openai:claude-sonnet-5` is the operator pointing somewhere else on
+ * purpose), and an unrecognized one names a model this pool has no claim on.
+ * `model` is expected already trimmed + lowercased.
+ */
+function stripClaudePrefix(model) {
+    const idx = model.indexOf(':');
+    if (idx <= 0)
+        return model || null;
+    if (!CLAUDE_PREFIXES.has(model.slice(0, idx)))
+        return null;
+    return model.slice(idx + 1) || null;
+}
 /**
  * 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
@@ -45,22 +64,22 @@ const CLAUDE_PREFIXES = new Set(['claude', 'anthropic']);
  * (operator aliases + pinned aliases) where one exists.
  */
 export function resolveClaudeServable(model, bases = BAKED_BASE_MODELS, resolve) {
-    let m = model.trim().toLowerCase();
-    if (!m)
+    const entry = stripClaudePrefix(model.trim().toLowerCase());
+    if (entry === null)
+        return null;
+    // The alias TARGET may carry a prefix of its own — operator aliases are
+    // declared the way a request model is written, and `--model-alias=backup=
+    // claude:opus` is the natural way to say it (dario#1151). The request path
+    // parses that prefix AFTER alias resolution; without the same pass here the
+    // target reached the base check as the literal `claude:opus`, matched
+    // nothing, and a perfectly valid fallback was skipped.
+    const target = stripClaudePrefix((resolve ? resolve(entry) : (resolveAliasAgainst(entry, bases) ?? entry)).trim().toLowerCase());
+    if (target === null)
         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();
+    // A target that arrived prefixed still holds a shorthand (`claude:opus` →
+    // `opus`), so the catalog pass runs on it. Idempotent for a target already
+    // canonical: resolveAliasAgainst only answers for family shorthands.
+    const resolved = resolveAliasAgainst(target, bases) ?? target;
     const base = resolved.endsWith('[1m]') ? resolved.slice(0, -4) : resolved;
     return bases.some((b) => b.toLowerCase() === base) ? resolved : null;
 }

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);
@@ -3590,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',
@@ -3680,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@askalf/dario",
-  "version": "6.0.2",
+  "version": "6.0.4",
   "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": {