portable-agent-layer 0.97.0 → 0.99.0

package/src/tools/lib/collectors/billing.ts

@@ -0,0 +1,105 @@
+/**
+ * How each agent's model calls are paid for: a subscription, an API key, or
+ * unknown. Each reader takes the few fields that say so and nothing else from
+ * files that also hold the agent's credentials.
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { platform } from "../../../hooks/lib/paths";
+
+export interface Billing {
+  billing: "subscription" | "api" | "unknown";
+  plan: string | null;
+  extraUsage: boolean | null;
+}
+
+export const UNKNOWN: Billing = { billing: "unknown", plan: null, extraUsage: null };
+const API: Billing = { billing: "api", plan: null, extraUsage: null };
+const SUBSCRIPTION: Billing = { billing: "subscription", plan: null, extraUsage: null };
+
+type Json = Record<string, unknown>;
+
+function readJson(path: string): Json {
+  try {
+    return existsSync(path) ? JSON.parse(readFileSync(path, "utf-8")) : {};
+  } catch {
+    return {};
+  }
+}
+
+function stringField(record: unknown, name: string): string | null {
+  const value = (record as Json | undefined)?.[name];
+  return typeof value === "string" ? value : null;
+}
+
+function booleanField(record: unknown, name: string): boolean | null {
+  const value = (record as Json | undefined)?.[name];
+  return typeof value === "boolean" ? value : null;
+}
+
+interface ClaudeSubscription {
+  plan: string | null;
+  extraUsage: boolean | null;
+  since: number;
+}
+
+function claudeSubscriptionOf(config: Json): ClaudeSubscription | null {
+  const account = config.oauthAccount;
+  if (!stringField(account, "billingType")) return null;
+  return {
+    plan:
+      stringField(account, "organizationRateLimitTier") ??
+      stringField(account, "organizationType"),
+    extraUsage: booleanField(account, "hasExtraUsageEnabled"),
+    since: Date.parse(stringField(account, "subscriptionCreatedAt") ?? ""),
+  };
+}
+
+export function claudeConfigFile(): string {
+  return resolve(dirname(platform.claudeDir()), ".claude.json");
+}
+
+/** Billing for a call at `at`; a call older than the subscription is unknown. */
+export function claudeBilling(configPath: string): (at: string) => Billing {
+  const config = readJson(configPath);
+  const subscription = claudeSubscriptionOf(config);
+  const apiKeyLogin = "primaryApiKey" in config;
+  return (at) => {
+    if (!subscription) return apiKeyLogin ? API : UNKNOWN;
+    if (Date.parse(at) < subscription.since) return UNKNOWN;
+    return {
+      billing: "subscription",
+      plan: subscription.plan,
+      extraUsage: subscription.extraUsage,
+    };
+  };
+}
+
+const CODEX_AUTH_MODES: Record<string, Billing> = { apikey: API, chatgpt: SUBSCRIPTION };
+
+export function codexBilling(authPath: string): Billing {
+  return CODEX_AUTH_MODES[stringField(readJson(authPath), "auth_mode") ?? ""] ?? UNKNOWN;
+}
+
+const OPENCODE_AUTH_TYPES: Record<string, Billing> = {
+  oauth: SUBSCRIPTION,
+  api: API,
+  wellknown: API,
+};
+
+/** Billing per provider, from the type of the login opencode holds for it. */
+export function opencodeBilling(
+  authPath: string
+): (provider: string | undefined) => Billing {
+  const logins = readJson(authPath);
+  const billingOf = new Map(
+    Object.entries(logins).map(([provider, login]) => [
+      provider,
+      OPENCODE_AUTH_TYPES[stringField(login, "type") ?? ""] ?? UNKNOWN,
+    ])
+  );
+  return (provider) => (provider && billingOf.get(provider)) || UNKNOWN;
+}
+
+export const COPILOT_BILLING = SUBSCRIPTION;

package/src/tools/lib/collectors/claude.ts

@@ -7,11 +7,12 @@
  * cursor stops where it starts.
  */
 
-import { readFileSync, statSync } from "node:fs";
-import { relative, sep } from "node:path";
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { relative, resolve, sep } from "node:path";
 import { appendEvent } from "../../../hooks/lib/events";
 import { cacheWritesOf, type TranscriptUsage } from "../transcript-usage";
 import { claudeTranscripts } from "../usage-buckets";
