@askalf/dario 6.0.16 → 6.0.18

package/dist/live-fingerprint.d.ts

@@ -496,7 +496,7 @@ export declare function detectDrift(t: TemplateData, installedOverride?: string
  */
 export declare const SUPPORTED_CC_RANGE: {
     readonly min: "1.0.0";
-    readonly maxTested: "2.1.259";
+    readonly maxTested: "2.1.260";
 };
 /**
  * Compare two dotted-numeric version strings. Returns negative if `a<b`,

package/dist/live-fingerprint.js

@@ -1194,7 +1194,7 @@ export function detectDrift(t, installedOverride) {
  */
 export const SUPPORTED_CC_RANGE = {
     min: '1.0.0',
-    maxTested: '2.1.259',
+    maxTested: '2.1.260',
 };
 /**
  * Compare two dotted-numeric version strings. Returns negative if `a<b`,

package/dist/pool-fallback-tier.d.ts

@@ -0,0 +1,6 @@
+/** Backward-compatible selection of a pool-fallback target for one request.
+ * A bare value or comma-separated model chain retains the legacy meaning.
+ * Tier maps use `tier:model`, e.g. `haiku:gpt-5.4-mini,sonnet:gpt-5.6-terra`.
+ * Unknown models use `default`, or the first (normally cheapest) configured tier.
+ */
+export declare function selectPoolFallbackModels(spec: string | undefined, requestedModel: string): string[];

package/dist/pool-fallback-tier.js

@@ -0,0 +1,28 @@
+/** Backward-compatible selection of a pool-fallback target for one request.
+ * A bare value or comma-separated model chain retains the legacy meaning.
+ * Tier maps use `tier:model`, e.g. `haiku:gpt-5.4-mini,sonnet:gpt-5.6-terra`.
+ * Unknown models use `default`, or the first (normally cheapest) configured tier.
+ */
+export function selectPoolFallbackModels(spec, requestedModel) {
+    const entries = (spec ?? '').trim().split(',').map((entry) => entry.trim()).filter(Boolean);
+    if (entries.length === 0)
+        return [];
+    const mapped = entries.every((entry) => /^(haiku|sonnet|opus|default):/i.test(entry));
+    if (!mapped)
+        return entries;
+    const tiers = new Map();
+    for (const entry of entries) {
+        const colon = entry.indexOf(':');
+        const tier = entry.slice(0, colon).trim().toLowerCase();
+        const model = entry.slice(colon + 1).trim();
+        if (tier && model)
+            tiers.set(tier, model);
+    }
+    const model = requestedModel.toLowerCase();
+    const tier = /haiku|mini|small/.test(model) ? 'haiku'
+        : /opus|sol|large/.test(model) ? 'opus'
+            : /sonnet|terra|medium/.test(model) ? 'sonnet'
+                : 'default';
+    const target = tiers.get(tier) ?? tiers.get('default') ?? tiers.values().next().value;
+    return target ? [target] : [];
+}

package/dist/proxy.js

@@ -24,6 +24,7 @@ import { forwardToCodex, getCodexModelSlugs, peekCodexModelSlugs, pickCodexFallb
 import { readCompareTarget, teeResponse, runCompare, writeCompareRecord, COMPARE_RESULT_HEADER } from './compare.js';
 import { listCodexAccountAliases, loadAllCodexAccounts, codexAccountNeedsRefresh, hasAnyCodexAccount, selectCodexAccount, getFreshCodexAccount } from './codex-accounts.js';
 import { route as routeProvider } from './provider-adapter.js';
+import { selectPoolFallbackModels } from './pool-fallback-tier.js';
 import { RequestQueue, QueueFullError, QueueTimeoutError, DEFAULT_MAX_CONCURRENT, DEFAULT_MAX_QUEUED, DEFAULT_QUEUE_TIMEOUT_MS } from './request-queue.js';
 import { redactSecrets } from './redact.js';
 import { BAKED_BASE_MODELS, withLongContextVariants, buildOpenAIModelsList, getModelCatalog, getCachedBases, resolveAliasAgainst, prewarmModelCatalog, retryModelCatalogNow, isSuspendedModel } from './model-catalog.js';
@@ -1256,9 +1257,19 @@ export async function startProxy(opts = {}) {
     // The value may name a chain — see pickCodexFallback/pickClaudeFallback.
     // `poolFallbackModel` stays the FIRST entry so every pre-6.0 reference and
     // every single-value config keeps its exact previous meaning.
-    const poolFallbackModels = ((opts.poolFallbackModel ?? '').trim() || '')
-        .split(',').map((m) => m.trim()).filter(Boolean);
+    const poolFallbackSpec = opts.poolFallbackModel;
+    // Tier maps are selected per request; this retains the legacy chain for startup reporting.
+    const poolFallbackModels = selectPoolFallbackModels(poolFallbackSpec, 'default');
     const poolFallbackModel = poolFallbackModels[0] ?? null;
+    const selectPoolFallbackForBody = (body) => {
+        try {
+            const parsed = JSON.parse(body.toString());
+            return selectPoolFallbackModels(poolFallbackSpec, String(parsed.model ?? ""));
+        }
+        catch {
+            return poolFallbackModels;
+        }
+    };
     if (poolFallbackModel) {
         const targets = [];
         if (startupCodexAliases.length > 0)
@@ -1905,15 +1916,16 @@ export async function startProxy(opts = {}) {
      * this by construction, not by remembering to copy six lines correctly.
      */
     const attemptPoolFallbackOn429 = async (req, res, body, isOpenAI, attempted) => {
-        if (await tryCodexPoolFallback(req, res, body, poolFallbackModels, isOpenAI ? 'openai' : 'anthropic', 'pool exhausted mid-flight (429, no peer)', attempted)) {
+        if (await tryCodexPoolFallback(req, res, body, selectPoolFallbackForBody(body), isOpenAI ? 'openai' : 'anthropic', 'pool exhausted mid-flight (429, no peer)', attempted)) {
             return true;
         }
-        if (isOpenAI && poolFallbackModel && openaiBackend) {
-            const fallbackBody = buildPoolFallbackBody(body, poolFallbackModel);
+        const fallbackModel = selectPoolFallbackForBody(body)[0] ?? null;
+        if (isOpenAI && fallbackModel && openaiBackend) {
+            const fallbackBody = buildPoolFallbackBody(body, fallbackModel);
             if (fallbackBody) {
-                console.log(`[dario] #${requestCount} pool exhausted mid-flight (429, no peer) → ${openaiBackend.name} as ${poolFallbackModel}`);
+                console.log(`[dario] #${requestCount} pool exhausted mid-flight (429, no peer) → ${openaiBackend.name} as ${fallbackModel}`);
                 requestCount++;
-                await forwardToOpenAI(req, res, fallbackBody, openaiBackend, corsOrigin, { ...SECURITY_HEADERS, 'x-dario-pool-fallback': poolFallbackModel }, upstreamTimeoutMs, verbose);
+                await forwardToOpenAI(req, res, fallbackBody, openaiBackend, corsOrigin, { ...SECURITY_HEADERS, 'x-dario-pool-fallback': fallbackModel }, upstreamTimeoutMs, verbose);
                 return true;
             }
         }
@@ -2755,6 +2767,8 @@ export async function startProxy(opts = {}) {
                 try {
                     const peek = JSON.parse(body.toString());
                     const rawModel = (peek.model || '').toString();
+                    const requestPoolFallbackModels = selectPoolFallbackModels(poolFallbackSpec, rawModel);
+                    const requestPoolFallbackModel = requestPoolFallbackModels[0] ?? null;
                     // Credentials are re-read per request (not cached at startup) because
                     // a refresh rotates them on disk; getFreshCodexAccount refreshes when
                     // inside the expiry buffer, collapsing concurrent refreshes per alias.
@@ -2781,7 +2795,7 @@ export async function startProxy(opts = {}) {
                         hasOpenAIBackend: openaiBackend !== null,
                         hasCodexAccount: codexCreds !== null,
                         codexModels,
-                        poolFallbackModel,
+                        poolFallbackModel: requestPoolFallbackModel,
                         poolSize: pool.size,
                     });
                     if (rawModel && codexCreds && decision.provider === 'codex') {
@@ -2801,7 +2815,7 @@ export async function startProxy(opts = {}) {
                         // request, and the classifier validates the id that would actually
                         // be forwarded. The entry's own effort suffix (`claude:opus:high`)
                         // comes back with it — see the swap below.
-                        const claudeTarget = pickClaudeTarget(poolFallbackModels, codexModels, getCachedBases(), (m) => resolveClaudeAlias(applyModelAlias(m, modelAliases) ?? m));
+                        const claudeTarget = pickClaudeTarget(requestPoolFallbackModels, codexModels, getCachedBases(), (m) => resolveClaudeAlias(applyModelAlias(m, modelAliases) ?? m));
                         const claudeTargetModel = claudeTarget?.model ?? null;
                         const canDefer = claudeTarget !== null && pool.size > 0 && !upstreamApiKey;
                         // DEV-f66b131c: an account still inside its 429 cool-down is not
@@ -2921,7 +2935,7 @@ export async function startProxy(opts = {}) {
             if (!upstreamApiKey && !poolAccount) {
                 attemptedProviders.add('claude');
             }
-            if (!upstreamApiKey && !poolAccount && await tryCodexPoolFallback(req, res, body, poolFallbackModels, isOpenAI ? 'openai' : 'anthropic', 'pool exhausted', attemptedProviders)) {
+            if (!upstreamApiKey && !poolAccount && await tryCodexPoolFallback(req, res, body, selectPoolFallbackForBody(body), isOpenAI ? 'openai' : 'anthropic', 'pool exhausted', attemptedProviders)) {
                 return;
             }
             // `isOpenAI` is REQUIRED here and was not, before v6.0.0 — the selector's
@@ -2931,15 +2945,16 @@ export async function startProxy(opts = {}) {
             // hand the client an OpenAI-shaped response for a Messages request. This
             // route still has no reverse translation; the codex route above does,
             // which is why it takes both shapes and this one does not.
-            if (!upstreamApiKey && !poolAccount && poolFallbackModel && openaiBackend && isOpenAI) {
-                const fallbackBody = buildPoolFallbackBody(body, poolFallbackModel);
+            const fallbackModel = selectPoolFallbackForBody(body)[0] ?? null;
+            if (!upstreamApiKey && !poolAccount && fallbackModel && openaiBackend && isOpenAI) {
+                const fallbackBody = buildPoolFallbackBody(body, fallbackModel);
                 if (!fallbackBody) {
                     writePoolUnavailable();
                     return;
                 }
-                console.log(`[dario] #${requestCount} pool exhausted — /v1/chat/completions → ${openaiBackend.name} as ${poolFallbackModel}`);
+                console.log(`[dario] #${requestCount} pool exhausted — /v1/chat/completions → ${openaiBackend.name} as ${fallbackModel}`);
                 requestCount++;
-                await forwardToOpenAI(req, res, fallbackBody, openaiBackend, corsOrigin, { ...SECURITY_HEADERS, 'x-dario-pool-fallback': poolFallbackModel }, upstreamTimeoutMs, verbose);
+                await forwardToOpenAI(req, res, fallbackBody, openaiBackend, corsOrigin, { ...SECURITY_HEADERS, 'x-dario-pool-fallback': fallbackModel }, upstreamTimeoutMs, verbose);
                 return;
             }
             // Deferred at selection because a fallback was armed, but nothing could

package/package.json

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