@askalf/dario 6.19.1 → 6.20.0

package/dist/cli.js

@@ -19,7 +19,7 @@
 import { unlink, writeFile } from 'node:fs/promises';
 import { formatLedgerSummary, formatLedgerConsumers, formatUsd, renderLedgerCard, readLedgerFile, resolveLedgerPath, summarizeLedger } from './ledger.js';
 import { renderSpendDonuts } from './donuts.js';
-import { KeyStore, createKey, revokeKey, rotateKey, deleteKey, parseExpiry, publicKey, resolveKeysPath, KEY_NAME_RE, parseKeySocketSpec, setKeyBudget, parseUsdBudget, parseTokenBudget, formatBudget } from './keys.js';
+import { KeyStore, createKey, revokeKey, rotateKey, deleteKey, parseExpiry, publicKey, resolveKeysPath, KEY_NAME_RE, parseKeySocketSpec, setKeyBudget, setKeyEffort, isKeyEffort, KEY_EFFORT_VALUES, parseUsdBudget, parseTokenBudget, formatBudget } from './keys.js';
 /**
  * `--budget=$5/day` / `--budget-tokens=2M/day` → a KeyBudget, or undefined when
  * neither flag is present. A flag that does not parse exits 1 with the accepted
@@ -875,9 +875,9 @@ async function keys() {
             return;
         }
         const w = Math.max(4, ...list.map((k) => k.name.length));
-        console.log(`  ${'NAME'.padEnd(w)}  ${'STATUS'.padEnd(7)}  ${'SEAT'.padEnd(12)}  ${'LAST USED'.padEnd(10)}  ${'EXPIRES'.padEnd(10)}  ${'BUDGET'.padEnd(20)}  MODELS`);
+        console.log(`  ${'NAME'.padEnd(w)}  ${'STATUS'.padEnd(7)}  ${'SEAT'.padEnd(12)}  ${'EFFORT'.padEnd(6)}  ${'LAST USED'.padEnd(10)}  ${'EXPIRES'.padEnd(10)}  ${'BUDGET'.padEnd(20)}  MODELS`);
         for (const k of list) {
-            console.log(`  ${k.name.padEnd(w)}  ${k.status.padEnd(7)}  ${(k.seat ?? '-').padEnd(12)}  ${fmtAgo(k.last_used).padEnd(10)}  ${fmtDay(k.expires).padEnd(10)}  ${formatBudget(k.budget ? { usdPerDay: k.budget.usd_per_day ?? undefined, tokensPerDay: k.budget.tokens_per_day ?? undefined } : null).padEnd(20)}  ${k.models.length ? k.models.join(', ') : 'any'}`);
+            console.log(`  ${k.name.padEnd(w)}  ${k.status.padEnd(7)}  ${(k.seat ?? '-').padEnd(12)}  ${(k.effort ?? '-').padEnd(6)}  ${fmtAgo(k.last_used).padEnd(10)}  ${fmtDay(k.expires).padEnd(10)}  ${formatBudget(k.budget ? { usdPerDay: k.budget.usd_per_day ?? undefined, tokensPerDay: k.budget.tokens_per_day ?? undefined } : null).padEnd(20)}  ${k.models.length ? k.models.join(', ') : 'any'}`);
         }
         console.log('');
         console.log(`  ${list.length} key${list.length === 1 ? '' : 's'} in ${path}. Spend per key: dario usage --by-key`);
@@ -888,7 +888,7 @@ async function keys() {
         const name = args[2];
         if (!name || name.startsWith('--')) {
             console.error('');
-            console.error('  Usage: dario keys create <name> [--seat=<alias>] [--models=a,b,prefix*] [--expires=30d|12h|2w|<ISO date>] [--budget=$5/day] [--budget-tokens=2M/day]');
+            console.error('  Usage: dario keys create <name> [--seat=<alias>] [--models=a,b,prefix*] [--expires=30d|12h|2w|<ISO date>] [--budget=$5/day] [--budget-tokens=2M/day] [--effort=low|medium|high|xhigh|max]');
             console.error('');
             process.exit(1);
         }
@@ -907,8 +907,14 @@ async function keys() {
             expiresAt = parsed;
         }
         const budget = readBudgetFlags(args);
+        const effortArg = args.find((a) => a.startsWith('--effort='));
+        const effort = effortArg ? effortArg.slice('--effort='.length).trim().toLowerCase() : undefined;
+        if (effort !== undefined && !isKeyEffort(effort)) {
+            console.error(`[dario] --effort: "${effort}" is not one of ${KEY_EFFORT_VALUES.join(', ')}.`);
+            process.exit(1);
+        }
         try {
-            const made = store.mutate((file) => createKey(file, name, { seat, models, expiresAt, budget, now }));
+            const made = store.mutate((file) => createKey(file, name, { seat, models, expiresAt, budget, effort, now }));
             printSecret('created', publicKey(made.record, now), made.secret);
         }
         catch (err) {
@@ -917,6 +923,34 @@ async function keys() {
         }
         return;
     }
+    // dario keys effort <name> low|medium|high|xhigh|max | --clear
+    if (sub === 'effort') {
+        const name = args[2];
+        const raw = args.includes('--clear') ? null : (args[3] ?? '').trim().toLowerCase();
+        if (!name || !KEY_NAME_RE.test(name) || (raw !== null && !isKeyEffort(raw))) {
+            console.error('');
+            console.error(`  Usage: dario keys effort <name> ${KEY_EFFORT_VALUES.join('|')} | --clear`);
+            console.error('');
+            console.error('  The effort this key\'s requests run at when they name none themselves (no model-name');
+            console.error('  suffix, no effort field in the body). --effort / DARIO_EFFORT still wins over it.');
+            console.error('');
+            process.exit(1);
+        }
+        const level = raw !== null && isKeyEffort(raw) ? raw : null;
+        try {
+            const updated = store.mutate((file) => setKeyEffort(file, name, level));
+            if (!updated) {
+                console.error(`[dario] No key named "${name}".`);
+                process.exit(1);
+            }
+            console.log(level ? `[dario] Key "${name}" default effort: ${level}` : `[dario] Key "${name}" default effort cleared.`);
+        }
+        catch (err) {
+            console.error(`[dario] ${err instanceof Error ? err.message : String(err)}`);
+            process.exit(1);
+        }
+        return;
+    }
     // dario keys budget <name> --budget=$5/day --budget-tokens=2M/day | --clear
     if (sub === 'budget') {
         const name = args[2];
@@ -985,7 +1019,7 @@ async function keys() {
         return;
     }
     console.error(`[dario] Unknown keys subcommand: ${sub}`);
-    console.error('Usage: dario keys [list|create <name> [--seat=..] [--models=..] [--expires=..] [--budget=..] [--budget-tokens=..]|budget <name> ..|revoke <name>|rotate <name>|remove <name>] [--json] [--keys-path=<file>]');
+    console.error('Usage: dario keys [list|create <name> [--seat=..] [--models=..] [--expires=..] [--budget=..] [--budget-tokens=..] [--effort=..]|budget <name> ..|effort <name> <level>|--clear|revoke <name>|rotate <name>|remove <name>] [--json] [--keys-path=<file>]');
     process.exit(1);
 }
 /**
@@ -2025,8 +2059,8 @@ async function help() {
                              miss. Needs \`dario proxy\` running; costs
                              at most a few tiny subscription requests.
     dario doctor --json      Emit the check report as structured JSON
-                             for machine consumption (claude-bridge
-                             /status, CI scripts, etc.) instead of the
+                             for machine consumption (status bots,
+                             CI scripts, etc.) instead of the
                              human-readable table.
     dario doctor --auth-check
                              One-shot listener on an ephemeral loopback
@@ -2759,8 +2793,8 @@ async function doctor() {
     }
     const checks = await runChecks({ probe, usage, obedience });
     if (asJson) {
-        // JSON mode is meant for machine consumption (claude-bridge /status,
-        // deepdive health checks, CI scripts) — no decorative header, no
+        // JSON mode is meant for machine consumption (status bots, health
+        // checks, CI scripts): no decorative header, no
         // trailing prose, stable shape. Exit code is also surfaced in the
         // JSON envelope for callers that can't read process exit codes.
         process.stdout.write(formatChecksJson(checks) + '\n');

package/dist/doctor-core.d.ts

@@ -108,7 +108,7 @@ export declare function formatChecks(checks: Check[]): string;
 export declare function exitCodeFor(checks: Check[]): number;
 /**
  * Serialize a check report as structured JSON. Lets other tools
- * (claude-bridge's /status command, deepdive, CI scripts) consume
+ * (chat-bot /status commands, health probes, CI scripts) consume
  * dario's health programmatically instead of scraping the formatted
  * text. Emitted by `dario doctor --json`.
  */

