@askalf/dario 3.23.0 → 3.25.0

package/dist/cli.js

@@ -208,7 +208,31 @@ async function proxy() {
     const strictTls = args.includes('--strict-tls');
     const modelArg = args.find(a => a.startsWith('--model='));
     const model = modelArg ? modelArg.split('=')[1] : undefined;
-    await startProxy({ port, host, verbose, verboseBodies, model, passthrough, preserveTools, hybridTools, noAutoDetect, strictTls });
+    // --pace-min=MS / --pace-jitter=MS (v3.24, direction #6 — behavioral
+    // smoothing). Inter-request gap floor + optional uniform-random jitter.
+    // Defaults preserve v3.23 behavior (500ms floor, no jitter). The pure
+    // calc lives in src/pacing.ts; the flags just feed it.
+    const pacingMinMs = parsePositiveIntFlag('--pace-min=');
+    const pacingJitterMs = parsePositiveIntFlag('--pace-jitter=');
+    // --drain-on-close (v3.25, direction #5). When set, a client
+    // disconnect no longer aborts the upstream SSE — dario keeps
+    // draining the stream to EOF so Anthropic sees the CC-shaped
+    // read-to-completion pattern. Costs tokens (the response is fully
+    // generated even if nobody reads it), so it's opt-in.
+    const drainOnClose = args.includes('--drain-on-close') || undefined;
+    await startProxy({ port, host, verbose, verboseBodies, model, passthrough, preserveTools, hybridTools, noAutoDetect, strictTls, pacingMinMs, pacingJitterMs, drainOnClose });
+}
+function parsePositiveIntFlag(prefix) {
+    const found = args.find(a => a.startsWith(prefix));
+    if (!found)
+        return undefined;
+    const raw = found.slice(prefix.length);
+    const n = parseInt(raw, 10);
+    if (!Number.isFinite(n) || n < 0) {
+        console.error(`[dario] Invalid ${prefix.replace(/=$/, '')} value: ${JSON.stringify(raw)}. Must be a non-negative integer (ms).`);
+        process.exit(1);
+    }
+    return n;
 }
 async function accounts() {
     const sub = args[1];
@@ -459,6 +483,23 @@ async function help() {
                              from a stock CC request. Install Bun
                              (https://bun.sh) so dario auto-relaunches
                              under it, or use shim mode. (v3.23)
+    --pace-min=MS            Minimum ms between upstream requests
+                             (default: 500). Prevents request floods
+                             that are distinguishable from human-paced
+                             CC traffic.
+    --pace-jitter=MS         Max additional uniform-random jitter (ms)
+                             added on top of --pace-min per request.
+                             Default: 0 (off). Set to e.g. 300 to hide
+                             the floor from long-run inter-arrival
+                             statistics. (v3.24)
+    --drain-on-close         When the client disconnects mid-stream,
+                             keep consuming the upstream SSE to EOF
+                             so Anthropic sees the same read-to-
+                             completion pattern native Claude Code
+                             produces. Trades tokens (the response
+                             is fully generated even if nobody reads
+                             it) for fingerprint fidelity. Bounded by
+                             the 5-minute upstream timeout. (v3.25)
     --port=PORT              Port to listen on (default: 3456)
     --host=ADDRESS           Address to bind to (default: 127.0.0.1)
                              Use 0.0.0.0 for LAN; see README for DARIO_API_KEY

package/dist/pacing.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Inter-request pacing (v3.24, direction #6 — behavioral smoothing).
+ *
+ * Real CC traffic has human-paced gaps between requests — sub-second when
+ * the model is streaming tool-loop output, multi-second when the user is
+ * typing the next message. A proxy that fires requests at machine speed
+ * with perfectly uniform spacing stands out against that rhythm.
+ *
+ * This module supplies the pure gap-calculation function the proxy's
+ * rate governor calls before every outbound fetch. Two knobs:
+ *
+ *   minGapMs    — lower bound on the wall-clock distance between requests.
+ *                 Was a hardcoded 500ms through v3.23; keep 500 as default
+ *                 so back-compat is exact when both knobs stay at defaults.
+ *
+ *   jitterMs    — uniform random addition on top of minGap. The *effective*
+ *                 gap for a given request is minGap + U(0, jitter). Adds
+ *                 non-uniformity so an observer can't infer the floor from
+ *                 the long-run minimum of inter-arrival times.
+ *
+ * Pure over (now, lastRequestTime, minGap, jitter, rng) so the tests can
+ * exercise every edge without spawning timers. The proxy passes
+ * `Math.random` as the rng at runtime; tests pass a deterministic stub.
+ *
+ * The first request in a session (lastRequestTime === 0) is never paced —
+ * the purpose is smoothing the *gap between* requests, not delaying the
+ * first one from whenever the consumer happens to connect.
+ */
+export interface PacingConfig {
+    /** Minimum wall-clock milliseconds between the completion of one request and the start of the next. */
+    minGapMs: number;
+    /** Max additional uniform-random jitter (ms) added on top of minGap. Pass 0 to disable. */
+    jitterMs: number;
+}
+/**
+ * How many milliseconds to sleep before the next upstream fetch.
+ *
+ * Returns 0 when no delay is required — either because this is the first
+ * request of the session, or enough wall-clock time has already elapsed
+ * since `lastRequestTime`.
+ *
+ * `rng` defaults to Math.random; tests inject a deterministic stub.
+ * Negative configuration values are clamped to 0 (lenient, not an error).
+ */
+export declare function computePacingDelay(now: number, lastRequestTime: number, cfg: PacingConfig, rng?: () => number): number;
+/**
+ * Resolve a PacingConfig from explicit options, env vars, and defaults.
+ *
+ * Precedence (highest first):
+ *   1. Explicit argument (typically from CLI flag)
+ *   2. DARIO_PACE_MIN_MS / DARIO_PACE_JITTER_MS env vars
+ *   3. Legacy DARIO_MIN_INTERVAL_MS env var (minGap only — matches v3.23
+ *      behavior so existing setups don't regress silently)
+ *   4. Defaults: minGap=500, jitter=0
+ *
+ * Invalid strings (non-numeric, negative) are ignored and fall through to
+ * the next source — a typoed env var shouldn't fail-loud at startup.
+ */
+export declare function resolvePacingConfig(explicit?: {
+    minGapMs?: number;
+    jitterMs?: number;
+}, env?: NodeJS.ProcessEnv): PacingConfig;

package/dist/pacing.js

@@ -0,0 +1,78 @@
+/**
+ * Inter-request pacing (v3.24, direction #6 — behavioral smoothing).
+ *
+ * Real CC traffic has human-paced gaps between requests — sub-second when
+ * the model is streaming tool-loop output, multi-second when the user is
+ * typing the next message. A proxy that fires requests at machine speed
+ * with perfectly uniform spacing stands out against that rhythm.
+ *
+ * This module supplies the pure gap-calculation function the proxy's
+ * rate governor calls before every outbound fetch. Two knobs:
+ *
+ *   minGapMs    — lower bound on the wall-clock distance between requests.
+ *                 Was a hardcoded 500ms through v3.23; keep 500 as default
+ *                 so back-compat is exact when both knobs stay at defaults.
+ *
+ *   jitterMs    — uniform random addition on top of minGap. The *effective*
+ *                 gap for a given request is minGap + U(0, jitter). Adds
+ *                 non-uniformity so an observer can't infer the floor from
+ *                 the long-run minimum of inter-arrival times.
+ *
+ * Pure over (now, lastRequestTime, minGap, jitter, rng) so the tests can
+ * exercise every edge without spawning timers. The proxy passes
+ * `Math.random` as the rng at runtime; tests pass a deterministic stub.
+ *
+ * The first request in a session (lastRequestTime === 0) is never paced —
+ * the purpose is smoothing the *gap between* requests, not delaying the
+ * first one from whenever the consumer happens to connect.
+ */
+/**
+ * How many milliseconds to sleep before the next upstream fetch.
+ *
+ * Returns 0 when no delay is required — either because this is the first
+ * request of the session, or enough wall-clock time has already elapsed
+ * since `lastRequestTime`.
+ *
+ * `rng` defaults to Math.random; tests inject a deterministic stub.
+ * Negative configuration values are clamped to 0 (lenient, not an error).
+ */
+export function computePacingDelay(now, lastRequestTime, cfg, rng = Math.random) {
+    if (lastRequestTime <= 0)
+        return 0;
+    const minGap = Math.max(0, cfg.minGapMs);
+    const jitter = Math.max(0, cfg.jitterMs);
+    const jitterAdd = jitter > 0 ? Math.floor(rng() * jitter) : 0;
+    const effectiveGap = minGap + jitterAdd;
+    const elapsed = now - lastRequestTime;
+    if (elapsed >= effectiveGap)
+        return 0;
+    return effectiveGap - elapsed;
+}
+/**
+ * Resolve a PacingConfig from explicit options, env vars, and defaults.
+ *
+ * Precedence (highest first):
+ *   1. Explicit argument (typically from CLI flag)
+ *   2. DARIO_PACE_MIN_MS / DARIO_PACE_JITTER_MS env vars
+ *   3. Legacy DARIO_MIN_INTERVAL_MS env var (minGap only — matches v3.23
+ *      behavior so existing setups don't regress silently)
+ *   4. Defaults: minGap=500, jitter=0
+ *
+ * Invalid strings (non-numeric, negative) are ignored and fall through to
+ * the next source — a typoed env var shouldn't fail-loud at startup.
+ */
+export function resolvePacingConfig(explicit = {}, env = process.env) {
+    const minGap = pickNonNegativeInt(explicit.minGapMs, env.DARIO_PACE_MIN_MS, env.DARIO_MIN_INTERVAL_MS) ?? 500;
+    const jitter = pickNonNegativeInt(explicit.jitterMs, env.DARIO_PACE_JITTER_MS) ?? 0;
+    return { minGapMs: minGap, jitterMs: jitter };
+}
+function pickNonNegativeInt(...candidates) {
+    for (const c of candidates) {
+        if (c === undefined || c === null || c === '')
+            continue;
+        const n = typeof c === 'number' ? c : parseInt(c, 10);
+        if (Number.isFinite(n) && n >= 0)
+            return Math.floor(n);
+    }
+    return undefined;
+}

package/dist/proxy.d.ts

@@ -13,6 +13,9 @@ interface ProxyOptions {
     hybridTools?: boolean;
     noAutoDetect?: boolean;
     strictTls?: boolean;
+    pacingMinMs?: number;
+    pacingJitterMs?: number;
+    drainOnClose?: boolean;
 }
 export declare function sanitizeError(err: unknown): string;
 export declare function startProxy(opts?: ProxyOptions): Promise<void>;

package/dist/proxy.js

@@ -571,10 +571,28 @@ export async function startProxy(opts = {}) {
         betaBase = betaBase ? `${betaBase},oauth-2025-04-20` : 'oauth-2025-04-20';
     }
     const betaWithoutContext1m = betaBase.split(',').filter((t) => t !== 'context-1m-2025-08-07').join(',');
-    // Rate governor — minimum 500ms between requests. Fast enough for agents,
-    // slow enough to not look like a scripted flood of identical traffic.
+    // Rate governor — floor + optional jitter between requests. A hardcoded
+    // 500ms floor keeps the default behavior identical to v3.23; `--pace-min`
+    // and `--pace-jitter` let callers tune the distribution. Pure calc lives
+    // in src/pacing.ts so the edge cases are unit-tested without timers.
+    const { computePacingDelay, resolvePacingConfig } = await import('./pacing.js');
     let lastRequestTime = 0;
-    const MIN_REQUEST_INTERVAL_MS = parseInt(process.env.DARIO_MIN_INTERVAL_MS || '500', 10);
+    const pacingCfg = resolvePacingConfig({
+        minGapMs: opts.pacingMinMs,
+        jitterMs: opts.pacingJitterMs,
+    });
+    if (verbose) {
+        console.log(`[dario] pacing: min=${pacingCfg.minGapMs}ms jitter=${pacingCfg.jitterMs}ms`);
+    }
+    // Stream-consumption replay (v3.25, direction #5). When on, a client
+    // disconnect no longer aborts the upstream fetch — we keep consuming
+    // the SSE so Anthropic sees a CC-shaped read-to-EOF pattern. See
+    // src/stream-drain.ts for the rationale + tradeoff.
+    const { decideOnClientClose, resolveDrainOnClose } = await import('./stream-drain.js');
+    const drainOnClose = resolveDrainOnClose(opts.drainOnClose);
+    if (verbose) {
+        console.log(`[dario] drain-on-close: ${drainOnClose ? 'enabled' : 'disabled'}`);
+    }
     // Optional proxy authentication — pre-encode key buffer for performance
     const apiKey = process.env.DARIO_API_KEY;
     const apiKeyBuf = apiKey ? Buffer.from(apiKey) : null;
@@ -1076,11 +1094,11 @@ export async function startProxy(opts = {}) {
                     beta = beta.split(',').filter((t) => t.length > 0 && !rejectedSet.has(t)).join(',');
                 }
             }
-            // Rate governor — prevent inhuman request cadence
-            const now = Date.now();
-            const elapsed = now - lastRequestTime;
-            if (elapsed < MIN_REQUEST_INTERVAL_MS && lastRequestTime > 0) {
-                await new Promise(r => setTimeout(r, MIN_REQUEST_INTERVAL_MS - elapsed));
+            // Rate governor — prevent inhuman request cadence. See src/pacing.ts
+            // for the pure delay calculator (floor + uniform jitter).
+            const pacingDelay = computePacingDelay(Date.now(), lastRequestTime, pacingCfg);
+            if (pacingDelay > 0) {
+                await new Promise(r => setTimeout(r, pacingDelay));
             }
             lastRequestTime = Date.now();
             // Session ID: pool mode uses the per-account identity.sessionId (stable
@@ -1107,11 +1125,15 @@ export async function startProxy(opts = {}) {
                 'x-stainless-timeout': '600',
             };
             // Client-disconnect abort: if the client drops the connection before
-            // we've finished sending the response, we abort the upstream fetch so
-            // Anthropic stops generating (and billing) a response nobody will
-            // read. Also carries the 5-minute upstream timeout via the same
-            // controller, so a single signal covers both cancellation reasons.
+            // we've finished sending the response, we default to aborting the
+            // upstream fetch so Anthropic stops generating (and billing) a
+            // response nobody will read. With `--drain-on-close` set, we
+            // instead keep the reader spinning to consume the full SSE — see
+            // src/stream-drain.ts for the fingerprint rationale. The 5-minute
+            // upstream timeout shares the same controller, so a hung upstream
+            // still gets cut off regardless of drain mode.
             const upstreamAbort = new AbortController();
+            let clientDisconnected = false;
             upstreamTimeout = setTimeout(() => {
                 if (!upstreamAbort.signal.aborted) {
                     upstreamAbortReason = 'timeout';
@@ -1119,13 +1141,18 @@ export async function startProxy(opts = {}) {
                 }
             }, UPSTREAM_TIMEOUT_MS);
             onClientClose = () => {
-                // 'close' fires on both normal teardown and client disconnect.
-                // We only want to abort if we haven't finished our response yet —
-                // normal teardown happens AFTER res.writableEnded becomes true.
-                if (!res.writableEnded && !upstreamAbort.signal.aborted) {
+                const action = decideOnClientClose(res.writableEnded, upstreamAbort.signal.aborted, drainOnClose);
+                if (action === 'abort') {
                     upstreamAbortReason = 'client_closed';
                     upstreamAbort.abort();
                 }
+                else if (action === 'drain') {
+                    clientDisconnected = true;
+                    if (verbose)
+                        console.log(`[dario] #${requestCount} client disconnected — draining upstream to EOF`);
+                }
+                // noop: either res is already ended (normal teardown) or upstream
+                // is already aborted for another reason.
             };
             req.on('close', onClientClose);
             const startTime = Date.now();
@@ -1439,6 +1466,14 @@ export async function startProxy(opts = {}) {
                 const streamMapper = ccToolMap && !isOpenAI
                     ? createStreamingReverseMapper(ccToolMap, reqCtx)
                     : null;
+                // Gated writer — a no-op once the downstream client has gone away
+                // in drain-on-close mode. The read loop keeps consuming so the
+                // upstream sees a full-length read; writes to a closed socket are
+                // suppressed to avoid EPIPE/warnings and pointless work.
+                const writeToClient = (chunk) => {
+                    if (!clientDisconnected)
+                        res.write(chunk);
+                };
                 try {
                     let buffer = '';
                     const MAX_LINE_LENGTH = 1_000_000; // 1MB max per SSE line
@@ -1492,8 +1527,8 @@ export async function startProxy(opts = {}) {
                                         type: 'upstream_protocol_error',
                                     },
                                 });
-                                res.write(`data: ${errPayload}\n\n`);
-                                res.write('data: [DONE]\n\n');
+                                writeToClient(`data: ${errPayload}\n\n`);
+                                writeToClient('data: [DONE]\n\n');
                                 upstreamAbortReason = 'sse_overflow';
                                 upstreamAbort.abort();
                                 break;
@@ -1503,28 +1538,28 @@ export async function startProxy(opts = {}) {
                             for (const line of lines) {
                                 const translated = translateStreamChunk(line);
                                 if (translated)
-                                    res.write(translated);
+                                    writeToClient(translated);
                             }
                         }
                         else if (streamMapper) {
                             const out = streamMapper.feed(value);
                             if (out.length > 0)
-                                res.write(out);
+                                writeToClient(out);
                         }
                         else {
-                            res.write(value);
+                            writeToClient(value);
                         }
                     }
                     // Flush remaining buffer
                     if (isOpenAI && buffer.trim()) {
                         const translated = translateStreamChunk(buffer);
                         if (translated)
-                            res.write(translated);
+                            writeToClient(translated);
                     }
                     if (streamMapper) {
                         const tail = streamMapper.end();
                         if (tail.length > 0)
-                            res.write(tail);
+                            writeToClient(tail);
                     }
                 }
                 catch (err) {

package/dist/stream-drain.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Stream-consumption replay (v3.25, direction #5 — behavioral fidelity).
+ *
+ * Native Claude Code, when it streams a response from `/v1/messages`, reads
+ * the SSE to its final event before closing the socket — even when the
+ * consumer logically already has enough. Third-party consumers routed
+ * through dario's proxy often abort mid-stream (close their request the
+ * instant they see the tool-use content block they wanted). Dario's
+ * default has been to propagate that abort upstream by triggering
+ * `upstreamAbort.abort()` from the `req.on('close')` handler — clean from
+ * a billing standpoint (Anthropic stops generating, stops billing), but a
+ * fingerprint axis: "connection closed mid-stream" vs CC's "connection
+ * read to EOF" is visible on Anthropic's side.
+ *
+ * `--drain-on-close` / `DARIO_DRAIN_ON_CLOSE=1` flips the tradeoff: when
+ * the downstream client disconnects, dario suppresses the upstream abort
+ * and keeps the reader loop spinning until the upstream emits its final
+ * event (or `UPSTREAM_TIMEOUT_MS` fires as a hard ceiling — we don't
+ * linger on dead upstreams). Writes to the closed `res` are gated off;
+ * the reads and any accumulator state (analytics, tool-map) continue so
+ * the captured usage numbers are complete rather than truncated.
+ *
+ * This has a real cost — you pay tokens for a response your consumer
+ * isn't going to read — so it's deliberately opt-in. Users on an
+ * unmetered subscription who care more about fingerprint than wasted
+ * generation can flip it on globally.
+ *
+ * This module exposes the *decision* as a pure function so the test
+ * suite can exercise every branch without spinning up a socket. The
+ * proxy wires the decision into its existing `onClientClose` handler.
+ */
+export type ClientCloseAction = 'abort' | 'drain' | 'noop';
+/**
+ * Decide what `onClientClose` should do when the client's `req.on('close')`
+ * fires. Pure over its three inputs.
+ *
+ *   `writableEnded`      — `res.writableEnded` at the moment the handler
+ *                          runs. `true` means the response is already
+ *                          finished (the 'close' event is a normal
+ *                          teardown notification after res.end()) — no
+ *                          action needed.
+ *   `upstreamAborted`    — whether upstream has already been aborted for
+ *                          some other reason (timeout, overflow, pool
+ *                          failover). Don't double-abort.
+ *   `drainOnClose`       — the runtime-configured knob.
+ *
+ * Returns:
+ *   `'noop'`  — already finished / already aborted; handler should return.
+ *   `'abort'` — fire `upstreamAbort.abort()` (the v3.24-and-earlier default).
+ *   `'drain'` — leave upstream alive; gate off client writes; let the
+ *               read loop consume to EOF (bounded by UPSTREAM_TIMEOUT_MS).
+ */
+export declare function decideOnClientClose(writableEnded: boolean, upstreamAborted: boolean, drainOnClose: boolean): ClientCloseAction;
+/**
+ * Resolve the `drainOnClose` effective setting from explicit options +
+ * `DARIO_DRAIN_ON_CLOSE` env var. Truthy env values: `'1'`, `'true'`,
+ * `'yes'` (case-insensitive). Anything else (including unset) is false.
+ * Explicit `true`/`false` on the options object always wins.
+ */
+export declare function resolveDrainOnClose(explicit: boolean | undefined, env?: NodeJS.ProcessEnv): boolean;

package/dist/stream-drain.js

@@ -0,0 +1,68 @@
+/**
+ * Stream-consumption replay (v3.25, direction #5 — behavioral fidelity).
+ *
+ * Native Claude Code, when it streams a response from `/v1/messages`, reads
+ * the SSE to its final event before closing the socket — even when the
+ * consumer logically already has enough. Third-party consumers routed
+ * through dario's proxy often abort mid-stream (close their request the
+ * instant they see the tool-use content block they wanted). Dario's
+ * default has been to propagate that abort upstream by triggering
+ * `upstreamAbort.abort()` from the `req.on('close')` handler — clean from
+ * a billing standpoint (Anthropic stops generating, stops billing), but a
+ * fingerprint axis: "connection closed mid-stream" vs CC's "connection
+ * read to EOF" is visible on Anthropic's side.
+ *
+ * `--drain-on-close` / `DARIO_DRAIN_ON_CLOSE=1` flips the tradeoff: when
+ * the downstream client disconnects, dario suppresses the upstream abort
+ * and keeps the reader loop spinning until the upstream emits its final
+ * event (or `UPSTREAM_TIMEOUT_MS` fires as a hard ceiling — we don't
+ * linger on dead upstreams). Writes to the closed `res` are gated off;
+ * the reads and any accumulator state (analytics, tool-map) continue so
+ * the captured usage numbers are complete rather than truncated.
+ *
+ * This has a real cost — you pay tokens for a response your consumer
+ * isn't going to read — so it's deliberately opt-in. Users on an
+ * unmetered subscription who care more about fingerprint than wasted
+ * generation can flip it on globally.
+ *
+ * This module exposes the *decision* as a pure function so the test
+ * suite can exercise every branch without spinning up a socket. The
+ * proxy wires the decision into its existing `onClientClose` handler.
+ */
+/**
+ * Decide what `onClientClose` should do when the client's `req.on('close')`
+ * fires. Pure over its three inputs.
+ *
+ *   `writableEnded`      — `res.writableEnded` at the moment the handler
+ *                          runs. `true` means the response is already
+ *                          finished (the 'close' event is a normal
+ *                          teardown notification after res.end()) — no
+ *                          action needed.
+ *   `upstreamAborted`    — whether upstream has already been aborted for
+ *                          some other reason (timeout, overflow, pool
+ *                          failover). Don't double-abort.
+ *   `drainOnClose`       — the runtime-configured knob.
+ *
+ * Returns:
+ *   `'noop'`  — already finished / already aborted; handler should return.
+ *   `'abort'` — fire `upstreamAbort.abort()` (the v3.24-and-earlier default).
+ *   `'drain'` — leave upstream alive; gate off client writes; let the
+ *               read loop consume to EOF (bounded by UPSTREAM_TIMEOUT_MS).
+ */
+export function decideOnClientClose(writableEnded, upstreamAborted, drainOnClose) {
+    if (writableEnded || upstreamAborted)
+        return 'noop';
+    return drainOnClose ? 'drain' : 'abort';
+}
+/**
+ * Resolve the `drainOnClose` effective setting from explicit options +
+ * `DARIO_DRAIN_ON_CLOSE` env var. Truthy env values: `'1'`, `'true'`,
+ * `'yes'` (case-insensitive). Anything else (including unset) is false.
+ * Explicit `true`/`false` on the options object always wins.
+ */
+export function resolveDrainOnClose(explicit, env = process.env) {
+    if (typeof explicit === 'boolean')
+        return explicit;
+    const v = (env.DARIO_DRAIN_ON_CLOSE ?? '').toLowerCase();
+    return v === '1' || v === 'true' || v === 'yes';
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@askalf/dario",
-  "version": "3.23.0",
+  "version": "3.25.0",
   "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": {
@@ -21,7 +21,7 @@
   ],
   "scripts": {
     "build": "tsc && cp src/cc-template-data.json dist/ && node -e \"require('fs').mkdirSync('dist/shim',{recursive:true})\" && cp src/shim/runtime.cjs dist/shim/",
-    "test": "node test/issue-29-tool-translation.mjs && node test/hybrid-tools.mjs && node test/tool-schema-contract.mjs && node test/scrub-paths.mjs && node test/provider-prefix.mjs && node test/analytics-recording.mjs && node test/analytics-billing-bucket.mjs && node test/failover-429.mjs && node test/pool-sticky.mjs && node test/sealed-pool.mjs && node test/live-fingerprint.mjs && node test/shim-runtime.mjs && node test/shim-e2e.mjs && node test/proxy-header-order.mjs && node test/proxy-body-order.mjs && node test/runtime-fingerprint.mjs && node test/drift-detection.mjs && node test/compat-range.mjs && node test/doctor-formatter.mjs && node test/atomic-write.mjs && node test/account-refresh-singleflight.mjs && node test/streaming-edge-cases.mjs && node test/client-detection.mjs && node test/manual-oauth-flow.mjs && node test/scrub-template.mjs",
+    "test": "node test/issue-29-tool-translation.mjs && node test/hybrid-tools.mjs && node test/tool-schema-contract.mjs && node test/scrub-paths.mjs && node test/provider-prefix.mjs && node test/analytics-recording.mjs && node test/analytics-billing-bucket.mjs && node test/failover-429.mjs && node test/pool-sticky.mjs && node test/sealed-pool.mjs && node test/live-fingerprint.mjs && node test/shim-runtime.mjs && node test/shim-e2e.mjs && node test/proxy-header-order.mjs && node test/proxy-body-order.mjs && node test/runtime-fingerprint.mjs && node test/pacing.mjs && node test/stream-drain.mjs && node test/drift-detection.mjs && node test/compat-range.mjs && node test/doctor-formatter.mjs && node test/atomic-write.mjs && node test/account-refresh-singleflight.mjs && node test/streaming-edge-cases.mjs && node test/client-detection.mjs && node test/manual-oauth-flow.mjs && node test/scrub-template.mjs",
     "audit": "npm audit --production --audit-level=high",
     "prepublishOnly": "npm run build",
     "start": "node dist/cli.js",