maqcli 0.2.0

package/dist/core/complexity.js

@@ -0,0 +1,87 @@
+/**
+ * Task complexity classifier (deterministic, zero-token).
+ *
+ * Used to gate the cost/quality dial: trivial tasks skip the Scout+Plan phases
+ * and go straight to Execute; complex tasks get the full pipeline. This is the
+ * lever that keeps multi-agent overhead (which can reach ~15x single-turn
+ * tokens) from being paid on work that does not need it.
+ */
+const COMPLEX_SIGNALS = [
+    "refactor",
+    "architecture",
+    "redesign",
+    "migrate",
+    "migration",
+    "across",
+    "multiple files",
+    "whole",
+    "entire",
+    "everything",
+    "improve the codebase",
+    "optimize",
+    "security",
+    "concurrency",
+    "distributed",
+    "design",
+];
+const TRIVIAL_SIGNALS = [
+    "typo",
+    "rename",
+    "bump version",
+    "add a comment",
+    "fix the comment",
+    "update the readme",
+    "change the string",
+    "one line",
+    "single line",
+];
+export function classifyComplexity(task, fileHints = []) {
+    const t = task.toLowerCase();
+    const reasons = [];
+    let score = 0;
+    for (const s of TRIVIAL_SIGNALS) {
+        if (t.includes(s)) {
+            score -= 2;
+            reasons.push(`trivial signal: "${s}"`);
+        }
+    }
+    for (const s of COMPLEX_SIGNALS) {
+        if (t.includes(s)) {
+            score += 2;
+            reasons.push(`complex signal: "${s}"`);
+        }
+    }
+    // Length is a weak proxy for scope.
+    const words = t.split(/\s+/).filter(Boolean).length;
+    if (words > 40) {
+        score += 2;
+        reasons.push("long task description");
+    }
+    else if (words <= 8) {
+        score -= 1;
+        reasons.push("short task description");
+    }
+    // Touching many files => complex; exactly one scoped file => simpler.
+    if (fileHints.length > 3) {
+        score += 2;
+        reasons.push(`${fileHints.length} files in scope`);
+    }
+    else if (fileHints.length === 1) {
+        score -= 1;
+        reasons.push("single scoped file");
+    }
+    let complexity;
+    // Trivial requires a genuinely low score (typically an explicit trivial
+    // signal), not just an accumulation of weak proxies like "short + one file".
+    if (score <= -3)
+        complexity = "trivial";
+    else if (score >= 3)
+        complexity = "complex";
+    else
+        complexity = "standard";
+    return { complexity, score, reasons };
+}
+/** Whether the Scout+Plan pre-flight phases should run for this complexity. */
+export function shouldRunPreflight(complexity) {
+    return complexity !== "trivial";
+}

package/dist/core/config-store.d.ts

@@ -0,0 +1,33 @@
+/** Persistent config store at ~/.maqcli/config.json (dependency-free). */
+export interface MaqConfig {
+    /** The lightest / user-chosen model the master uses for Scout/Plan/Verify. */
+    masterModel: string;
+    /** Default worker target: auto | claude | codex | gemini | none */
+    defaultTarget: string;
+    /** Provider for the master model. "heuristic" runs fully offline. */
+    provider: string;
+    /** RouteLLM-style tier models: cheap for triage, strong for hard steps. */
+    cheapModel: string;
+    strongModel: string;
+    /** Directory (relative to cwd) holding project skill/rule .md files. */
+    skillsDir: string;
+    /** Extended-thinking effort hint for providers that support it. */
+    thinkingEffort: string;
+    /** Write run artifacts + a hash-chained audit log for every run. */
+    auditRuns: boolean;
+    /** Optional outbound webhook URL for event forwarding (plugins). */
+    webhookUrl: string;
+    /** Proactive compaction threshold (fraction of context). */
+    compactionThreshold: number;
+    /** Per-project remembered target choices, keyed by cwd. */
+    projectTargets: Record<string, string>;
+    /** Default permission level (strict or standard) */
+    defaultPermission: string;
+}
+export declare const DEFAULT_CONFIG: MaqConfig;
+export declare function configDir(): string;
+export declare function configPath(): string;
+export declare function loadConfig(): MaqConfig;
+export declare function saveConfig(cfg: MaqConfig): void;
+/** Set a single top-level scalar key by string, coercing to the existing type. */
+export declare function setConfigKey(key: string, value: string): MaqConfig;

