letmecode 0.1.20 → 0.1.22

package/ink-app/dist/providers/copilot/provider.js

@@ -0,0 +1,259 @@
+import os from "node:os";
+import path from "node:path";
+import { UsageProviderBase, createEmptyUsageTotals } from "../contract.js";
+import { configureCopilotVsCodeLogging, getCopilotCliOtelEnv, getConfiguredCopilotOutfiles } from "./otel/configure.js";
+import { discoverCopilotOtelFiles } from "./otel/discover.js";
+import { parseCopilotOtelFiles } from "./otel/parse.js";
+import { getCopilotUserInfo, subtractOneUtcCalendarMonth } from "./quota.js";
+import { aggregateCopilotUsage, filterCopilotUsageEvents } from "./usage/aggregate.js";
+// The token-metered bucket that maps to the "AI Credits" window.
+const AI_CREDITS_QUOTA_ID = "premium_interactions";
+export { configureCopilotVsCodeLogging, getCopilotCliOtelEnv };
+// Quota buckets shown as the most prominent (primary) limit windows.
+const PRIMARY_QUOTA_IDS = new Set([
+    "premium_interactions",
+    "chat",
+    "completions"
+]);
+/**
+ * Joins two INDEPENDENT sources — the Copilot quota HTTP API and local OTEL
+ * JSONL token usage. A failure in either degrades to a warning and never blocks
+ * the other.
+ */
+export class CopilotUsageProvider extends UsageProviderBase {
+    constructor(options = {}) {
+        super("copilot", "Copilot");
+        this.root = path.resolve(options.root ?? os.homedir());
+        this.env = options.env ?? process.env;
+        this.fetchUserInfo = options.fetchUserInfo ?? getCopilotUserInfo;
+    }
+    async getStats(_options = {}) {
+        const [quotaResult, usageResult] = await Promise.allSettled([
+            this.fetchUserInfo({ env: this.env }),
+            this.loadUsage()
+        ]);
+        const warnings = [];
+        let quotaInfo;
+        if (quotaResult.status === "fulfilled") {
+            warnings.push(...quotaResult.value.warnings);
+            quotaInfo = quotaResult.value.quotaInfo;
+        }
+        else {
+            warnings.push("Copilot plan and quota are unavailable.");
+        }
+        const usage = usageResult.status === "fulfilled"
+            ? usageResult.value
+            : {
+                filesScanned: 0,
+                linesRead: 0,
+                events: [],
+                aggregated: aggregateCopilotUsage([]),
+                warnings: ["Copilot OTEL usage is unavailable."]
+            };
+        warnings.push(...usage.warnings);
+        const { windows, unknownLabels, windowWarnings } = quotaInfo
+            ? buildLimitWindows(quotaInfo, usage.events)
+            : { windows: [], unknownLabels: [], windowWarnings: [] };
+        if (unknownLabels.length > 0) {
+            warnings.push(`Copilot quota usage is unknown for: ${unknownLabels.join(", ")}.`);
+        }
+        warnings.push(...windowWarnings);
+        const { aggregated } = usage;
+        return {
+            providerId: this.id,
+            providerLabel: this.label,
+            summary: {
+                filesScanned: usage.filesScanned,
+                linesRead: usage.linesRead,
+                tokenEvents: aggregated.tokenEvents,
+                totals: aggregated.summaryTotals,
+                distinctModels: aggregated.distinctModels,
+                distinctPlanTypes: quotaInfo?.plan ? [quotaInfo.plan] : [],
+                rootLabel: "~/.copilot/otel",
+                rootPath: path.join(this.root, ".copilot", "otel")
+            },
+            modelUsage: aggregated.modelUsage,
+            dayUsage: aggregated.dayUsage,
+            primaryLimitWindows: windows.filter((w) => w.scope === "primary"),
+            secondaryLimitWindows: windows.filter((w) => w.scope === "secondary"),
+            warnings: dedupeWarnings(warnings)
+        };
+    }
+    /** Discover → parse → aggregate local OTEL usage, collecting warnings. */
+    async loadUsage() {
+        const discovery = await discoverCopilotOtelFiles({ root: this.root, env: this.env });
+        const parsed = await parseCopilotOtelFiles(discovery.files);
+        const aggregated = aggregateCopilotUsage(parsed.events);
+        const warnings = [...discovery.warnings, ...parsed.warnings];
+        if (parsed.malformedLines > 0) {
+            warnings.push(`Skipped ${parsed.malformedLines} malformed Copilot JSONL line(s).`);
+        }
+        if (discovery.files.length === 0) {
+            warnings.push((await describeMissingOtelFile(this.root)) ?? "No Copilot OTEL files were found.");
+        }
+        else if (aggregated.tokenEvents === 0) {
+            warnings.push("No Copilot token usage events were found in the discovered OTEL file(s).");
+        }
+        return {
+            filesScanned: parsed.filesScanned,
+            linesRead: parsed.linesRead,
+            events: parsed.events,
+            aggregated,
+            warnings
+        };
+    }
+}
+/**
+ * When no OTEL files were discovered but VS Code is configured to export to one,
+ * surface the actionable "logging is on, file not created yet" hint.
+ */
+async function describeMissingOtelFile(root) {
+    let configured;
+    try {
+        configured = await getConfiguredCopilotOutfiles(root);
+    }
+    catch {
+        return undefined;
+    }
+    const missing = configured.find((entry) => entry.enabled);
+    return missing
+        ? `VS Code Copilot logging is enabled, but ${missing.path} has not been created yet. Reload VS Code and send a Copilot Chat request.`
+        : undefined;
+}
+function buildLimitWindows(quotaInfo, events) {
+    const planType = quotaInfo.plan ?? "unknown";
+    const billing = deriveBillingWindow(quotaInfo.resetAt);
+    const windows = [];
+    const unknownLabels = [];
+    const windowWarnings = [];
+    for (const quota of quotaInfo.quotas) {
+        // Unlimited buckets (e.g. chat/completions on paid plans) are not limits, so
+        // they get no window and no "unknown" warning.
+        if (quota.unlimited) {
+            continue;
+        }
+        const usedPercent = usedPercentOf(quota);
+        // LimitWindowRow cannot represent an unknown percent without showing a false
+        // 0%, so an unusable bucket is omitted and reported as a warning instead.
+        if (usedPercent === undefined) {
+            unknownLabels.push(quota.label);
+            continue;
+        }
+        const isAiCredits = quotaInfo.tokenBasedBilling === true && quota.id === AI_CREDITS_QUOTA_ID;
+        const startIso = billing ? billing.startIso : resolveResetIso(quotaInfo.resetAt);
+        const endIso = billing ? billing.endIso : startIso;
+        const windowMinutes = billing ? billing.windowMinutes : 0;
+        let totals = createEmptyUsageTotals();
+        let modelUsage = [];
+        let eventCount = 0;
+        let firstSeenIso = startIso;
+        let lastSeenIso = startIso;
+        // For the metered AI Credits bucket, join the official percentage with the
+        // local OTEL token usage that falls inside this billing window.
+        if (isAiCredits && billing) {
+            const windowEvents = filterCopilotUsageEvents(events, billing.startMs, billing.endMs);
+            const windowUsage = aggregateCopilotUsage(windowEvents);
+            totals = windowUsage.summaryTotals;
+            modelUsage = windowUsage.modelUsage;
+            eventCount = windowUsage.tokenEvents;
+            if (windowEvents.length > 0) {
+                const times = windowEvents.map((event) => event.timestampMs);
+                firstSeenIso = new Date(Math.min(...times)).toISOString();
+                lastSeenIso = new Date(Math.max(...times)).toISOString();
+                // Some Copilot surfaces export no cache token attributes; without them
+                // the API-equivalent cost cannot be computed, so say so explicitly
+                // instead of presenting a misleading number.
+                if (totals.cacheReadStatus === "unavailable" ||
+                    totals.cacheWriteStatus === "unavailable") {
+                    windowWarnings.push("Copilot did not report cache token counts for some events, so the API-equivalent cost cannot be estimated exactly.");
+                }
+            }
+            else if (officialUsageIsPositive(quota)) {
+                // GitHub reports consumption but local telemetry has no matching events.
+                // Don't present a trusted $0 — mark the cost unknown and warn.
+                totals = {
+                    ...totals,
+                    estimatedCreditsStatus: "unavailable",
+                    cacheReadStatus: "unavailable",
+                    cacheWriteStatus: "unavailable"
+                };
+                windowWarnings.push("Copilot reports usage in the current billing period, but no matching local OTEL events were found. Local token totals are incomplete.");
+            }
+        }
+        windows.push({
+            scope: PRIMARY_QUOTA_IDS.has(quota.id) ? "primary" : "secondary",
+            planType,
+            limitId: quota.id,
+            modelType: isAiCredits ? "AI Credits" : quota.label,
+            windowMinutes,
+            startTimeUtcIso: startIso,
+            endTimeUtcIso: endIso,
+            firstSeenUtcIso: firstSeenIso,
+            lastSeenUtcIso: lastSeenIso,
+            minUsedPercent: usedPercent,
+            maxUsedPercent: usedPercent,
+            totals,
+            modelUsage,
+            eventCount
+        });
+    }
+    return { windows, unknownLabels, windowWarnings };
+}
+/**
+ * Copilot's monthly subscriber quota always resets on the 1st at 00:00 UTC, so
+ * the current window is [1st of the previous month, 1st of the reset month).
+ * Returns null when no/invalid reset date is available.
+ */
+function deriveBillingWindow(resetAt) {
+    if (!resetAt) {
+        return null;
+    }
+    const resetMs = Date.parse(resetAt);
+    if (!Number.isFinite(resetMs)) {
+        return null;
+    }
+    const reset = new Date(resetMs);
+    const end = new Date(Date.UTC(reset.getUTCFullYear(), reset.getUTCMonth(), 1));
+    const start = subtractOneUtcCalendarMonth(end);
+    const startMs = start.getTime();
+    const endMs = end.getTime();
+    return {
+        startMs,
+        endMs,
+        startIso: start.toISOString(),
+        endIso: end.toISOString(),
+        windowMinutes: (endMs - startMs) / 60000
+    };
+}
+function officialUsageIsPositive(quota) {
+    return ((quota.used !== undefined && quota.used > 0) ||
+        (quota.usedPercent !== undefined && quota.usedPercent > 0));
+}
+/** The used percent when derivable from valid data, otherwise undefined. */
+function usedPercentOf(quota) {
+    if (quota.usedPercent !== undefined) {
+        return clampPercent(quota.usedPercent);
+    }
+    if (quota.remainingPercent !== undefined) {
+        return clampPercent(100 - quota.remainingPercent);
+    }
+    if (quota.total !== undefined && quota.total > 0 && quota.used !== undefined) {
+        return clampPercent((quota.used / quota.total) * 100);
+    }
+    return undefined;
+}
+function resolveResetIso(resetAt) {
+    if (resetAt) {
+        const parsed = Date.parse(resetAt);
+        if (Number.isFinite(parsed)) {
+            return new Date(parsed).toISOString();
+        }
+    }
+    return new Date(0).toISOString();
+}
+function clampPercent(value) {
+    return Number.isFinite(value) ? Math.min(100, Math.max(0, value)) : 0;
+}
+function dedupeWarnings(warnings) {
+    return [...new Set(warnings)];
+}

