@askalf/dario 3.31.16 → 3.31.18

package/dist/cli.js

@@ -652,6 +652,12 @@ async function help() {
                              the server's verdict — the single reliable
                              signal for scope-policy drift (dario#42/#71
                              class). One GET to claude.ai; no PII.
+    dario doctor --usage     Fire one minimal Haiku request through your
+                             OAuth and surface the rate-limit snapshot:
+                             All-models 5h/7d, per-model 7d buckets
+                             (Sonnet only, Opus only when Anthropic ships
+                             them), overage. Mirrors the user-dashboard
+                             usage page. Costs ~1 subscription request.
     dario doctor --json      Emit the check report as structured JSON
                              for machine consumption (claude-bridge
                              /status, CI scripts, etc.) instead of the
@@ -972,6 +978,7 @@ async function mcp() {
 async function doctor() {
     const { runChecks, formatChecks, formatChecksJson, exitCodeFor, runAuthCheck } = await import('./doctor.js');
     const probe = args.includes('--probe');
+    const usage = args.includes('--usage');
     const asJson = args.includes('--json');
     const authCheck = args.includes('--auth-check');
     if (authCheck) {
@@ -1008,7 +1015,7 @@ async function doctor() {
         console.log('');
         process.exit(result.verdict === 'match' ? 0 : 1);
     }
-    const checks = await runChecks({ probe });
+    const checks = await runChecks({ probe, usage });
     if (asJson) {
         // JSON mode is meant for machine consumption (claude-bridge /status,
         // deepdive health checks, CI scripts) — no decorative header, no

package/dist/doctor.d.ts

@@ -50,6 +50,16 @@ export interface RunChecksOptions {
      * GET to `claude.ai` and runs in parallel with the other checks.
      */
     probe?: boolean;
+    /**
+     * Opt-in: fire a minimal `POST /v1/messages` through the user's OAuth
+     * (Haiku, `max_tokens=1`) to capture the current rate-limit snapshot,
+     * including the unified buckets AND the per-model buckets Anthropic
+     * started carving in late April 2026 (`7d_sonnet-utilization` etc).
+     * Surfaces "All models X%, Sonnet only Y%" the way the user dashboard
+     * does. Enable with `dario doctor --usage`; costs ~1 subscription
+     * request.
+     */
+    usage?: boolean;
 }
 /**
  * Run every available health check. Never throws — each check is

package/dist/doctor.js

@@ -282,6 +282,135 @@ export async function runChecks(opts = {}) {
             });
         }
     }
+    // ---- Usage snapshot (opt-in, --usage).
+    // Fires one `POST /v1/messages` via the loaded OAuth (Haiku, max_tokens=1)
+    // to capture the current rate-limit snapshot including the per-model
+    // buckets Anthropic started carving around 2026-04-25. Surfaces the
+    // `All models` vs `Sonnet only` split the way the user dashboard does.
+    // Direct-to-Anthropic, not through the proxy — the proxy doesn't need
+    // to be running for `dario doctor --usage`.
+    if (opts.usage) {
+        try {
+            const { parseRateLimits } = await import('./pool.js');
+            const { billingBucketFromClaim } = await import('./analytics.js');
+            // Probe routing decision: Anthropic's subscription path rejects
+            // non-CC-shaped requests on Sonnet/Opus (returns 429 with no
+            // rate-limit headers). Haiku accepts the raw shape. So:
+            //   - If a local `dario proxy` is listening, route through it —
+            //     the proxy injects the full CC template and all three families
+            //     succeed, giving us the _sonnet / _opus / _haiku per-model
+            //     bucket headers on a single round trip each.
+            //   - Else fall back to direct-to-Anthropic with Haiku only.
+            //     Unified buckets surface but per-model buckets won't.
+            const dario_base = process.env.DARIO_TEST_URL || 'http://127.0.0.1:3456';
+            let probeEndpoint = `${dario_base}/v1/messages`;
+            let probeHeaders = {
+                'content-type': 'application/json',
+                'anthropic-version': '2023-06-01',
+                'authorization': 'Bearer dario',
+            };
+            let proxyAvailable = false;
+            try {
+                const healthRes = await fetch(`${dario_base}/health`, { signal: AbortSignal.timeout(800) });
+                proxyAvailable = healthRes.ok;
+            }
+            catch { /* proxy not running */ }
+            if (!proxyAvailable) {
+                const { getAccessToken } = await import('./oauth.js');
+                const token = await getAccessToken();
+                probeEndpoint = 'https://api.anthropic.com/v1/messages';
+                probeHeaders = {
+                    'content-type': 'application/json',
+                    'anthropic-version': '2023-06-01',
+                    'anthropic-beta': 'oauth-2025-04-20',
+                    'authorization': `Bearer ${token}`,
+                };
+                checks.push({
+                    status: 'info',
+                    label: 'Usage probe',
+                    detail: 'dario proxy not running — probing direct. Per-model buckets visible only when probing through a running proxy (start `dario proxy` in another terminal and re-run).',
+                });
+            }
+            // Probe each family in parallel. Anthropic only returns the
+            // per-model 7d bucket header on a request TO that family.
+            const families = [
+                { family: 'haiku', model: 'claude-haiku-4-5' },
+                { family: 'sonnet', model: 'claude-sonnet-4-6' },
+                { family: 'opus', model: 'claude-opus-4-7' },
+            ];
+            const probe = async (model) => {
+                const res = await fetch(probeEndpoint, {
+                    method: 'POST',
+                    headers: probeHeaders,
+                    body: JSON.stringify({
+                        model,
+                        max_tokens: 1,
+                        messages: [{ role: 'user', content: 'ok' }],
+                    }),
+                    signal: AbortSignal.timeout(15_000),
+                });
+                // Consume the body so the socket releases; we only care about headers.
+                await res.text().catch(() => '');
+                // Ignore 429/4xx snapshots without useful rate-limit headers.
+                if (!res.headers.get('anthropic-ratelimit-unified-status'))
+                    return null;
+                return parseRateLimits(res.headers);
+            };
+            const results = await Promise.all(families.map(f => probe(f.model).catch(() => null)));
+            // Use the first non-null snapshot for the unified view — they
+            // should all agree on the unified buckets (same account, same moment).
+            const firstOk = results.find(s => s !== null);
+            if (!firstOk)
+                throw new Error('all probe requests failed');
+            const bucket = billingBucketFromClaim(firstOk.claim);
+            const pct = (n) => `${(n * 100).toFixed(1)}%`;
+            checks.push({
+                status: firstOk.util5h >= 0.90 ? 'warn' : 'ok',
+                label: 'Usage 5h (all)',
+                detail: `${pct(firstOk.util5h)} used  •  status=${firstOk.status}  •  claim=${firstOk.claim} (${bucket})`,
+            });
+            checks.push({
+                status: firstOk.util7d >= 0.90 ? 'warn' : 'ok',
+                label: 'Usage 7d (all)',
+                detail: `${pct(firstOk.util7d)} used`,
+            });
+            // Merge per-model buckets across all probes — each probe's response
+            // carries at most its own family bucket; union them for display.
+            const mergedPerModel = {};
+            for (const s of results) {
+                if (!s)
+                    continue;
+                for (const [family, util] of Object.entries(s.perModel7d)) {
+                    mergedPerModel[family] = util;
+                }
+            }
+            for (const [family, util] of Object.entries(mergedPerModel).sort()) {
+                const divergence = util - firstOk.util7d;
+                const marker = Math.abs(divergence) > 0.05
+                    ? `  •  Δ vs 7d(all): ${divergence >= 0 ? '+' : ''}${(divergence * 100).toFixed(1)}pp`
+                    : '';
+                checks.push({
+                    status: util >= 0.90 ? 'warn' : 'ok',
+                    label: `Usage 7d (${family} only)`,
+                    detail: `${pct(util)} used${marker}`,
+                });
+            }
+            if (firstOk.overageUtil > 0) {
+                checks.push({
+                    status: firstOk.overageUtil >= 0.90 ? 'warn' : 'info',
+                    label: 'Usage overage',
+                    detail: `${pct(firstOk.overageUtil)} of configured monthly spend`,
+                });
+            }
+        }
+        catch (err) {
+            checks.push({
+                status: 'warn',
+                label: 'Usage snapshot',
+                detail: `probe failed: ${err.message}`,
+            });
+        }
+    }
     // ---- Account pool
     try {
         const { listAccountAliases, loadAllAccounts } = await import('./accounts.js');

package/dist/pool.d.ts

@@ -19,6 +19,20 @@ export interface RateLimitSnapshot {
     status: string;
     util5h: number;
     util7d: number;
+    /**
+     * Per-model 7-day utilization buckets — Anthropic carves separate
+     * weekly windows for some model families. As of 2026-04-25 the live
+     * API emits `anthropic-ratelimit-unified-7d_sonnet-utilization` on
+     * Sonnet responses (corresponds to the "Sonnet only" line on the user
+     * dashboard); other families do not yet have dedicated buckets but
+     * the parser scans the header set generically so any future
+     * `7d_<family>` header is captured automatically.
+     *
+     * Keyed by the family suffix as it arrived on the wire (lowercase,
+     * e.g. `sonnet` / `opus` / `haiku`). Empty when no per-model headers
+     * were on the response.
+     */
+    perModel7d: Record<string, number>;
     overageUtil: number;
     claim: string;
     reset: number;
@@ -45,6 +59,30 @@ export interface PoolStatus {
 }
 /** Parse an Anthropic response's rate-limit headers into a snapshot. */
 export declare function parseRateLimits(headers: Headers): RateLimitSnapshot;
+/**
+ * Extract the model family (`opus` / `sonnet` / `haiku`) from a request's
+ * model id. Used to look up the per-model 7d bucket in
+ * `RateLimitSnapshot.perModel7d` during routing decisions. Returns null
+ * for non-Claude models or model ids that don't carry a recognizable
+ * family token (those requests just use the unified buckets).
+ *
+ * Generous on input shape: matches `claude-opus-4-7`, `opus`, `claude-3-7-sonnet-…`,
+ * `claude-haiku-4-5`, anything containing the family token. Lowercase-normalized
+ * so it pairs cleanly with `parseRateLimits`'s lowercase family keys.
+ */
+export declare function modelFamily(modelId: string | null | undefined): string | null;
+/**
+ * Compute headroom for a single account given its rate-limit snapshot.
+ * Headroom is the slack between the most-saturated relevant bucket and
+ * full utilization: `1 - max(util5h, util7d, util_per_model_if_known)`.
+ *
+ * When `family` is supplied AND the snapshot has a corresponding per-
+ * model 7d bucket, that bucket is included in the max. When the family
+ * isn't represented in the snapshot (e.g. account hasn't seen a Sonnet
+ * request yet so `7d_sonnet` is unknown), headroom is computed from the
+ * unified buckets only — best-effort, populated on the next response.
+ */
+export declare function computeHeadroom(snapshot: RateLimitSnapshot, family?: string | null): number;
 export declare class AccountPool {
     private accounts;
     private queue;
@@ -61,8 +99,14 @@ export declare class AccountPool {
     }): void;
     remove(alias: string): boolean;
     get size(): number;
-    /** Select the best account for the next request. */
-    select(): PoolAccount | null;
+    /**
+     * Select the best account for the next request. `family` (when supplied)
+     * is the request's model family (`opus` / `sonnet` / `haiku`); when
+     * present and the account has a matching per-model 7d bucket, that
+     * bucket joins the headroom max. Family-less calls fall back to the
+     * unified-buckets-only headroom — same behavior as before this PR.
+     */
+    select(family?: string | null): PoolAccount | null;
     /**
      * Select with session stickiness. If `stickyKey` is already bound to a
      * healthy account (not rejected, token not near expiry, headroom > 2%),
@@ -79,7 +123,7 @@ export declare class AccountPool {
      *
      * Also performs lazy cleanup of expired bindings (TTL or size cap).
      */
-    selectSticky(stickyKey: string | null): PoolAccount | null;
+    selectSticky(stickyKey: string | null, family?: string | null): PoolAccount | null;
     /**
      * Rebind a sticky key to a different account — called by proxy after an
      * in-request 429 failover moves to the next-best account. Without this
@@ -99,7 +143,7 @@ export declare class AccountPool {
     /** Test/inspection helper — current alias bound to a key, or null. */
     stickyAliasFor(stickyKey: string): string | null;
     /** Select the next-best account, excluding the given set of aliases. */
-    selectExcluding(excluded: Set<string>): PoolAccount | null;
+    selectExcluding(excluded: Set<string>, family?: string | null): PoolAccount | null;
     updateRateLimits(alias: string, snapshot: RateLimitSnapshot): void;
     markRejected(alias: string, snapshot: RateLimitSnapshot): void;
     updateTokens(alias: string, accessToken: string, refreshToken: string, expiresAt: number): void;

package/dist/pool.js

@@ -28,19 +28,44 @@ export const EMPTY_SNAPSHOT = {
     status: 'unknown',
     util5h: 0,
     util7d: 0,
+    perModel7d: {},
     overageUtil: 0,
     claim: 'unknown',
     reset: 0,
     fallbackPct: 0,
     updatedAt: 0,
 };
+/**
+ * Match `anthropic-ratelimit-unified-7d_<family>-utilization`. Generic on
+ * `<family>` so a future `7d_opus` / `7d_haiku` (or anything Anthropic
+ * adds without notice) is captured automatically. The family is
+ * normalized to lowercase to match `modelFamily()` output.
+ */
+const PER_MODEL_7D_HEADER = /^anthropic-ratelimit-unified-7d_([a-z0-9-]+)-utilization$/i;
 /** Parse an Anthropic response's rate-limit headers into a snapshot. */
 export function parseRateLimits(headers) {
     const get = (key) => headers.get(`anthropic-ratelimit-unified-${key}`) ?? '';
+    const perModel7d = {};
+    // Iterate the full header set — `headers.get` only retrieves known
+    // keys, but Anthropic can add new `7d_<family>-utilization` shapes
+    // unannounced. Scanning the iterator means the parser is automatically
+    // forward-compatible. Real `Headers` instances and test-side mocks
+    // (which implement `.entries()` but not direct iteration) both work
+    // through the explicit `.entries()` call.
+    const entries = (typeof headers.entries === 'function')
+        ? headers.entries()
+        : headers;
+    for (const [k, v] of entries) {
+        const m = k.match(PER_MODEL_7D_HEADER);
+        if (m && m[1]) {
+            perModel7d[m[1].toLowerCase()] = parseFloat(v) || 0;
+        }
+    }
     return {
         status: get('status') || 'unknown',
         util5h: parseFloat(get('5h-utilization')) || 0,
         util7d: parseFloat(get('7d-utilization')) || 0,
+        perModel7d,
         overageUtil: parseFloat(get('overage-utilization')) || 0,
         claim: get('representative-claim') || 'unknown',
         reset: parseInt(get('reset')) || 0,
@@ -48,6 +73,49 @@ export function parseRateLimits(headers) {
         updatedAt: Date.now(),
     };
 }
+/**
+ * Extract the model family (`opus` / `sonnet` / `haiku`) from a request's
+ * model id. Used to look up the per-model 7d bucket in
+ * `RateLimitSnapshot.perModel7d` during routing decisions. Returns null
+ * for non-Claude models or model ids that don't carry a recognizable
+ * family token (those requests just use the unified buckets).
+ *
+ * Generous on input shape: matches `claude-opus-4-7`, `opus`, `claude-3-7-sonnet-…`,
+ * `claude-haiku-4-5`, anything containing the family token. Lowercase-normalized
+ * so it pairs cleanly with `parseRateLimits`'s lowercase family keys.
+ */
+export function modelFamily(modelId) {
+    if (!modelId)
+        return null;
+    const m = modelId.toLowerCase();
+    if (m.includes('opus'))
+        return 'opus';
+    if (m.includes('sonnet'))
+        return 'sonnet';
+    if (m.includes('haiku'))
+        return 'haiku';
+    return null;
+}
+/**
+ * Compute headroom for a single account given its rate-limit snapshot.
+ * Headroom is the slack between the most-saturated relevant bucket and
+ * full utilization: `1 - max(util5h, util7d, util_per_model_if_known)`.
+ *
+ * When `family` is supplied AND the snapshot has a corresponding per-
+ * model 7d bucket, that bucket is included in the max. When the family
+ * isn't represented in the snapshot (e.g. account hasn't seen a Sonnet
+ * request yet so `7d_sonnet` is unknown), headroom is computed from the
+ * unified buckets only — best-effort, populated on the next response.
+ */
+export function computeHeadroom(snapshot, family) {
+    const utils = [snapshot.util5h, snapshot.util7d];
+    if (family) {
+        const perModel = snapshot.perModel7d[family];
+        if (perModel !== undefined)
+            utils.push(perModel);
+    }
+    return 1 - Math.max(...utils);
+}
 const STICKY_TTL_MS = 6 * 60 * 60 * 1000; // 6h
 const STICKY_MAX_ENTRIES = 2_000; // lazy cleanup cap
 /**
@@ -87,8 +155,14 @@ export class AccountPool {
     get size() {
         return this.accounts.size;
     }
-    /** Select the best account for the next request. */
-    select() {
+    /**
+     * Select the best account for the next request. `family` (when supplied)
+     * is the request's model family (`opus` / `sonnet` / `haiku`); when
+     * present and the account has a matching per-model 7d bucket, that
+     * bucket joins the headroom max. Family-less calls fall back to the
+     * unified-buckets-only headroom — same behavior as before this PR.
+     */
+    select(family) {
         if (this.accounts.size === 0)
             return null;
         const now = Date.now();
@@ -97,8 +171,8 @@ export class AccountPool {
             a.expiresAt > now + 30_000);
         if (eligible.length > 0) {
             return eligible.reduce((best, curr) => {
-                const bestHeadroom = 1 - Math.max(best.rateLimit.util5h, best.rateLimit.util7d);
-                const currHeadroom = 1 - Math.max(curr.rateLimit.util5h, curr.rateLimit.util7d);
+                const bestHeadroom = computeHeadroom(best.rateLimit, family);
+                const currHeadroom = computeHeadroom(curr.rateLimit, family);
                 return currHeadroom > bestHeadroom ? curr : best;
             });
         }
@@ -126,9 +200,9 @@ export class AccountPool {
      *
      * Also performs lazy cleanup of expired bindings (TTL or size cap).
      */
-    selectSticky(stickyKey) {
+    selectSticky(stickyKey, family) {
         if (!stickyKey)
-            return this.select();
+            return this.select(family);
         this.cleanupSticky();
         const binding = this.sticky.get(stickyKey);
         if (binding) {
@@ -137,11 +211,11 @@ export class AccountPool {
             if (bound
                 && bound.rateLimit.status !== 'rejected'
                 && bound.expiresAt > now + 30_000
-                && (1 - Math.max(bound.rateLimit.util5h, bound.rateLimit.util7d)) > POOL_HEADROOM_FLOOR) {
+                && computeHeadroom(bound.rateLimit, family) > POOL_HEADROOM_FLOOR) {
                 return bound;
             }
         }
-        const picked = this.select();
+        const picked = this.select(family);
         if (picked) {
             this.sticky.set(stickyKey, { alias: picked.alias, boundAt: Date.now() });
         }
@@ -189,7 +263,7 @@ export class AccountPool {
         return this.sticky.get(stickyKey)?.alias ?? null;
     }
     /** Select the next-best account, excluding the given set of aliases. */
-    selectExcluding(excluded) {
+    selectExcluding(excluded, family) {
         if (this.accounts.size <= 1)
             return null;
         const now = Date.now();
@@ -198,8 +272,8 @@ export class AccountPool {
             a.expiresAt > now + 30_000);
         if (eligible.length > 0) {
             return eligible.reduce((best, curr) => {
-                const bestHeadroom = 1 - Math.max(best.rateLimit.util5h, best.rateLimit.util7d);
-                const currHeadroom = 1 - Math.max(curr.rateLimit.util5h, curr.rateLimit.util7d);
+                const bestHeadroom = computeHeadroom(best.rateLimit, family);
+                const currHeadroom = computeHeadroom(curr.rateLimit, family);
                 return currHeadroom > bestHeadroom ? curr : best;
             });
         }
@@ -240,7 +314,10 @@ export class AccountPool {
         const now = Date.now();
         const healthy = all.filter(a => a.rateLimit.status !== 'rejected' &&
             a.expiresAt > now + 30_000);
-        const headrooms = all.map(a => 1 - Math.max(a.rateLimit.util5h, a.rateLimit.util7d));
+        // Status is a pool-wide aggregate; family-agnostic. Per-model
+        // headroom is request-context-specific and only meaningful at
+        // select() time.
+        const headrooms = all.map(a => computeHeadroom(a.rateLimit));
         const avgHeadroom = headrooms.length > 0 ? headrooms.reduce((a, b) => a + b, 0) / headrooms.length : 0;
         const best = this.select();
         return {
@@ -260,7 +337,7 @@ export class AccountPool {
     async waitForAccount() {
         const immediate = this.select();
         if (immediate) {
-            const headroom = 1 - Math.max(immediate.rateLimit.util5h, immediate.rateLimit.util7d);
+            const headroom = computeHeadroom(immediate.rateLimit);
             if (headroom > POOL_HEADROOM_FLOOR)
                 return immediate;
         }
@@ -303,7 +380,7 @@ export class AccountPool {
             const account = this.select();
             if (!account)
                 break;
-            const headroom = 1 - Math.max(account.rateLimit.util5h, account.rateLimit.util7d);
+            const headroom = computeHeadroom(account.rateLimit);
             if (headroom <= POOL_HEADROOM_FLOOR)
                 break;
             const entry = this.queue.shift();

package/dist/proxy.js

@@ -8,7 +8,7 @@ import { arch, platform } from 'node:process';
 import { getAccessToken, getStatus } from './oauth.js';
 import { buildCCRequest, reverseMapResponse, createStreamingReverseMapper, orderHeadersForOutbound, CC_TEMPLATE } from './cc-template.js';
 import { describeTemplate, detectDrift, checkCCCompat } from './live-fingerprint.js';
-import { AccountPool, computeStickyKey, parseRateLimits } from './pool.js';
+import { AccountPool, computeStickyKey, parseRateLimits, modelFamily } from './pool.js';
 import { Analytics, billingBucketFromClaim } from './analytics.js';
 import { loadAllAccounts, loadAccount, refreshAccountToken } from './accounts.js';
 import { getOpenAIBackend, isOpenAIModel, forwardToOpenAI } from './openai-backend.js';
@@ -460,6 +460,11 @@ export async function startProxy(opts = {}) {
     // Single-account dario keeps its existing code path unchanged.
     const accountsList = await loadAllAccounts();
     const pool = accountsList.length >= 2 ? new AccountPool() : null;
+    // Per-model rate-limit bucket families seen during this proxy run. First-
+    // sight is logged once when verbose so a new Anthropic bucket (e.g. an
+    // eventual `7d_opus`) doesn't slip past unnoticed. Pure observability —
+    // routing already handles unknown families generically.
+    const seenPerModelBuckets = new Set();
     const analytics = pool ? new Analytics() : null;
     let status;
     if (pool) {
@@ -964,7 +969,7 @@ export async function startProxy(opts = {}) {
                         // Rotating off mid-session costs cache-create on every turn.
                         stickyKey = computeStickyKey(userMsg);
                         if (pool && stickyKey) {
-                            const preferred = pool.selectSticky(stickyKey);
+                            const preferred = pool.selectSticky(stickyKey, modelFamily(requestModel));
                             if (preferred && preferred.alias !== poolAccount?.alias) {
                                 poolAccount = preferred;
                                 accessToken = preferred.accessToken;
@@ -1185,6 +1190,20 @@ export async function startProxy(opts = {}) {
                     else {
                         pool.updateRateLimits(poolAccount.alias, snapshot);
                     }
+                    // First-sight detector for per-model rate-limit buckets. Anthropic
+                    // ships these unannounced — e.g. `7d_sonnet-utilization` appeared
+                    // around 2026-04-25 — and verbose-mode users want a heads-up the
+                    // first time a new family shows up so they can decide whether to
+                    // bump dario's expectations. Pure logging; the routing path
+                    // already handles arbitrary family keys (see pool.computeHeadroom).
+                    for (const family of Object.keys(snapshot.perModel7d)) {
+                        if (!seenPerModelBuckets.has(family)) {
+                            seenPerModelBuckets.add(family);
+                            if (verbose) {
+                                console.log(`[dario] new per-model rate-limit bucket observed: 7d_${family} (util=${snapshot.perModel7d[family]?.toFixed(2)})`);
+                            }
+                        }
+                    }
                 }
                 // Auto-retry without context-1m if it triggers a long-context billing error.
                 // Anthropic returns this as either 400 ("long context beta is not yet available
@@ -1287,7 +1306,7 @@ export async function startProxy(opts = {}) {
                     else if (upstream.status === 429) {
                         // Not a context-1m issue — try pool failover before surfacing to client
                         if (pool && poolAccount) {
-                            const nextAccount = pool.selectExcluding(triedAliases);
+                            const nextAccount = pool.selectExcluding(triedAliases, modelFamily(requestModel));
                             if (nextAccount) {
                                 triedAliases.add(nextAccount.alias);
                                 poolAccount = nextAccount;
@@ -1346,7 +1365,7 @@ export async function startProxy(opts = {}) {
                 if (upstream.status === 429) {
                     // Try pool failover before surfacing to client
                     if (pool && poolAccount) {
-                        const nextAccount = pool.selectExcluding(triedAliases);
+                        const nextAccount = pool.selectExcluding(triedAliases, modelFamily(requestModel));
                         if (nextAccount) {
                             triedAliases.add(nextAccount.alias);
                             poolAccount = nextAccount;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@askalf/dario",
-  "version": "3.31.16",
+  "version": "3.31.18",
   "description": "A local LLM router. One endpoint, every provider — Claude subscriptions, OpenAI, OpenRouter, Groq, local LiteLLM, any OpenAI-compat endpoint — your tools don't need to change.",
   "type": "module",
   "bin": {