package/dist/core/config-store.js

@@ -0,0 +1,61 @@
+/** Persistent config store at ~/.maqcli/config.json (dependency-free). */
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+export const DEFAULT_CONFIG = {
+    masterModel: "heuristic-local",
+    defaultTarget: "auto",
+    provider: "heuristic",
+    cheapModel: "heuristic-local",
+    strongModel: "heuristic-local",
+    skillsDir: ".maq/skills",
+    thinkingEffort: "high",
+    auditRuns: false,
+    webhookUrl: "",
+    compactionThreshold: 0.6,
+    projectTargets: {},
+    defaultPermission: "standard",
+};
+export function configDir() {
+    return process.env.MAQ_CONFIG_DIR ?? join(homedir(), ".maqcli");
+}
+export function configPath() {
+    return join(configDir(), "config.json");
+}
+export function loadConfig() {
+    const p = configPath();
+    if (!existsSync(p))
+        return { ...DEFAULT_CONFIG };
+    try {
+        const raw = JSON.parse(readFileSync(p, "utf8"));
+        return { ...DEFAULT_CONFIG, ...raw };
+    }
+    catch {
+        return { ...DEFAULT_CONFIG };
+    }
+}
+export function saveConfig(cfg) {
+    const dir = configDir();
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    writeFileSync(configPath(), JSON.stringify(cfg, null, 2), "utf8");
+}
+/** Set a single top-level scalar key by string, coercing to the existing type. */
+export function setConfigKey(key, value) {
+    const cfg = loadConfig();
+    const current = cfg[key];
+    if (current === undefined) {
+        throw new Error(`Unknown config key: ${key}`);
+    }
+    let coerced = value;
+    if (typeof current === "number")
+        coerced = Number(value);
+    if (typeof current === "boolean")
+        coerced = value === "true";
+    if (typeof current === "object") {
+        throw new Error(`Cannot set object key '${key}' from the CLI`);
+    }
+    cfg[key] = coerced;
+    saveConfig(cfg);
+    return cfg;
+}

package/dist/core/connectivity.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Connectivity tier selection (pure decision logic).
+ *
+ * Mirrors the product's automatic fallback chain:
+ *   LAN (mDNS, lowest latency) -> P2P (WebRTC + STUN) -> relay/tunnel -> warn.
+ * The actual transports live in the native tracks; this module encodes the
+ * decision so it can be unit-tested and reused by daemon and app alike.
+ */
+export type Tier = "lan" | "p2p" | "relay" | "blocked";
+export interface NetworkObservation {
+    /** A candidate peer was found on the local network (mDNS/Bonjour). */
+    lanPeerFound: boolean;
+    /** Round-trip latency to the LAN peer, if measured (ms). */
+    lanLatencyMs?: number;
+    /** WebRTC ICE reached a direct P2P connection (STUN succeeded). */
+    p2pConnected: boolean;
+    /** A relay/tunnel path (Cloudflare Tunnel / Tailscale DERP) is available. */
+    relayAvailable: boolean;
+    /** Relay round-trip latency, if known (ms). */
+    relayLatencyMs?: number;
+    /** ICE stuck in "checking"/"failed" => strict/symmetric NAT suspected. */
+    symmetricNatSuspected: boolean;
+    /** User has premium (TURN relay) entitlement. */
+    premium: boolean;
+}
+export interface TierDecision {
+    tier: Tier;
+    reason: string;
+    /** High-latency advisory the UI should surface. */
+    latencyWarning: boolean;
+    /** Whether to show the "strict network -> go premium" upsell. */
+    upsell: boolean;
+}
+export declare function selectTier(obs: NetworkObservation): TierDecision;

package/dist/core/connectivity.js

