@askalf/dario 3.31.21 → 3.32.0

package/dist/doctor.js

@@ -210,6 +210,38 @@ export async function runChecks(opts = {}) {
     catch (err) {
         checks.push({ status: 'fail', label: 'Template', detail: `load failed: ${err.message}` });
     }
+    // ---- Per-request overhead surfacing.
+    // The CC system prompt + tool definitions are injected into every
+    // non-passthrough request and dominate the input-token cost on small
+    // turns. Anthropic caches them after the first hit (cache_creation
+    // tokens on call 1, then cache_read on subsequent calls within the
+    // 5-min/1-hr TTL), but non-CC users routing heavy tooling get
+    // surprised by the first-request charge. Surface the size up front
+    // so they can plan.
+    //
+    // No token estimate — char counts and tool count are factual; the
+    // tokenizer ratio varies enough between prose and tool-schema JSON
+    // (compressible structural keys) that any single divisor is
+    // misleading. Operators who want the exact number can read it off
+    // their first request's `cache_creation_input_tokens` once the proxy
+    // is warm. `--usage` adds the live snapshot for those who want it.
+    try {
+        const promptChars = CC_TEMPLATE.system_prompt?.length ?? 0;
+        const toolCount = (CC_TEMPLATE.tools ?? []).length;
+        const toolChars = JSON.stringify(CC_TEMPLATE.tools ?? []).length;
+        if (promptChars > 0 || toolCount > 0) {
+            checks.push({
+                status: 'info',
+                label: 'Overhead',
+                detail: `${promptChars.toLocaleString()} chars system prompt + ${toolCount} tool defs ` +
+                    `(${toolChars.toLocaleString()} chars JSON-serialized) injected per non-passthrough ` +
+                    `request. Cached after first hit; read-cost only on subsequent calls within ` +
+                    `the 5-min/1-hr TTL. Exact token count surfaces as cache_creation_input_tokens ` +
+                    `on the first response (or run \`dario doctor --usage\`).`,
+            });
+        }
+    }
+    catch { /* don't let overhead reporting break the doctor */ }
     // ---- Template drift
     try {
         const drift = detectDrift(CC_TEMPLATE);
@@ -429,6 +461,43 @@ export async function runChecks(opts = {}) {
                     (expired > 0 ? `, ${expired} expired` : '') +
                     (aliases.length < 2 ? ' (pool activates at 2+)' : ''),
             });
+            // Next-account-in-rotation surfacing. The proxy's per-request
+            // selector picks by max headroom (with 7d_<family> per-model
+            // bucket considered when a request's model family is known);
+            // doctor doesn't know the next request's model so it reports
+            // the family-agnostic pick. That's still the right preview for
+            // operators wondering "if I send a request right now, which
+            // account gets it?" — it matches `pool.select()` with no family
+            // hint, the same call the proxy uses when no model is parsed
+            // yet (e.g. on misshapen requests). Bypassed when only one
+            // account is loaded since "rotation" doesn't apply.
+            if (aliases.length >= 2) {
+                try {
+                    const { AccountPool } = await import('./pool.js');
+                    const pool = new AccountPool();
+                    for (const acc of loaded) {
+                        pool.add(acc.alias, {
+                            accessToken: acc.accessToken,
+                            refreshToken: acc.refreshToken,
+                            expiresAt: acc.expiresAt,
+                            deviceId: acc.deviceId,
+                            accountUuid: acc.accountUuid,
+                        });
+                    }
+                    const next = pool.select();
+                    const ps = pool.status();
+                    checks.push({
+                        status: 'info',
+                        label: 'Pool routing',
+                        detail: next
+                            ? `next: ${next.alias}  (max-headroom select; ${ps.healthy}/${ps.accounts} healthy)`
+                            : `no eligible account — all rejected or near-expiry (${ps.exhausted}/${ps.accounts} exhausted)`,
+                    });
+                }
+                catch (err) {
+                    checks.push({ status: 'warn', label: 'Pool routing', detail: `check failed: ${err.message}` });
+                }
+            }
         }
     }
     catch (err) {

package/dist/mcp/tools.d.ts

@@ -22,6 +22,32 @@ import type { McpTool } from './protocol.js';
  * tests can substitute pure synthetic data to avoid touching network /
  * filesystem / OAuth state.
  */
+/**
+ * Shape returned by the `usage` data source. Mirrors the public subset
+ * of /analytics — keeps the MCP tool decoupled from internal Analytics
+ * record fields. Single-account mode returns `{ mode: 'single-account' }`
+ * with no stats since Analytics only collects in pool mode.
+ */
+export interface UsageSummary {
+    mode: 'pool' | 'single-account';
+    reachable: boolean;
+    port?: number;
+    detail?: string;
+    window?: {
+        minutes: number;
+        requests: number;
+        totalInputTokens: number;
+        totalOutputTokens: number;
+        avgLatencyMs: number;
+        errorRate: number;
+        subscriptionPercent: number;
+        estimatedCost: number;
+    };
+    perAccount?: Record<string, {
+        requests: number;
+        subscriptionPercent: number;
+    }>;
+}
 export interface ToolDataSources {
     doctor: () => Promise<Array<{
         status: string;
@@ -58,6 +84,8 @@ export interface ToolDataSources {
         templateSource: string;
         templateSchema: number | null;
     }>;
+    /** Burn-rate / consumption summary; see UsageSummary for the shape. */
+    usage: () => Promise<UsageSummary>;
     darioVersion: () => string;
 }
 export declare function buildToolRegistry(data: ToolDataSources): McpTool[];

package/dist/mcp/tools.js

@@ -131,6 +131,56 @@ export function buildToolRegistry(data) {
                 return textResult(lines.join('\n'));
             },
         },
+        {
+            name: 'usage',
+            description: 'Burn-rate summary of the running dario proxy\'s traffic over the last 60 minutes: requests, token totals, subscription % vs. extra-usage, per-account rotation if pool mode is on. Read-only — fetches /analytics from the local proxy. Returns a compact text summary; pair with the `dario usage --json` CLI for the full /analytics payload.',
+            inputSchema: emptyObjectSchema,
+            handler: async () => {
+                const u = await data.usage();
+                if (!u.reachable) {
+                    const lines = [];
+                    lines.push(`Proxy not reachable on port ${u.port ?? 3456}.`);
+                    if (u.detail)
+                        lines.push(`Detail: ${u.detail}`);
+                    lines.push('');
+                    lines.push('`usage` summarizes traffic from a running proxy. Start `dario proxy`, then re-call.');
+                    lines.push('For a one-off rate-limit snapshot, run `dario doctor --usage` (~1 subscription request).');
+                    return textResult(lines.join('\n'), true);
+                }
+                if (u.mode === 'single-account') {
+                    return textResult([
+                        'Mode: single-account',
+                        '',
+                        'Analytics history is collected only in pool mode (2+ accounts in ~/.dario/accounts/).',
+                        'For a one-off rate-limit snapshot from Anthropic, run `dario doctor --usage`.',
+                    ].join('\n'));
+                }
+                const lines = [];
+                const w = u.window;
+                lines.push('Mode:    pool');
+                lines.push(`Window:  last ${w?.minutes ?? 60} minutes`);
+                lines.push(`Requests:        ${w?.requests ?? 0}`);
+                if (w && w.requests > 0) {
+                    lines.push(`Input tokens:    ${w.totalInputTokens.toLocaleString()}`);
+                    lines.push(`Output tokens:   ${w.totalOutputTokens.toLocaleString()}`);
+                    lines.push(`Avg latency:     ${w.avgLatencyMs} ms`);
+                    if (w.errorRate > 0)
+                        lines.push(`Error rate:      ${(w.errorRate * 100).toFixed(1)}%`);
+                    lines.push(`Subscription %:  ${w.subscriptionPercent}%`);
+                    if (w.estimatedCost > 0)
+                        lines.push(`Est. cost:       $${w.estimatedCost.toFixed(4)} (would-be API cost)`);
+                }
+                if (u.perAccount && Object.keys(u.perAccount).length > 0) {
+                    lines.push('');
+                    lines.push('Per-account:');
+                    const aliasWidth = Math.max(...Object.keys(u.perAccount).map((a) => a.length));
+                    for (const [alias, stats] of Object.entries(u.perAccount)) {
+                        lines.push(`  ${alias.padEnd(aliasWidth)}  ${stats.requests} req${stats.requests === 1 ? '' : 's'}  (${stats.subscriptionPercent}% subscription)`);
+                    }
+                }
+                return textResult(lines.join('\n'));
+            },
+        },
     ];
 }
 /**
@@ -187,9 +237,63 @@ export async function buildDefaultToolRegistry() {
                 templateSchema: tmpl._schemaVersion ?? null,
             };
         },
+        usage: async () => fetchUsage(),
         darioVersion: () => pkgVersion,
     });
 }
+/**
+ * Fetch the local proxy's `/analytics` endpoint and shape it into the
+ * MCP-tool surface. Port resolution mirrors `dario usage`:
+ * DARIO_USAGE_PORT, then DARIO_PORT (proxy's own default-port env), then
+ * 3456. 3-second timeout — we don't block the MCP client on a slow
+ * proxy.
+ *
+ * Failure modes are returned as `{ reachable: false, detail }` rather
+ * than thrown, so the tool handler can present a helpful message
+ * instead of a generic protocol error.
+ */
+async function fetchUsage() {
+    const port = process.env.DARIO_USAGE_PORT
+        ? parseInt(process.env.DARIO_USAGE_PORT, 10)
+        : process.env.DARIO_PORT
+            ? parseInt(process.env.DARIO_PORT, 10)
+            : 3456;
+    try {
+        const res = await fetch(`http://127.0.0.1:${port}/analytics`, { signal: AbortSignal.timeout(3000) });
+        if (!res.ok) {
+            return { mode: 'pool', reachable: false, port, detail: `HTTP ${res.status}` };
+        }
+        const body = await res.json();
+        if (body.mode === 'single-account') {
+            return { mode: 'single-account', reachable: true, port };
+        }
+        const w = body.window;
+        return {
+            mode: 'pool',
+            reachable: true,
+            port,
+            window: {
+                minutes: w?.minutes ?? 60,
+                requests: w?.requests ?? 0,
+                totalInputTokens: w?.totalInputTokens ?? 0,
+                totalOutputTokens: w?.totalOutputTokens ?? 0,
+                avgLatencyMs: w?.avgLatencyMs ?? 0,
+                errorRate: w?.errorRate ?? 0,
+                subscriptionPercent: w?.subscriptionPercent ?? 0,
+                estimatedCost: w?.estimatedCost ?? 0,
+            },
+            perAccount: body.perAccount,
+        };
+    }
+    catch (err) {
+        return {
+            mode: 'pool',
+            reachable: false,
+            port,
+            detail: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
 async function readDarioVersion() {
     try {
         const { readFileSync } = await import('node:fs');

package/dist/proxy.d.ts

@@ -1,4 +1,5 @@
 import { type IncomingMessage } from 'node:http';
+import { type WriteStream } from 'node:fs';
 import { type EffortValue } from './cc-template.js';
 export declare function parseProviderPrefix(model: string): {
     provider: 'openai' | 'claude';
@@ -36,6 +37,15 @@ interface ProxyOptions {
     passthrough?: boolean;
     preserveTools?: boolean;
     hybridTools?: boolean;
+    /**
+     * Merge mode: send CC's canonical tools first, append client tools after
+     * (deduped by name). Mutually exclusive with preserveTools and hybridTools
+     * — proxy startup enforces the mutex. Experimental: Anthropic's billing
+     * classifier may treat the appended tail as a divergence from CC's wire
+     * shape and flip routing. Verify locally with `--verbose` and watch the
+     * billing-bucket line on the first 1-2 requests before relying on it.
+     */
+    mergeTools?: boolean;
     noAutoDetect?: boolean;
     strictTls?: boolean;
     pacingMinMs?: number;
@@ -90,7 +100,64 @@ interface ProxyOptions {
      * their output capacity. dario#88 (Hermes compat).
      */
     maxTokens?: number | 'client';
+    /**
+     * Append-only request log file. One JSON line per completed request,
+     * with secrets scrubbed via redactSecrets. Useful for backgrounded
+     * proxies where stdout is unobserved — `verbose` only helps when you
+     * can watch the foreground. Off by default; opt in with `--log-file`
+     * or `DARIO_LOG_FILE`. Write errors are swallowed (never crash the
+     * request path on a log mishap). dario#XYZ.
+     */
+    logFile?: string;
+    /**
+     * Beta flags to ALWAYS forward upstream regardless of CC's captured
+     * set or the client's anthropic-beta header. Operator declaration
+     * that "I know I want these survived through dario's substitution."
+     * Bypasses `filterBillableBetas`; still respects the per-account
+     * rejected-beta cache (so a flag the upstream 400's gets dropped on
+     * the retry rather than re-sent forever). dario passthrough-betas.
+     *
+     * Sourced from `--passthrough-betas=name1,name2` or
+     * DARIO_PASSTHROUGH_BETAS. Empty / undefined leaves current behavior
+     * unchanged. Surfaced at startup so operators can see exactly which
+     * flags are pinned-on; surfaced again per request when one of the
+     * pinned flags has been rejected and is therefore being dropped.
+     */
+    passthroughBetas?: string[];
 }
+/**
+ * One JSON-ND record per completed request. Field set kept narrow to
+ * stay grep-friendly and avoid leaking content. No request bodies, no
+ * tool args, no headers — those still go through `--verbose-bodies` /
+ * DARIO_LOG_BODIES (which has its own opt-in and is foreground-only).
+ */
+export interface ProxyLogEntry {
+    ts: string;
+    req: number;
+    method: string;
+    path: string;
+    model?: string;
+    status?: number;
+    latency_ms?: number;
+    in_tokens?: number;
+    out_tokens?: number;
+    cache_read?: number;
+    cache_create?: number;
+    claim?: string;
+    bucket?: string;
+    account?: string;
+    client?: string;
+    preserve_tools?: boolean;
+    stream?: boolean;
+    reject?: string;
+    error?: string;
+}
+/**
+ * Append a JSON-ND line to the proxy log file. No-op when stream is
+ * null (logFile not configured). Errors are swallowed — log writes
+ * must never break the request path.
+ */
+export declare function writeLogLine(stream: WriteStream | null, entry: ProxyLogEntry): void;
 export declare function sanitizeError(err: unknown): string;
 /**
  * API-key auth via DARIO_API_KEY (x-api-key or Authorization: Bearer).