package/dist/doctor-core.js

@@ -227,7 +227,7 @@ export function exitCodeFor(checks) {
 }
 /**
  * Serialize a check report as structured JSON. Lets other tools
- * (claude-bridge's /status command, deepdive, CI scripts) consume
+ * (chat-bot /status commands, health probes, CI scripts) consume
  * dario's health programmatically instead of scraping the formatted
  * text. Emitted by `dario doctor --json`.
  */
@@ -1019,7 +1019,7 @@ export async function runChecks(opts = {}) {
         }
     }
     // ---- Client-system obedience probe (opt-in, --obedience).
-    // dario#509 / the 2026-06-12 deepdive planner outage: Anthropic's serving
+    // dario#509 / the 2026-06-12 downstream planner outage: Anthropic's serving
     // side changed how claude-sonnet-4-6 weighed client system text merged
     // after the CC persona in block 3 — wire bytes identical, every existing
     // check green — and the only symptom was a downstream consumer failing to

package/dist/effort.d.ts

@@ -32,6 +32,24 @@ export declare const VALID_EFFORT_VALUES: ReadonlyArray<EffortValue>;
  *     and the request's own thinking budget decides, as before.
  */
 export declare function effortForCodex(effort: EffortValue | undefined): 'low' | 'medium' | 'high' | 'xhigh' | 'max' | undefined;