@@ -0,0 +1,49 @@
+/**
+ * Connectivity tier selection (pure decision logic).
+ *
+ * Mirrors the product's automatic fallback chain:
+ *   LAN (mDNS, lowest latency) -> P2P (WebRTC + STUN) -> relay/tunnel -> warn.
+ * The actual transports live in the native tracks; this module encodes the
+ * decision so it can be unit-tested and reused by daemon and app alike.
+ */
+const HIGH_LATENCY_MS = 300;
+export function selectTier(obs) {
+    // 1. Same room / LAN: lowest latency, no internet required.
+    if (obs.lanPeerFound) {
+        return {
+            tier: "lan",
+            reason: "LAN peer discovered via mDNS",
+            latencyWarning: (obs.lanLatencyMs ?? 0) > HIGH_LATENCY_MS,
+            upsell: false,
+        };
+    }
+    // 2. Direct P2P via WebRTC + STUN.
+    if (obs.p2pConnected) {
+        return {
+            tier: "p2p",
+            reason: "direct P2P established (STUN)",
+            latencyWarning: false,
+            upsell: false,
+        };
+    }
+    // 3. Relay / tunnel fallback. Free-tier users get pass-through/DERP; if a
+    //    symmetric NAT blocked P2P and no free relay works, premium TURN is the fix.
+    if (obs.relayAvailable) {
+        return {
+            tier: "relay",
+            reason: "P2P unavailable; using relay/tunnel",
+            latencyWarning: (obs.relayLatencyMs ?? 0) > HIGH_LATENCY_MS,
+            upsell: false,
+        };
+    }
+    // 4. Blocked. If a strict/symmetric NAT is the cause and the user is not
+    //    premium, surface the premium TURN upsell instead of an infinite spinner.
+    return {
+        tier: "blocked",
+        reason: obs.symmetricNatSuspected
+            ? "strict/symmetric NAT blocked direct connection and no relay available"
+            : "no connectivity path available",
+        latencyWarning: false,
+        upsell: obs.symmetricNatSuspected && !obs.premium,
+    };
+}

package/dist/core/cost-tracker.d.ts

@@ -0,0 +1,89 @@
+/**
+ * @module cost-tracker
+ * @description Aggregated cost tracking across maq runs.
+ *
+ * Persists individual cost entries to `<cwd>/.maq/costs.jsonl` and
+ * provides reporting aggregated by model and day.
+ *
+ * Zero npm dependencies — uses only Node built-ins.
+ */
+/** A single cost-tracking entry written per LLM call or task. */
+export interface CostEntry {
+    /** ISO-8601 timestamp of the call. */
+    ts: string;
+    /** Unique identifier for the parent task. */
+    taskId: string;
+    /** Human-readable task description. */
+    task: string;
+    /** LLM provider name (e.g. "openai", "anthropic"). */
+    provider: string;
+    /** Model identifier (e.g. "gpt-4o", "claude-3-opus"). */
+    model: string;
+    /** Number of API calls represented by this entry. */
+    calls: number;
+    /** Prompt / input tokens consumed. */
+    promptTokens: number;
+    /** Completion / output tokens produced. */
+    completionTokens: number;
+    /** Total tokens (prompt + completion). */
+    totalTokens: number;
+    /** Estimated cost in US dollars. */
+    usd: number;
+}
+/** Aggregated cost report produced by {@link CostTracker.report}. */
+export interface CostReport {
+    totalUsd: number;
+    totalTokens: number;
+    totalCalls: number;
+    byModel: Record<string, {
+        usd: number;
+        tokens: number;
+        calls: number;
+    }>;
+    byDay: Record<string, {
+        usd: number;
+        tokens: number;
+        calls: number;
+    }>;
+    entries: CostEntry[];
+}
+/**
+ * Tracks and reports LLM usage costs across maq runs.
+ *
+ * Data is persisted as newline-delimited JSON (JSONL) at
+ * `<cwd>/.maq/costs.jsonl`.
+ */
+export declare class CostTracker {
+    private readonly filePath;
+    /**
+     * @param cwd - The project working directory containing the `.maq/` folder.
+     */
+    constructor(cwd: string);
+    /**
+     * Appends a cost entry as a single JSON line.
+     * Creates the parent directory if it does not exist.
+     */
+    record(entry: CostEntry): void;
+    /**
+     * Deletes the cost ledger file (if it exists).
+     */
+    reset(): void;
+    /**
+     * Reads all recorded entries and produces an aggregated {@link CostReport}.
+     *
+     * Returns a zero-value report when the file is missing or empty.
+     */
+    report(): CostReport;
+    /**
+     * Formats a {@link CostReport} into a human-readable multi-section string.
+     *
+     * Sections: **Total**, **By model**, **By day**, **Recent runs**.
+     */
+    static renderReport(report: CostReport): string;
+    /**
+     * Reads and parses the JSONL ledger file.
+     * Returns an empty array if the file is missing, empty, or contains
+     * only malformed lines (which are silently skipped).
+     */
+    private _readEntries;
+}

