letmecode 0.1.1 → 0.1.3

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

@@ -4,31 +4,34 @@ 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: 500, cacheWrite5m: 625, cacheWrite1h: 1000, cacheRead: 50, output: 2500 },
-    "claude-opus-4-7": { input: 500, cacheWrite5m: 625, cacheWrite1h: 1000, cacheRead: 50, output: 2500 },
-    "claude-opus-4-6": { input: 500, cacheWrite5m: 625, cacheWrite1h: 1000, cacheRead: 50, output: 2500 },
-    "claude-opus-4-5": { input: 500, cacheWrite5m: 625, cacheWrite1h: 1000, cacheRead: 50, output: 2500 },
-    "claude-opus-4-1": { input: 1500, cacheWrite5m: 1875, cacheWrite1h: 3000, cacheRead: 150, output: 7500 },
-    "claude-opus-4": { input: 1500, cacheWrite5m: 1875, cacheWrite1h: 3000, cacheRead: 150, output: 7500 },
-    "claude-sonnet-4-6": { input: 300, cacheWrite5m: 375, cacheWrite1h: 600, cacheRead: 30, output: 1500 },
-    "claude-sonnet-4-5": { input: 300, cacheWrite5m: 375, cacheWrite1h: 600, cacheRead: 30, output: 1500 },
-    "claude-sonnet-4": { input: 300, cacheWrite5m: 375, cacheWrite1h: 600, cacheRead: 30, output: 1500 },
-    "claude-haiku-4-5": { input: 100, cacheWrite5m: 125, cacheWrite1h: 200, cacheRead: 10, output: 500 },
-    "claude-haiku-3-5": { input: 80, cacheWrite5m: 100, cacheWrite1h: 160, cacheRead: 8, output: 400 }
+    "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() {
+    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 seenUsageEvents = new Set();
+        const parsedEvents = createParsedUsageEventAccumulator();
         const parseTotals = {
             filesScanned: 0,
             linesRead: 0,
@@ -37,14 +40,34 @@ export class ClaudeUsageProvider extends UsageProviderBase {
         };
         for await (const file of walkSessionFiles(sessionsRoot)) {
             parseTotals.filesScanned += 1;
-            const fileStats = await parseSessionFile(file, byModel, windows, planTypes, seenUsageEvents);
+            const fileStats = await parseSessionFile(file, parsedEvents);
             parseTotals.linesRead += fileStats.linesRead;
-            parseTotals.tokenEvents += fileStats.tokenEvents;
             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);
@@ -58,6 +81,7 @@ export class ClaudeUsageProvider extends UsageProviderBase {
             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 &&
@@ -79,6 +103,7 @@ export class ClaudeUsageProvider extends UsageProviderBase {
                 rootPath: sessionsRoot
             },
             modelUsage,
+            dayUsage,
             primaryLimitWindows,
             secondaryLimitWindows,
             warnings
@@ -115,37 +140,53 @@ function creditsFor(modelId, usage) {
     if (!rate) {
         return 0;
     }
-    const cacheWriteKnownTokens = usage.cacheCreation5mInputTokens + usage.cacheCreation1hInputTokens;
-    const cacheWriteFallbackTokens = Math.max(0, usage.cacheCreationInputTokens - cacheWriteKnownTokens);
+    const cacheWriteBreakdown = resolveClaudeCacheWriteBreakdown(usage);
     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 +
+        (cacheWriteBreakdown.cacheWrite5mInputTokens / 1000000) * rate.cacheWrite5m +
+        (cacheWriteBreakdown.cacheWrite1hInputTokens / 1000000) * rate.cacheWrite1h +
         (usage.outputTokens / 1000000) * rate.output) *
-        inferenceMultiplier);
+        inferenceMultiplier *
+        USD_TO_CREDITS);
 }
 function usageToTotals(modelId, usage) {
-    const nonCachedInputTokens = usage.inputTokens + usage.cacheCreationInputTokens;
-    const cachedInputTokens = usage.cacheReadInputTokens;
+    const cacheWriteBreakdown = resolveClaudeCacheWriteBreakdown(usage);
+    const inputTotalTokens = usage.inputTokens +
+        cacheWriteBreakdown.cacheWrite5mInputTokens +
+        cacheWriteBreakdown.cacheWrite1hInputTokens +
+        usage.cacheReadInputTokens;
     return {
-        inputTokens: nonCachedInputTokens + cachedInputTokens,
-        cachedInputTokens,
-        nonCachedInputTokens,
+        inputTotalTokens,
         outputTokens: usage.outputTokens,
         reasoningOutputTokens: 0,
-        totalTokens: nonCachedInputTokens + cachedInputTokens + usage.outputTokens,
+        totalTokens: inputTotalTokens + usage.outputTokens,
         estimatedCredits: creditsFor(modelId, usage),
-        eventCount: 1
+        eventCount: 1,
+        tokenBreakdown: {
+            schema: "anthropic",
+            inputTokens: usage.inputTokens,
+            cacheWrite5mInputTokens: cacheWriteBreakdown.cacheWrite5mInputTokens,
+            cacheWrite1hInputTokens: cacheWriteBreakdown.cacheWrite1hInputTokens,
+            cacheReadInputTokens: usage.cacheReadInputTokens,
+            outputTokens: usage.outputTokens
+        }
     };
 }
 function addModelUsage(byModel, modelId, deltaTotals) {
     const resolvedModelId = modelId || "unknown";
-    const totals = byModel.get(resolvedModelId) ?? createEmptyUsageTotals();
+    const totals = byModel.get(resolvedModelId) ?? createEmptyUsageTotals("anthropic");
     addUsageTotals(totals, deltaTotals);
     byModel.set(resolvedModelId, totals);
 }