+/**
+ * Did the request name an effort of its own? Three places a client can say it:
+ * `output_config.effort` (Messages shape), `reasoning_effort` (chat completions),
+ * `reasoning.effort` (Responses). A named key's default effort fills in only when
+ * this is false, so a client that chose is never overruled by a default. The
+ * model-name suffix is checked separately by the caller (it is parsed off the
+ * model before this runs).
+ */
+export declare function requestNamesEffort(body: Record<string, unknown> | null | undefined): boolean;
+/**
+ * A Responses body for the codex passthrough with `reasoning.effort` filled in.
+ * Returned as is when there is no effort to add or when the client already
+ * named one (a non-empty `reasoning.effort`); otherwise a copy carries the
+ * level and keeps every other `reasoning` field, since Codex CLI sends
+ * `summary` there. The passthrough forwards the client's body as written, so
+ * this is the only place a suffix or a key default can reach that route.
+ */
+export declare function withResponsesEffort(body: Record<string, unknown>, effort: 'low' | 'medium' | 'high' | 'xhigh' | 'max' | undefined): Record<string, unknown>;
 export declare function parseEffortSuffix(model: string): {
     model: string;
     effort?: EffortValue;

package/dist/effort.js

@@ -52,6 +52,44 @@ export function effortForCodex(effort) {
         default: return undefined;
     }
 }