package/dist/core/cost-tracker.js

@@ -0,0 +1,189 @@
+/**
+ * @module cost-tracker
+ * @description Aggregated cost tracking across maq runs.
+ *
+ * Persists individual cost entries to `<cwd>/.maq/costs.jsonl` and
+ * provides reporting aggregated by model and day.
+ *
+ * Zero npm dependencies — uses only Node built-ins.
+ */
+import { appendFileSync, existsSync, mkdirSync, readFileSync, unlinkSync, } from "node:fs";
+import { dirname, join } from "node:path";
+/* ------------------------------------------------------------------ */
+/*  Helpers                                                            */
+/* ------------------------------------------------------------------ */
+/** Extracts the YYYY-MM-DD date portion from an ISO timestamp. */
+function dayKey(ts) {
+    return ts.slice(0, 10);
+}
+/**
+ * Pads or truncates `str` to exactly `len` characters, right-aligned
+ * when `align` is `"right"`, left-aligned otherwise.
+ */
+function pad(str, len, align = "left") {
+    if (align === "right") {
+        return str.padStart(len);
+    }
+    return str.padEnd(len);
+}
+/** Formats a USD amount to four decimal places with a `$` prefix. */
+function fmtUsd(usd) {
+    return `$${usd.toFixed(4)}`;
+}
+/** Formats a number with locale-aware thousands separators. */
+function fmtNum(n) {
+    return n.toLocaleString("en-US");
+}
+/* ------------------------------------------------------------------ */
+/*  CostTracker                                                        */
+/* ------------------------------------------------------------------ */
+/**
+ * Tracks and reports LLM usage costs across maq runs.
+ *
+ * Data is persisted as newline-delimited JSON (JSONL) at
+ * `<cwd>/.maq/costs.jsonl`.
+ */
+export class CostTracker {
+    filePath;
+    /**
+     * @param cwd - The project working directory containing the `.maq/` folder.
+     */
+    constructor(cwd) {
+        this.filePath = join(cwd, ".maq", "costs.jsonl");
+    }
+    /* ── Mutation ─────────────────────────────────────────────────── */
+    /**
+     * Appends a cost entry as a single JSON line.
+     * Creates the parent directory if it does not exist.
+     */
+    record(entry) {
+        const dir = dirname(this.filePath);
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+        appendFileSync(this.filePath, JSON.stringify(entry) + "\n", "utf-8");
+    }
+    /**
+     * Deletes the cost ledger file (if it exists).
+     */
+    reset() {
+        if (existsSync(this.filePath)) {
+            unlinkSync(this.filePath);
+        }
+    }
+    /* ── Reporting ────────────────────────────────────────────────── */
+    /**
+     * Reads all recorded entries and produces an aggregated {@link CostReport}.
+     *
+     * Returns a zero-value report when the file is missing or empty.
+     */
+    report() {
+        const entries = this._readEntries();
+        let totalUsd = 0;
+        let totalTokens = 0;
+        let totalCalls = 0;
+        const byModel = {};
+        const byDay = {};
+        for (const e of entries) {
+            totalUsd += e.usd;
+            totalTokens += e.totalTokens;
+            totalCalls += e.calls;
+            // Aggregate by model
+            const m = byModel[e.model] ??= { usd: 0, tokens: 0, calls: 0 };
+            m.usd += e.usd;
+            m.tokens += e.totalTokens;
+            m.calls += e.calls;
+            // Aggregate by day
+            const dk = dayKey(e.ts);
+            const d = byDay[dk] ??= { usd: 0, tokens: 0, calls: 0 };
+            d.usd += e.usd;
+            d.tokens += e.totalTokens;
+            d.calls += e.calls;
+        }
+        // Sort entries newest-first
+        const sorted = [...entries].sort((a, b) => new Date(b.ts).getTime() - new Date(a.ts).getTime());
+        return { totalUsd, totalTokens, totalCalls, byModel, byDay, entries: sorted };
+    }
+    /* ── Static rendering ─────────────────────────────────────────── */
+    /**
+     * Formats a {@link CostReport} into a human-readable multi-section string.
+     *
+     * Sections: **Total**, **By model**, **By day**, **Recent runs**.
+     */
+    static renderReport(report) {
+        const lines = [];
+        /* ── Total ───────────────────────────────────────────────── */
+        lines.push("┌─────────────────────────────────────────┐");
+        lines.push("│  Cost Report                            │");
+        lines.push("├─────────────────────────────────────────┤");
+        lines.push(`│  Total cost:   ${pad(fmtUsd(report.totalUsd), 24, "right")} │`);
+        lines.push(`│  Total tokens: ${pad(fmtNum(report.totalTokens), 24, "right")} │`);
+        lines.push(`│  Total calls:  ${pad(fmtNum(report.totalCalls), 24, "right")} │`);
+        lines.push("└─────────────────────────────────────────┘");
+        lines.push("");
+        /* ── By model ────────────────────────────────────────────── */
+        const modelKeys = Object.keys(report.byModel).sort();
+        if (modelKeys.length > 0) {
+            lines.push("  By model:");
+            for (const model of modelKeys) {
+                const m = report.byModel[model];
+                lines.push(`    ${pad(model, 24)} ${pad(fmtUsd(m.usd), 12, "right")}  ${pad(fmtNum(m.tokens) + " tok", 16, "right")}  ${pad(String(m.calls) + " calls", 10, "right")}`);
+            }
+            lines.push("");
+        }
+        /* ── By day ──────────────────────────────────────────────── */
+        const dayKeys = Object.keys(report.byDay).sort().reverse();
+        if (dayKeys.length > 0) {
+            lines.push("  By day:");
+            for (const day of dayKeys) {
+                const d = report.byDay[day];
+                lines.push(`    ${day}   ${pad(fmtUsd(d.usd), 12, "right")}  ${pad(fmtNum(d.tokens) + " tok", 16, "right")}  ${pad(String(d.calls) + " calls", 10, "right")}`);
+            }
+            lines.push("");
+        }
+        /* ── Recent runs ─────────────────────────────────────────── */
+        const recent = report.entries.slice(0, 10);
+        if (recent.length > 0) {
+            lines.push("  Recent runs:");
+            for (const e of recent) {
+                const ts = e.ts.slice(0, 19).replace("T", " ");
+                const desc = e.task.length > 30 ? e.task.slice(0, 27) + "..." : e.task;
+                lines.push(`    ${ts}  ${pad(desc, 30)}  ${pad(e.model, 18)}  ${pad(fmtUsd(e.usd), 10, "right")}`);
+            }
+            lines.push("");
+        }
+        if (report.entries.length === 0) {
+            lines.push("  No cost data recorded yet.");
+            lines.push("");
+        }
+        return lines.join("\n");
+    }
+    /* ── Private ──────────────────────────────────────────────────── */
+    /**
+     * Reads and parses the JSONL ledger file.
+     * Returns an empty array if the file is missing, empty, or contains
+     * only malformed lines (which are silently skipped).
+     */
+    _readEntries() {
+        if (!existsSync(this.filePath)) {
+            return [];
+        }
+        const raw = readFileSync(this.filePath, "utf-8");
+        if (!raw.trim()) {
+            return [];
+        }
+        const entries = [];
+        for (const line of raw.split("\n")) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            try {
+                entries.push(JSON.parse(trimmed));
+            }
+            catch {
+                // Skip malformed lines gracefully
+            }
+        }
+        return entries;
+    }
+}