+function resolveClaudeCacheWriteBreakdown(usage) {
+    const cacheWriteKnownTokens = usage.cacheCreation5mInputTokens + usage.cacheCreation1hInputTokens;
+    const cacheWriteFallbackTokens = Math.max(0, usage.cacheCreationInputTokens - cacheWriteKnownTokens);
+    return {
+        cacheWrite5mInputTokens: usage.cacheCreation5mInputTokens + cacheWriteFallbackTokens,
+        cacheWrite1hInputTokens: usage.cacheCreation1hInputTokens
+    };
+}
 function isSessionFile(filePath) {
     return filePath.endsWith(".jsonl") && filePath.includes(`${path.sep}.claude${path.sep}projects${path.sep}`);
 }
@@ -167,11 +208,10 @@ async function* walkSessionFiles(directory) {
         }
     }
 }
-async function parseSessionFile(filePath, byModel, windows, planTypes, seenUsageEvents) {
+async function parseSessionFile(filePath, parsedEvents) {
     const stream = fs.createReadStream(filePath, { encoding: "utf8" });
     const lineReader = readline.createInterface({ input: stream, crlfDelay: Infinity });
     let linesRead = 0;
-    let tokenEvents = 0;
     let malformedLines = 0;
     for await (const line of lineReader) {
         linesRead += 1;
@@ -194,22 +234,23 @@ async function parseSessionFile(filePath, byModel, windows, planTypes, seenUsage
         if (!usage) {
             continue;
         }
-        const usageKey = buildUsageEventKey(payloadObject, message);
-        if (usageKey && seenUsageEvents.has(usageKey)) {
-            continue;
-        }
-        if (usageKey) {
-            seenUsageEvents.add(usageKey);
-        }
         const modelId = String(message?.model ?? "unknown");
-        const deltaTotals = usageToTotals(modelId, normalizeUsage(usage));
-        addModelUsage(byModel, modelId, deltaTotals);
-        tokenEvents += 1;
         const eventTimeMs = Date.parse(String(payloadObject.timestamp ?? ""));
-        const safeEventTimeMs = Number.isFinite(eventTimeMs) ? eventTimeMs : 0;
-        applyRateLimits(windows, extractRateLimits(payloadObject, message), safeEventTimeMs, deltaTotals, planTypes);
+        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, tokenEvents, malformedLines };
+    return { linesRead, malformedLines };
 }
 function buildUsageEventKey(payloadObject, message) {
     const sessionId = String(payloadObject.sessionId ?? "");
@@ -220,6 +261,66 @@ function buildUsageEventKey(payloadObject, message) {
     }
     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

@@ -4,6 +4,7 @@ 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 = {
     "gpt-5.5": { input: 125, cachedInput: 12.5, output: 750 },
     "gpt-5.4": { input: 62.5, cachedInput: 6.25, output: 375 },
@@ -14,9 +15,10 @@ 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 byDay = createDailyUsageAggregates();
         const windows = createLimitWindowAggregates();
         const planTypes = new Set();
         const warnings = [];
@@ -28,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;
@@ -49,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,
@@ -64,6 +67,7 @@ export class CodexUsageProvider extends UsageProviderBase {
                 rootPath: sessionsRoot
             },
             modelUsage,
+            dayUsage,
             primaryLimitWindows,
             secondaryLimitWindows,
             warnings
@@ -103,23 +107,25 @@ function creditsFor(modelId, usage) {
     if (!rate) {
         return 0;
     }
-    const cachedInputTokens = Math.min(usage.cachedInputTokens, usage.inputTokens);
-    const nonCachedInputTokens = Math.max(0, usage.inputTokens - cachedInputTokens);
-    return ((nonCachedInputTokens / 1000000) * rate.input +
-        (cachedInputTokens / 1000000) * rate.cachedInput +
+    return ((usage.inputTokens / 1000000) * rate.input +
+        (usage.cachedInputTokens / 1000000) * rate.cachedInput +
         (usage.outputTokens / 1000000) * rate.output);
 }
 function rawUsageToTotals(usage) {
-    const cachedInputTokens = Math.min(usage.cachedInputTokens, usage.inputTokens);
+    const inputTotalTokens = usage.inputTokens + usage.cachedInputTokens;
     return {
-        inputTokens: usage.inputTokens,
-        cachedInputTokens,
-        nonCachedInputTokens: Math.max(0, usage.inputTokens - cachedInputTokens),
+        inputTotalTokens,
         outputTokens: usage.outputTokens,
         reasoningOutputTokens: usage.reasoningOutputTokens,
-        totalTokens: usage.totalTokens,
+        totalTokens: inputTotalTokens + usage.outputTokens,
         estimatedCredits: 0,
-        eventCount: 0
+        eventCount: 0,
+        tokenBreakdown: {
+            schema: "openai",
+            nonCachedInputTokens: usage.inputTokens,
+            cachedInputTokens: usage.cachedInputTokens,
+            outputTokens: usage.outputTokens
+        }
     };
 }
 function createUsageTotalsForModel(modelId, usage) {
@@ -131,7 +137,7 @@ function createUsageTotalsForModel(modelId, usage) {
 }
 function addModelUsage(byModel, modelId, deltaTotals) {
     const resolvedModelId = modelId || "unknown";
-    const totals = byModel.get(resolvedModelId) ?? createEmptyUsageTotals();
+    const totals = byModel.get(resolvedModelId) ?? createEmptyUsageTotals("openai");
     addUsageTotals(totals, deltaTotals);
     byModel.set(resolvedModelId, totals);
 }
@@ -156,7 +162,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";
@@ -202,7 +208,10 @@ async function parseSessionFile(filePath, byModel, windows, planTypes) {
         addModelUsage(byModel, resolvedModelId, deltaTotals);
         const eventTimeMs = Date.parse(String(payloadObject.timestamp ?? ""));
         const safeEventTimeMs = Number.isFinite(eventTimeMs) ? eventTimeMs : 0;
-        applyRateLimits(windows, asRecord(payload.rate_limits), safeEventTimeMs, deltaTotals, planTypes);
+        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 };
 }

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

@@ -4,32 +4,77 @@ export class UsageProviderBase {
         this.label = label;
     }
 }
-export function createEmptyUsageTotals() {
+export function createEmptyUsageTotals(schema = "openai") {
     return {
-        inputTokens: 0,
-        cachedInputTokens: 0,
-        nonCachedInputTokens: 0,
+        inputTotalTokens: 0,
         outputTokens: 0,
         reasoningOutputTokens: 0,
         totalTokens: 0,
         estimatedCredits: 0,
-        eventCount: 0
+        eventCount: 0,
+        tokenBreakdown: createEmptyUsageTokenBreakdown(schema)
+    };
+}
+export function cloneUsageTotals(totals) {
+    return {
+        ...totals,
+        tokenBreakdown: { ...totals.tokenBreakdown }
     };
 }
 export function addUsageTotals(target, source) {
-    target.inputTokens += source.inputTokens;
-    target.cachedInputTokens += source.cachedInputTokens;
-    target.nonCachedInputTokens += source.nonCachedInputTokens;
+    target.inputTotalTokens += source.inputTotalTokens;
     target.outputTokens += source.outputTokens;
     target.reasoningOutputTokens += source.reasoningOutputTokens;
     target.totalTokens += source.totalTokens;
     target.estimatedCredits += source.estimatedCredits;
     target.eventCount += source.eventCount;
+    addUsageTokenBreakdown(target.tokenBreakdown, source.tokenBreakdown);
+    if (source.cacheStatus === "unavailable") {
+        target.cacheStatus = "unavailable";
+    }
+    if (source.estimatedCreditsStatus === "unavailable") {
+        target.estimatedCreditsStatus = "unavailable";
+    }
 }
 export function sumUsageTotals(rows) {
-    const totals = createEmptyUsageTotals();
+    const totals = createEmptyUsageTotals(rows[0]?.tokenBreakdown.schema ?? "openai");
     for (const row of rows) {
         addUsageTotals(totals, row);
     }
     return totals;
 }
+function createEmptyUsageTokenBreakdown(schema) {
+    if (schema === "anthropic") {
+        return {
+            schema,
+            inputTokens: 0,
+            cacheWrite5mInputTokens: 0,
+            cacheWrite1hInputTokens: 0,
+            cacheReadInputTokens: 0,
+            outputTokens: 0
+        };
+    }
+    return {
+        schema,
+        nonCachedInputTokens: 0,
+        cachedInputTokens: 0,
+        outputTokens: 0
+    };
+}
+function addUsageTokenBreakdown(target, source) {
+    if (target.schema !== source.schema) {
+        throw new Error(`Cannot merge ${source.schema} usage totals into ${target.schema} totals.`);
+    }
+    target.outputTokens += source.outputTokens;
+    if (target.schema === "anthropic" && source.schema === "anthropic") {
+        target.inputTokens += source.inputTokens;
+        target.cacheWrite5mInputTokens += source.cacheWrite5mInputTokens;
+        target.cacheWrite1hInputTokens += source.cacheWrite1hInputTokens;
+        target.cacheReadInputTokens += source.cacheReadInputTokens;
+        return;
+    }
+    if (target.schema === "openai" && source.schema === "openai") {
+        target.nonCachedInputTokens += source.nonCachedInputTokens;
+        target.cachedInputTokens += source.cachedInputTokens;
+    }
+}