package/ink-app/dist/providers/copilot/quota.js

@@ -0,0 +1,257 @@
+import { execFile } from "node:child_process";
+import { asRecord } from "../limits.js";
+/**
+ * Resolve a GitHub token and fetch the Copilot quota/plan. The token is never
+ * echoed into the result or warnings. Token resolution and the HTTP fetch are
+ * injectable so tests run fully offline. A missing token is not an error — it
+ * yields a warning and no quota, leaving local OTEL usage unaffected.
+ */
+export async function getCopilotUserInfo(options) {
+    const env = options?.env ?? process.env;
+    const resolveToken = options?.resolveToken ?? resolveGitHubToken;
+    const fetchUser = options?.fetchUser ?? getCopilotUser;
+    const token = await resolveToken(env);
+    if (!token) {
+        return {
+            warnings: [
+                "Copilot plan and quota are unavailable: no GitHub token found. " +
+                    "Set GH_TOKEN or GITHUB_TOKEN, or install GitHub CLI and run `gh auth login`."
+            ]
+        };
+    }
+    const result = await fetchUser(token);
+    if (!result.ok) {
+        return { warnings: [result.warning] };
+    }
+    return { quotaInfo: parseCopilotQuota(result.data), warnings: [] };
+}
+// ────────────────────────────────────────────────────────────────────────────
+// Token resolution: GH_TOKEN → GITHUB_TOKEN → `gh auth token`
+// ────────────────────────────────────────────────────────────────────────────
+const GH_TIMEOUT_MS = 2000;
+async function resolveGitHubToken(env) {
+    const fromEnv = nonEmpty(env.GH_TOKEN) ?? nonEmpty(env.GITHUB_TOKEN);
+    if (fromEnv) {
+        return fromEnv;
+    }
+    return ghAuthToken();
+}
+function ghAuthToken() {
+    return new Promise((resolve) => {
+        execFile("gh", ["auth", "token"], { timeout: GH_TIMEOUT_MS }, (error, stdout) => {
+            resolve(error ? null : nonEmpty(stdout));
+        });
+    });
+}
+function nonEmpty(value) {
+    const trimmed = value?.trim();
+    return trimmed && trimmed.length > 0 ? trimmed : null;
+}
+// ────────────────────────────────────────────────────────────────────────────
+// HTTP transport (Node built-in fetch)
+// ────────────────────────────────────────────────────────────────────────────
+const COPILOT_USER_URL = "https://api.github.com/copilot_internal/user";
+const REQUEST_TIMEOUT_MS = 10000;
+// Header values mirror a real Copilot Chat client; the endpoint ignores requests
+// with implausible editor/plugin versions.
+const HEADERS = {
+    Accept: "application/json",
+    "User-Agent": "GitHubCopilotChat/0.26.7",
+    "Editor-Version": "vscode/1.96.2",
+    "Editor-Plugin-Version": "copilot-chat/0.26.7",
+    "X-GitHub-Api-Version": "2025-04-01"
+};
+async function getCopilotUser(token) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+    try {
+        const response = await fetch(COPILOT_USER_URL, {
+            headers: { ...HEADERS, Authorization: `token ${token}` },
+            signal: controller.signal
+        });
+        if (!response.ok) {
+            return { ok: false, warning: warningForStatus(response.status) };
+        }
+        try {
+            return { ok: true, data: await response.json() };
+        }
+        catch {
+            return { ok: false, warning: "Copilot quota API returned invalid JSON." };
+        }
+    }
+    catch {
+        // Aborts (timeout) and network failures land here; the response body, if any,
+        // is never read or logged.
+        return { ok: false, warning: "Copilot quota API request failed." };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+function warningForStatus(status) {
+    switch (status) {
+        case 401:
+            return "Copilot quota API returned 401; run `gh auth login` again.";
+        case 403:
+            return "Copilot quota API returned 403; the token may lack Copilot access.";
+        case 404:
+            return "Copilot quota API returned 404; the Copilot user endpoint is unavailable.";
+        case 429:
+            return "Copilot quota API is rate limited; try again later.";
+        default:
+            return `Copilot quota API returned ${status}.`;
+    }
+}
+// ────────────────────────────────────────────────────────────────────────────
+// Quota parsing (two known response shapes)
+// ────────────────────────────────────────────────────────────────────────────
+const KNOWN_LABELS = {
+    premium_interactions: "Premium",
+    chat: "Chat",
+    completions: "Completions"
+};
+/**
+ * Parse the raw `/copilot_internal/user` JSON into {@link CopilotQuotaInfo}.
+ * Tolerates both the paid (`quota_snapshots`) and free
+ * (`monthly_quotas`/`limited_user_quotas`) shapes, never throws, derives
+ * percentages only from valid data, clamps them to 0..100, and leaves an
+ * unknown percentage undefined (never a false 0%). If the paid form yields no
+ * usable buckets, the free form is used as a fallback.
+ */
+export function parseCopilotQuota(raw) {
+    const root = asRecord(raw);
+    if (!root) {
+        return { quotas: [] };
+    }
+    const snapshots = asRecord(root.quota_snapshots);
+    const paid = snapshots ? parsePaidQuotas(snapshots) : [];
+    const usePaid = paid.length > 0;
+    const quotas = usePaid ? paid : parseFreeQuotas(root);
+    const info = {
+        quotas: quotas.sort((a, b) => a.id.localeCompare(b.id))
+    };
+    const plan = asString(root.copilot_plan);
+    if (plan !== undefined) {
+        info.plan = plan;
+    }
+    if (root.token_based_billing === true) {
+        info.tokenBasedBilling = true;
+    }
+    // Prefer the precise UTC reset timestamp; fall back to the date-only field.
+    const resetAt = usePaid
+        ? asString(root.quota_reset_date_utc) ?? asString(root.quota_reset_date)
+        : asString(root.limited_user_reset_date);
+    if (resetAt !== undefined) {
+        info.resetAt = resetAt;
+    }
+    return info;
+}
+function parsePaidQuotas(snapshots) {
+    const quotas = [];
+    for (const [key, value] of Object.entries(snapshots)) {
+        const snapshot = asRecord(value);
+        const id = (snapshot && asString(snapshot.quota_id)) || key;
+        const quota = { id, label: labelForKey(key) };
+        if (!snapshot) {
+            quotas.push(quota);
+            continue;
+        }
+        if (snapshot.unlimited === true) {
+            quota.unlimited = true;
+        }
+        const total = finiteNonNegative(snapshot.entitlement);
+        if (total !== undefined) {
+            quota.total = total;
+        }
+        const percentRemaining = finiteNonNegative(snapshot.percent_remaining);
+        // `quota_remaining` carries the precise (often fractional) balance; `remaining`
+        // is a rounded integer. Prefer the precise one for credit math.
+        const rawRemaining = finiteNonNegative(snapshot.quota_remaining) ?? finiteNonNegative(snapshot.remaining);
+        if (percentRemaining !== undefined) {
+            quota.remainingPercent = clampPercent(percentRemaining);
+            quota.usedPercent = clampPercent(100 - quota.remainingPercent);
+        }
+        else if (rawRemaining !== undefined && total !== undefined && total > 0) {
+            quota.remainingPercent = clampPercent((rawRemaining / total) * 100);
+            quota.usedPercent = clampPercent(100 - quota.remainingPercent);
+        }
+        if (rawRemaining !== undefined) {
+            const remaining = total !== undefined ? Math.min(rawRemaining, total) : rawRemaining;
+            quota.remaining = remaining;
+            if (total !== undefined) {
+                quota.used = Math.max(0, total - remaining);
+            }
+        }
+        quotas.push(quota);
+    }
+    return quotas;
+}
+function parseFreeQuotas(root) {
+    const monthly = asRecord(root.monthly_quotas) ?? {};
+    const limited = asRecord(root.limited_user_quotas) ?? {};
+    const keys = new Set([...Object.keys(monthly), ...Object.keys(limited)]);
+    const quotas = [];
+    for (const key of keys) {
+        const quota = { id: key, label: labelForKey(key) };
+        const total = finiteNonNegative(monthly[key]);
+        const rawRemaining = finiteNonNegative(limited[key]);
+        if (total !== undefined) {
+            quota.total = total;
+        }
+        if (rawRemaining !== undefined) {
+            const remaining = total !== undefined ? Math.min(rawRemaining, total) : rawRemaining;
+            quota.remaining = remaining;
+            if (total !== undefined) {
+                quota.used = Math.max(0, total - remaining);
+                if (total > 0) {
+                    quota.usedPercent = clampPercent((quota.used / total) * 100);
+                    quota.remainingPercent = clampPercent(100 - quota.usedPercent);
+                }
+            }
+        }
+        quotas.push(quota);
+    }
+    return quotas;
+}
+function labelForKey(key) {
+    if (KNOWN_LABELS[key] !== undefined) {
+        return KNOWN_LABELS[key];
+    }
+    const words = key.replace(/_/g, " ").trim().split(/\s+/);
+    return words
+        .map((word) => (word.length === 0 ? word : word.charAt(0).toUpperCase() + word.slice(1)))
+        .join(" ") || key;
+}
+function asString(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+/** Coerce a number-or-numeric-string into a finite, non-negative number. */
+function finiteNonNegative(value) {
+    const n = typeof value === "number"
+        ? value
+        : typeof value === "string" && value.trim().length > 0
+            ? Number(value)
+            : undefined;
+    return n !== undefined && Number.isFinite(n) && n >= 0 ? n : undefined;
+}
+function clampPercent(value) {
+    if (!Number.isFinite(value)) {
+        return 0;
+    }
+    return Math.min(100, Math.max(0, value));
+}
+/**
+ * Subtract one calendar month from a date in UTC, clamping the day so that, e.g.
+ * 2026-03-31 → 2026-02-28 and 2024-03-31 → 2024-02-29. A reset on the first of a
+ * month maps to the first of the previous month. Used to derive the start of the
+ * current monthly billing window from its reset (end) date.
+ */
+export function subtractOneUtcCalendarMonth(value) {
+    const result = new Date(value);
+    const originalDay = result.getUTCDate();
+    result.setUTCDate(1);
+    result.setUTCMonth(result.getUTCMonth() - 1);
+    const daysInTargetMonth = new Date(Date.UTC(result.getUTCFullYear(), result.getUTCMonth() + 1, 0)).getUTCDate();
+    result.setUTCDate(Math.min(originalDay, daysInTargetMonth));
+    return result;
+}

package/ink-app/dist/providers/copilot/usage/aggregate.js

@@ -0,0 +1,84 @@
+import { addUsageTotals, sumUsageTotals } from "../../contract.js";
+import { addDailyUsage, buildDailyUsageRows, createDailyUsageAggregates } from "../../daily.js";
+import { isNonBillableCopilotModel, normalizeCopilotModelId, rateForCopilotModel } from "../models.js";
+/**
+ * Select events whose timestamp falls in the half-open interval
+ * `[startTimeMs, endTimeMs)`. An event exactly at `endTimeMs` belongs to the
+ * next window and is excluded. Used to scope OTEL usage to a billing window
+ * without re-parsing — the same events feed all-time and per-window rollups.
+ */
+export function filterCopilotUsageEvents(events, startTimeMs, endTimeMs) {
+    return events.filter((event) => event.timestampMs >= startTimeMs && event.timestampMs < endTimeMs);
+}
+/**
+ * Aggregate normalized Copilot usage events into per-model and per-day rollups
+ * plus summary totals, applying the corrected cache accounting model where the
+ * reported input already INCLUDES cache-read tokens but NOT cache-write tokens.
+ * Pure and deterministic: independent of input ordering.
+ */
+export function aggregateCopilotUsage(events) {
+    const byModel = new Map();
+    const byDay = createDailyUsageAggregates();
+    for (const event of events) {
+        const modelId = normalizeCopilotModelId(event.modelId);
+        const hasCacheInfo = event.cacheReadStatus === "known" || event.cacheWriteStatus === "known";
+        // The reported input already INCLUDES cache-read but NOT cache-write. The
+        // cache-read bucket is preserved IN FULL; only the portion that overlaps the
+        // reported input is subtracted to derive the uncached input. Capping cacheRead
+        // at inputTokens would silently lose cache-only events (input 0, cacheRead N).
+        const reportedInput = Math.max(0, event.inputTokens);
+        const cacheRead = hasCacheInfo ? Math.max(0, event.cacheReadInputTokens) : 0;
+        const uncachedInput = hasCacheInfo
+            ? Math.max(0, reportedInput - cacheRead)
+            : reportedInput;
+        const cacheWrite = hasCacheInfo ? Math.max(0, event.cacheWriteInputTokens) : 0;
+        const output = event.outputTokens;
+        const reasoning = Math.min(event.reasoningOutputTokens, output);
+        const nonBillable = isNonBillableCopilotModel(modelId);
+        const rate = nonBillable ? undefined : rateForCopilotModel(modelId, event.inputTokens);
+        const creditsKnown = nonBillable || (hasCacheInfo && rate !== undefined);
+        const estimatedCreditsStatus = creditsKnown ? "known" : "unavailable";
+        const estimatedCredits = rate !== undefined && hasCacheInfo
+            ? (uncachedInput / 1000000) * rate.input +
+                (cacheRead / 1000000) * rate.cacheRead +
+                (cacheWrite / 1000000) * rate.cacheWrite +
+                (output / 1000000) * rate.output
+            : 0;
+        const totals = {
+            inputTokens: uncachedInput,
+            outputTokens: output,
+            cacheReadInputTokens: cacheRead,
+            cacheWriteInputTokens: cacheWrite,
+            cacheWrite5mInputTokens: 0,
+            cacheWrite1hInputTokens: 0,
+            reasoningOutputTokens: reasoning,
+            totalTokens: uncachedInput + cacheRead + cacheWrite + output,
+            estimatedCredits,
+            eventCount: 1,
+            cacheReadStatus: event.cacheReadStatus,
+            cacheWriteStatus: event.cacheWriteStatus,
+            estimatedCreditsStatus
+        };
+        const existing = byModel.get(modelId);
+        if (existing) {
+            addUsageTotals(existing, totals);
+        }
+        else {
+            byModel.set(modelId, { ...totals });
+        }
+        addDailyUsage(byDay, event.timestampMs, modelId, undefined, totals);
+    }
+    const modelUsage = [...byModel.entries()]
+        .map(([modelId, totals]) => ({ modelId, totals }))
+        .sort((left, right) => right.totals.estimatedCredits - left.totals.estimatedCredits);
+    const summaryTotals = sumUsageTotals(modelUsage.map((row) => row.totals));
+    const distinctModels = modelUsage.map((row) => row.modelId);
+    const dayUsage = buildDailyUsageRows(byDay);
+    return {
+        modelUsage,
+        dayUsage,
+        summaryTotals,
+        distinctModels,
+        tokenEvents: events.length
+    };
+}