package/dist/core/cost.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Token / cost accounting (LiteLLM-style spend visibility, dependency-free).
+ *
+ * Prices are USD per 1,000,000 tokens and are ESTIMATES for budgeting only —
+ * they change over time and per-region. Override any of them at runtime via
+ * `MAQ_PRICES` (a JSON map of "model" -> { in, out }) or programmatically with
+ * `setPrice`. Unknown models cost $0 (est) so accounting never throws.
+ */
+export interface Price {
+    /** USD per 1M input/prompt tokens. */
+    in: number;
+    /** USD per 1M output/completion tokens. */
+    out: number;
+}
+/** Register or override a model price at runtime. */
+export declare function setPrice(model: string, price: Price): void;
+/** Look up the price for a model by longest-prefix match; $0 if unknown. */
+export declare function priceFor(model: string): Price;
+/** Compute USD cost for a completed call. Ollama/local models are free. */
+export declare function costUsd(model: string, promptTokens: number, completionTokens: number): number;
+/** Running spend accumulator. Thread one through a pipeline/session. */
+export declare class CostMeter {
+    private _promptTokens;
+    private _completionTokens;
+    private _usd;
+    private _calls;
+    record(model: string, promptTokens: number, completionTokens: number): void;
+    get summary(): {
+        calls: number;
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+        usd: number;
+    };
+}

