zevairouter 1.0.153 → 1.0.154

package/src/lib/db/repos/usageRepo.js

@@ -1,4 +1,5 @@
 import { EventEmitter } from "events";
+import { createHash } from "node:crypto";
 import { getAdapter } from "../driver.js";
 import { parseJson, stringifyJson } from "../helpers/jsonCol.js";
 import { getMeta, setMeta } from "../helpers/metaStore.js";
@@ -18,12 +19,14 @@ if (!global._statsEmitter) {
 if (!global._pendingTimers) global._pendingTimers = {};
 if (!global._recentRing) global._recentRing = { items: [], initialized: false };
 if (!global._connectionMapCache) global._connectionMapCache = { map: {}, ts: 0 };
+if (!global._usageWritesInFlight) global._usageWritesInFlight = new Set();
 
 const pendingRequests = global._pendingRequests;
 const lastErrorProvider = global._lastErrorProvider;
 const pendingTimers = global._pendingTimers;
 const recentRing = global._recentRing;
 const connCache = global._connectionMapCache;
+const usageWritesInFlight = global._usageWritesInFlight;
 
 export const statsEmitter = global._statsEmitter;
 
@@ -53,6 +56,62 @@ function extractCachedTokens(tokens) {
   );
 }
 
+function getAccountBucketKey(connectionId, model, provider) {
+  return `${connectionId}|${model || "unknown"}|${provider || "unknown"}`;
+}
+
+function getApiKeyBucketKey(apiKey, model, provider) {
+  return `${apiKey || "local-no-key"}|${model || "unknown"}|${provider || "unknown"}`;
+}
+
+function hashUsageIdentity(value) {
+  return createHash("sha256").update(String(value)).digest("hex").slice(0, 20);
+}
+
+function getUsageApiKeyLabel(rawApiKey, keyInfo) {
+  if (!rawApiKey) return "Local (No API Key)";
+  return keyInfo?.name || `External Key ${hashUsageIdentity(rawApiKey).slice(0, 8)}`;
+}
+
+function sanitizeApiKeyBreakdown(byApiKey, apiKeyMap) {
+  const sanitized = {};
+  for (const [internalBucketKey, entry] of Object.entries(byApiKey || {})) {
+    const rawApiKey = typeof entry.apiKey === "string" && entry.apiKey ? entry.apiKey : null;
+    const keyInfo = rawApiKey ? apiKeyMap[rawApiKey] : null;
+    const apiKeyKey = rawApiKey
+      ? (keyInfo?.id || `external-${hashUsageIdentity(rawApiKey)}`)
+      : "local-no-key";
+    const safeEntry = { ...entry, apiKeyKey };
+    delete safeEntry.apiKey;
+    sanitized[`bucket-${hashUsageIdentity(internalBucketKey)}`] = safeEntry;
+  }
+  return sanitized;
+}
+
+function rebuildAccountBucketsFromHistory(rows) {
+  const buckets = {};
+  for (const row of rows) {
+    if (!row.connectionId) continue;
+    const tokens = parseJson(row.tokens, {}) || {};
+    const promptTokens = row.promptTokens || tokens.prompt_tokens || tokens.input_tokens || 0;
+    const completionTokens = row.completionTokens || tokens.completion_tokens || tokens.output_tokens || 0;
+    const key = getAccountBucketKey(row.connectionId, row.model, row.provider);
+    addToCounter(buckets, key, {
+      requests: 1,
+      promptTokens,
+      completionTokens,
+      cachedTokens: extractCachedTokens(tokens),
+      cost: row.cost || 0,
+      meta: {
+        connectionId: row.connectionId,
+        rawModel: row.model || "",
+        provider: row.provider || "",
+      },
+    });
+  }
+  return buckets;
+}
+
 function aggregateEntryToDay(day, entry) {
   const promptTokens = entry.tokens?.prompt_tokens || entry.tokens?.input_tokens || 0;
   const completionTokens = entry.tokens?.completion_tokens || entry.tokens?.output_tokens || 0;
@@ -78,11 +137,15 @@ function aggregateEntryToDay(day, entry) {
   addToCounter(day.byModel, modelKey, { ...vals, meta: { rawModel: entry.model, provider: entry.provider } });
 
   if (entry.connectionId) {
-    addToCounter(day.byAccount, entry.connectionId, { ...vals, meta: { rawModel: entry.model, provider: entry.provider } });
+    const accountKey = getAccountBucketKey(entry.connectionId, entry.model, entry.provider);
+    addToCounter(day.byAccount, accountKey, {
+      ...vals,
+      meta: { connectionId: entry.connectionId, rawModel: entry.model, provider: entry.provider },
+    });
   }
 
-  const apiKeyVal = entry.apiKey && typeof entry.apiKey === "string" ? entry.apiKey : "local-no-key";
-  const akModelKey = `${apiKeyVal}|${entry.model}|${entry.provider || "unknown"}`;
+  const apiKeyVal = entry.apiKey && typeof entry.apiKey === "string" ? entry.apiKey : null;
+  const akModelKey = getApiKeyBucketKey(apiKeyVal, entry.model, entry.provider);
   addToCounter(day.byApiKey, akModelKey, { ...vals, meta: { rawModel: entry.model, provider: entry.provider, apiKey: entry.apiKey || null } });
 
   const endpoint = entry.endpoint || "Unknown";
@@ -133,8 +196,17 @@ async function calculateCost(provider, model, tokens) {
 
     let cost = 0;
     const inputTokens = tokens.prompt_tokens || tokens.input_tokens || 0;
-    const cachedTokens = tokens.cached_tokens || tokens.cache_read_input_tokens || 0;
-    const nonCachedInput = Math.max(0, inputTokens - cachedTokens);
+    const cachedTokens = extractCachedTokens(tokens);
+    // OpenAI prompt_tokens includes cached input; Anthropic input_tokens does
+    // not. Native Anthropic usage is normalized with cache_read_input_tokens,
+    // so only subtract cache when the OpenAI-style field is present.
+    const cachedIncludedInInput = (
+      tokens.cached_tokens !== undefined
+      || tokens.prompt_tokens_details?.cached_tokens !== undefined
+    );
+    const nonCachedInput = cachedIncludedInInput
+      ? Math.max(0, inputTokens - cachedTokens)
+      : inputTokens;
     cost += nonCachedInput * (pricing.input / 1000000);
 
     if (cachedTokens > 0) {
@@ -185,18 +257,15 @@ export function dedupeRecentRequests(entries, limit = 20) {
     .slice(0, limit);
 }
 
-export function trackPendingRequest(model, provider, connectionId, started, error = false) {
-  const modelKey = provider ? `${model} (${provider})` : model;
-  const timerKey = `${connectionId}|${modelKey}`;
-
+function adjustPendingCount(modelKey, connectionId, delta) {
   if (!pendingRequests.byModel[modelKey]) pendingRequests.byModel[modelKey] = 0;
-  pendingRequests.byModel[modelKey] = Math.max(0, pendingRequests.byModel[modelKey] + (started ? 1 : -1));
+  pendingRequests.byModel[modelKey] = Math.max(0, pendingRequests.byModel[modelKey] + delta);
   if (pendingRequests.byModel[modelKey] === 0) delete pendingRequests.byModel[modelKey];
 
   if (connectionId) {
     if (!pendingRequests.byAccount[connectionId]) pendingRequests.byAccount[connectionId] = {};
     if (!pendingRequests.byAccount[connectionId][modelKey]) pendingRequests.byAccount[connectionId][modelKey] = 0;
-    pendingRequests.byAccount[connectionId][modelKey] = Math.max(0, pendingRequests.byAccount[connectionId][modelKey] + (started ? 1 : -1));
+    pendingRequests.byAccount[connectionId][modelKey] = Math.max(0, pendingRequests.byAccount[connectionId][modelKey] + delta);
     if (pendingRequests.byAccount[connectionId][modelKey] === 0) {
       delete pendingRequests.byAccount[connectionId][modelKey];
       if (Object.keys(pendingRequests.byAccount[connectionId]).length === 0) {
@@ -204,20 +273,53 @@ export function trackPendingRequest(model, provider, connectionId, started, erro
       }
     }
   }
+}
+
+function getPendingTimerQueue(timerKey, modelKey, connectionId) {
+  const existing = pendingTimers[timerKey];
+  if (Array.isArray(existing)) return existing;
+  // Hot reload may leave one timer from the previous implementation behind.
+  if (existing) {
+    clearTimeout(existing);
+    adjustPendingCount(modelKey, connectionId, -1);
+  }
+  const queue = [];
+  pendingTimers[timerKey] = queue;
+  return queue;
+}
+
+export function trackPendingRequest(model, provider, connectionId, started, error = false) {
+  const modelKey = provider ? `${model} (${provider})` : model;
+  const timerKey = `${connectionId}|${modelKey}`;
+
+  adjustPendingCount(modelKey, connectionId, started ? 1 : -1);
 
   if (started) {
-    clearTimeout(pendingTimers[timerKey]);
-    pendingTimers[timerKey] = setTimeout(() => {
-      delete pendingTimers[timerKey];
-      if (pendingRequests.byModel[modelKey] > 0) pendingRequests.byModel[modelKey] = 0;
-      if (connectionId && pendingRequests.byAccount[connectionId]?.[modelKey] > 0) {
-        pendingRequests.byAccount[connectionId][modelKey] = 0;
+    const queue = getPendingTimerQueue(timerKey, modelKey, connectionId);
+    const timer = setTimeout(() => {
+      const currentQueue = pendingTimers[timerKey];
+      if (Array.isArray(currentQueue)) {
+        const index = currentQueue.indexOf(timer);
+        if (index >= 0) currentQueue.splice(index, 1);
+        if (currentQueue.length === 0) delete pendingTimers[timerKey];
       }
+      // Expire only the request represented by this timer. Other accounts or
+      // concurrent requests in the same bucket may still be active.
+      adjustPendingCount(modelKey, connectionId, -1);
       statsEmitter.emit("pending");
     }, PENDING_TIMEOUT_MS);
+    timer.unref?.();
+    queue.push(timer);
   } else {
-    clearTimeout(pendingTimers[timerKey]);
-    delete pendingTimers[timerKey];
+    const queue = pendingTimers[timerKey];
+    if (Array.isArray(queue)) {
+      const timer = queue.shift();
+      if (timer) clearTimeout(timer);
+      if (queue.length === 0) delete pendingTimers[timerKey];
+    } else if (queue) {
+      clearTimeout(queue);
+      delete pendingTimers[timerKey];
+    }
   }
 
   if (!started && error && provider) {
@@ -265,7 +367,7 @@ export async function getActiveRequests() {
   return { activeRequests, recentRequests, errorProvider };
 }
 
-export async function saveRequestUsage(entry) {
+async function persistRequestUsage(entry) {
   try {
     const db = await getAdapter();
 
@@ -315,6 +417,19 @@ export async function saveRequestUsage(entry) {
   }
 }
 
+export function saveRequestUsage(entry) {
+  const write = persistRequestUsage(entry);
+  usageWritesInFlight.add(write);
+  void write.finally(() => usageWritesInFlight.delete(write));
+  return write;
+}
+
+export async function flushRequestUsageWrites() {
+  while (usageWritesInFlight.size > 0) {
+    await Promise.allSettled([...usageWritesInFlight]);
+  }
+}
+
 export async function getUsageHistory(filter = {}) {
   const db = await getAdapter();
   const conds = [];
@@ -440,6 +555,16 @@ export async function getUsageStats(period = "all") {
     const periodDays = { "7d": 7, "30d": 30, "60d": 60 };
     const maxDays = periodDays[period] || null;
     const dayRows = loadDaysInRange(db, maxDays);
+    const overlayCutoff = maxDays ? Date.now() - maxDays * 86400000 : 0;
+    const histRows = db.all(
+      `SELECT timestamp, provider, model, connectionId, apiKey, endpoint, promptTokens, completionTokens, cost, tokens FROM usageHistory WHERE timestamp >= ?`,
+      [new Date(overlayCutoff).toISOString()]
+    );
+    const historyByDay = {};
+    for (const row of histRows) {
+      const dateKey = getLocalDateKey(row.timestamp);
+      (historyByDay[dateKey] ||= []).push(row);
+    }
 
     for (const dr of dayRows) {
       const dateKey = dr.dateKey;
@@ -464,27 +589,39 @@ export async function getUsageStats(period = "all") {
         const statsKey = provider ? `${rawModel} (${provider})` : rawModel;
         const providerDisplayName = providerNodeNameMap[provider] || provider;
         if (!stats.byModel[statsKey]) {
-          stats.byModel[statsKey] = { requests: 0, promptTokens: 0, completionTokens: 0, cost: 0, rawModel, provider: providerDisplayName, lastUsed: dateKey };
+          stats.byModel[statsKey] = { requests: 0, promptTokens: 0, completionTokens: 0, cachedTokens: 0, cost: 0, rawModel, provider: providerDisplayName, lastUsed: dateKey };
         }
         stats.byModel[statsKey].requests += m.requests || 0;
         stats.byModel[statsKey].promptTokens += m.promptTokens || 0;
         stats.byModel[statsKey].completionTokens += m.completionTokens || 0;
+        stats.byModel[statsKey].cachedTokens += m.cachedTokens || 0;
         stats.byModel[statsKey].cost += m.cost || 0;
         if (dateKey > (stats.byModel[statsKey].lastUsed || "")) stats.byModel[statsKey].lastUsed = dateKey;
       }
 
-      for (const [connId, a] of Object.entries(day.byAccount || {})) {
+      let accountBuckets = day.byAccount || {};
+      const hasLegacyAccountBucket = Object.values(accountBuckets).some((entry) => !entry?.connectionId);
+      const dayHistory = historyByDay[dateKey] || [];
+      if (hasLegacyAccountBucket && dayHistory.length === (day.requests || 0)) {
+        accountBuckets = rebuildAccountBucketsFromHistory(dayHistory);
+      }
+
+      for (const [storedKey, a] of Object.entries(accountBuckets)) {
+        // Legacy rows used only connectionId as the key. New rows carry it as
+        // metadata because their persisted key also includes model/provider.
+        const connId = a.connectionId || storedKey;
         const accountName = connectionMap[connId] || `Account ${connId.slice(0, 8)}...`;
         const rawModel = a.rawModel || "";
         const provider = a.provider || "";
         const providerDisplayName = providerNodeNameMap[provider] || provider;
-        const accountKey = `${rawModel} (${provider} - ${accountName})`;
+        const accountKey = getAccountBucketKey(connId, rawModel, provider);
         if (!stats.byAccount[accountKey]) {
-          stats.byAccount[accountKey] = { requests: 0, promptTokens: 0, completionTokens: 0, cost: 0, rawModel, provider: providerDisplayName, connectionId: connId, accountName, lastUsed: dateKey };
+          stats.byAccount[accountKey] = { requests: 0, promptTokens: 0, completionTokens: 0, cachedTokens: 0, cost: 0, rawModel, provider: providerDisplayName, providerId: provider, connectionId: connId, accountName, lastUsed: dateKey };
         }
         stats.byAccount[accountKey].requests += a.requests || 0;
         stats.byAccount[accountKey].promptTokens += a.promptTokens || 0;
         stats.byAccount[accountKey].completionTokens += a.completionTokens || 0;
+        stats.byAccount[accountKey].cachedTokens += a.cachedTokens || 0;
         stats.byAccount[accountKey].cost += a.cost || 0;
         if (dateKey > (stats.byAccount[accountKey].lastUsed || "")) stats.byAccount[accountKey].lastUsed = dateKey;
       }
@@ -495,14 +632,15 @@ export async function getUsageStats(period = "all") {
         const providerDisplayName = providerNodeNameMap[provider] || provider;
         const apiKeyVal = ak.apiKey;
         const keyInfo = apiKeyVal ? apiKeyMap[apiKeyVal] : null;
-        const keyName = keyInfo?.name || (apiKeyVal ? apiKeyVal.slice(0, 8) + "..." : "Local (No API Key)");
+        const keyName = getUsageApiKeyLabel(apiKeyVal, keyInfo);
         const apiKeyKey = apiKeyVal || "local-no-key";
         if (!stats.byApiKey[akKey]) {
-          stats.byApiKey[akKey] = { requests: 0, promptTokens: 0, completionTokens: 0, cost: 0, rawModel, provider: providerDisplayName, apiKey: apiKeyVal, keyName, apiKeyKey, lastUsed: dateKey };
+          stats.byApiKey[akKey] = { requests: 0, promptTokens: 0, completionTokens: 0, cachedTokens: 0, cost: 0, rawModel, provider: providerDisplayName, apiKey: apiKeyVal, keyName, apiKeyKey, lastUsed: dateKey };
         }
         stats.byApiKey[akKey].requests += ak.requests || 0;
         stats.byApiKey[akKey].promptTokens += ak.promptTokens || 0;
         stats.byApiKey[akKey].completionTokens += ak.completionTokens || 0;
+        stats.byApiKey[akKey].cachedTokens += ak.cachedTokens || 0;
         stats.byApiKey[akKey].cost += ak.cost || 0;
         if (dateKey > (stats.byApiKey[akKey].lastUsed || "")) stats.byApiKey[akKey].lastUsed = dateKey;
       }
@@ -513,36 +651,33 @@ export async function getUsageStats(period = "all") {
         const provider = ep.provider || "";
         const providerDisplayName = providerNodeNameMap[provider] || provider;
         if (!stats.byEndpoint[epKey]) {
-          stats.byEndpoint[epKey] = { requests: 0, promptTokens: 0, completionTokens: 0, cost: 0, endpoint, rawModel, provider: providerDisplayName, lastUsed: dateKey };
+          stats.byEndpoint[epKey] = { requests: 0, promptTokens: 0, completionTokens: 0, cachedTokens: 0, cost: 0, endpoint, rawModel, provider: providerDisplayName, lastUsed: dateKey };
         }
         stats.byEndpoint[epKey].requests += ep.requests || 0;
         stats.byEndpoint[epKey].promptTokens += ep.promptTokens || 0;
         stats.byEndpoint[epKey].completionTokens += ep.completionTokens || 0;
+        stats.byEndpoint[epKey].cachedTokens += ep.cachedTokens || 0;
         stats.byEndpoint[epKey].cost += ep.cost || 0;
         if (dateKey > (stats.byEndpoint[epKey].lastUsed || "")) stats.byEndpoint[epKey].lastUsed = dateKey;
       }
     }
 
     // Overlay precise lastUsed timestamps from history
-    const overlayCutoff = maxDays ? Date.now() - maxDays * 86400000 : 0;
-    const histRows = db.all(
-      `SELECT timestamp, provider, model, connectionId, apiKey, endpoint FROM usageHistory WHERE timestamp >= ?`,
-      [new Date(overlayCutoff).toISOString()]
-    );
     for (const e of histRows) {
       const ts = e.timestamp;
       const modelKey = e.provider ? `${e.model} (${e.provider})` : e.model;
       if (stats.byModel[modelKey] && new Date(ts) > new Date(stats.byModel[modelKey].lastUsed)) stats.byModel[modelKey].lastUsed = ts;
 
       if (e.connectionId) {
-        const accountName = connectionMap[e.connectionId] || `Account ${e.connectionId.slice(0, 8)}...`;
-        const accountKey = `${e.model} (${e.provider} - ${accountName})`;
+        const accountKey = getAccountBucketKey(e.connectionId, e.model, e.provider);
         if (stats.byAccount[accountKey] && new Date(ts) > new Date(stats.byAccount[accountKey].lastUsed)) stats.byAccount[accountKey].lastUsed = ts;
       }
 
-      const apiKeyKey = (e.apiKey && typeof e.apiKey === "string")
-        ? `${e.apiKey}|${e.model}|${e.provider || "unknown"}`
-        : "local-no-key";
+      const apiKeyKey = getApiKeyBucketKey(
+        e.apiKey && typeof e.apiKey === "string" ? e.apiKey : null,
+        e.model,
+        e.provider
+      );
       if (stats.byApiKey[apiKeyKey] && new Date(ts) > new Date(stats.byApiKey[apiKeyKey].lastUsed)) stats.byApiKey[apiKeyKey].lastUsed = ts;
 
       const endpoint = e.endpoint || "Unknown";
@@ -566,8 +701,8 @@ export async function getUsageStats(period = "all") {
 
     for (const r of filtered) {
       const tokens = parseJson(r.tokens, {}) || {};
-      const promptTokens = tokens.prompt_tokens || 0;
-      const completionTokens = tokens.completion_tokens || 0;
+      const promptTokens = tokens.prompt_tokens || tokens.input_tokens || 0;
+      const completionTokens = tokens.completion_tokens || tokens.output_tokens || 0;
       const cachedTokens = extractCachedTokens(tokens);
       const entryCost = r.cost || 0;
       const providerDisplayName = providerNodeNameMap[r.provider] || r.provider;
@@ -586,58 +721,62 @@ export async function getUsageStats(period = "all") {
 
       const modelKey = r.provider ? `${r.model} (${r.provider})` : r.model;
       if (!stats.byModel[modelKey]) {
-        stats.byModel[modelKey] = { requests: 0, promptTokens: 0, completionTokens: 0, cost: 0, rawModel: r.model, provider: providerDisplayName, lastUsed: r.timestamp };
+        stats.byModel[modelKey] = { requests: 0, promptTokens: 0, completionTokens: 0, cachedTokens: 0, cost: 0, rawModel: r.model, provider: providerDisplayName, lastUsed: r.timestamp };
       }
       stats.byModel[modelKey].requests++;
       stats.byModel[modelKey].promptTokens += promptTokens;
       stats.byModel[modelKey].completionTokens += completionTokens;
+      stats.byModel[modelKey].cachedTokens += cachedTokens;
       stats.byModel[modelKey].cost += entryCost;
       if (new Date(r.timestamp) > new Date(stats.byModel[modelKey].lastUsed)) stats.byModel[modelKey].lastUsed = r.timestamp;
 
       if (r.connectionId) {
         const accountName = connectionMap[r.connectionId] || `Account ${r.connectionId.slice(0, 8)}...`;
-        const accountKey = `${r.model} (${r.provider} - ${accountName})`;
+        const accountKey = getAccountBucketKey(r.connectionId, r.model, r.provider);
         if (!stats.byAccount[accountKey]) {
-          stats.byAccount[accountKey] = { requests: 0, promptTokens: 0, completionTokens: 0, cost: 0, rawModel: r.model, provider: providerDisplayName, connectionId: r.connectionId, accountName, lastUsed: r.timestamp };
+          stats.byAccount[accountKey] = { requests: 0, promptTokens: 0, completionTokens: 0, cachedTokens: 0, cost: 0, rawModel: r.model, provider: providerDisplayName, providerId: r.provider, connectionId: r.connectionId, accountName, lastUsed: r.timestamp };
         }
         stats.byAccount[accountKey].requests++;
         stats.byAccount[accountKey].promptTokens += promptTokens;
         stats.byAccount[accountKey].completionTokens += completionTokens;
+        stats.byAccount[accountKey].cachedTokens += cachedTokens;
         stats.byAccount[accountKey].cost += entryCost;
         if (new Date(r.timestamp) > new Date(stats.byAccount[accountKey].lastUsed)) stats.byAccount[accountKey].lastUsed = r.timestamp;
       }
 
       if (r.apiKey && typeof r.apiKey === "string") {
         const keyInfo = apiKeyMap[r.apiKey];
-        const keyName = keyInfo?.name || r.apiKey.slice(0, 8) + "...";
-        const akKey = `${r.apiKey}|${r.model}|${r.provider || "unknown"}`;
+        const keyName = getUsageApiKeyLabel(r.apiKey, keyInfo);
+        const akKey = getApiKeyBucketKey(r.apiKey, r.model, r.provider);
         if (!stats.byApiKey[akKey]) {
-          stats.byApiKey[akKey] = { requests: 0, promptTokens: 0, completionTokens: 0, cost: 0, rawModel: r.model, provider: providerDisplayName, apiKey: r.apiKey, keyName, apiKeyKey: r.apiKey, lastUsed: r.timestamp };
+          stats.byApiKey[akKey] = { requests: 0, promptTokens: 0, completionTokens: 0, cachedTokens: 0, cost: 0, rawModel: r.model, provider: providerDisplayName, apiKey: r.apiKey, keyName, apiKeyKey: r.apiKey, lastUsed: r.timestamp };
         }
         const ake = stats.byApiKey[akKey];
-        ake.requests++; ake.promptTokens += promptTokens; ake.completionTokens += completionTokens; ake.cost += entryCost;
+        ake.requests++; ake.promptTokens += promptTokens; ake.completionTokens += completionTokens; ake.cachedTokens += cachedTokens; ake.cost += entryCost;
         if (new Date(r.timestamp) > new Date(ake.lastUsed)) ake.lastUsed = r.timestamp;
       } else {
-        if (!stats.byApiKey["local-no-key"]) {
-          stats.byApiKey["local-no-key"] = { requests: 0, promptTokens: 0, completionTokens: 0, cost: 0, rawModel: r.model, provider: providerDisplayName, apiKey: null, keyName: "Local (No API Key)", apiKeyKey: "local-no-key", lastUsed: r.timestamp };
+        const akKey = getApiKeyBucketKey(null, r.model, r.provider);
+        if (!stats.byApiKey[akKey]) {
+          stats.byApiKey[akKey] = { requests: 0, promptTokens: 0, completionTokens: 0, cachedTokens: 0, cost: 0, rawModel: r.model, provider: providerDisplayName, apiKey: null, keyName: "Local (No API Key)", apiKeyKey: "local-no-key", lastUsed: r.timestamp };
         }
-        const ake = stats.byApiKey["local-no-key"];
-        ake.requests++; ake.promptTokens += promptTokens; ake.completionTokens += completionTokens; ake.cost += entryCost;
+        const ake = stats.byApiKey[akKey];
+        ake.requests++; ake.promptTokens += promptTokens; ake.completionTokens += completionTokens; ake.cachedTokens += cachedTokens; ake.cost += entryCost;
         if (new Date(r.timestamp) > new Date(ake.lastUsed)) ake.lastUsed = r.timestamp;
       }
 
       const endpoint = r.endpoint || "Unknown";
       const epKey = `${endpoint}|${r.model}|${r.provider || "unknown"}`;
       if (!stats.byEndpoint[epKey]) {
-        stats.byEndpoint[epKey] = { requests: 0, promptTokens: 0, completionTokens: 0, cost: 0, endpoint, rawModel: r.model, provider: providerDisplayName, lastUsed: r.timestamp };
+        stats.byEndpoint[epKey] = { requests: 0, promptTokens: 0, completionTokens: 0, cachedTokens: 0, cost: 0, endpoint, rawModel: r.model, provider: providerDisplayName, lastUsed: r.timestamp };
       }
       const epe = stats.byEndpoint[epKey];
-      epe.requests++; epe.promptTokens += promptTokens; epe.completionTokens += completionTokens; epe.cost += entryCost;
+      epe.requests++; epe.promptTokens += promptTokens; epe.completionTokens += completionTokens; epe.cachedTokens += cachedTokens; epe.cost += entryCost;
       if (new Date(r.timestamp) > new Date(epe.lastUsed)) epe.lastUsed = r.timestamp;
     }
   }
 
   stats.totalRequests = Object.values(stats.byProvider).reduce((sum, p) => sum + (p.requests || 0), 0);
+  stats.byApiKey = sanitizeApiKeyBreakdown(stats.byApiKey, apiKeyMap);
   return stats;
 }