@askalf/dario 3.31.16 → 3.31.17

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.17",
   "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": {