@askalf/dario 5.5.27 → 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/cc-template.js

@@ -1672,10 +1672,19 @@ export function buildCCRequest(clientBody, billingTag, cacheControl, identity, o
     // appended its assistant reply locally, dario stripped it from the next
     // request, the model regenerated the same reply, dario stripped that, and
     // the loop never terminated (133 POSTs from a single user prompt).
+    //
+    // Restricted to ASSISTANT turns, which is the only shape this loop was
+    // written for (a thinking-only assistant turn emptied by the strip above).
+    // Popping an empty *user* turn is what the loop must not do: it exposes the
+    // assistant turn behind it and produces the very prefill rejection the loop
+    // exists to prevent (dario#1033). An empty user turn is a malformed client
+    // request either way — leaving it in place lets the upstream name it
+    // accurately ("messages.N: content must contain at least one block")
+    // instead of dario converting it into a misleading prefill error.
     while (messages.length > 0) {
         const last = messages[messages.length - 1];
         const contentEmpty = Array.isArray(last.content) && last.content.length === 0;
-        if (contentEmpty) {
+        if (contentEmpty && last.role === 'assistant') {
             messages.pop();
             continue;
         }

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';
@@ -658,6 +658,12 @@ export function sanitizeMessages(body, preserveTags) {
     if (!messages)
         return;
     const patterns = orchestrationPatternsFor(preserveTags);
+    // Snapshot the tail turn before scrubbing. If the scrub empties it and the
+    // drop below would expose an assistant turn, we put the original content
+    // back rather than ship a prefill (dario#1033) — see the guard after the
+    // filter for the reasoning.
+    const tail = messages.length > 0 ? messages[messages.length - 1] : undefined;
+    const tailContentBeforeScrub = tail ? tail.content : undefined;
     for (const msg of messages) {
         if (typeof msg.content === 'string') {
             msg.content = sanitizeContent(msg.content, patterns);
@@ -691,13 +697,48 @@ export function sanitizeMessages(body, preserveTags) {
     // The message carried nothing for the model, so removing it is the same
     // decision the block filter already made, applied one level up. String
     // content scrubbed to '' is the same case in its other shape.
-    body.messages = messages.filter((m) => {
+    const kept = messages.filter((m) => {
         if (Array.isArray(m.content))
             return m.content.length > 0;
         if (typeof m.content === 'string')
             return m.content !== '';
         return true;
     });
+    // Invariant: the scrub must never turn a request that ended on a USER turn
+    // into one that ends on an ASSISTANT turn. Anthropic reads a trailing
+    // assistant turn as a prefill ("continue from this text") and Opus 4.6 under
+    // adaptive thinking + the claude-code beta rejects it outright:
+    //   400 "This model does not support assistant message prefill.
+    //        The conversation must end with a user message."
+    //
+    // CC emits standalone `<system-reminder>` / `<task_metadata>` user turns —
+    // notably right after a Task (sub-agent) result is folded back into the
+    // parent transcript. Both tags are in ORCHESTRATION_TAG_NAMES, so that turn
+    // scrubs to empty, the filter above drops it, and a valid CC request leaves
+    // as a prefill (dario#1033).
+    //
+    // The fix restores the turn's PRE-SCRUB content instead of dropping it. The
+    // orchestration tag survives in this one position only, which is the right
+    // trade in both directions: for a CC client the tag is CC's own injection,
+    // so keeping it is *more* wire-faithful, not less; for a non-CC client a
+    // lone tag as the final turn is the actual prompt, and forwarding it beats
+    // a hard 400. Every other position still scrubs exactly as before.
+    const tailWasDropped = tail !== undefined && kept[kept.length - 1] !== tail;
+    const tailHadContent = Array.isArray(tailContentBeforeScrub)
+        ? tailContentBeforeScrub.length > 0
+        : typeof tailContentBeforeScrub === 'string'
+            ? tailContentBeforeScrub !== ''
+            : tailContentBeforeScrub != null;
+    if (tail !== undefined &&
+        tailWasDropped &&
+        tail.role === 'user' &&
+        tailHadContent &&
+        kept.length > 0 &&
+        kept[kept.length - 1].role === 'assistant') {
+        tail.content = tailContentBeforeScrub;
+        kept.push(tail);
+    }
+    body.messages = kept;
 }
 /**
  * Scrub non-Claude-Code fields and normalize field ordering.
@@ -1793,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,
@@ -1872,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.27",
+  "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": {