+import { type Billing, UNKNOWN } from "./billing";
 import { readCursor, writeCursor } from "./cursors";
 
 const SETTLE_MS = 5 * 60_000;
@@ -34,12 +35,14 @@ interface ClaudeLine {
   };
 }
 
+type ModelCallLine = ClaudeLine & { timestamp: string };
+
 interface SettledRead {
-  messages: ClaudeLine[];
+  messages: ModelCallLine[];
   resumeAt: number;
 }
 
-function isModelCall(line: ClaudeLine | null): line is ClaudeLine {
+function isModelCall(line: ClaudeLine | null): line is ModelCallLine {
   return (
     line?.type === "assistant" &&
     !!line.message?.usage &&
@@ -57,8 +60,7 @@ function parsed(text: string): ClaudeLine | null {
   }
 }
 
-function completeLinesFrom(filepath: string, offset: number) {
-  const bytes = readFileSync(filepath);
+function completeLinesFrom(bytes: Buffer, offset: number) {
   const end = bytes.lastIndexOf(10) + 1;
   if (end <= offset) return { lines: [], end: offset };
   const lines: { text: string; start: number }[] = [];
@@ -73,13 +75,9 @@ function completeLinesFrom(filepath: string, offset: number) {
   return { lines, end };
 }
 
-function settledMessages(
-  filepath: string,
-  offset: number,
-  settled: boolean
-): SettledRead {
-  const { lines, end } = completeLinesFrom(filepath, offset);
-  const groups = new Map<string, { start: number; line: ClaudeLine }>();
+function settledMessages(bytes: Buffer, offset: number, settled: boolean): SettledRead {
+  const { lines, end } = completeLinesFrom(bytes, offset);
+  const groups = new Map<string, { start: number; line: ModelCallLine }>();
   let newest: string | undefined;
   for (const { text, start } of lines) {
     if (!text.includes('"usage"')) continue;
@@ -97,11 +95,12 @@ function settledMessages(
   };
 }
 
-function emitModelCall(line: ClaudeLine): void {
+function emitModelCall(line: ClaudeLine, billing: Billing): void {
   const usage = line.message?.usage ?? {};
   appendEvent(
     "model_call",
     {
+      ...billing,
       model: line.message?.model,
       requestedModel: line.requestedModel,
       inputTokens: usage.input_tokens,
@@ -132,17 +131,58 @@ function isSettled(filepath: string, now: Date): boolean {
   return now.getTime() - statSync(filepath).mtimeMs > SETTLE_MS;
 }
 
-export function collectClaude(projectsDir: string, now: Date = new Date()): number {
+interface Transcript {
+  key: string;
+  bytes: () => Buffer;
+  settled: boolean;
+}
+
+function liveTranscripts(projectsDir: string, now: Date): Transcript[] {
+  return claudeTranscripts(projectsDir).map((filepath) => ({
+    key: relative(projectsDir, filepath).split(sep).join("/"),
+    bytes: () => readFileSync(filepath),
+    settled: isSettled(filepath, now),
+  }));
+}
+
+function copiesOfDeletedTranscripts(
+  copiesDir: string,
+  projectsDir: string
+): Transcript[] {
+  if (!existsSync(copiesDir)) return [];
+  return readdirSync(copiesDir, { recursive: true, encoding: "utf-8" })
+    .map((file) => file.split(sep).join("/"))
+    .filter((file) => file.endsWith(".jsonl.gz"))
+    .map((file) => file.slice(0, -".gz".length))
+    .filter((key) => !existsSync(resolve(projectsDir, key)))
+    .map((key) => ({
+      key,
+      bytes: () =>
+        Buffer.from(Bun.gunzipSync(readFileSync(resolve(copiesDir, `${key}.gz`)))),
+      settled: true,
+    }));
+}
+
+/** Reads each transcript from its cursor; one Claude Code already deleted is read from PAL's copy. */
+export function collectClaude(
+  projectsDir: string,
+  now: Date = new Date(),
+  billingAt: (at: string) => Billing = () => UNKNOWN,
+  copiesDir?: string
+): number {
   const cursor = readCursor("claude");
   let emitted = 0;
-  for (const filepath of claudeTranscripts(projectsDir)) {
-    const key = relative(projectsDir, filepath).split(sep).join("/");
-    const offset = Number(cursor[key] ?? 0);
-    const read = settledMessages(filepath, offset, isSettled(filepath, now));
+  const transcripts = [
+    ...liveTranscripts(projectsDir, now),
+    ...(copiesDir ? copiesOfDeletedTranscripts(copiesDir, projectsDir) : []),
+  ];
+  for (const transcript of transcripts) {
+    const offset = Number(cursor[transcript.key] ?? 0);
+    const read = settledMessages(transcript.bytes(), offset, transcript.settled);
     if (read.resumeAt === offset) continue;
-    for (const line of read.messages) emitModelCall(line);
+    for (const line of read.messages) emitModelCall(line, billingAt(line.timestamp));
     emitted += read.messages.length;
-    cursor[key] = read.resumeAt;
+    cursor[transcript.key] = read.resumeAt;
     writeCursor("claude", cursor);
   }
   return emitted;

package/src/tools/lib/collectors/codex.ts

@@ -5,9 +5,10 @@
  */
 
 import { readFileSync, statSync } from "node:fs";
-import { relative, sep } from "node:path";
+import { relative, resolve, sep } from "node:path";
 import { appendEvent } from "../../../hooks/lib/events";
 import { codexRollouts } from "../agent-usage";
+import { type Billing, codexBilling } from "./billing";
 import { readCursor, writeCursor } from "./cursors";
 
 interface CodexUsage {
@@ -90,12 +91,13 @@ function callsOf(filepath: string): CodexCall[] {
   return calls;
 }
 
-function emitModelCall({ ts, usage, context }: CodexCall): void {
+function emitModelCall({ ts, usage, context }: CodexCall, billing: Billing): void {
   const cacheRead = usage.cached_input_tokens ?? 0;
   const cacheWrite = usage.cache_write_input_tokens ?? 0;
   appendEvent(
     "model_call",
     {
+      ...billing,
       model: context.model,
       provider: context.provider,
       inputTokens: (usage.input_tokens ?? 0) - cacheRead - cacheWrite,
@@ -111,6 +113,7 @@ function emitModelCall({ ts, usage, context }: CodexCall): void {
 
 export function collectCodex(codexDir: string): number {
   const cursor = readCursor("codex");
+  const billing = codexBilling(resolve(codexDir, "auth.json"));
   let emitted = 0;
   for (const filepath of codexRollouts(codexDir)) {
     const key = relative(codexDir, filepath).split(sep).join("/");
@@ -119,7 +122,7 @@ export function collectCodex(codexDir: string): number {
     const collectedTotal = Number(cursor[key] ?? -1);
     for (const call of callsOf(filepath)) {
       if (call.total <= collectedTotal) continue;
-      emitModelCall(call);
+      emitModelCall(call, billing);
       emitted++;
       cursor[key] = call.total;
     }

package/src/tools/lib/collectors/copilot.ts

@@ -7,6 +7,7 @@
 import { existsSync } from "node:fs";
 import { resolve } from "node:path";
 import { appendEvent } from "../../../hooks/lib/events";
+import { COPILOT_BILLING } from "./billing";
 import { readCursor, writeCursor } from "./cursors";
 import { type AllowList, selectAllowed } from "./sqlite";
 
@@ -66,6 +67,7 @@ function emitModelCall(row: UsageRow, session: SessionRow | undefined): void {
   appendEvent(
     "model_call",
     {
+      ...COPILOT_BILLING,
       model: row.model,
       inputTokens: num(row.input_tokens) - cacheRead,
       outputTokens: row.output_tokens,

package/src/tools/lib/collectors/index.ts

@@ -12,6 +12,7 @@ import { paths, platform } from "../../../hooks/lib/paths";
 import { eventLogEnabled } from "../../../hooks/lib/settings";
 import { opencodeDatabase } from "../agent-usage";
 import { antigravityDatabase, collectAntigravity } from "./antigravity";
+import { claudeBilling, claudeConfigFile } from "./billing";
 import { collectClaude } from "./claude";
 import { collectCodex } from "./codex";
 import { collectCopilot, copilotDatabase } from "./copilot";
@@ -20,7 +21,13 @@ import { collectOpencode } from "./opencode";
 const LOCK_STALE_MS = 10 * 60_000;
 
 const COLLECTORS: Record<string, () => number> = {
-  claude: () => collectClaude(resolve(platform.claudeDir(), "projects")),
+  claude: () =>
+    collectClaude(
+      resolve(platform.claudeDir(), "projects"),
+      new Date(),
+      claudeBilling(claudeConfigFile()),
+      resolve(paths.content(), "claude")
+    ),
   opencode: () => collectOpencode(opencodeDatabase()),
   codex: () => collectCodex(platform.codexDir()),
   copilot: () => collectCopilot(copilotDatabase(platform.copilotDir())),

package/src/tools/lib/collectors/opencode.ts

@@ -5,7 +5,9 @@
  */
 
 import { existsSync } from "node:fs";
+import { dirname, resolve } from "node:path";
 import { appendEvent } from "../../../hooks/lib/events";
+import { type Billing, opencodeBilling } from "./billing";
 import { readCursor, writeCursor } from "./cursors";
 import { type AllowList, selectAllowed } from "./sqlite";
 
@@ -57,11 +59,16 @@ function durationOf(message: AssistantMessage): number | undefined {
   return created && completed ? completed - created : undefined;
 }
 
-function emitModelCall(row: MessageRow, message: AssistantMessage): void {
+function emitModelCall(
+  row: MessageRow,
+  message: AssistantMessage,
+  billing: Billing
+): void {
   const tokens = message.tokens ?? {};
   appendEvent(
     "model_call",
     {
+      ...billing,
       model: message.modelID,
       provider: message.providerID,
       inputTokens: tokens.input,
@@ -99,12 +106,13 @@ export function collectOpencode(dbPath: string, now: Date = new Date()): number
       id: String(cursor.id ?? ""),
     }
   );
+  const billingOf = opencodeBilling(resolve(dirname(dbPath), "auth.json"));
   let emitted = 0;
   for (const row of rows) {
     const message = assistantMessageOf(row);
     if (message && stillStreaming(message, row, now)) break;
     if (message) {
-      emitModelCall(row, message);
+      emitModelCall(row, message, billingOf(message.providerID));
       emitted++;
     }
     cursor.order = row.time_created;

package/src/tools/lib/cost-report.ts

@@ -0,0 +1,134 @@
+/**
+ * What each month cost against what the same calls would have cost at API
+ * prices, read off the model_call events. A call is priced exactly as
+ * pal cli usage prices it, so the two never disagree about the same data.
+ */
+
+import type { LoggedEvent } from "../../hooks/lib/events";
+import { costOfUsage } from "../../hooks/lib/models";
+import { planPriceFor } from "./plan-prices";
+import { fmtCost } from "./token-report";
+
+export interface AgentMonth {
+  calls: number;
+  unpriced: number;
+  apiEquivalent: number;
+  billing: Set<string>;
+  plans: Map<string, string>;
+  apiBilled: number;
+  extraUsage: boolean;
+}
+
+export type CostMonths = Map<string, Map<string, AgentMonth>>;
+
+const numberOf = (value: unknown) => (typeof value === "number" ? value : 0);
+
+/** Claude Code at its dated rates, opencode at the cost it recorded, anything else unknown. */
+function apiPriceOf(event: LoggedEvent): number | null {
+  if (event.runtime === "opencode")
+    return typeof event.costUsd === "number" ? event.costUsd : null;
+  if (event.runtime !== "claude" || typeof event.model !== "string") return null;
+  return costOfUsage(
+    event.model,
+    {
+      input: numberOf(event.inputTokens),
+      output: numberOf(event.outputTokens),
+      cacheWrite5m: numberOf(event.cacheWrite5m),
+      cacheWrite1h: numberOf(event.cacheWrite1h),
+      cacheRead: numberOf(event.cacheRead),
+    },
+    event.ts
+  );
+}
+
+function emptyAgentMonth(): AgentMonth {
+  return {
+    calls: 0,
+    unpriced: 0,
+    apiEquivalent: 0,
+    billing: new Set(),
+    plans: new Map(),
+    apiBilled: 0,
+    extraUsage: false,
+  };
+}
+
+function addCall(month: AgentMonth, event: LoggedEvent): void {
+  const price = apiPriceOf(event);
+  const billing = typeof event.billing === "string" ? event.billing : "unknown";
+  month.calls++;
+  month.billing.add(billing);
+  if (price === null) month.unpriced++;
+  else month.apiEquivalent += price;
+  if (billing === "api") month.apiBilled += price ?? 0;
+  if (billing === "subscription" && typeof event.plan === "string")
+    month.plans.set(event.plan, month.plans.get(event.plan) ?? event.ts);
+  if (event.extraUsage === true) month.extraUsage = true;
+}
+
+export function costMonths(events: LoggedEvent[]): CostMonths {
+  const months: CostMonths = new Map();
+  for (const event of events) {
+    const month = event.ts.slice(0, 7);
+    const agents = months.get(month) ?? new Map<string, AgentMonth>();
+    months.set(month, agents);
+    const agent = agents.get(event.runtime) ?? emptyAgentMonth();
+    agents.set(event.runtime, agent);
+    addCall(agent, event);
+  }
+  return months;
+}
+
+/** Null when any part of what was paid is unknown. */
+function paidFor(month: AgentMonth): number | null {
+  if (month.billing.has("unknown")) return null;
+  let paid = month.billing.has("api") ? month.apiBilled : 0;
+  if (!month.billing.has("subscription")) return paid;
+  if (month.plans.size === 0) return null;
+  for (const [plan, since] of month.plans) {
+    const price = planPriceFor(plan, since);
+    if (price === null) return null;
+    paid += price;
+  }
+  return paid;
+}
+
+/** Null unless both sides are known and something was paid. */
+function leverageOf(month: AgentMonth): number | null {
+  const paid = paidFor(month);
+  if (paid === null || paid === 0 || month.unpriced > 0) return null;
+  return month.apiEquivalent / paid;
+}
+
+function apiEquivalentLabel(month: AgentMonth): string {
+  if (month.unpriced === month.calls) return "unknown";
+  const priced = fmtCost(month.apiEquivalent);
+  return month.unpriced > 0 ? `${priced} + ${month.unpriced} unpriced calls` : priced;
+}
+
+function paidLabel(month: AgentMonth): string {
+  const paid = paidFor(month);
+  if (paid === null) return "unknown";
+  const extra = month.extraUsage ? " + extra usage (unknown)" : "";
+  return `${fmtCost(paid)}${extra}`;
+}
+
+function agentLine(label: string, month: AgentMonth): string {
+  const leverage = leverageOf(month);
+  const bound = month.extraUsage ? "up to " : "";
+  const leverageText =
+    leverage === null ? "" : `   leverage ${bound}${leverage.toFixed(1)}x`;
+  return `    ${label.padEnd(16)} paid ${paidLabel(month)}   API-equivalent ${apiEquivalentLabel(month)}${leverageText}`;
+}
+
+export function costLines(months: CostMonths, labelOf: (runtime: string) => string) {
+  if (months.size === 0) return ["\n  No model calls in the event log yet\n"];
+  return [...months.keys()]
+    .sort()
+    .flatMap((month) => [
+      `\n  ${month}\n`,
+      ...[...(months.get(month) ?? [])]
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([runtime, agent]) => agentLine(labelOf(runtime), agent)),
+    ]);
+}

package/src/tools/lib/plan-prices.ts

@@ -0,0 +1,24 @@
+/**
+ * What a subscription costs per month, keyed by the plan recorded on each
+ * model_call. Prices from support.claude.com's Max plan article, checked
+ * 2026-10-12; the Max launch date from Bloomberg, 2025-04-09.
+ */
+
+interface PlanPrice {
+  from: string;
+  monthlyUsd: number;
+}
+
+export const PLAN_PRICES: Record<string, PlanPrice[]> = {
+  default_claude_max_5x: [{ from: "2025-04-09", monthlyUsd: 100 }],
+  default_claude_max_20x: [{ from: "2025-04-09", monthlyUsd: 200 }],
+};
+
+/** The monthly price in force at `at`, or null when the plan or its price then is unknown. */
+export function planPriceFor(plan: string | null, at: string): number | null {
+  const when = Date.parse(at);
+  const inForce = (PLAN_PRICES[plan ?? ""] ?? []).filter(
+    (p) => Date.parse(p.from) <= when
+  );
+  return inForce.at(-1)?.monthlyUsd ?? null;
+}

package/src/tools/lib/project-history.ts

@@ -0,0 +1,100 @@
+/**
+ * A project's history as events: its registration, its dated decisions, and
+ * each ISC it closed or retired as the commitment kept or dropped. The live
+ * commands and the backfill build the same rows, so both give one id.
+ */
+
+import type { RecordAttribution } from "../../hooks/lib/actor";
+import { appendEvent } from "../../hooks/lib/events";
+import type { ProjectProgress } from "../../hooks/lib/projects";
+import { parseIscs } from "./project-isc";
+
+export interface HistoryRow {
+  id: string;
+  ts: string;
+  type: "project" | "commitment" | "decision";
+  project: string;
+  fields: Record<string, unknown>;
+  content?: Record<string, unknown>;
+}
+
+const ARCHIVE_HEADING = /^### (Archived|Retired) (\d{4}-\d{2}-\d{2})$/;
+const DECISION_LINE = /^- (\d{4}-\d{2}-\d{2}): (.+)$/;
+
+const dayStart = (day: string) => `${day}T00:00:00.000Z`;
+
+function shortHash(text: string): string {
+  return new Bun.CryptoHasher("sha256").update(text).digest("hex").slice(0, 12);
+}
+
+export function registrationRow(
+  project: Pick<ProjectProgress, "name" | "created" | "status">
+): HistoryRow {
+  return {
+    id: `project:${project.name}:registered`,
+    ts: project.created,
+    type: "project",
+    project: project.name,
+    fields: { change: "registered", status: project.status },
+  };
+}
+
+export function decisionRow(project: string, day: string, text: string): HistoryRow {
+  return {
+    id: `decision:${project}:${day}:${shortHash(text)}`,
+    ts: dayStart(day),
+    type: "decision",
+    project,
+    fields: { words: text.split(/\s+/).length },
+    content: { text },
+  };
+}
+
+export function decisionRows(project: ProjectProgress): HistoryRow[] {
+  return (project.decisions ?? "").split("\n").flatMap((line) => {
+    const decision = DECISION_LINE.exec(line);
+    return decision ? [decisionRow(project.name, decision[1], decision[2])] : [];
+  });
+}
+
+export function closedIscRows(project: ProjectProgress): HistoryRow[] {
+  const rows: HistoryRow[] = [];
+  let heading: RegExpExecArray | null = null;
+  for (const line of (project.changelog ?? "").split("\n")) {
+    heading = ARCHIVE_HEADING.exec(line) ?? heading;
+    const [isc] = parseIscs(line);
+    if (!heading || !isc) continue;
+    const outcome = heading[1] === "Retired" ? "dropped" : "kept";
+    rows.push({
+      id: `commitment:${project.name}:${isc.id}:${outcome}:${heading[2]}`,
+      ts: dayStart(heading[2]),
+      type: "commitment",
+      project: project.name,
+      fields: {
+        iscProject: project.name,
+        isc: isc.id,
+        outcome,
+        surface: null,
+        snoozeDays: null,
+      },
+      content: { text: isc.text },
+    });
+  }
+  return rows;
+}
+
+export function emitHistoryRow(
+  row: HistoryRow,
+  attribution: Partial<RecordAttribution> = {}
+): string | null {
+  return appendEvent(row.type, row.fields, {
+    id: row.id,
+    ts: row.ts,
+    session: null,
+    channel: null,
+    cwd: "",
+    project: row.project,
+    attribution,
+    ...(row.content && { content: row.content }),
+  });
+}

package/src/tools/lib/session-usage.ts

@@ -147,13 +147,17 @@ export function accumulateUsage(transcript: string, sessionId: string): SessionU
     const cacheRead = usage.cache_read_input_tokens ?? 0;
     const { cacheWrite5m, cacheWrite1h } = cacheWritesOf(usage);
 
-    total.cost += costOfUsage(model, {
-      input,
-      output,
-      cacheWrite5m,
-      cacheWrite1h,
-      cacheRead,
-    });
+    total.cost += costOfUsage(
+      model,
+      {
+        input,
+        output,
+        cacheWrite5m,
+        cacheWrite1h,
+        cacheRead,
+      },
+      entry.timestamp
+    );
     total.input += input;
     total.output += output;
     total.cacheWrite5m += cacheWrite5m;