+/**
+ * Did the request name an effort of its own? Three places a client can say it:
+ * `output_config.effort` (Messages shape), `reasoning_effort` (chat completions),
+ * `reasoning.effort` (Responses). A named key's default effort fills in only when
+ * this is false, so a client that chose is never overruled by a default. The
+ * model-name suffix is checked separately by the caller (it is parsed off the
+ * model before this runs).
+ */
+export function requestNamesEffort(body) {
+    if (!body || typeof body !== 'object')
+        return false;
+    const oc = body.output_config;
+    if (oc && typeof oc === 'object' && typeof oc.effort === 'string')
+        return true;
+    if (typeof body.reasoning_effort === 'string' && body.reasoning_effort.length > 0)
+        return true;
+    const reasoning = body.reasoning;
+    if (reasoning && typeof reasoning === 'object' && typeof reasoning.effort === 'string')
+        return true;
+    return false;
+}
+/**
+ * A Responses body for the codex passthrough with `reasoning.effort` filled in.
+ * Returned as is when there is no effort to add or when the client already
+ * named one (a non-empty `reasoning.effort`); otherwise a copy carries the
+ * level and keeps every other `reasoning` field, since Codex CLI sends
+ * `summary` there. The passthrough forwards the client's body as written, so
+ * this is the only place a suffix or a key default can reach that route.
+ */
+export function withResponsesEffort(body, effort) {
+    if (!effort)
+        return body;
+    const r = body.reasoning;
+    const existing = r !== null && typeof r === 'object' && !Array.isArray(r) ? r : {};
+    if (typeof existing.effort === 'string' && existing.effort.length > 0)
+        return body;
+    return { ...body, reasoning: { ...existing, effort } };
+}
 export function parseEffortSuffix(model) {
     for (const e of SUFFIX_EFFORTS) {
         for (const sep of [':', '-']) {

package/dist/keys.d.ts

@@ -3,6 +3,14 @@ export declare const KEY_PREFIX = "dk_";
 /** Same charset as a pool alias — a key name is printed next to one. */
 export declare const KEY_NAME_RE: RegExp;
 export declare const KEYS_FLUSH_DELAY_MS = 3000;
+/**
+ * The effort levels a named key may carry as its default: the wire-valid set,
+ * and nothing that means "ask the client" (`client`) or names a client mode
+ * (`ultracode`). Applied per request when the request named no effort itself.
+ */
+export type KeyEffort = 'low' | 'medium' | 'high' | 'xhigh' | 'max';
+export declare const KEY_EFFORT_VALUES: ReadonlyArray<KeyEffort>;
+export declare function isKeyEffort(v: unknown): v is KeyEffort;
 export interface KeyRecord {
     /** Stable short id (8 hex), for logs and rotation; never the secret. */
     id: string;
@@ -23,6 +31,12 @@ export interface KeyRecord {
     models?: string[];
     /** Daily caps, UTC day, enforced from the ledger (dario#1318 follow-up). Absent = unlimited. */
     budget?: KeyBudget;
+    /**
+     * Default effort for this key's requests when the request names none itself
+     * (no model-name suffix, no effort field in the body). Absent = the proxy's
+     * usual resolution. The operator's --effort pin still wins over it.
+     */
+    effort?: KeyEffort;
 }
 /**
  * A key's daily budget. Both caps are per UTC day and both are read from the
@@ -126,6 +140,8 @@ export declare function budgetVerdict(budget: KeyBudget, usage: KeyBudgetUsage,
 export declare function budgetHeaders(v: KeyBudgetVerdict, keyName: string): Record<string, string>;
 /** Replace (or clear, with null) a key's budget. Null result: no such key. */
 export declare function setKeyBudget(file: KeysFile, name: string, budget: KeyBudget | null): KeyRecord | null;
+/** Set or clear a key's default effort. Returns null when there is no such key; throws on a level outside KEY_EFFORT_VALUES. */
+export declare function setKeyEffort(file: KeysFile, name: string, effort: KeyEffort | string | null): KeyRecord | null;
 export interface KeysFile {
     version: number;
     keys: KeyRecord[];
@@ -161,6 +177,8 @@ export interface CreateKeyOptions {
     budget?: KeyBudget;
     /** Absolute expiry, epoch ms. */
     expiresAt?: number;
+    /** Default effort; one of KEY_EFFORT_VALUES, validated. */
+    effort?: string;
     now?: number;
 }
 /** Mint a key. Returns the record (stored) and the secret (shown once). Mutates `file`. */
@@ -203,6 +221,8 @@ export interface KeyPublic {
         usd_per_day: number | null;
         tokens_per_day: number | null;
     } | null;
+    /** Default effort, or null when the key has none. */
+    effort: KeyEffort | null;
 }
 export declare function publicKey(k: KeyRecord, now?: number): KeyPublic;
 /** `--expires=30d` / `12h` / `2026-12-31` → epoch ms, or null when unparseable. */

package/dist/keys.js

@@ -37,6 +37,10 @@ export const KEY_PREFIX = 'dk_';
 export const KEY_NAME_RE = /^[A-Za-z0-9][A-Za-z0-9_\-.]{0,63}$/;
 export const KEYS_FLUSH_DELAY_MS = 3_000;
 const SECRET_BYTES = 24;
+export const KEY_EFFORT_VALUES = ['low', 'medium', 'high', 'xhigh', 'max'];
+export function isKeyEffort(v) {
+    return typeof v === 'string' && KEY_EFFORT_VALUES.includes(v);
+}
 /** A conservative bytes-per-token for the reservation: prose is ~4, code and CJK are lower. */
 export const BUDGET_BYTES_PER_TOKEN = 3;
 /** Reserved output when the client sends no max_tokens / max_completion_tokens / max_output_tokens. */
@@ -166,6 +170,20 @@ export function setKeyBudget(file, name, budget) {
         delete k.budget;
     return k;
 }
+/** Set or clear a key's default effort. Returns null when there is no such key; throws on a level outside KEY_EFFORT_VALUES. */
+export function setKeyEffort(file, name, effort) {
+    const k = file.keys.find((x) => x.name === name);
+    if (!k)
+        return null;
+    if (effort === null || effort === undefined || effort === '') {
+        delete k.effort;
+        return k;
+    }
+    if (!isKeyEffort(effort))
+        throw new Error(`invalid effort "${effort}": one of ${KEY_EFFORT_VALUES.join(', ')}`);
+    k.effort = effort;
+    return k;
+}
 export function keysPathFor(home = homedir()) {
     return join(home, '.dario', 'keys.json');
 }
@@ -239,6 +257,9 @@ export function parseKeysFile(text) {
             }
             catch { /* a malformed cap is dropped, never a reason to refuse the whole file */ }
         }
+        // A default effort outside the wire-valid set is dropped, like a malformed cap.
+        if (isKeyEffort(k.effort))
+            rec.effort = k.effort;
         seen.add(rec.name);
         keys.push(rec);
     }
@@ -294,6 +315,11 @@ export function createKey(file, name, opts = {}) {
     const budget = normalizeBudget(opts.budget);
     if (budget)
         record.budget = budget;
+    if (opts.effort !== undefined && opts.effort !== '') {
+        if (!isKeyEffort(opts.effort))
+            throw new Error(`invalid effort "${opts.effort}": one of ${KEY_EFFORT_VALUES.join(', ')}`);
+        record.effort = opts.effort;
+    }
     if (opts.expiresAt !== undefined) {
         if (!Number.isFinite(opts.expiresAt) || opts.expiresAt <= (opts.now ?? Date.now()))
             throw new Error('expiry must be in the future');
@@ -371,7 +397,7 @@ export function keyAllowsModel(k, model) {
 export function publicKey(k, now = Date.now()) {
     const status = k.disabled ? 'revoked' : k.expires && Date.parse(k.expires) <= now ? 'expired' : 'active';
     const budget = k.budget ? { usd_per_day: k.budget.usdPerDay ?? null, tokens_per_day: k.budget.tokensPerDay ?? null } : null;
-    return { id: k.id, name: k.name, created: k.created, last_used: k.lastUsed ?? null, status, expires: k.expires ?? null, seat: k.seat ?? null, budget, models: k.models ?? [] };
+    return { id: k.id, name: k.name, created: k.created, last_used: k.lastUsed ?? null, status, expires: k.expires ?? null, seat: k.seat ?? null, budget, effort: k.effort ?? null, models: k.models ?? [] };
 }
 /** `--expires=30d` / `12h` / `2026-12-31` → epoch ms, or null when unparseable. */
 export function parseExpiry(value, now = Date.now()) {

package/dist/ledger.d.ts

@@ -38,6 +38,12 @@ export interface LedgerCell {
     outputTokens: number;
     cacheReadTokens: number;
     cacheCreateTokens: number;
+    /**
+     * Thinking tokens INSIDE outputTokens, a share and never an addition (the
+     * model's reasoning is billed as output). Counted from the usage block the
+     * backend returns; rows written before the field existed read as 0.
+     */
+    thinkingTokens: number;
 }
 export type LedgerRow = Partial<Record<LedgerBucket, LedgerCell>>;
 export interface LedgerFile {
@@ -67,6 +73,9 @@ export interface LedgerConsumerSummary {
     outputTokens: number;
     cacheReadTokens: number;
     cacheCreateTokens: number;
+    /** Of outputTokens, how many were thinking; and what that thinking would have cost at the model's output rate (both buckets). */
+    thinkingTokens: number;
+    thinkingCost: number;
     recent: {
         today: number;
         last7d: number;
@@ -84,6 +93,8 @@ export interface LedgerModelSummary {
     outputTokens: number;
     cacheReadTokens: number;
     cacheCreateTokens: number;
+    /** Of the covered outputTokens, how many were thinking. */
+    thinkingTokens: number;
     /** API-equivalent cost of this model's covered traffic, USD. */
     apiEquivalentCost: number;
     /** What this model's metered traffic cost at list price, USD. */
@@ -106,13 +117,16 @@ export interface LedgerSummary {
     apiEquivalentCost: number;
     /** What metered traffic (API key, paid overage) actually cost at list price, USD. */
     meteredCost: number;
-    /** Covered token totals. */
+    /** Covered token totals. `thinking` is the share of `output` that was reasoning. */
     tokens: {
         input: number;
         output: number;
         cacheRead: number;
         cacheCreate: number;
+        thinking: number;
     };
+    /** The part of apiEquivalentCost that paid for thinking: covered thinking tokens at each model's output rate, USD. */
+    thinkingCost: number;
     perProvider: Record<PricingProvider, {
         requests: number;
         apiEquivalentCost: number;
@@ -238,6 +252,8 @@ export declare function shortModelName(model: string): string;
  * to match the rest of that command's output.
  */
 export declare function formatLedgerSummary(s: LedgerSummary): string[];
+/** Thinking as a whole percent of output; 0 when there was no output. */
+export declare function thinkingPercent(thinking: number, output: number): number;
 /**
  * `dario usage --by-key`: the lifetime number per consumer, biggest first.
  * A consumer is a named key's name, an `x-dario-consumer` header, or the

package/dist/ledger.js

@@ -52,7 +52,7 @@ export function resolveLedgerPath(port, env = process.env) {
 export function ledgerDisabledByEnv(env = process.env) {
     return ['0', 'false', 'no', 'off'].includes((env['DARIO_LEDGER'] ?? '').toLowerCase());
 }
-const emptyCell = () => ({ requests: 0, inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheCreateTokens: 0 });
+const emptyCell = () => ({ requests: 0, inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheCreateTokens: 0, thinkingTokens: 0 });
 export function emptyLedger(now = Date.now()) {
     const iso = new Date(now).toISOString();
     return { version: LEDGER_VERSION, since: iso, updated: iso, days: {} };
@@ -90,6 +90,17 @@ function isCell(v) {
     return ['requests', 'inputTokens', 'outputTokens', 'cacheReadTokens', 'cacheCreateTokens']
         .every((k) => typeof c[k] === 'number' && Number.isFinite(c[k]) && c[k] >= 0);
 }
+/**
+ * A cell as read from disk, with the fields added after the file was written
+ * filled in: `thinkingTokens` is 0 on rows older than the field (and never
+ * above the output count it is a share of).
+ */
+function cleanCell(c) {
+    const raw = c.thinkingTokens;
+    const thinking = typeof raw === 'number' && Number.isFinite(raw) && raw >= 0 ? Math.min(raw, c.outputTokens) : 0;
+    return { requests: c.requests, inputTokens: c.inputTokens, outputTokens: c.outputTokens,
+        cacheReadTokens: c.cacheReadTokens, cacheCreateTokens: c.cacheCreateTokens, thinkingTokens: thinking };
+}
 /**
  * Parse a ledger file's text, keeping only well-formed rows. A file that is
  * not a ledger at all throws; the caller moves it aside and starts fresh.
@@ -109,9 +120,9 @@ export function parseLedger(text) {
                 continue;
             const r = {};
             if (isCell(row.covered))
-                r.covered = { ...row.covered };
+                r.covered = cleanCell(row.covered);
             if (isCell(row.metered))
-                r.metered = { ...row.metered };
+                r.metered = cleanCell(row.metered);
             if (r.covered || r.metered)
                 clean[model] = r;
         }
@@ -136,9 +147,9 @@ export function parseLedger(text) {
                         continue;
                     const r = {};
                     if (isCell(row.covered))
-                        r.covered = { ...row.covered };
+                        r.covered = cleanCell(row.covered);
                     if (isCell(row.metered))
-                        r.metered = { ...row.metered };
+                        r.metered = cleanCell(row.metered);
                     if (r.covered || r.metered)
                         clean[model] = r;
                 }
@@ -160,6 +171,8 @@ function addCell(row, bucket, record) {
     cell.outputTokens += record.outputTokens;
     cell.cacheReadTokens += record.cacheReadTokens;
     cell.cacheCreateTokens += record.cacheCreateTokens;
+    const thinking = Number.isFinite(record.thinkingTokens) && record.thinkingTokens > 0 ? record.thinkingTokens : 0;
+    cell.thinkingTokens = (cell.thinkingTokens ?? 0) + Math.min(thinking, record.outputTokens);
 }
 /** Add one record's tokens to the file in place. Returns false when it was not counted. */
 export function addToLedger(file, record) {
@@ -203,13 +216,14 @@ export function summarizeLedgerConsumers(file, now = Date.now()) {
     for (const [day, byConsumer] of Object.entries(file.consumers ?? {})) {
         const at = dayMs(day);
         for (const [consumer, models] of Object.entries(byConsumer)) {
-            const c = (out[consumer] ??= { requests: 0, apiEquivalentCost: 0, meteredCost: 0, inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheCreateTokens: 0, recent: { today: 0, last7d: 0, last30d: 0 }, lastDay: day, models: [], _models: {} });
+            const c = (out[consumer] ??= { requests: 0, apiEquivalentCost: 0, meteredCost: 0, inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheCreateTokens: 0, thinkingTokens: 0, thinkingCost: 0, recent: { today: 0, last7d: 0, last30d: 0 }, lastDay: day, models: [], _models: {} });
             if (day > c.lastDay)
                 c.lastDay = day;
             for (const [model, row] of Object.entries(models)) {
                 if (row.covered) {
                     const cost = costOfTokens(model, at, row.covered);
                     c.apiEquivalentCost += cost;
+                    c.thinkingCost += costOfTokens(model, at, thinkingOnly(row.covered));
                     c.requests += row.covered.requests;
                     addTokens(c, row.covered);
                     c._models[model] = (c._models[model] ?? 0) + row.covered.requests;
@@ -222,6 +236,7 @@ export function summarizeLedgerConsumers(file, now = Date.now()) {
                 }
                 if (row.metered) {
                     c.meteredCost += costOfTokens(model, at, row.metered);
+                    c.thinkingCost += costOfTokens(model, at, thinkingOnly(row.metered));
                     c.requests += row.metered.requests;
                     addTokens(c, row.metered);
                     c._models[model] = (c._models[model] ?? 0) + row.metered.requests;
@@ -239,6 +254,8 @@ export function summarizeLedgerConsumers(file, now = Date.now()) {
             outputTokens: c.outputTokens,
             cacheReadTokens: c.cacheReadTokens,
             cacheCreateTokens: c.cacheCreateTokens,
+            thinkingTokens: c.thinkingTokens,
+            thinkingCost: round(c.thinkingCost),
             recent: { today: round(c.recent.today), last7d: round(c.recent.last7d), last30d: round(c.recent.last30d) },
             lastDay: c.lastDay,
             models: Object.entries(c._models).sort((a, b) => b[1] - a[1]).map(([m]) => m),
@@ -276,6 +293,11 @@ function addTokens(into, cell) {
     into.outputTokens += cell.outputTokens;
     into.cacheReadTokens += cell.cacheReadTokens;
     into.cacheCreateTokens += cell.cacheCreateTokens;
+    into.thinkingTokens += cell.thinkingTokens ?? 0;
+}
+/** The cell's thinking alone, shaped for the price list: output tokens and nothing else. */
+function thinkingOnly(cell) {
+    return { inputTokens: 0, outputTokens: cell.thinkingTokens ?? 0, cacheReadTokens: 0, cacheCreateTokens: 0 };
 }
 // Round BEFORE choosing the unit. Picking the unit on the raw value and
 // rounding afterwards let 999_600 print as "1000k": once the rounded
@@ -305,32 +327,36 @@ export function summarizeLedger(file, path, now = Date.now()) {
         anthropic: { requests: 0, apiEquivalentCost: 0 },
         openai: { requests: 0, apiEquivalentCost: 0 },
     };
-    const tokens = { input: 0, output: 0, cacheRead: 0, cacheCreate: 0 };
+    const tokens = { input: 0, output: 0, cacheRead: 0, cacheCreate: 0, thinking: 0 };
     let requests = 0;
     let covered = 0;
     let metered = 0;
+    let thinkingCost = 0;
     const recent = { today: 0, last7d: 0, last30d: 0 };
     for (const [day, models] of Object.entries(file.days)) {
         const at = dayMs(day);
         for (const [model, row] of Object.entries(models)) {
             const m = (perModel[model] ??= {
                 provider: providerOfModel(model), requests: 0,
-                inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheCreateTokens: 0,
+                inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheCreateTokens: 0, thinkingTokens: 0,
                 apiEquivalentCost: 0, meteredCost: 0,
             });
             if (row.covered) {
                 const cost = costOfTokens(model, at, row.covered);
                 covered += cost;
+                thinkingCost += costOfTokens(model, at, thinkingOnly(row.covered));
                 m.apiEquivalentCost += cost;
                 m.requests += row.covered.requests;
                 m.inputTokens += row.covered.inputTokens;
                 m.outputTokens += row.covered.outputTokens;
                 m.cacheReadTokens += row.covered.cacheReadTokens;
                 m.cacheCreateTokens += row.covered.cacheCreateTokens;
+                m.thinkingTokens += row.covered.thinkingTokens ?? 0;
                 tokens.input += row.covered.inputTokens;
                 tokens.output += row.covered.outputTokens;
                 tokens.cacheRead += row.covered.cacheReadTokens;
                 tokens.cacheCreate += row.covered.cacheCreateTokens;
+                tokens.thinking += row.covered.thinkingTokens ?? 0;
                 perProvider[m.provider].requests += row.covered.requests;
                 perProvider[m.provider].apiEquivalentCost += cost;
                 requests += row.covered.requests;
@@ -364,6 +390,7 @@ export function summarizeLedger(file, path, now = Date.now()) {
         apiEquivalentCost: round(covered),
         meteredCost: round(metered),
         tokens,
+        thinkingCost: round(thinkingCost),
         perProvider,
         perModel,
         recent: { today: round(recent.today), last7d: round(recent.last7d), last30d: round(recent.last30d) },
@@ -559,8 +586,14 @@ export function formatLedgerSummary(s) {
     lines.push(`    Today ${formatUsd(s.recent.today)} · Last 7d ${formatUsd(s.recent.last7d)} · Last 30d ${formatUsd(s.recent.last30d)}`);
     if (s.meteredCost > 0)
         lines.push(`    Paid per token on top (API key / extra usage): ${formatUsd(s.meteredCost)}`);
+    if (s.tokens.thinking > 0)
+        lines.push(`    Thinking: ${formatTokenCount(s.tokens.thinking)} of ${formatTokenCount(s.tokens.output)} output tokens (${thinkingPercent(s.tokens.thinking, s.tokens.output)}%) · ${formatUsd(s.thinkingCost)} of the number above`);
     return lines;
 }
+/** Thinking as a whole percent of output; 0 when there was no output. */
+export function thinkingPercent(thinking, output) {
+    return output > 0 ? Math.round((100 * thinking) / output) : 0;
+}
 /**
  * `dario usage --by-key`: the lifetime number per consumer, biggest first.
  * A consumer is a named key's name, an `x-dario-consumer` header, or the
@@ -576,7 +609,8 @@ export function formatLedgerConsumers(s, limit = 20) {
     for (const [consumer, c] of entries.slice(0, limit)) {
         const models = c.models.slice(0, 2).map(shortModelName).join(', ');
         lines.push(`    ${consumer.slice(0, width).padEnd(width)} ${formatUsd(c.apiEquivalentCost).padStart(9)} · ${formatUsd(c.recent.today).padStart(8)} · ${formatUsd(c.recent.last7d).padStart(8)} · ${formatUsd(c.recent.last30d).padStart(8)}   ${c.requests.toLocaleString('en-US')} req${c.requests === 1 ? '' : 's'}${models ? `, ${models}` : ''}${c.meteredCost > 0 ? `, ${formatUsd(c.meteredCost)} metered` : ''}`);
-        lines.push(`    ${' '.repeat(width)} in ${formatTokenCount(c.inputTokens)} · out ${formatTokenCount(c.outputTokens)} · cache read ${formatTokenCount(c.cacheReadTokens)} · cache write ${formatTokenCount(c.cacheCreateTokens)}`);
+        const thinking = c.thinkingTokens > 0 ? ` · thinking ${formatTokenCount(c.thinkingTokens)} (${thinkingPercent(c.thinkingTokens, c.outputTokens)}% of out, ${formatUsd(c.thinkingCost)})` : '';
+        lines.push(`    ${' '.repeat(width)} in ${formatTokenCount(c.inputTokens)} · out ${formatTokenCount(c.outputTokens)} · cache read ${formatTokenCount(c.cacheReadTokens)} · cache write ${formatTokenCount(c.cacheCreateTokens)}${thinking}`);
     }
     if (entries.length > limit)
         lines.push(`    … and ${entries.length - limit} more`);

package/dist/live-fingerprint.js

@@ -451,7 +451,7 @@ export function loadTemplate(_options) {
         // Stale cache: prefer whichever of the live cache and the bundled
         // snapshot was captured more recently — do NOT blindly keep the cache.
         // A frozen live cache must not shadow a newer bundled template, which is
-        // exactly what happens in a no-CC deployment (e.g. the Hetzner container):
+        // exactly what happens in a no-CC deployment (e.g. a container deploy):
         // the async refresh can never run there, so the cache stays pinned at its
         // last capture while shipped releases move the bundle ahead. Without this
         // comparison, every bundled-template update is silently ignored until the
@@ -1069,7 +1069,7 @@ const STATIC_HEADER_EXCLUDE = new Set([
     // Found 2026-07-25: the bundled template had been baked on Windows for
     // several releases (#820/#828/#840/#849/#851 -> x-stainless-os: Windows,
     // 30 tools incl. PowerShell), while cc-drift-template-watch runs its live
-    // capture every 30 min on the Linux Hetzner runner. So the Linux box served
+    // capture every 30 min on a Linux self-hosted runner. So the Linux box served
     // `x-stainless-os: Windows`, and the watch saw permanent drift against a
     // bundle it could never match -- auto-rebaking to Linux (#852), which the next
     // Windows-side bake (#854) would flip straight back. Excluding these ends