tokenmax-collector 0.2.0 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tokenmax-collector",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Report local ccusage token usage to a tokenmax instance",
   "type": "module",
   "bin": {
@@ -19,7 +19,7 @@
     "directory": "packages/collector"
   },
   "engines": {
-    "bun": ">=1.3.14"
+    "bun": ">=1.4.0"
   },
   "scripts": {
     "check-types": "tsc --noEmit",

package/src/antigravity.ts

@@ -11,6 +11,11 @@ export interface AntigravityStep {
   output: number;
 }
 
+export interface AntigravityUsage {
+  failures: string[];
+  steps: AntigravityStep[];
+}
+
 interface ProtoField {
   number: number;
   value: bigint | Uint8Array;
@@ -43,10 +48,16 @@ export function antigravityConversationsDir(home: string): string {
 function decodeMessage(bytes: Uint8Array): ProtoField[] {
   const fields: ProtoField[] = [];
   let offset = 0;
+  const truncated = (): never => {
+    throw new Error("truncated protobuf message");
+  };
   const varint = (): bigint => {
     let result = 0n;
     let shift = 0n;
     for (;;) {
+      if (offset >= bytes.length) {
+        truncated();
+      }
       const byte = bytes[offset++];
       result |= BigInt(byte & 0x7f) << shift;
       if (byte < 0x80) {
@@ -56,6 +67,9 @@ function decodeMessage(bytes: Uint8Array): ProtoField[] {
     }
   };
   const bytesOf = (length: number): Uint8Array => {
+    if (offset + length > bytes.length) {
+      truncated();
+    }
     const slice = bytes.subarray(offset, offset + length);
     offset += length;
     return slice;
@@ -108,7 +122,7 @@ function text(fields: ProtoField[], number: number): string | null {
 function openReadOnly(file: string): DatabaseSync {
   const location = existsSync(`${file}-wal`)
     ? file
-    : `file:${file}?immutable=1`;
+    : `file:${file.split("/").map(encodeURIComponent).join("/")}?immutable=1`;
   return new DatabaseSync(location, { readOnly: true });
 }
 
@@ -159,23 +173,35 @@ function readConversation(
 
 export async function readAntigravitySteps(
   dir: string,
-): Promise<AntigravityStep[]> {
+): Promise<AntigravityUsage> {
   let files: string[];
   try {
     files = await readdir(dir);
   } catch (error) {
     if ((error as NodeJS.ErrnoException).code === "ENOENT") {
-      return [];
+      return { failures: [], steps: [] };
     }
     throw error;
   }
   const names = new Map<number, string>();
   const steps: RawStep[] = [];
+  const failures: string[] = [];
   for (const file of files.filter((name) => name.endsWith(".db")).sort()) {
-    readConversation(resolve(dir, file), names, steps);
+    const conversation = resolve(dir, file);
+    const before = steps.length;
+    try {
+      readConversation(conversation, names, steps);
+    } catch (error) {
+      steps.length = before;
+      const message = error instanceof Error ? error.message : String(error);
+      failures.push(`${conversation}: ${message}`);
+    }
   }
-  return steps.map(({ modelCode, ...step }) => ({
-    ...step,
-    model: names.get(modelCode) ?? unknownModel,
-  }));
+  return {
+    failures,
+    steps: steps.map(({ modelCode, ...step }) => ({
+      ...step,
+      model: names.get(modelCode) ?? unknownModel,
+    })),
+  };
 }

package/src/cli.ts

@@ -36,13 +36,26 @@ async function runCollect(io: CliIo): Promise<number> {
     runner: io.runner,
     today: io.today,
   });
-  if (result.kind === "reported") {
-    io.stdout(`accepted ${result.accepted} days for ${result.machine}`);
-    return 0;
-  }
-  if (result.kind === "empty") {
-    io.stdout("nothing to report");
-    return 0;
+  if (result.kind === "reported" || result.kind === "empty") {
+    for (const warning of result.warnings) {
+      io.stderr(warning);
+    }
+    if (result.kind === "empty") {
+      io.stdout("nothing to report");
+      return 0;
+    }
+    let exitCode = 0;
+    for (const target of result.targets) {
+      if ("accepted" in target) {
+        io.stdout(
+          `accepted ${target.accepted} days for ${result.machine} at ${target.url}`,
+        );
+      } else {
+        io.stderr(`${target.url}: ${target.message}`);
+        exitCode = 1;
+      }
+    }
+    return exitCode;
   }
   if (result.kind === "missing-config") {
     io.stderr(

package/src/collect.ts

@@ -1,4 +1,5 @@
 import {
+  type AntigravityStep,
   antigravityConversationsDir,
   readAntigravitySteps,
 } from "./antigravity";
@@ -9,12 +10,19 @@ import {
   windowStart,
 } from "./ccusage";
 import { type CommandRunner, runCommand } from "./command";
-import { readConfig, runtimeTimezone } from "./config";
+import { type CollectorTarget, readConfig, runtimeTimezone } from "./config";
+import { type DevinStep, devinTranscriptsDir, readDevinSteps } from "./devin";
 import type { Fetcher } from "./http";
 import { type MachineIdentity, machineId } from "./machine";
-import { mapAntigravitySteps, mapCcusageDays } from "./mapping";
+import {
+  antigravityProvider,
+  devinProvider,
+  mapAntigravitySteps,
+  mapCcusageDays,
+  mapDevinSteps,
+} from "./mapping";
 import { type CollectorEnv, collectorPaths, processEnv } from "./paths";
-import { loadPrices } from "./pricing";
+import { loadPrices, type PriceTable } from "./pricing";
 import type { UsageDay, UsageReport } from "./usage";
 
 export interface CollectOptions {
@@ -26,9 +34,18 @@ export interface CollectOptions {
   timezone?: string;
 }
 
+export type TargetResult =
+  | { accepted: number; url: string }
+  | { message: string; url: string };
+
 export type CollectResult =
-  | { kind: "reported"; accepted: number; machine: string }
-  | { kind: "empty" }
+  | {
+      kind: "reported";
+      machine: string;
+      targets: TargetResult[];
+      warnings: string[];
+    }
+  | { kind: "empty"; warnings: string[] }
   | { kind: "missing-config"; configFile: string }
   | { kind: "failed"; message: string };
 
@@ -56,53 +73,100 @@ function acceptedCount(body: string): number | null {
   return typeof accepted === "number" ? accepted : null;
 }
 
+interface LocalRows {
+  days: UsageDay[];
+  warnings: string[];
+}
+
+interface LocalSource<Step extends { at: Date }> {
+  map: (steps: Step[], timezone: string, prices: PriceTable) => UsageDay[];
+  provider: string;
+  read: (home: string) => Promise<{ failures: string[]; steps: Step[] }>;
+}
+
+interface LocalWindow {
+  fetcher: Fetcher;
+  home: string;
+  pricesFile: string;
+  since: string;
+  timezone: string;
+  today: Date;
+}
+
+const antigravitySource: LocalSource<AntigravityStep> = {
+  map: mapAntigravitySteps,
+  provider: antigravityProvider,
+  read: (home) => readAntigravitySteps(antigravityConversationsDir(home)),
+};
+
+const devinSource: LocalSource<DevinStep> = {
+  map: mapDevinSteps,
+  provider: devinProvider,
+  read: (home) => readDevinSteps(devinTranscriptsDir(home)),
+};
+
 async function report(
   fetcher: Fetcher,
-  url: string,
-  key: string,
-  usage: UsageReport,
-): Promise<CollectResult> {
-  const response = await fetcher(reportUrl(url), {
-    body: JSON.stringify(usage),
-    headers: {
-      Authorization: `Bearer ${key}`,
-      "Content-Type": "application/json",
-    },
-    method: "POST",
-  });
-  const body = await response.text();
-  if (response.status !== 200) {
-    return {
-      kind: "failed",
-      message: `tokenmax responded ${response.status}: ${body}`,
-    };
-  }
-  const accepted = acceptedCount(body);
-  if (accepted === null) {
-    return {
-      kind: "failed",
-      message: `tokenmax responded an unexpected body: ${body}`,
-    };
+  target: CollectorTarget,
+  body: string,
+): Promise<TargetResult> {
+  const { url } = target;
+  try {
+    const response = await fetcher(reportUrl(url), {
+      body,
+      headers: {
+        Authorization: `Bearer ${target.key}`,
+        "Content-Type": "application/json",
+      },
+      method: "POST",
+    });
+    const answer = await response.text();
+    if (response.status !== 200) {
+      return {
+        message: `tokenmax responded ${response.status}: ${answer}`,
+        url,
+      };
+    }
+    const accepted = acceptedCount(answer);
+    if (accepted === null) {
+      return {
+        message: `tokenmax responded an unexpected body: ${answer}`,
+        url,
+      };
+    }
+    return { accepted, url };
+  } catch (error) {
+    return { message: messageOf(error), url };
   }
-  return { accepted, kind: "reported", machine: usage.machine };
 }
 
-async function antigravityDays(
-  home: string,
-  today: Date,
-  timezone: string,
-  fetcher: Fetcher,
-  pricesFile: string,
-): Promise<UsageDay[]> {
-  const since = windowStart(today, timezone);
-  const steps = (
-    await readAntigravitySteps(antigravityConversationsDir(home))
-  ).filter((step) => calendarDate(step.at, timezone) >= since);
-  if (steps.length === 0) {
-    return [];
+async function localDays<Step extends { at: Date }>(
+  source: LocalSource<Step>,
+  window: LocalWindow,
+): Promise<LocalRows> {
+  try {
+    const usage = await source.read(window.home);
+    const warnings = usage.failures.map(
+      (failure) => `${source.provider}: skipped ${failure}`,
+    );
+    const steps = usage.steps.filter(
+      (step) => calendarDate(step.at, window.timezone) >= window.since,
+    );
+    if (steps.length === 0) {
+      return { days: [], warnings };
+    }
+    const prices = await loadPrices(
+      window.fetcher,
+      window.pricesFile,
+      window.today,
+    );
+    return { days: source.map(steps, window.timezone, prices), warnings };
+  } catch (error) {
+    return {
+      days: [],
+      warnings: [`${source.provider}: ${messageOf(error)}`],
+    };
   }
-  const prices = await loadPrices(fetcher, pricesFile, today);
-  return mapAntigravitySteps(steps, timezone, prices);
 }
 
 export async function collect(options: CollectOptions): Promise<CollectResult> {
@@ -133,30 +197,32 @@ export async function collect(options: CollectOptions): Promise<CollectResult> {
       sinceArgument(today, timezone),
       timezone,
     );
-    days = [
-      ...mapCcusageDays(daily),
-      ...(await antigravityDays(
-        env.home,
-        today,
-        timezone,
-        fetcher,
-        paths.pricesFile,
-      )),
-    ];
+    days = mapCcusageDays(daily);
   } catch (error) {
     return { kind: "failed", message: messageOf(error) };
   }
+
+  const window: LocalWindow = {
+    fetcher,
+    home: env.home,
+    pricesFile: paths.pricesFile,
+    since: windowStart(today, timezone),
+    timezone,
+    today,
+  };
+  const antigravity = await localDays(antigravitySource, window);
+  const devin = await localDays(devinSource, window);
+  days.push(...antigravity.days, ...devin.days);
+  const warnings = [...antigravity.warnings, ...devin.warnings];
   if (days.length === 0) {
-    return { kind: "empty" };
+    return { kind: "empty", warnings };
   }
 
-  try {
-    return await report(fetcher, config.config.url, config.config.key, {
-      days,
-      machine,
-      timezone,
-    });
-  } catch (error) {
-    return { kind: "failed", message: messageOf(error) };
+  const usage: UsageReport = { days, machine, timezone };
+  const body = JSON.stringify(usage);
+  const targets: TargetResult[] = [];
+  for (const target of config.config.targets) {
+    targets.push(await report(fetcher, target, body));
   }
+  return { kind: "reported", machine, targets, warnings };
 }

package/src/config.ts

@@ -2,12 +2,25 @@ import { chmod, mkdir, readFile, writeFile } from "node:fs/promises";
 import { dirname } from "node:path";
 import { z } from "zod";
 
-export const collectorConfig = z.object({
+export const collectorTarget = z.object({
   key: z.string().min(1),
-  timezone: z.string().min(1).optional(),
   url: z.url({ protocol: /^https?$/ }),
 });
 
+const timezone = z.string().min(1).optional();
+
+export const collectorConfig = z.object({
+  targets: z.array(collectorTarget).min(1),
+  timezone,
+});
+
+const singleTargetConfig = collectorTarget
+  .extend({ timezone })
+  .transform(({ key, url, ...rest }) => ({ targets: [{ key, url }], ...rest }));
+
+const storedConfig = z.union([collectorConfig, singleTargetConfig]);
+
+export type CollectorTarget = z.infer<typeof collectorTarget>;
 export type CollectorConfig = z.infer<typeof collectorConfig>;
 
 export function canonicalTimezone(value: string): string | null {
@@ -62,7 +75,7 @@ export async function readConfig(
     };
   }
 
-  const parsed = collectorConfig.safeParse(payload);
+  const parsed = storedConfig.safeParse(payload);
   if (!parsed.success) {
     return {
       kind: "invalid",

package/src/devin.ts

@@ -0,0 +1,94 @@
+import { readdir, readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { z } from "zod";
+
+export interface DevinStep {
+  at: Date;
+  cacheCreate: number;
+  cacheRead: number;
+  input: number;
+  model: string;
+  output: number;
+}
+
+export interface DevinUsage {
+  failures: string[];
+  steps: DevinStep[];
+}
+
+const unknownModel = "devin-unknown";
+
+const metrics = z.object({
+  cached_tokens: z.int().optional(),
+  completion_tokens: z.int(),
+  extra: z
+    .object({ cache_creation_input_tokens: z.int().optional() })
+    .optional(),
+  prompt_tokens: z.int(),
+});
+
+const step = z.object({
+  metrics: metrics.optional(),
+  model_name: z.string().optional(),
+  source: z.string(),
+  timestamp: z.iso.datetime({ offset: true }),
+});
+
+const transcript = z.object({ steps: z.array(step) });
+
+const issueText = (error: z.ZodError): string =>
+  error.issues
+    .map((issue) => `${issue.path.join(".")}: ${issue.message}`)
+    .join("; ");
+
+export function devinTranscriptsDir(home: string): string {
+  return resolve(home, ".local", "share", "devin", "cli", "transcripts");
+}
+
+function parseTranscript(source: string): DevinStep[] {
+  const parsed = transcript.safeParse(JSON.parse(source));
+  if (!parsed.success) {
+    throw new Error(issueText(parsed.error));
+  }
+  const steps: DevinStep[] = [];
+  for (const entry of parsed.data.steps) {
+    if (entry.source !== "agent" || entry.metrics === undefined) {
+      continue;
+    }
+    const cacheRead = entry.metrics.cached_tokens ?? 0;
+    const cacheCreate = entry.metrics.extra?.cache_creation_input_tokens ?? 0;
+    steps.push({
+      at: new Date(entry.timestamp),
+      cacheCreate,
+      cacheRead,
+      input: entry.metrics.prompt_tokens - cacheRead - cacheCreate,
+      model: entry.model_name ?? unknownModel,
+      output: entry.metrics.completion_tokens,
+    });
+  }
+  return steps;
+}
+
+export async function readDevinSteps(dir: string): Promise<DevinUsage> {
+  let files: string[];
+  try {
+    files = await readdir(dir);
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+      return { failures: [], steps: [] };
+    }
+    throw error;
+  }
+  const steps: DevinStep[] = [];
+  const failures: string[] = [];
+  for (const file of files.filter((name) => name.endsWith(".json")).sort()) {
+    const path = resolve(dir, file);
+    try {
+      steps.push(...parseTranscript(await readFile(path, "utf8")));
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      failures.push(`${path}: ${message}`);
+    }
+  }
+  return { failures, steps };
+}

package/src/install.ts

@@ -3,8 +3,10 @@ import { dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import {
   type CollectorConfig,
+  type CollectorTarget,
   canonicalTimezone,
   collectorConfig,
+  readConfig,
   runtimeTimezone,
   writeConfig,
 } from "./config";
@@ -67,6 +69,13 @@ function scheduleFiles(
   ];
 }
 
+async function configuredTargets(
+  configFile: string,
+): Promise<CollectorTarget[]> {
+  const existing = await readConfig(configFile);
+  return existing.kind === "ok" ? existing.config.targets : [];
+}
+
 export async function install(options: InstallOptions): Promise<InstallPlan> {
   const env = options.env ?? processEnv();
   const platform = resolvePlatform(options.platform ?? process.platform);
@@ -76,10 +85,12 @@ export async function install(options: InstallOptions): Promise<InstallPlan> {
   if (timezone === null) {
     throw new Error(`invalid timezone: ${requestedTimezone}`);
   }
+  const others = (await configuredTargets(paths.configFile)).filter(
+    (target) => target.url !== options.url,
+  );
   const config = collectorConfig.parse({
-    key: options.key,
+    targets: [...others, { key: options.key, url: options.url }],
     timezone,
-    url: options.url,
   });
   const cliPath = options.cliPath ?? resolveCliPath();
   if (
@@ -106,6 +117,9 @@ export async function install(options: InstallOptions): Promise<InstallPlan> {
   const log = options.log ?? console.log;
 
   log(`config: ${plan.configFile} (600, key redacted)`);
+  for (const target of plan.config.targets) {
+    log(`target: ${target.url}`);
+  }
   for (const file of plan.files) {
     log(`schedule: ${file.path}`);
   }

package/src/mapping.ts

@@ -1,11 +1,18 @@
 import type { AntigravityStep } from "./antigravity";
 import { type CcusageDaily, calendarDate } from "./ccusage";
-import { costOf, type PriceTable } from "./pricing";
+import type { DevinStep } from "./devin";
+import { costOf, type ModelPrice, type PriceTable } from "./pricing";
 import type { UsageDay } from "./usage";
 
 export const antigravityProvider = "antigravity";
+export const devinProvider = "devin";
 
 const agentModelPrefix = /^\[[^\]]*\]\s*/;
+const effortSuffix = /-(low|medium|high|xhigh)$/;
+const gptMinorVersion = /^gpt-(\d+)-(\d+)-/;
+
+const litellmModel = (devinModel: string): string =>
+  devinModel.replace(effortSuffix, "").replace(gptMinorVersion, "gpt-$1.$2-");
 
 const rowKey = (day: UsageDay): string =>
   `${day.date}\u0000${day.provider}\u0000${day.model}`;
@@ -53,23 +60,33 @@ export function mapCcusageDays(output: CcusageDaily): UsageDay[] {
   return sortedRows(rows);
 }
 
-export function mapAntigravitySteps(
-  steps: AntigravityStep[],
+interface LocalStep {
+  at: Date;
+  cacheCreate?: number;
+  cacheRead: number;
+  input: number;
+  model: string;
+  output: number;
+}
+
+function mapLocalSteps(
+  steps: LocalStep[],
+  provider: string,
   timezone: string,
-  prices: PriceTable,
+  priceOf: (model: string) => ModelPrice | undefined,
 ): UsageDay[] {
   const rows = new Map<string, UsageDay>();
 
   for (const step of steps) {
     const row: UsageDay = {
-      cache_create: 0,
+      cache_create: step.cacheCreate ?? 0,
       cache_read: step.cacheRead,
       cost_usd: 0,
       date: calendarDate(step.at, timezone),
       input: step.input,
       model: step.model,
       output: step.output,
-      provider: antigravityProvider,
+      provider,
     };
     if (isEmptyRow(row)) {
       continue;
@@ -80,17 +97,19 @@ export function mapAntigravitySteps(
       rows.set(key, row);
       continue;
     }
+    existing.cache_create += row.cache_create;
     existing.cache_read += row.cache_read;
     existing.input += row.input;
     existing.output += row.output;
   }
 
   for (const row of rows.values()) {
-    const price = prices.get(row.model) ?? prices.get(`gemini/${row.model}`);
+    const price = priceOf(row.model);
     row.cost_usd =
       price === undefined
         ? 0
         : costOf(price, {
+            cacheCreate: row.cache_create,
             cacheRead: row.cache_read,
             input: row.input,
             output: row.output,
@@ -100,6 +119,32 @@ export function mapAntigravitySteps(
   return sortedRows(rows);
 }
 
+export function mapAntigravitySteps(
+  steps: AntigravityStep[],
+  timezone: string,
+  prices: PriceTable,
+): UsageDay[] {
+  return mapLocalSteps(
+    steps,
+    antigravityProvider,
+    timezone,
+    (model) => prices.get(model) ?? prices.get(`gemini/${model}`),
+  );
+}
+
+export function mapDevinSteps(
+  steps: DevinStep[],
+  timezone: string,
+  prices: PriceTable,
+): UsageDay[] {
+  return mapLocalSteps(
+    steps.map((step) => ({ ...step, model: litellmModel(step.model) })),
+    devinProvider,
+    timezone,
+    (model) => prices.get(model),
+  );
+}
+
 function sortedRows(rows: Map<string, UsageDay>): UsageDay[] {
   return [...rows.values()].sort(
     (a, b) =>

package/src/pricing.ts

@@ -1,9 +1,10 @@
-import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import { mkdir, readFile, rename, stat, writeFile } from "node:fs/promises";
 import { dirname } from "node:path";
 import { z } from "zod";
 import type { Fetcher } from "./http";
 
 export interface ModelPrice {
+  cacheCreate: number;
   cacheRead: number;
   input: number;
   output: number;
@@ -12,6 +13,7 @@ export interface ModelPrice {
 export type PriceTable = Map<string, ModelPrice>;
 
 export interface PricedUsage {
+  cacheCreate?: number;
   cacheRead: number;
   input: number;
   output: number;
@@ -23,6 +25,7 @@ export const litellmPricesUrl =
 const maxAgeMs = 24 * 60 * 60 * 1000;
 
 const pricedEntry = z.object({
+  cache_creation_input_token_cost: z.number().optional(),
   cache_read_input_token_cost: z.number().optional(),
   input_cost_per_token: z.number(),
   output_cost_per_token: z.number(),
@@ -38,6 +41,7 @@ export function parseLitellmPrices(source: string): PriceTable {
     const priced = pricedEntry.safeParse(entry);
     if (priced.success) {
       table.set(model, {
+        cacheCreate: priced.data.cache_creation_input_token_cost ?? 0,
         cacheRead: priced.data.cache_read_input_token_cost ?? 0,
         input: priced.data.input_cost_per_token,
         output: priced.data.output_cost_per_token,
@@ -51,25 +55,39 @@ export function costOf(price: ModelPrice, usage: PricedUsage): number {
   return (
     usage.input * price.input +
     usage.output * price.output +
-    usage.cacheRead * price.cacheRead
+    usage.cacheRead * price.cacheRead +
+    (usage.cacheCreate ?? 0) * price.cacheCreate
   );
 }
 
 async function readCache(
   pricesFile: string,
-): Promise<{ modifiedAt: number; source: string } | null> {
+): Promise<{ modifiedAt: number; table: PriceTable } | null> {
+  let source: string;
+  let modifiedAt: number;
   try {
-    const [source, info] = await Promise.all([
+    [source, modifiedAt] = await Promise.all([
       readFile(pricesFile, "utf8"),
-      stat(pricesFile),
+      stat(pricesFile).then((info) => info.mtimeMs),
     ]);
-    return { modifiedAt: info.mtimeMs, source };
   } catch (error) {
     if ((error as NodeJS.ErrnoException).code === "ENOENT") {
       return null;
     }
     throw error;
   }
+  try {
+    return { modifiedAt, table: parseLitellmPrices(source) };
+  } catch {
+    return null;
+  }
+}
+
+async function writeCache(pricesFile: string, source: string): Promise<void> {
+  await mkdir(dirname(pricesFile), { recursive: true });
+  const partial = `${pricesFile}.${process.pid}.tmp`;
+  await writeFile(partial, source);
+  await rename(partial, pricesFile);
 }
 
 async function fetchPrices(fetcher: Fetcher): Promise<string> {
@@ -88,7 +106,7 @@ export async function loadPrices(
 ): Promise<PriceTable> {
   const cached = await readCache(pricesFile);
   if (cached !== null && now.getTime() - cached.modifiedAt < maxAgeMs) {
-    return parseLitellmPrices(cached.source);
+    return cached.table;
   }
   let source: string;
   let table: PriceTable;
@@ -97,12 +115,11 @@ export async function loadPrices(
     table = parseLitellmPrices(source);
   } catch (error) {
     if (cached !== null) {
-      return parseLitellmPrices(cached.source);
+      return cached.table;
     }
     const message = error instanceof Error ? error.message : String(error);
     throw new Error(`could not load model prices: ${message}`);
   }
-  await mkdir(dirname(pricesFile), { recursive: true });
-  await writeFile(pricesFile, source);
+  await writeCache(pricesFile, source);
   return table;
 }