@askalf/dario 5.5.28 → 5.5.29

package/dist/admin-api.d.ts

@@ -77,6 +77,17 @@ export interface AdminAccountRecord {
 export interface AdminAccountLive {
     util5h: number;
     util7d: number;
+    /**
+     * When `util5h` / `util7d` were last observed, epoch ms — or `null` if this
+     * account has never served a response. The utilisation figures are a
+     * snapshot of the last response the account served, not a live gauge: while
+     * an account is parked nothing refreshes them, so without a timestamp a
+     * consumer cannot tell a current reading from one frozen minutes ago
+     * (dario#1032).
+     */
+    lastObservedAt: number | null;
+    /** Age of that reading in ms, or `null` when never observed. */
+    utilAgeMs: number | null;
     claim: string;
     status: string;
     requestCount: number;

package/dist/pool.d.ts

@@ -40,6 +40,31 @@ export interface RateLimitSnapshot {
     updatedAt: number;
 }
 export declare const EMPTY_SNAPSHOT: RateLimitSnapshot;
+/** Freshness of an account's utilisation reading — see `utilFreshness`. */
+export interface UtilFreshness {
+    /** When util5h/util7d were last observed, epoch ms; null if never. */
+    lastObservedAt: number | null;
+    /** Age of that reading in ms; null if never observed. */
+    utilAgeMs: number | null;
+}
+/**
+ * Derive how old an account's utilisation reading is (dario#1032).
+ *
+ * `util5h` / `util7d` are a SNAPSHOT of the last response the account served.
+ * They do not tick on their own, and nothing refreshes them while an account is
+ * parked (rejected, or in auth cooldown) — so they stay frozen at whatever they
+ * read at the moment it was parked. The pool does return parked accounts to
+ * service on its own and the value corrects itself when it does, which is what
+ * makes this a REPORTING problem rather than a routing one: the payload carried
+ * no timestamp, so no consumer could tell a current reading from one frozen
+ * minutes ago, and a dashboard rendered "5-hour window full" for an account
+ * that had since reset and was free.
+ *
+ * `updatedAt` was already on the snapshot; it was simply never surfaced. An
+ * `updatedAt` of 0 is EMPTY_SNAPSHOT's "never observed", which must report as
+ * null rather than as an age of ~56 years since epoch.
+ */
+export declare function utilFreshness(rl: RateLimitSnapshot, now: number): UtilFreshness;
 export interface PoolAccount {
     alias: string;
     accessToken: string;

package/dist/pool.js

@@ -34,6 +34,30 @@ export const EMPTY_SNAPSHOT = {
     fallbackPct: 0,
     updatedAt: 0,
 };
+/**
+ * Derive how old an account's utilisation reading is (dario#1032).
+ *
+ * `util5h` / `util7d` are a SNAPSHOT of the last response the account served.
+ * They do not tick on their own, and nothing refreshes them while an account is
+ * parked (rejected, or in auth cooldown) — so they stay frozen at whatever they
+ * read at the moment it was parked. The pool does return parked accounts to
+ * service on its own and the value corrects itself when it does, which is what
+ * makes this a REPORTING problem rather than a routing one: the payload carried
+ * no timestamp, so no consumer could tell a current reading from one frozen
+ * minutes ago, and a dashboard rendered "5-hour window full" for an account
+ * that had since reset and was free.
+ *
+ * `updatedAt` was already on the snapshot; it was simply never surfaced. An
+ * `updatedAt` of 0 is EMPTY_SNAPSHOT's "never observed", which must report as
+ * null rather than as an age of ~56 years since epoch.
+ */
+export function utilFreshness(rl, now) {
+    const lastObservedAt = rl.updatedAt || null;
+    return {
+        lastObservedAt,
+        utilAgeMs: lastObservedAt === null ? null : Math.max(0, now - lastObservedAt),
+    };
+}
 /**
  * Cool-down schedule after auth failures. First failure: 60s. Each
  * consecutive failure doubles the window up to 30 minutes. Cleared

package/dist/proxy.js

@@ -12,7 +12,7 @@ import { darioVersion } from './version.js';
 import { buildCCRequest, applyCcPromptCaching, parseEffortSuffix, reverseMapResponse, createStreamingReverseMapper, orderHeadersForOutbound, overlayTemplateHeaderValues, forwardClientCCIdentityHeaders, isMcpToolName, CC_TEMPLATE, effectiveCacheControl, withForced1hBeta } from './cc-template.js';
 import { stampCch, hasCchSeed } from './cch.js';
 import { describeTemplate, detectDrift, checkCCCompat, probeInstalledCCVersion } from './live-fingerprint.js';
-import { AccountPool, computeStickyKey, parseRateLimits, modelFamily, isInAuthCooldown, authCooldownMs, reconcilePoolAccounts, resolvePoolStrategy } from './pool.js';
+import { AccountPool, computeStickyKey, parseRateLimits, modelFamily, isInAuthCooldown, authCooldownMs, reconcilePoolAccounts, resolvePoolStrategy, utilFreshness } from './pool.js';
 import { Analytics, billingBucketFromClaim, formatUsageLogLine, SUBSCRIPTION_CLAIMS } from './analytics.js';
 import { OverageGuard, buildHaltErrorBody } from './overage-guard.js';
 import { notify as osNotify } from './notify.js';
@@ -1834,6 +1834,10 @@ export async function startProxy(opts = {}) {
                         snap.set(a.alias, {
                             util5h: a.rateLimit.util5h,
                             util7d: a.rateLimit.util7d,
+                            // Same freshness fields GET /accounts exposes (#1032) — this
+                            // surface documents itself as reporting the same snapshot, so it
+                            // must not be the one place a stale reading still looks current.
+                            ...utilFreshness(a.rateLimit, snapNow),
                             claim: a.rateLimit.claim,
                             status: isInAuthCooldown(a, snapNow) ? 'auth-cooldown' : a.rateLimit.status,
                             requestCount: a.requestCount,
@@ -1913,10 +1917,25 @@ export async function startProxy(opts = {}) {
                 const cooldownMs = inCooldown && a.lastAuthFailureAt
                     ? Math.max(0, authCooldownMs(a.consecutiveAuthFailures) - (now - a.lastAuthFailureAt))
                     : 0;
+                // Freshness of the utilisation reading (#1032). util5h/util7d are a
+                // SNAPSHOT of the last response this account served — they do not tick
+                // on their own. While an account is parked (rejected, or in auth
+                // cooldown) nothing refreshes them, so they stay frozen at whatever
+                // they read at the moment it was parked, and a consumer sees "5-hour
+                // window full" for an account that has since reset and is free.
+                //
+                // The pool does return parked accounts to service on its own and the
+                // value corrects itself the moment it does, so this is a reporting
+                // problem, not a routing one: nothing downstream could tell a current
+                // reading from one frozen minutes ago, because the payload carried no
+                // timestamp at all. `updatedAt` was already on the snapshot; it was
+                // simply never surfaced. null means "never observed" (no response has
+                // been served on this account yet) rather than "observed at epoch 0".
                 return {
                     alias: a.alias,
                     util5h: a.rateLimit.util5h,
                     util7d: a.rateLimit.util7d,
+                    ...utilFreshness(a.rateLimit, now),
                     claim: a.rateLimit.claim,
                     status: inCooldown ? 'auth-cooldown' : a.rateLimit.status,
                     requestCount: a.requestCount,

package/package.json

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