@askalf/dario 3.11.0 → 3.12.0

package/dist/analytics.d.ts

@@ -23,6 +23,26 @@ export interface RequestRecord {
     isStream: boolean;
     isOpenAI: boolean;
 }
+/**
+ * The four billing buckets a request can land in, derived from the
+ * `anthropic-ratelimit-unified-representative-claim` response header.
+ *
+ * - `subscription`         — request billed against the user's 5h subscription window (Max/Pro)
+ * - `subscription_fallback` — server-side fallback subscription bucket (rare, still covered)
+ * - `extra_usage`          — overage / pay-as-you-go, paid on top of subscription
+ * - `api`                  — pure API key billing, no subscription involved
+ * - `unknown`              — header absent or unparseable (non-200 responses, stream aborts)
+ *
+ * Exposed in `/analytics` summaries and in verbose per-request logs so
+ * users can see at a glance which bucket their traffic is actually hitting.
+ * See #34 for background.
+ */
+export type BillingBucket = 'subscription' | 'subscription_fallback' | 'extra_usage' | 'api' | 'unknown';
+/**
+ * Map the raw `representative-claim` header value to a human-friendly
+ * billing bucket. Pure function; no state; safe to call from any context.
+ */
+export declare function billingBucketFromClaim(claim: string | null | undefined): BillingBucket;
 export declare class Analytics {
     private records;
     private maxRecords;
@@ -60,27 +80,30 @@ interface PerModelStat {
     avgThinkingTokens: number;
     estimatedCost: number;
 }
+interface WindowStats {
+    totalInputTokens: number;
+    totalOutputTokens: number;
+    totalThinkingTokens: number;
+    estimatedCost: number;
+    avgLatencyMs: number;
+    errorRate: number;
+    claimBreakdown: Record<string, number>;
+    /** Count of requests in each derived billing bucket. See #34. */
+    billingBucketBreakdown: Record<BillingBucket, number>;
+    /**
+     * Percentage of *classified* requests (non-unknown) that hit a
+     * subscription bucket. The headline number for "is dario routing me
+     * through my subscription?" — should be 100% for a clean setup. See #34.
+     */
+    subscriptionPercent: number;
+}
 export interface AnalyticsSummary {
-    window: {
+    window: WindowStats & {
         minutes: number;
         requests: number;
-        totalInputTokens: number;
-        totalOutputTokens: number;
-        totalThinkingTokens: number;
-        estimatedCost: number;
-        avgLatencyMs: number;
-        errorRate: number;
-        claimBreakdown: Record<string, number>;
     };
-    allTime: {
+    allTime: WindowStats & {
         requests: number;
-        totalInputTokens: number;
-        totalOutputTokens: number;
-        totalThinkingTokens: number;
-        estimatedCost: number;
-        avgLatencyMs: number;
-        errorRate: number;
-        claimBreakdown: Record<string, number>;
     };
     perAccount: Record<string, PerAccountStat>;
     perModel: Record<string, PerModelStat>;

package/dist/analytics.js

@@ -5,6 +5,24 @@
  * In-memory rolling window; exposed via the /analytics endpoint when
  * pool mode is active.
  */
+/**
+ * Map the raw `representative-claim` header value to a human-friendly
+ * billing bucket. Pure function; no state; safe to call from any context.
+ */
+export function billingBucketFromClaim(claim) {
+    switch (claim) {
+        case 'five_hour':
+            return 'subscription';
+        case 'five_hour_fallback':
+            return 'subscription_fallback';
+        case 'overage':
+            return 'extra_usage';
+        case 'api':
+            return 'api';
+        default:
+            return 'unknown';
+    }
+}
 // Anthropic pricing (per 1M tokens, USD). Not authoritative — used for
 // rough burn-rate display in the /analytics summary.
 const PRICING = {
@@ -74,6 +92,14 @@ export class Analytics {
                 totalInputTokens: 0, totalOutputTokens: 0, totalThinkingTokens: 0,
                 estimatedCost: 0, avgLatencyMs: 0, errorRate: 0,
                 claimBreakdown: {},
+                billingBucketBreakdown: {
+                    subscription: 0,
+                    subscription_fallback: 0,
+                    extra_usage: 0,
+                    api: 0,
+                    unknown: 0,
+                },
+                subscriptionPercent: 0,
             };
         }
         const totalInput = records.reduce((s, r) => s + r.inputTokens, 0);
@@ -83,9 +109,22 @@ export class Analytics {
         const avgLatency = records.reduce((s, r) => s + r.latencyMs, 0) / records.length;
         const errors = records.filter(r => r.status >= 400).length;
         const claims = {};
+        const buckets = {
+            subscription: 0,
+            subscription_fallback: 0,
+            extra_usage: 0,
+            api: 0,
+            unknown: 0,
+        };
         for (const r of records) {
             claims[r.claim] = (claims[r.claim] ?? 0) + 1;
+            buckets[billingBucketFromClaim(r.claim)]++;
         }
+        const subscriptionHits = buckets.subscription + buckets.subscription_fallback;
+        const billedRequests = records.length - buckets.unknown;
+        const subscriptionPct = billedRequests > 0
+            ? Math.round((subscriptionHits / billedRequests) * 10000) / 100
+            : 0;
         return {
             totalInputTokens: totalInput,
             totalOutputTokens: totalOutput,
@@ -94,6 +133,8 @@ export class Analytics {
             avgLatencyMs: Math.round(avgLatency),
             errorRate: Math.round((errors / records.length) * 10000) / 10000,
             claimBreakdown: claims,
+            billingBucketBreakdown: buckets,
+            subscriptionPercent: subscriptionPct,
         };
     }
     perAccountStats(records) {

package/dist/cli.js

@@ -366,6 +366,8 @@ async function help() {
     dario backend add NAME --key=sk-... [--base-url=...]
                              Add an OpenAI-compat backend (OpenAI, OpenRouter, Groq, etc.)
     dario backend remove N   Remove an OpenAI-compat backend
+    dario shim -- CMD ARGS   Run CMD inside the dario shim (experimental,
+                             stealth fingerprint via in-process fetch patch)
 
   Proxy options:
     --model=MODEL            Force a model for all requests
@@ -402,6 +404,55 @@ async function help() {
   Tokens auto-refresh in the background — set it and forget it.
 `);
 }
+async function shim() {
+    // dario shim -- <command> [args...]
+    // The `--` separator is conventional but optional; if the user omits it
+    // we just pass everything after `shim` through to the child.
+    const rest = args.slice(1);
+    const sepIdx = rest.indexOf('--');
+    let verbose = false;
+    let head;
+    let childArgs;
+    if (sepIdx >= 0) {
+        head = rest.slice(0, sepIdx);
+        childArgs = rest.slice(sepIdx + 1);
+    }
+    else {
+        head = [];
+        childArgs = rest;
+    }
+    for (const flag of head) {
+        if (flag === '-v' || flag === '--verbose')
+            verbose = true;
+        else {
+            console.error(`Unknown shim flag: ${flag}`);
+            process.exit(1);
+        }
+    }
+    if (childArgs.length === 0) {
+        console.error('Usage: dario shim [-v] -- <command> [args...]');
+        console.error('Example: dario shim -- claude --print -p "hi"');
+        process.exit(1);
+    }
+    const { runShim } = await import('./shim/host.js');
+    try {
+        const result = await runShim({
+            command: childArgs[0],
+            args: childArgs.slice(1),
+            verbose,
+        });
+        if (verbose) {
+            const summary = result.analytics.summary(60);
+            console.error(`[dario shim] ${result.events.length} relay events, ` +
+                `subscriptionPercent=${summary.window.subscriptionPercent}%`);
+        }
+        process.exit(result.exitCode);
+    }
+    catch (err) {
+        console.error('shim failed:', sanitizeError(err));
+        process.exit(1);
+    }
+}
 async function version() {
     try {
         const { fileURLToPath } = await import('node:url');
@@ -423,6 +474,7 @@ const commands = {
     logout,
     accounts,
     backend,
+    shim,
     help,
     version,
     '--help': help,

package/dist/proxy.js

@@ -8,7 +8,7 @@ import { arch, platform } from 'node:process';
 import { getAccessToken, getStatus } from './oauth.js';
 import { buildCCRequest, reverseMapResponse, createStreamingReverseMapper } from './cc-template.js';
 import { AccountPool, parseRateLimits } from './pool.js';
-import { Analytics } from './analytics.js';
+import { Analytics, billingBucketFromClaim } from './analytics.js';
 import { loadAllAccounts, loadAccount, refreshAccountToken } from './accounts.js';
 import { getOpenAIBackend, isOpenAIModel, forwardToOpenAI } from './openai-backend.js';
 const ANTHROPIC_API = 'https://api.anthropic.com';
@@ -1039,7 +1039,13 @@ export async function startProxy(opts = {}) {
                     else {
                         overagePct = 'n/a';
                     }
-                    console.log(`[dario] #${requestCount} billing: ${billingClaim} (overage: ${overagePct})`);
+                    // Show the derived billing bucket as the headline, with the raw
+                    // claim value in parens so power users still see the header as-is.
+                    // See #34 — users want "am I actually on subscription?" answered
+                    // at a glance instead of having to memorize that `five_hour` means
+                    // "yes, subscription."
+                    const bucket = billingBucketFromClaim(billingClaim);
+                    console.log(`[dario] #${requestCount} billing: ${bucket} (${billingClaim}, overage: ${overagePct})`);
                 }
                 else if (verbose) {
                     console.log(`[dario] #${requestCount} billing: headers absent (status=${upstream.status})`);

package/dist/shim/host.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Shim host — dario-side of the shim transport.
+ *
+ * Runs `dario shim -- <cmd> [args...]`. Spawns the child with NODE_OPTIONS
+ * pointing at the shim runtime, listens on a unix socket (or named pipe on
+ * Windows) for billing relay events from the runtime, feeds them into the
+ * Analytics class, and forwards the child's stdio to the host TTY so the
+ * user experience is identical to running the command directly.
+ *
+ * Why a socket and not a file or stdout: the runtime patches `globalThis.fetch`
+ * inside the *child*'s process — that child still owns its own stdout (the
+ * user's TTY), and we don't want shim relay traffic interleaved with CC's
+ * normal output. A unix socket gives us a clean side-channel, lets the host
+ * keep accumulating analytics across the child's lifetime, and stays open if
+ * the child re-execs (rare but possible with claude wrappers).
+ *
+ * See v3.12.0 CHANGELOG for the design rationale.
+ */
+import { Analytics } from './../analytics.js';
+/**
+ * Locate the shim runtime CJS file. In the published package it lives at
+ * `dist/shim/runtime.cjs` next to this module's compiled output. In dev
+ * (running via tsx from src/) it lives at `src/shim/runtime.cjs`.
+ */
+export declare function locateShimRuntime(): string;
+interface RelayEvent {
+    kind: 'request' | 'response';
+    timestamp: number;
+    bytes?: number;
+    status?: number;
+    claim?: string | null;
+    overageUtil?: number | null;
+}
+export interface ShimHostOptions {
+    /** Command to spawn (the user's claude binary, or any node-based CC wrapper). */
+    command: string;
+    /** Args passed through to the child. */
+    args: string[];
+    /** Override the template path the runtime reads. Defaults to ~/.dario/cc-template.live.json. */
+    templatePath?: string;
+    /** Print per-event lines to stderr. */
+    verbose?: boolean;
+    /** Optional Analytics sink. If omitted, a fresh instance is created. */
+    analytics?: Analytics;
+}
+export interface ShimHostResult {
+    exitCode: number;
+    events: RelayEvent[];
+    analytics: Analytics;
+}
+/**
+ * Spawn the child command with the shim runtime injected, relay billing
+ * events to Analytics, return when the child exits.
+ *
+ * Stdio is inherited so the user sees the child's output exactly as if they
+ * had run it without the shim.
+ */
+export declare function runShim(opts: ShimHostOptions): Promise<ShimHostResult>;
+export {};

package/dist/shim/host.js

@@ -0,0 +1,169 @@
+/**
+ * Shim host — dario-side of the shim transport.
+ *
+ * Runs `dario shim -- <cmd> [args...]`. Spawns the child with NODE_OPTIONS
+ * pointing at the shim runtime, listens on a unix socket (or named pipe on
+ * Windows) for billing relay events from the runtime, feeds them into the
+ * Analytics class, and forwards the child's stdio to the host TTY so the
+ * user experience is identical to running the command directly.
+ *
+ * Why a socket and not a file or stdout: the runtime patches `globalThis.fetch`
+ * inside the *child*'s process — that child still owns its own stdout (the
+ * user's TTY), and we don't want shim relay traffic interleaved with CC's
+ * normal output. A unix socket gives us a clean side-channel, lets the host
+ * keep accumulating analytics across the child's lifetime, and stays open if
+ * the child re-execs (rare but possible with claude wrappers).
+ *
+ * See v3.12.0 CHANGELOG for the design rationale.
+ */
+import { createServer } from 'node:net';
+import { spawn } from 'node:child_process';
+import { mkdtempSync, existsSync } from 'node:fs';
+import { tmpdir, homedir } from 'node:os';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { Analytics } from './../analytics.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+/**
+ * Locate the shim runtime CJS file. In the published package it lives at
+ * `dist/shim/runtime.cjs` next to this module's compiled output. In dev
+ * (running via tsx from src/) it lives at `src/shim/runtime.cjs`.
+ */
+export function locateShimRuntime() {
+    const candidates = [
+        join(__dirname, 'runtime.cjs'), // dist/shim/runtime.cjs (production)
+        join(__dirname, '..', '..', 'src', 'shim', 'runtime.cjs'), // dev: from dist/shim → ../../src/shim
+        join(__dirname, '..', 'src', 'shim', 'runtime.cjs'), // dev: from src/shim → ../src/shim (rare)
+    ];
+    for (const c of candidates) {
+        if (existsSync(c))
+            return c;
+    }
+    throw new Error(`shim runtime not found; checked: ${candidates.join(', ')}`);
+}
+/**
+ * Pick a socket path: unix domain socket on POSIX, named pipe on Windows.
+ * Both forms are accepted directly by net.createServer / net.connect.
+ */
+function makeSockPath() {
+    if (process.platform === 'win32') {
+        return `\\\\.\\pipe\\dario-shim-${process.pid}-${Date.now()}`;
+    }
+    const dir = mkdtempSync(join(tmpdir(), 'dario-shim-'));
+    return join(dir, 'sock');
+}
+/**
+ * Build the child env. We *prepend* our --require to NODE_OPTIONS rather than
+ * overwrite, so existing user NODE_OPTIONS (debuggers, source maps, tracers)
+ * still apply. Quoting paths defends against spaces in the dario install dir.
+ */
+function buildChildEnv(parentEnv, runtimePath, sockPath, templatePath, verbose) {
+    const requireFlag = `--require=${JSON.stringify(runtimePath)}`;
+    const existing = parentEnv.NODE_OPTIONS ?? '';
+    const NODE_OPTIONS = existing ? `${requireFlag} ${existing}` : requireFlag;
+    return {
+        ...parentEnv,
+        NODE_OPTIONS,
+        DARIO_SHIM: '1',
+        DARIO_SHIM_SOCK: sockPath,
+        DARIO_SHIM_TEMPLATE: templatePath,
+        ...(verbose ? { DARIO_SHIM_VERBOSE: '1' } : {}),
+    };
+}
+/** Stream parser: relay events arrive as newline-delimited JSON over the socket. */
+function makeSocketHandler(events, analytics, verbose) {
+    return (sock) => {
+        let buf = '';
+        sock.setEncoding('utf-8');
+        sock.on('data', (chunk) => {
+            buf += chunk;
+            let nl;
+            while ((nl = buf.indexOf('\n')) !== -1) {
+                const line = buf.slice(0, nl);
+                buf = buf.slice(nl + 1);
+                if (!line)
+                    continue;
+                try {
+                    const event = JSON.parse(line);
+                    events.push(event);
+                    if (event.kind === 'response') {
+                        // Synthesize a minimal RequestRecord so this surfaces in /analytics.
+                        // Token counts aren't available from the shim transport — the runtime
+                        // would need to parse the SSE stream to extract them, which we
+                        // explicitly chose not to do (it's expensive and intrusive). So this
+                        // is a request-count + claim-tracking record, not a token-cost record.
+                        analytics.record({
+                            timestamp: event.timestamp ?? Date.now(),
+                            account: 'shim',
+                            model: 'unknown',
+                            inputTokens: 0, outputTokens: 0,
+                            cacheReadTokens: 0, cacheCreateTokens: 0, thinkingTokens: 0,
+                            claim: event.claim ?? '',
+                            util5h: 0, util7d: 0,
+                            overageUtil: event.overageUtil ?? 0,
+                            latencyMs: 0,
+                            status: event.status ?? 0,
+                            isStream: false,
+                            isOpenAI: false,
+                        });
+                    }
+                    if (verbose) {
+                        process.stderr.write(`[dario shim] ${JSON.stringify(event)}\n`);
+                    }
+                }
+                catch {
+                    // Malformed line — drop silently. The runtime is best-effort.
+                }
+            }
+        });
+    };
+}
+/** Internal: stand up the socket server and resolve when it's listening. */
+function startSocketServer(sockPath, events, analytics, verbose) {
+    return new Promise((resolve, reject) => {
+        const server = createServer(makeSocketHandler(events, analytics, verbose));
+        server.once('error', reject);
+        server.listen(sockPath, () => resolve(server));
+    });
+}
+/**
+ * Spawn the child command with the shim runtime injected, relay billing
+ * events to Analytics, return when the child exits.
+ *
+ * Stdio is inherited so the user sees the child's output exactly as if they
+ * had run it without the shim.
+ */
+export async function runShim(opts) {
+    const runtimePath = locateShimRuntime();
+    const sockPath = makeSockPath();
+    const templatePath = opts.templatePath ?? join(homedir(), '.dario', 'cc-template.live.json');
+    const verbose = opts.verbose ?? false;
+    const analytics = opts.analytics ?? new Analytics();
+    const events = [];
+    const server = await startSocketServer(sockPath, events, analytics, verbose);
+    let child;
+    try {
+        child = spawn(opts.command, opts.args, {
+            stdio: 'inherit',
+            env: buildChildEnv(process.env, runtimePath, sockPath, templatePath, verbose),
+        });
+    }
+    catch (e) {
+        server.close();
+        throw e;
+    }
+    const exitCode = await new Promise((resolve) => {
+        child.on('exit', (code, signal) => {
+            if (signal)
+                resolve(128 + (signal === 'SIGTERM' ? 15 : 1));
+            else
+                resolve(code ?? 0);
+        });
+        child.on('error', () => resolve(1));
+    });
+    // Give any in-flight relay writes a brief window to land before tearing down.
+    await new Promise((r) => setTimeout(r, 50));
+    server.close();
+    return { exitCode, events, analytics };
+}

package/dist/shim/runtime.cjs

@@ -0,0 +1,186 @@
+// dario shim runtime — loaded into a CC child process via NODE_OPTIONS=--require
+//
+// CommonJS by necessity: --require only accepts CJS. Hand-written, no build step.
+//
+// Responsibilities, in order of importance:
+//   1. Patch globalThis.fetch so outbound POSTs to *.anthropic.com/v1/messages
+//      are rewritten with the dario template (system blocks, tools, fingerprint headers).
+//   2. Peek the response headers and relay billing markers
+//      (anthropic-ratelimit-unified-representative-claim and friends) to the
+//      dario host over a unix/named-pipe socket if DARIO_SHIM_SOCK is set.
+//   3. Be invisible when DARIO_SHIM is unset — so dario can install the require
+//      globally without breaking unrelated Node processes.
+//   4. Failsafe: any internal error falls through to the original fetch. The shim
+//      must never break the host process. CC's retry/auth/streaming logic stays intact.
+
+'use strict';
+
+const fs = require('fs');
+const net = require('net');
+const path = require('path');
+const os = require('os');
+
+const TEMPLATE_PATH = process.env.DARIO_SHIM_TEMPLATE
+  || path.join(os.homedir(), '.dario', 'cc-template.live.json');
+const RELAY_SOCK = process.env.DARIO_SHIM_SOCK || null;
+const VERBOSE = process.env.DARIO_SHIM_VERBOSE === '1';
+
+function log(msg) {
+  if (VERBOSE) {
+    try { process.stderr.write(`[dario-shim] ${msg}\n`); } catch (_) { /* noop */ }
+  }
+}
+
+let template = null;
+function loadTemplate() {
+  if (template) return template;
+  try {
+    const raw = fs.readFileSync(TEMPLATE_PATH, 'utf-8');
+    const parsed = JSON.parse(raw);
+    if (parsed && parsed.agent_identity && parsed.system_prompt && Array.isArray(parsed.tools)) {
+      template = parsed;
+      log(`template loaded from ${TEMPLATE_PATH} (cc_version=${parsed.cc_version || 'unknown'})`);
+      return template;
+    }
+    log(`template at ${TEMPLATE_PATH} missing required fields — passthrough`);
+  } catch (e) {
+    log(`template load failed: ${e.message} — passthrough`);
+  }
+  return null;
+}
+
+let relaySock = null;
+function relay(event) {
+  if (!RELAY_SOCK) return;
+  try {
+    if (!relaySock) {
+      relaySock = net.createConnection(RELAY_SOCK);
+      relaySock.on('error', () => { relaySock = null; });
+    }
+    relaySock.write(JSON.stringify(event) + '\n');
+  } catch (_) { /* relay is best-effort */ }
+}
+
+function isAnthropicMessages(url) {
+  try {
+    const u = typeof url === 'string' ? new URL(url) : url;
+    return /(^|\.)anthropic\.com$/.test(u.hostname) && u.pathname === '/v1/messages';
+  } catch (_) {
+    return false;
+  }
+}
+
+function rewriteBody(bodyText, tmpl) {
+  let body;
+  try { body = JSON.parse(bodyText); } catch (_) { return null; }
+  if (!body || typeof body !== 'object') return null;
+
+  // CC system shape: array of 3 blocks — billing tag, agent identity, system prompt.
+  // We replace blocks [1] and [2] with template values; block [0] (the billing tag)
+  // is left alone since the host process owns its OAuth context.
+  if (Array.isArray(body.system) && body.system.length >= 1) {
+    const billingTag = body.system[0];
+    body.system = [
+      billingTag,
+      { type: 'text', text: tmpl.agent_identity, cache_control: { type: 'ephemeral', ttl: '1h' } },
+      { type: 'text', text: tmpl.system_prompt,  cache_control: { type: 'ephemeral', ttl: '1h' } },
+    ];
+  }
+  body.tools = tmpl.tools;
+  return JSON.stringify(body);
+}
+
+function rewriteHeaders(headers, tmpl) {
+  // Headers in fetch() init can be Headers, plain object, or array of pairs.
+  // Normalize into a plain object so we can mutate, then return Headers.
+  const out = new Headers(headers || {});
+  if (tmpl.cc_version) {
+    out.set('user-agent', `claude-cli/${tmpl.cc_version} (external, cli)`);
+    out.set('x-anthropic-billing-header', `cc_version=${tmpl.cc_version}`);
+  }
+  out.set('anthropic-beta', tmpl.anthropic_beta || 'claude-code-20250219');
+  return out;
+}
+
+function shouldIntercept(input, init) {
+  const method = (init && init.method) || (input && input.method) || 'GET';
+  if (String(method).toUpperCase() !== 'POST') return false;
+  const url = typeof input === 'string' ? input : (input && input.url) || '';
+  return isAnthropicMessages(url);
+}
+
+const originalFetch = globalThis.fetch;
+
+function installFetchPatch() {
+  if (typeof originalFetch !== 'function') {
+    log('globalThis.fetch is not a function — shim disabled');
+    return;
+  }
+  globalThis.fetch = darioShimFetch;
+}
+
+async function darioShimFetch(input, init) {
+  try {
+    if (!shouldIntercept(input, init)) {
+      return originalFetch.call(this, input, init);
+    }
+
+    const tmpl = loadTemplate();
+    if (!tmpl) return originalFetch.call(this, input, init);
+
+    let bodyText;
+    if (init && typeof init.body === 'string') {
+      bodyText = init.body;
+    } else if (input && typeof input.text === 'function') {
+      bodyText = await input.clone().text();
+    } else {
+      log('unsupported body shape — passthrough');
+      return originalFetch.call(this, input, init);
+    }
+
+    const rewritten = rewriteBody(bodyText, tmpl);
+    if (!rewritten) {
+      log('body rewrite failed — passthrough');
+      return originalFetch.call(this, input, init);
+    }
+
+    const newInit = Object.assign({}, init || {}, {
+      method: 'POST',
+      body: rewritten,
+      headers: rewriteHeaders((init && init.headers) || (input && input.headers), tmpl),
+    });
+    const url = typeof input === 'string' ? input : input.url;
+
+    relay({ kind: 'request', timestamp: Date.now(), bytes: rewritten.length });
+    const response = await originalFetch.call(this, url, newInit);
+
+    const claim = response.headers.get('anthropic-ratelimit-unified-representative-claim');
+    const overage = response.headers.get('anthropic-ratelimit-unified-overage-utilization');
+    relay({
+      kind: 'response',
+      timestamp: Date.now(),
+      status: response.status,
+      claim: claim || null,
+      overageUtil: overage ? parseFloat(overage) : null,
+    });
+    return response;
+  } catch (e) {
+    log(`shim fetch error: ${e.message} — passthrough`);
+    return originalFetch.call(this, input, init);
+  }
+};
+
+if (process.env.DARIO_SHIM === '1') {
+  installFetchPatch();
+}
+
+// Internal hooks for unit tests. Always exported so tests can require this
+// file without setting DARIO_SHIM (which would patch the test process's fetch).
+module.exports = {
+  _rewriteBody: rewriteBody,
+  _rewriteHeaders: rewriteHeaders,
+  _shouldIntercept: shouldIntercept,
+  _isAnthropicMessages: isAnthropicMessages,
+  _darioShimFetch: darioShimFetch,
+  _installFetchPatch: installFetchPatch,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@askalf/dario",
-  "version": "3.11.0",
+  "version": "3.12.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": {
@@ -20,8 +20,8 @@
     "LICENSE"
   ],
   "scripts": {
-    "build": "tsc && cp src/cc-template-data.json dist/",
-    "test": "node test/issue-29-tool-translation.mjs && node test/hybrid-tools.mjs && node test/scrub-paths.mjs && node test/provider-prefix.mjs && node test/analytics-recording.mjs && node test/failover-429.mjs && node test/live-fingerprint.mjs",
+    "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/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/live-fingerprint.mjs && node test/shim-runtime.mjs && node test/shim-e2e.mjs",
     "audit": "npm audit --production --audit-level=high",
     "prepublishOnly": "npm run build",
     "start": "node dist/cli.js",