package/dist/core/cost.js

@@ -0,0 +1,89 @@
+/**
+ * Token / cost accounting (LiteLLM-style spend visibility, dependency-free).
+ *
+ * Prices are USD per 1,000,000 tokens and are ESTIMATES for budgeting only —
+ * they change over time and per-region. Override any of them at runtime via
+ * `MAQ_PRICES` (a JSON map of "model" -> { in, out }) or programmatically with
+ * `setPrice`. Unknown models cost $0 (est) so accounting never throws.
+ */
+/**
+ * Built-in price table (USD / 1M tokens). Estimates as of 2026; treat as
+ * defaults, not billing truth. Keyed by a normalized model name prefix.
+ */
+const DEFAULT_PRICES = {
+    // OpenAI
+    "gpt-4o-mini": { in: 0.15, out: 0.6 },
+    "gpt-4o": { in: 2.5, out: 10 },
+    "gpt-4.1-mini": { in: 0.4, out: 1.6 },
+    "gpt-4.1": { in: 2, out: 8 },
+    "o4-mini": { in: 1.1, out: 4.4 },
+    // Anthropic
+    "claude-haiku": { in: 0.8, out: 4 },
+    "claude-3-5-haiku": { in: 0.8, out: 4 },
+    "claude-sonnet": { in: 3, out: 15 },
+    "claude-3-5-sonnet": { in: 3, out: 15 },
+    "claude-opus": { in: 15, out: 75 },
+    // Local / offline
+    "heuristic": { in: 0, out: 0 },
+    "heuristic-local": { in: 0, out: 0 },
+    "ollama": { in: 0, out: 0 },
+};
+const overrides = loadEnvPrices();
+function loadEnvPrices() {
+    const raw = process.env.MAQ_PRICES;
+    if (!raw)
+        return {};
+    try {
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed === "object" ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+/** Register or override a model price at runtime. */
+export function setPrice(model, price) {
+    overrides[model.toLowerCase()] = price;
+}
+/** Look up the price for a model by longest-prefix match; $0 if unknown. */
+export function priceFor(model) {
+    const key = model.toLowerCase();
+    if (overrides[key])
+        return overrides[key];
+    // Longest matching known prefix wins (so "claude-3-5-haiku-20241022" -> haiku).
+    const table = { ...DEFAULT_PRICES, ...overrides };
+    let best = null;
+    for (const [name, price] of Object.entries(table)) {
+        if (key.includes(name) && (!best || name.length > best.len)) {
+            best = { len: name.length, price };
+        }
+    }
+    return best?.price ?? { in: 0, out: 0 };
+}
+/** Compute USD cost for a completed call. Ollama/local models are free. */
+export function costUsd(model, promptTokens, completionTokens) {
+    const p = priceFor(model);
+    return (promptTokens / 1e6) * p.in + (completionTokens / 1e6) * p.out;
+}
+/** Running spend accumulator. Thread one through a pipeline/session. */
+export class CostMeter {
+    _promptTokens = 0;
+    _completionTokens = 0;
+    _usd = 0;
+    _calls = 0;
+    record(model, promptTokens, completionTokens) {
+        this._promptTokens += promptTokens;
+        this._completionTokens += completionTokens;
+        this._usd += costUsd(model, promptTokens, completionTokens);
+        this._calls += 1;
+    }
+    get summary() {
+        return {
+            calls: this._calls,
+            promptTokens: this._promptTokens,
+            completionTokens: this._completionTokens,
+            totalTokens: this._promptTokens + this._completionTokens,
+            usd: Number(this._usd.toFixed(6)),
+        };
+    }
+}