letmecode 0.1.0 → 0.1.2

package/ink-app/dist/providers/claude.js

@@ -0,0 +1,311 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import readline from "node:readline";
+import { UsageProviderBase, addUsageTotals, createEmptyUsageTotals, sumUsageTotals } from "./contract.js";
+import { applyRateLimits, asRecord, buildWindowLists, createLimitWindowAggregates, numberOrZero } from "./limits.js";
+import { addDailyUsage, buildDailyUsageRows, createDailyUsageAggregates } from "./daily.js";
+const RATE_CARD = {
+    "claude-opus-4-8": { input: 5, cacheWrite5m: 6.25, cacheWrite1h: 10, cacheRead: 0.5, output: 25 },
+    "claude-opus-4-7": { input: 5, cacheWrite5m: 6.25, cacheWrite1h: 10, cacheRead: 0.5, output: 25 },
+    "claude-opus-4-6": { input: 5, cacheWrite5m: 6.25, cacheWrite1h: 10, cacheRead: 0.5, output: 25 },
+    "claude-opus-4-5": { input: 5, cacheWrite5m: 6.25, cacheWrite1h: 10, cacheRead: 0.5, output: 25 },
+    "claude-opus-4-1": { input: 15, cacheWrite5m: 18.75, cacheWrite1h: 30, cacheRead: 1.5, output: 75 },
+    "claude-opus-4": { input: 15, cacheWrite5m: 18.75, cacheWrite1h: 30, cacheRead: 1.5, output: 75 },
+    "claude-sonnet-4-6": { input: 3, cacheWrite5m: 3.75, cacheWrite1h: 6, cacheRead: 0.3, output: 15 },
+    "claude-sonnet-4-5": { input: 3, cacheWrite5m: 3.75, cacheWrite1h: 6, cacheRead: 0.3, output: 15 },
+    "claude-sonnet-4": { input: 3, cacheWrite5m: 3.75, cacheWrite1h: 6, cacheRead: 0.3, output: 15 },
+    "claude-haiku-4-5": { input: 1, cacheWrite5m: 1.25, cacheWrite1h: 2, cacheRead: 0.1, output: 5 },
+    "claude-haiku-3-5": { input: 0.8, cacheWrite5m: 1, cacheWrite1h: 1.6, cacheRead: 0.08, output: 4 }
+};
+const USD_TO_CREDITS = 100;
+export class ClaudeUsageProvider extends UsageProviderBase {
+    constructor(options = {}) {
+        super("claude", "Claude");
+        this.root = path.resolve(options.root ?? os.homedir());
+    }
+    async getStats(options = {}) {
+        const sessionsRoot = path.join(this.root, ".claude", "projects");
+        const byModel = new Map();
+        const byDay = createDailyUsageAggregates();
+        const windows = createLimitWindowAggregates();
+        const planTypes = new Set();
+        const warnings = [];
+        const parsedEvents = createParsedUsageEventAccumulator();
+        const parseTotals = {
+            filesScanned: 0,
+            linesRead: 0,
+            tokenEvents: 0,
+            malformedLines: 0
+        };
+        for await (const file of walkSessionFiles(sessionsRoot)) {
+            parseTotals.filesScanned += 1;
+            const fileStats = await parseSessionFile(file, parsedEvents);
+            parseTotals.linesRead += fileStats.linesRead;
+            parseTotals.malformedLines += fileStats.malformedLines;
+        }
+        const selectedEvents = [
+            ...parsedEvents.keyedEvents.values(),
+            ...parsedEvents.unkeyedEvents.values()
+        ];
+        for (const event of selectedEvents) {
+            addModelUsage(byModel, event.modelId, event.totals);
+            const planType = typeof event.rateLimits?.plan_type === "string" ? event.rateLimits.plan_type : undefined;
+            const safeEventTimeMs = Number.isFinite(event.timestampMs) ? event.timestampMs : 0;
+            addDailyUsage(byDay, event.timestampMs, event.modelId, planType, event.totals);
+            applyRateLimits(windows, event.rateLimits, safeEventTimeMs, event.totals, planTypes);
+        }
+        parseTotals.tokenEvents = selectedEvents.length;
+        if (parseTotals.malformedLines > 0) {
+            warnings.push(`Skipped ${parseTotals.malformedLines} malformed JSONL line(s).`);
+        }
+        if (options.verbose && parsedEvents.duplicateUsageKeys > 0) {
+            warnings.push(`Collapsed ${parsedEvents.duplicateUsageKeys} duplicate Claude usage event(s) by request/message key.`);
+        }
+        if (options.verbose && parsedEvents.duplicateUsageKeyCollisions > 0) {
+            warnings.push(`Detected ${parsedEvents.duplicateUsageKeyCollisions} Claude usage key collision(s) with different token usage; keeping the highest-cost/latest event per key.`);
+        }
+        if (options.verbose && parsedEvents.duplicateUnkeyedEvents > 0) {
+            warnings.push(`Collapsed ${parsedEvents.duplicateUnkeyedEvents} duplicate unkeyed Claude usage event(s) by usage signature.`);
+        }
+        const modelUsage = [...byModel.entries()]
+            .map(([modelId, totals]) => ({ modelId, totals }))
+            .sort((left, right) => right.totals.estimatedCredits - left.totals.estimatedCredits);
+        const unknownPricedModels = modelUsage
+            .map((row) => row.modelId)
+            .filter((modelId) => !resolveRate(modelId));
+        if (unknownPricedModels.length > 0) {
+            warnings.push(`No credit rate configured for: ${unknownPricedModels.join(", ")}.`);
+        }
+        if (parseTotals.filesScanned === 0) {
+            warnings.push(`No Claude session files found under ${sessionsRoot}.`);
+        }
+        const summaryTotals = sumUsageTotals(modelUsage.map((row) => row.totals));
+        const dayUsage = buildDailyUsageRows(byDay);
+        const [primaryLimitWindows, secondaryLimitWindows] = buildWindowLists(windows);
+        if (parseTotals.filesScanned > 0 &&
+            parseTotals.tokenEvents > 0 &&
+            primaryLimitWindows.length === 0 &&
+            secondaryLimitWindows.length === 0) {
+            warnings.push("Claude transcripts did not expose rate-limit windows in the local logs.");
+        }
+        return {
+            providerId: this.id,
+            providerLabel: this.label,
+            summary: {
+                filesScanned: parseTotals.filesScanned,
+                linesRead: parseTotals.linesRead,
+                tokenEvents: parseTotals.tokenEvents,
+                totals: summaryTotals,
+                distinctModels: modelUsage.map((row) => row.modelId),
+                distinctPlanTypes: [...planTypes].sort(),
+                rootLabel: "~/.claude/projects",
+                rootPath: sessionsRoot
+            },
+            modelUsage,
+            dayUsage,
+            primaryLimitWindows,
+            secondaryLimitWindows,
+            warnings
+        };
+    }
+}
+function normalizeUsage(value) {
+    const usage = asRecord(value) ?? {};
+    const cacheCreation = asRecord(usage.cache_creation);
+    const cacheCreation5mInputTokens = numberOrZero(cacheCreation?.ephemeral_5m_input_tokens);
+    const cacheCreation1hInputTokens = numberOrZero(cacheCreation?.ephemeral_1h_input_tokens);
+    const cacheCreationInputTokens = Math.max(numberOrZero(usage.cache_creation_input_tokens), cacheCreation5mInputTokens + cacheCreation1hInputTokens);
+    return {
+        inputTokens: numberOrZero(usage.input_tokens),
+        cacheReadInputTokens: numberOrZero(usage.cache_read_input_tokens),
+        cacheCreationInputTokens,
+        cacheCreation5mInputTokens,
+        cacheCreation1hInputTokens,
+        outputTokens: numberOrZero(usage.output_tokens),
+        inferenceGeo: String(usage.inference_geo ?? "")
+    };
+}
+function resolveRate(modelId) {
+    const candidates = Object.keys(RATE_CARD).sort((left, right) => right.length - left.length);
+    for (const candidate of candidates) {
+        if (modelId === candidate || modelId.startsWith(`${candidate}-`)) {
+            return RATE_CARD[candidate];
+        }
+    }
+    return undefined;
+}
+function creditsFor(modelId, usage) {
+    const rate = resolveRate(modelId);
+    if (!rate) {
+        return 0;
+    }
+    const cacheWriteKnownTokens = usage.cacheCreation5mInputTokens + usage.cacheCreation1hInputTokens;
+    const cacheWriteFallbackTokens = Math.max(0, usage.cacheCreationInputTokens - cacheWriteKnownTokens);
+    const inferenceMultiplier = usage.inferenceGeo === "us" ? 1.1 : 1;
+    return (((usage.inputTokens / 1000000) * rate.input +
+        (usage.cacheReadInputTokens / 1000000) * rate.cacheRead +
+        (usage.cacheCreation5mInputTokens / 1000000) * rate.cacheWrite5m +
+        (usage.cacheCreation1hInputTokens / 1000000) * rate.cacheWrite1h +
+        (cacheWriteFallbackTokens / 1000000) * rate.cacheWrite5m +
+        (usage.outputTokens / 1000000) * rate.output) *
+        inferenceMultiplier *
+        USD_TO_CREDITS);
+}
+function usageToTotals(modelId, usage) {
+    const nonCachedInputTokens = usage.inputTokens + usage.cacheCreationInputTokens;
+    const cachedInputTokens = usage.cacheReadInputTokens;
+    return {
+        inputTokens: nonCachedInputTokens + cachedInputTokens,
+        cachedInputTokens,
+        nonCachedInputTokens,
+        outputTokens: usage.outputTokens,
+        reasoningOutputTokens: 0,
+        totalTokens: nonCachedInputTokens + cachedInputTokens + usage.outputTokens,
+        estimatedCredits: creditsFor(modelId, usage),
+        eventCount: 1
+    };
+}
+function addModelUsage(byModel, modelId, deltaTotals) {
+    const resolvedModelId = modelId || "unknown";
+    const totals = byModel.get(resolvedModelId) ?? createEmptyUsageTotals();
+    addUsageTotals(totals, deltaTotals);
+    byModel.set(resolvedModelId, totals);
+}
+function isSessionFile(filePath) {
+    return filePath.endsWith(".jsonl") && filePath.includes(`${path.sep}.claude${path.sep}projects${path.sep}`);
+}
+async function* walkSessionFiles(directory) {
+    let entries;
+    try {
+        entries = await fs.promises.readdir(directory, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        const fullPath = path.join(directory, entry.name);
+        if (entry.isDirectory()) {
+            yield* walkSessionFiles(fullPath);
+        }
+        else if (entry.isFile() && isSessionFile(fullPath)) {
+            yield fullPath;
+        }
+    }
+}
+async function parseSessionFile(filePath, parsedEvents) {
+    const stream = fs.createReadStream(filePath, { encoding: "utf8" });
+    const lineReader = readline.createInterface({ input: stream, crlfDelay: Infinity });
+    let linesRead = 0;
+    let malformedLines = 0;
+    for await (const line of lineReader) {
+        linesRead += 1;
+        if (!line.trim()) {
+            continue;
+        }
+        let payloadObject;
+        try {
+            payloadObject = JSON.parse(line);
+        }
+        catch {
+            malformedLines += 1;
+            continue;
+        }
+        if (payloadObject.type !== "assistant") {
+            continue;
+        }
+        const message = asRecord(payloadObject.message);
+        const usage = asRecord(message?.usage);
+        if (!usage) {
+            continue;
+        }
+        const modelId = String(message?.model ?? "unknown");
+        const eventTimeMs = Date.parse(String(payloadObject.timestamp ?? ""));
+        const rateLimits = extractRateLimits(payloadObject, message);
+        const normalizedUsage = normalizeUsage(usage);
+        const usageKey = buildUsageEventKey(payloadObject, message);
+        const usageSignature = buildUsageSignature(payloadObject, modelId, normalizedUsage);
+        const parsedEvent = {
+            usageKey,
+            usageSignature,
+            timestampMs: eventTimeMs,
+            modelId,
+            totals: usageToTotals(modelId, normalizedUsage),
+            rateLimits
+        };
+        recordParsedUsageEvent(parsedEvents, parsedEvent);
+    }
+    return { linesRead, malformedLines };
+}
+function buildUsageEventKey(payloadObject, message) {
+    const sessionId = String(payloadObject.sessionId ?? "");
+    const requestId = typeof payloadObject.requestId === "string" ? payloadObject.requestId : "";
+    const messageId = typeof message?.id === "string" ? message.id : "";
+    if (!requestId && !messageId) {
+        return null;
+    }
+    return `${sessionId}|${requestId || messageId}`;
+}
+function buildUsageSignature(payloadObject, modelId, usage) {
+    return [
+        String(payloadObject.sessionId ?? ""),
+        modelId,
+        usage.inputTokens,
+        usage.cacheCreationInputTokens,
+        usage.cacheCreation5mInputTokens,
+        usage.cacheCreation1hInputTokens,
+        usage.cacheReadInputTokens,
+        usage.outputTokens,
+        usage.inferenceGeo
+    ].join("|");
+}
+function createParsedUsageEventAccumulator() {
+    return {
+        keyedEvents: new Map(),
+        unkeyedEvents: new Map(),
+        duplicateUsageKeys: 0,
+        duplicateUsageKeyCollisions: 0,
+        duplicateUnkeyedEvents: 0
+    };
+}
+function recordParsedUsageEvent(parsedEvents, event) {
+    if (event.usageKey) {
+        const previous = parsedEvents.keyedEvents.get(event.usageKey);
+        if (!previous) {
+            parsedEvents.keyedEvents.set(event.usageKey, event);
+            return;
+        }
+        parsedEvents.duplicateUsageKeys += 1;
+        if (previous.usageSignature !== event.usageSignature) {
+            parsedEvents.duplicateUsageKeyCollisions += 1;
+        }
+        if (shouldReplaceUsageEvent(previous, event)) {
+            parsedEvents.keyedEvents.set(event.usageKey, event);
+        }
+        return;
+    }
+    const previous = parsedEvents.unkeyedEvents.get(event.usageSignature);
+    if (!previous) {
+        parsedEvents.unkeyedEvents.set(event.usageSignature, event);
+        return;
+    }
+    parsedEvents.duplicateUnkeyedEvents += 1;
+    if (shouldReplaceUsageEvent(previous, event)) {
+        parsedEvents.unkeyedEvents.set(event.usageSignature, event);
+    }
+}
+function shouldReplaceUsageEvent(previous, next) {
+    if (next.totals.estimatedCredits > previous.totals.estimatedCredits) {
+        return true;
+    }
+    if (next.totals.estimatedCredits === previous.totals.estimatedCredits) {
+        return normalizeTimestamp(next.timestampMs) > normalizeTimestamp(previous.timestampMs);
+    }
+    return false;
+}
+function normalizeTimestamp(value) {
+    return Number.isFinite(value) ? value : Number.NEGATIVE_INFINITY;
+}
+function extractRateLimits(payloadObject, message) {
+    return asRecord(payloadObject.rate_limits) ?? asRecord(message?.rate_limits);
+}

package/ink-app/dist/providers/codex.js

@@ -2,7 +2,9 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import readline from "node:readline";
-import { UsageProviderBase, createEmptyUsageTotals } from "./contract.js";
+import { UsageProviderBase, addUsageTotals, createEmptyUsageTotals, sumUsageTotals } from "./contract.js";
+import { applyRateLimits, asRecord, buildWindowLists, createLimitWindowAggregates, numberOrZero } from "./limits.js";
+import { addDailyUsage, buildDailyUsageRows, createDailyUsageAggregates } from "./daily.js";
 const RATE_CARD = {
     "gpt-5.5": { input: 125, cachedInput: 12.5, output: 750 },
     "gpt-5.4": { input: 62.5, cachedInput: 6.25, output: 375 },
@@ -13,10 +15,11 @@ export class CodexUsageProvider extends UsageProviderBase {
         super("codex", "Codex");
         this.root = path.resolve(options.root ?? os.homedir());
     }
-    async getStats() {
+    async getStats(_options = {}) {
         const sessionsRoot = path.join(this.root, ".codex", "sessions");
         const byModel = new Map();
-        const windows = new Map();
+        const byDay = createDailyUsageAggregates();
+        const windows = createLimitWindowAggregates();
         const planTypes = new Set();
         const warnings = [];
         const parseTotals = {
@@ -27,7 +30,7 @@ export class CodexUsageProvider extends UsageProviderBase {
         };
         for await (const file of walkSessionFiles(sessionsRoot)) {
             parseTotals.filesScanned += 1;
-            const fileStats = await parseSessionFile(file, byModel, windows, planTypes);
+            const fileStats = await parseSessionFile(file, byModel, byDay, windows, planTypes);
             parseTotals.linesRead += fileStats.linesRead;
             parseTotals.tokenEvents += fileStats.tokenEvents;
             parseTotals.malformedLines += fileStats.malformedLines;
@@ -48,6 +51,7 @@ export class CodexUsageProvider extends UsageProviderBase {
             warnings.push(`No Codex session files found under ${sessionsRoot}.`);
         }
         const summaryTotals = sumUsageTotals(modelUsage.map((row) => row.totals));
+        const dayUsage = buildDailyUsageRows(byDay);
         const [primaryLimitWindows, secondaryLimitWindows] = buildWindowLists(windows);
         return {
             providerId: this.id,
@@ -63,6 +67,7 @@ export class CodexUsageProvider extends UsageProviderBase {
                 rootPath: sessionsRoot
             },
             modelUsage,
+            dayUsage,
             primaryLimitWindows,
             secondaryLimitWindows,
             warnings
@@ -78,9 +83,6 @@ function createEmptyRawUsage() {
         totalTokens: 0
     };
 }
-function numberOrZero(value) {
-    return typeof value === "number" && Number.isFinite(value) ? value : 0;
-}
 function normalizeRawUsage(value) {
     const usage = value && typeof value === "object" ? value : {};
     return {
@@ -124,104 +126,19 @@ function rawUsageToTotals(usage) {
         eventCount: 0
     };
 }
-function addUsageTotals(target, source) {
-    target.inputTokens += source.inputTokens;
-    target.cachedInputTokens += source.cachedInputTokens;
-    target.nonCachedInputTokens += source.nonCachedInputTokens;
-    target.outputTokens += source.outputTokens;
-    target.reasoningOutputTokens += source.reasoningOutputTokens;
-    target.totalTokens += source.totalTokens;
-    target.estimatedCredits += source.estimatedCredits;
-    target.eventCount += source.eventCount;
-}
-function addModelUsage(byModel, modelId, usage) {
+function createUsageTotalsForModel(modelId, usage) {
     const resolvedModelId = modelId || "unknown";
-    const totals = byModel.get(resolvedModelId) ?? createEmptyUsageTotals();
     const deltaTotals = rawUsageToTotals(usage);
     deltaTotals.estimatedCredits = creditsFor(resolvedModelId, usage);
     deltaTotals.eventCount = 1;
+    return deltaTotals;
+}
+function addModelUsage(byModel, modelId, deltaTotals) {
+    const resolvedModelId = modelId || "unknown";
+    const totals = byModel.get(resolvedModelId) ?? createEmptyUsageTotals();
     addUsageTotals(totals, deltaTotals);
     byModel.set(resolvedModelId, totals);
 }
-function sumUsageTotals(rows) {
-    const totals = createEmptyUsageTotals();
-    for (const row of rows) {
-        addUsageTotals(totals, row);
-    }
-    return totals;
-}
-function formatIsoFromSeconds(seconds) {
-    return new Date(seconds * 1000).toISOString().replace(".000Z", "Z");
-}
-function formatIsoFromMilliseconds(milliseconds) {
-    return new Date(milliseconds).toISOString().replace(".000Z", "Z");
-}
-function makeWindowKey(scope, rateLimits, window) {
-    return [
-        scope,
-        String(rateLimits.limit_id ?? "unknown"),
-        String(rateLimits.plan_type ?? "unknown"),
-        numberOrZero(window.window_minutes),
-        Math.round(numberOrZero(window.resets_at) / 60)
-    ].join("|");
-}
-function upsertWindow(windows, scope, rateLimits, window, eventTimeMs) {
-    if (!window) {
-        return;
-    }
-    const windowMinutes = numberOrZero(window.window_minutes);
-    const resetsAt = numberOrZero(window.resets_at);
-    if (!windowMinutes || !resetsAt) {
-        return;
-    }
-    const startsAt = resetsAt - windowMinutes * 60;
-    const usedPercent = numberOrZero(window.used_percent);
-    const key = makeWindowKey(scope, rateLimits, window);
-    const existing = windows.get(key);
-    if (!existing) {
-        windows.set(key, {
-            scope,
-            limitId: String(rateLimits.limit_id ?? "unknown"),
-            planType: String(rateLimits.plan_type ?? "unknown"),
-            windowMinutes,
-            minStartsAt: startsAt,
-            maxResetsAt: resetsAt,
-            firstSeenMs: eventTimeMs,
-            lastSeenMs: eventTimeMs,
-            minUsedPercent: usedPercent,
-            maxUsedPercent: usedPercent,
-            eventCount: 1
-        });
-        return;
-    }
-    existing.minStartsAt = Math.min(existing.minStartsAt, startsAt);
-    existing.maxResetsAt = Math.max(existing.maxResetsAt, resetsAt);
-    existing.firstSeenMs = Math.min(existing.firstSeenMs, eventTimeMs);
-    existing.lastSeenMs = Math.max(existing.lastSeenMs, eventTimeMs);
-    existing.minUsedPercent = Math.min(existing.minUsedPercent, usedPercent);
-    existing.maxUsedPercent = Math.max(existing.maxUsedPercent, usedPercent);
-    existing.eventCount += 1;
-}
-function buildWindowLists(windows) {
-    const rows = [...windows.values()]
-        .map((window) => ({
-        scope: window.scope,
-        planType: window.planType,
-        limitId: window.limitId,
-        windowMinutes: window.windowMinutes,
-        startTimeIso: formatIsoFromSeconds(window.minStartsAt),
-        endTimeIso: formatIsoFromSeconds(window.maxResetsAt),
-        firstSeenIso: formatIsoFromMilliseconds(window.firstSeenMs),
-        lastSeenIso: formatIsoFromMilliseconds(window.lastSeenMs),
-        minUsedPercent: window.minUsedPercent,
-        maxUsedPercent: window.maxUsedPercent,
-        eventCount: window.eventCount
-    }))
-        .sort((left, right) => right.endTimeIso.localeCompare(left.endTimeIso));
-    const primary = rows.filter((row) => row.scope === "primary").slice(0, 5);
-    const secondary = rows.filter((row) => row.scope === "secondary").slice(0, 5);
-    return [primary, secondary];
-}
 function isSessionFile(filePath) {
     return filePath.endsWith(".jsonl") && filePath.includes(`${path.sep}.codex${path.sep}sessions${path.sep}`);
 }
@@ -243,7 +160,7 @@ async function* walkSessionFiles(directory) {
         }
     }
 }
-async function parseSessionFile(filePath, byModel, windows, planTypes) {
+async function parseSessionFile(filePath, byModel, byDay, windows, planTypes) {
     const stream = fs.createReadStream(filePath, { encoding: "utf8" });
     const lineReader = readline.createInterface({ input: stream, crlfDelay: Infinity });
     let currentModel = "unknown";
@@ -279,23 +196,20 @@ async function parseSessionFile(filePath, byModel, windows, planTypes) {
             continue;
         }
         const info = payload.info;
-        const rateLimits = payload.rate_limits;
         const totalUsage = normalizeRawUsage(info?.total_token_usage);
         const lastUsage = info?.last_token_usage;
         const usage = lastUsage ? normalizeRawUsage(lastUsage) : previousTotal ? subtractRawUsage(totalUsage, previousTotal) : totalUsage;
         previousTotal = totalUsage;
+        const resolvedModelId = currentModel || "unknown";
+        const deltaTotals = createUsageTotalsForModel(resolvedModelId, usage);
         tokenEvents += 1;
-        addModelUsage(byModel, currentModel, usage);
-        if (typeof rateLimits?.plan_type === "string") {
-            planTypes.add(rateLimits.plan_type);
-        }
+        addModelUsage(byModel, resolvedModelId, deltaTotals);
         const eventTimeMs = Date.parse(String(payloadObject.timestamp ?? ""));
         const safeEventTimeMs = Number.isFinite(eventTimeMs) ? eventTimeMs : 0;
-        upsertWindow(windows, "primary", rateLimits ?? {}, asRecord(rateLimits?.primary), safeEventTimeMs);
-        upsertWindow(windows, "secondary", rateLimits ?? {}, asRecord(rateLimits?.secondary), safeEventTimeMs);
+        const rateLimits = asRecord(payload.rate_limits);
+        const planType = typeof rateLimits?.plan_type === "string" ? rateLimits.plan_type : undefined;
+        addDailyUsage(byDay, eventTimeMs, resolvedModelId, planType, deltaTotals);
+        applyRateLimits(windows, rateLimits, safeEventTimeMs, deltaTotals, planTypes);
     }
     return { linesRead, tokenEvents, malformedLines };
 }
-function asRecord(value) {
-    return value && typeof value === "object" ? value : null;
-}

package/ink-app/dist/providers/contract.js

@@ -16,3 +16,26 @@ export function createEmptyUsageTotals() {
         eventCount: 0
     };
 }
+export function addUsageTotals(target, source) {
+    target.inputTokens += source.inputTokens;
+    target.cachedInputTokens += source.cachedInputTokens;
+    target.nonCachedInputTokens += source.nonCachedInputTokens;
+    target.outputTokens += source.outputTokens;
+    target.reasoningOutputTokens += source.reasoningOutputTokens;
+    target.totalTokens += source.totalTokens;
+    target.estimatedCredits += source.estimatedCredits;
+    target.eventCount += source.eventCount;
+    if (source.cacheStatus === "unavailable") {
+        target.cacheStatus = "unavailable";
+    }
+    if (source.estimatedCreditsStatus === "unavailable") {
+        target.estimatedCreditsStatus = "unavailable";
+    }
+}
+export function sumUsageTotals(rows) {
+    const totals = createEmptyUsageTotals();
+    for (const row of rows) {
+        addUsageTotals(totals, row);
+    }
+    return totals;
+}