@leo000001/opencode-quota-sidebar 4.0.9 → 4.0.11

package/dist/usage_service.js

@@ -1,16 +1,19 @@
-import { TtlValueCache } from './cache.js';
-import { API_COST_ENABLED_PROVIDERS, cacheCoverageModeFromRates, calcEquivalentApiCostForMessage, canonicalApiCostProviderID, canonicalPricingProviderID, getBundledModelCostMap, modelCostLookupKeys, modelCostKey, parseModelCostRates, } from './cost.js';
-import { deleteSessionFromDayChunk, dateKeyFromTimestamp, scanAllSessions, updateSessionsInDayChunks, } from './storage.js';
-import { periodStart } from './period.js';
-import { debug, debugError, isRecord, mapConcurrent, swallow, } from './helpers.js';
-import { accumulateMessagesInCompletedRange, emptyUsageSummary, fromCachedSessionUsage, mergeCursorFromEntries, mergeUsage, summarizeMessagesIncremental, toCachedSessionUsage, USAGE_BILLING_CACHE_VERSION, } from './usage.js';
-import { decodeMessageEntries, isMissingSessionError, nextCursorFromResponse, } from './history_messages.js';
-import { computeHistoryUsage } from './history_usage.js';
+import { TtlValueCache } from "./cache.js";
+import { applyExplicitRatesFromSource, applyDerivedTierRatesFromSource, API_COST_RULES_VERSION, cacheCoverageModeFromRates, calcEquivalentApiCostForMessage, canonicalApiCostProviderID, derivedTierBaseModelID, explicitModelCostMap, getBundledModelCostMap, mergeModelCostSource, modelCostLookupKeys, modelCostKey, } from "./cost.js";
+import { deleteSessionFromDayChunk, dateKeyFromTimestamp, scanAllSessions, updateSessionsInDayChunks, } from "./storage.js";
+import { periodStart } from "./period.js";
+import { debug, debugError, isRecord, mapConcurrent, swallow, } from "./helpers.js";
+import { accumulateMessagesInCompletedRange, emptyUsageSummary, fromCachedSessionUsage, mergeCursorFromEntries, mergeUsage, summarizeMessagesIncremental, toCachedSessionUsage, USAGE_BILLING_CACHE_VERSION, } from "./usage.js";
+import { decodeMessageEntries, isMissingSessionError, nextCursorFromResponse, } from "./history_messages.js";
+import { computeHistoryUsage } from "./history_usage.js";
+import { loadModelsDevPricingModels, modelsDevHasProvider, } from "./models_dev_pricing.js";
+import { loadOpenCodePricingModels, } from "./opencode_pricing.js";
+import { opencodeConfigPaths } from "./storage_paths.js";
 const READ_ONLY_CACHE_PROVIDERS = new Set([
-    'openai',
-    'github-copilot',
-    'venice',
-    'openrouter',
+    "openai",
+    "github-copilot",
+    "venice",
+    "openrouter",
 ]);
 export function createUsageService(deps) {
     const forceRescanSessions = new Set();
@@ -33,65 +36,175 @@ export function createUsageService(deps) {
     // (generation bumps), callers should not reuse a stale in-flight computation.
     const usageInFlight = new Map();
     const modelCostCache = new TtlValueCache();
+    let lastSuccessfulRuntimePricingLayer;
     const missingApiCostRateKeys = new Set();
+    const collectModelsDevRequests = (models, currentMap) => {
+        const requests = new Map();
+        const enqueue = (model) => {
+            if (!modelsDevHasProvider(model.providerID))
+                return;
+            requests.set(`${model.providerID}:${model.modelID}`, model);
+        };
+        const hasRates = (providerID, modelID) => modelCostLookupKeys(providerID, modelID).some((key) => Boolean(currentMap[key]));
+        for (const model of models) {
+            if (!hasRates(model.providerID, model.modelID))
+                enqueue(model);
+            const baseModelID = derivedTierBaseModelID(model);
+            if (!baseModelID || hasRates(model.providerID, baseModelID))
+                continue;
+            enqueue({
+                providerID: model.providerID,
+                modelID: baseModelID,
+            });
+        }
+        return [...requests.values()];
+    };
+    const runtimePricingModels = (providers) => {
+        const models = [];
+        for (const provider of providers) {
+            if (!isRecord(provider))
+                continue;
+            const providerID = typeof provider.id === "string" ? provider.id : undefined;
+            if (!providerID)
+                continue;
+            const providerModels = provider.models;
+            if (!isRecord(providerModels))
+                continue;
+            for (const [modelKey, modelValue] of Object.entries(providerModels)) {
+                if (!isRecord(modelValue))
+                    continue;
+                const modelID = typeof modelValue.id === "string" ? modelValue.id : modelKey;
+                models.push({
+                    providerID,
+                    modelID,
+                    modelKey,
+                    cost: modelValue.cost,
+                    options: isRecord(modelValue.options)
+                        ? modelValue.options
+                        : undefined,
+                    headers: isRecord(modelValue.headers)
+                        ? modelValue.headers
+                        : undefined,
+                    api: isRecord(modelValue.api) ? modelValue.api : undefined,
+                    limit: isRecord(modelValue.limit) ? modelValue.limit : undefined,
+                });
+            }
+        }
+        return models;
+    };
     const getModelCostMap = async () => {
         const cached = modelCostCache.get();
         if (cached)
             return cached;
         const fallbackMap = getBundledModelCostMap();
+        const configModels = await loadOpenCodePricingModels(opencodeConfigPaths(deps.worktree || deps.directory, deps.directory));
         const providerClient = deps.client;
         if (!providerClient.provider?.list) {
-            return modelCostCache.set(fallbackMap, 30_000);
+            return modelCostCache.set(mergeModelCostSource(fallbackMap, configModels), 30_000);
         }
         const response = await providerClient.provider
             .list({
             query: { directory: deps.directory },
             throwOnError: true,
         })
-            .catch(swallow('getModelCostMap'));
-        const all = response &&
-            typeof response === 'object' &&
-            'data' in response &&
+            .catch(swallow("getModelCostMap"));
+        const hasRuntimeProviderList = response &&
+            typeof response === "object" &&
+            "data" in response &&
             isRecord(response.data) &&
-            Array.isArray(response.data.all)
-            ? response.data.all
+            Array.isArray(response.data.all);
+        const responseData = hasRuntimeProviderList &&
+            response &&
+            typeof response === "object" &&
+            "data" in response
+            ? response.data
+            : undefined;
+        const runtimeModels = hasRuntimeProviderList && responseData
+            ? runtimePricingModels(responseData.all)
             : [];
-        const map = all.reduce((acc, provider) => {
-            if (!isRecord(provider))
-                return acc;
-            const rawProviderID = typeof provider.id === 'string' ? provider.id : undefined;
-            if (!rawProviderID)
-                return acc;
-            const canonicalProviderID = canonicalPricingProviderID(rawProviderID);
-            const models = provider.models;
-            if (!isRecord(models))
-                return acc;
-            for (const [modelKey, modelValue] of Object.entries(models)) {
-                if (!isRecord(modelValue))
-                    continue;
-                const rates = parseModelCostRates(modelValue.cost);
-                if (!rates)
-                    continue;
-                const modelID = typeof modelValue.id === 'string' ? modelValue.id : modelKey;
-                const lookupKeys = new Set([
-                    ...modelCostLookupKeys(rawProviderID, modelID),
-                    ...modelCostLookupKeys(rawProviderID, modelKey),
-                ]);
-                if (canonicalProviderID !== rawProviderID) {
-                    lookupKeys.add(modelCostKey(canonicalProviderID, modelID));
-                    lookupKeys.add(modelCostKey(canonicalProviderID, modelKey));
-                }
-                for (const key of lookupKeys) {
-                    acc[key] = rates;
+        const configAndBundledLayer = mergeModelCostSource(fallbackMap, configModels);
+        const runtimeExplicitRates = explicitModelCostMap(runtimeModels);
+        const modelsDevModels = await loadModelsDevPricingModels(collectModelsDevRequests(runtimeModels, {
+            ...configAndBundledLayer,
+            ...runtimeExplicitRates,
+        }));
+        const modelsDevLayer = mergeModelCostSource({}, modelsDevModels);
+        const configExplicitRates = explicitModelCostMap(configModels);
+        const runtimeBaseLayer = hasRuntimeProviderList && runtimeModels.length > 0
+            ? mergeModelCostSource(lastSuccessfulRuntimePricingLayer || {}, runtimeModels)
+            : lastSuccessfulRuntimePricingLayer || {};
+        const runtimeLayer = applyDerivedTierRatesFromSource(runtimeBaseLayer, runtimeModels, {
+            ...fallbackMap,
+            ...modelsDevLayer,
+            ...lastSuccessfulRuntimePricingLayer,
+            ...runtimeExplicitRates,
+        }, { skipExplicitRates: runtimeExplicitRates });
+        if (hasRuntimeProviderList) {
+            lastSuccessfulRuntimePricingLayer = runtimeLayer;
+        }
+        let map = {
+            ...fallbackMap,
+            ...modelsDevLayer,
+            ...runtimeLayer,
+        };
+        map = applyExplicitRatesFromSource(map, runtimeModels, configExplicitRates);
+        map = applyDerivedTierRatesFromSource(map, runtimeModels, configExplicitRates, { skipExplicitRates: configExplicitRates });
+        const merged = mergeModelCostSource(map, configModels);
+        return modelCostCache.set(merged, Math.max(30_000, deps.config.quota.refreshMs));
+    };
+    const pricingKeyForMessage = (message) => `${message.providerID}:${message.modelID}`;
+    const collectPricingKeys = (entries, target = new Set()) => {
+        for (const { info } of entries) {
+            if (info.role !== "assistant")
+                continue;
+            target.add(pricingKeyForMessage(info));
+        }
+        return target;
+    };
+    const serializeRates = (rates) => rates
+        ? {
+            input: rates.input,
+            output: rates.output,
+            cacheRead: rates.cacheRead,
+            cacheWrite: rates.cacheWrite,
+            contextOver200k: rates.contextOver200k
+                ? {
+                    input: rates.contextOver200k.input,
+                    output: rates.contextOver200k.output,
+                    cacheRead: rates.contextOver200k.cacheRead,
+                    cacheWrite: rates.contextOver200k.cacheWrite,
                 }
-            }
-            return acc;
-        }, fallbackMap);
-        return modelCostCache.set(map, Math.max(30_000, deps.config.quota.refreshMs));
+                : undefined,
+        }
+        : null;
+    const pricingFingerprintForKeys = (pricingKeys, modelCostMap) => {
+        const normalized = Array.from(new Set(pricingKeys)).sort();
+        return JSON.stringify({
+            version: API_COST_RULES_VERSION,
+            prices: normalized.map((pricingKey) => {
+                const separator = pricingKey.indexOf(":");
+                const providerID = separator >= 0 ? pricingKey.slice(0, separator) : pricingKey;
+                const modelID = separator >= 0 ? pricingKey.slice(separator + 1) : "";
+                const rates = modelCostLookupKeys(providerID, modelID)
+                    .map((key) => modelCostMap[key])
+                    .find(Boolean);
+                return {
+                    providerID,
+                    modelID,
+                    rates: serializeRates(rates),
+                };
+            }),
+        });
+    };
+    const pricingFingerprintForEntries = (entries, modelCostMap) => pricingFingerprintForKeys([...collectPricingKeys(entries)].sort(), modelCostMap);
+    const expectedPricingFingerprintForCached = (cached, modelCostMap) => {
+        if (!cached?.pricingKeys)
+            return undefined;
+        return pricingFingerprintForKeys(cached.pricingKeys, modelCostMap);
     };
     const calcEquivalentApiCost = (message, modelCostMap) => {
         const providerID = canonicalApiCostProviderID(message.providerID);
-        if (!API_COST_ENABLED_PROVIDERS.has(providerID))
+        if (providerID === "github-copilot")
             return 0;
         const rates = modelCostLookupKeys(message.providerID, message.modelID)
             .map((key) => modelCostMap[key])
@@ -111,31 +224,29 @@ export function createUsageService(deps) {
         const baseRates = modelCostLookupKeys(message.providerID, message.modelID)
             .map((key) => modelCostMap[key])
             .find(Boolean);
-        const effectiveRates = baseRates &&
-            message.tokens.input + message.tokens.cache.read > 200_000 &&
-            baseRates.contextOver200k
+        const effectiveRates = baseRates && message.tokens.input > 200_000 && baseRates.contextOver200k
             ? baseRates.contextOver200k
             : baseRates;
         const fromRates = cacheCoverageModeFromRates(effectiveRates);
-        if (fromRates !== 'none')
+        if (fromRates !== "none")
             return fromRates;
         if (message.tokens.cache.write > 0)
-            return 'read-write';
+            return "read-write";
         if (message.tokens.cache.read <= 0)
-            return 'none';
+            return "none";
         const rawProviderID = message.providerID.toLowerCase();
         if (READ_ONLY_CACHE_PROVIDERS.has(canonicalProviderID) ||
             READ_ONLY_CACHE_PROVIDERS.has(rawProviderID)) {
-            return 'read-only';
+            return "read-only";
         }
         // Heuristic fallback: classify by provider identity when pricing is missing.
-        if (canonicalProviderID === 'anthropic' ||
-            message.modelID.toLowerCase().includes('claude')) {
-            return 'read-write';
+        if (canonicalProviderID === "anthropic" ||
+            message.modelID.toLowerCase().includes("claude")) {
+            return "read-write";
         }
         // Last resort: if the message has cache.read tokens from an unknown provider,
         // treat it as read-only (the safer default — avoids overstating cached ratio).
-        return 'read-only';
+        return "read-only";
     };
     const loadSessionEntries = async (sessionID) => {
         try {
@@ -147,13 +258,13 @@ export function createUsageService(deps) {
             const data = response.data;
             const entries = decodeMessageEntries(data);
             if (!entries)
-                return { status: 'error' };
-            return { status: 'ok', entries };
+                return { status: "error" };
+            return { status: "ok", entries };
         }
         catch (error) {
             debugError(`loadSessionEntries ${sessionID}`, error);
             return {
-                status: isMissingSessionError(error) ? 'missing' : 'error',
+                status: isMissingSessionError(error) ? "missing" : "error",
             };
         }
     };
@@ -172,9 +283,9 @@ export function createUsageService(deps) {
             const data = response.data;
             const entries = decodeMessageEntries(data);
             if (!entries)
-                return { status: 'error' };
+                return { status: "error" };
             return {
-                status: 'ok',
+                status: "ok",
                 entries,
                 nextBefore: nextCursorFromResponse(response),
             };
@@ -182,7 +293,7 @@ export function createUsageService(deps) {
         catch (error) {
             debugError(`loadSessionEntriesPage ${sessionID}`, error);
             return {
-                status: isMissingSessionError(error) ? 'missing' : 'error',
+                status: isMissingSessionError(error) ? "missing" : "error",
             };
         }
     };
@@ -196,74 +307,41 @@ export function createUsageService(deps) {
         deps.state.sessionDateMap[sessionID] = dateKey;
         deps.persistence.markDirty(dateKey);
     };
-    const isUsageBillingCurrent = (cached) => {
-        if (!cached)
-            return false;
-        return cached.billingVersion === USAGE_BILLING_CACHE_VERSION;
-    };
-    const hasAnySubscriptionProvider = (cached) => {
-        const providerIDs = Object.keys(cached.providers);
-        if (providerIDs.length === 0)
-            return true;
-        return providerIDs.some((providerID) => {
-            const canonical = canonicalApiCostProviderID(providerID);
-            return API_COST_ENABLED_PROVIDERS.has(canonical);
-        });
-    };
-    const shouldRecomputeUsageCache = (cached, hasPricing, hasResolvableApiCostMessage) => {
-        if (!isUsageBillingCurrent(cached))
-            return true;
-        if (!hasPricing)
-            return false;
-        if (!hasResolvableApiCostMessage)
-            return false;
-        if (cached.assistantMessages <= 0)
+    const isUsageBillingCurrent = (cached, pricingFingerprint) => {
+        if (!cached || !pricingFingerprint)
             return false;
-        if (cached.apiCost > 0)
+        if (cached.billingVersion !== USAGE_BILLING_CACHE_VERSION)
             return false;
-        if (cached.total <= 0)
-            return false;
-        if (!hasAnySubscriptionProvider(cached))
-            return false;
-        return true;
+        return cached.pricingFingerprint === pricingFingerprint;
     };
+    const shouldRecomputeUsageCache = (cached, pricingFingerprint) => !isUsageBillingCurrent(cached, pricingFingerprint);
     const hasResolvableApiCostMessages = (entries, modelCostMap) => {
         return entries.some(({ info }) => {
-            if (info.role !== 'assistant')
+            if (info.role !== "assistant")
                 return false;
             const providerID = canonicalApiCostProviderID(info.providerID);
-            if (!API_COST_ENABLED_PROVIDERS.has(providerID))
+            if (providerID === "github-copilot")
                 return false;
             return modelCostLookupKeys(info.providerID, info.modelID).some((key) => Boolean(modelCostMap[key]));
         });
     };
-    const shouldTrackFullUsageForRange = (cached, hasPricing) => {
-        if (!cached)
-            return true;
-        if (!isUsageBillingCurrent(cached))
-            return true;
-        if (!hasPricing)
-            return false;
-        if (cached.assistantMessages <= 0)
-            return false;
-        if (cached.apiCost > 0)
-            return false;
-        if (cached.total <= 0)
-            return false;
-        return hasAnySubscriptionProvider(cached);
-    };
+    const shouldTrackFullUsageForRange = (cached, modelCostMap) => !isUsageBillingCurrent(cached, expectedPricingFingerprintForCached(cached, modelCostMap));
     const summarizeSessionUsage = async (sessionID, generationAtStart, options) => {
         const load = await loadSessionEntries(sessionID);
-        const entries = load.status === 'ok' ? load.entries : undefined;
+        const entries = load.status === "ok" ? load.entries : undefined;
         const sessionState = deps.state.sessions[sessionID];
         // If we can't load messages (transient API failure), fall back to cached
         // usage if available and avoid mutating cursor/dirty state.
         if (!entries) {
-            if (sessionState?.usage) {
-                return {
-                    usage: fromCachedSessionUsage(sessionState.usage, 1),
-                    persist: false,
-                };
+            if (sessionState?.usage && sessionState.dirty !== true) {
+                const modelCostMap = await getModelCostMap();
+                const cachedPricingFingerprint = expectedPricingFingerprintForCached(sessionState.usage, modelCostMap);
+                if (isUsageBillingCurrent(sessionState.usage, cachedPricingFingerprint)) {
+                    return {
+                        usage: fromCachedSessionUsage(sessionState.usage, 1),
+                        persist: false,
+                    };
+                }
             }
             if (options?.requireEntries) {
                 throw new Error(`session usage unavailable: failed to load messages for ${sessionID}`);
@@ -273,13 +351,14 @@ export function createUsageService(deps) {
             return { usage: empty, persist: false };
         }
         const modelCostMap = await getModelCostMap();
-        const hasPricing = Object.keys(modelCostMap).length > 0;
-        const hasResolvablePricing = hasResolvableApiCostMessages(entries, modelCostMap);
+        const pricingKeys = [...collectPricingKeys(entries)].sort();
+        const pricingFingerprint = pricingFingerprintForEntries(entries, modelCostMap);
         const staleBillingCache = Boolean(sessionState?.usage) &&
-            !isUsageBillingCurrent(sessionState?.usage);
+            sessionState?.usage?.billingVersion !== USAGE_BILLING_CACHE_VERSION;
         const pricingRefreshCache = sessionState?.usage &&
-            shouldRecomputeUsageCache(sessionState.usage, hasPricing, hasResolvablePricing);
+            shouldRecomputeUsageCache(sessionState.usage, pricingFingerprint);
         const forceRescan = forceRescanSessions.has(sessionID) ||
+            sessionState?.dirty === true ||
             staleBillingCache ||
             Boolean(pricingRefreshCache);
         if (forceRescan)
@@ -303,7 +382,12 @@ export function createUsageService(deps) {
         if ((dirtyGeneration.get(sessionID) || 0) === generationAtStart) {
             cleanGeneration.set(sessionID, generationAtStart);
         }
-        return { usage, persist: true };
+        return {
+            usage,
+            persist: true,
+            pricingFingerprint,
+            pricingKeys,
+        };
     };
     const summarizeSessionUsageLocked = async (sessionID, options) => {
         for (let attempt = 0; attempt < 2; attempt++) {
@@ -334,11 +418,15 @@ export function createUsageService(deps) {
         return summarizeSessionUsage(sessionID, generationAtStart);
     };
     const summarizeSessionUsageForDisplay = async (sessionID, includeChildren) => {
+        const modelCostMap = await getModelCostMap();
         const root = await summarizeSessionUsageLocked(sessionID);
         const usage = root.usage;
         let dirty = false;
         if (root.persist) {
-            persistSessionUsage(sessionID, toCachedSessionUsage(usage));
+            persistSessionUsage(sessionID, toCachedSessionUsage(usage, {
+                pricingFingerprint: root.pricingFingerprint,
+                pricingKeys: root.pricingKeys,
+            }));
             dirty = true;
         }
         if (!includeChildren) {
@@ -361,7 +449,9 @@ export function createUsageService(deps) {
         const needsFetch = [];
         for (const childID of descendantIDs) {
             const cached = deps.state.sessions[childID]?.usage;
-            if (cached && !isDirty(childID) && isUsageBillingCurrent(cached)) {
+            if (cached &&
+                !isDirty(childID) &&
+                isUsageBillingCurrent(cached, expectedPricingFingerprintForCached(cached, modelCostMap))) {
                 // Keep measured cost aligned with OpenCode session semantics by only
                 // using child sessions for token/API-cost aggregation.
                 mergeUsage(merged, fromCachedSessionUsage(cached, 1), {
@@ -376,7 +466,10 @@ export function createUsageService(deps) {
             const fetched = await mapConcurrent(needsFetch, deps.config.sidebar.childrenConcurrency, async (childID) => {
                 const child = await summarizeSessionUsageLocked(childID);
                 if (child.persist) {
-                    persistSessionUsage(childID, toCachedSessionUsage(child.usage));
+                    persistSessionUsage(childID, toCachedSessionUsage(child.usage, {
+                        pricingFingerprint: child.pricingFingerprint,
+                        pricingKeys: child.pricingKeys,
+                    }));
                     dirty = true;
                 }
                 return child.usage;
@@ -397,7 +490,7 @@ export function createUsageService(deps) {
             if (session.state.dirty === true)
                 return true;
             const lastMessageTime = session.state.cursor?.lastMessageTime;
-            if (typeof lastMessageTime === 'number' &&
+            if (typeof lastMessageTime === "number" &&
                 Number.isFinite(lastMessageTime) &&
                 lastMessageTime < startAt) {
                 return false;
@@ -413,7 +506,6 @@ export function createUsageService(deps) {
         const sessions = filterRangeSessions(await scanAllSessions(deps.statePath, deps.state), startAt, endAt);
         const usage = emptyUsageSummary();
         const modelCostMap = await getModelCostMap();
-        const hasPricing = Object.keys(modelCostMap).length > 0;
         if (sessions.length > 0) {
             const fetched = await mapConcurrent(sessions, RANGE_USAGE_CONCURRENCY, async (session) => {
                 const usageOptions = {
@@ -421,14 +513,14 @@ export function createUsageService(deps) {
                     classifyCacheMode: (message) => classifyCacheMode(message, modelCostMap),
                 };
                 const computed = emptyUsageSummary();
-                const trackFullUsage = shouldTrackFullUsageForRange(session.state.usage, hasPricing);
+                const trackFullUsage = shouldTrackFullUsageForRange(session.state.usage, modelCostMap);
                 const fullUsage = trackFullUsage ? emptyUsageSummary() : undefined;
                 let cursor;
-                let hasResolvableApiCostMessage = false;
+                const pricingKeys = new Set();
                 let before;
                 while (true) {
                     const load = await loadSessionEntriesPage(session.sessionID, before);
-                    if (load.status !== 'ok') {
+                    if (load.status !== "ok") {
                         return {
                             sessionID: session.sessionID,
                             dateKey: session.dateKey,
@@ -437,8 +529,8 @@ export function createUsageService(deps) {
                             dirty: session.state.dirty === true,
                             computed: emptyUsageSummary(),
                             fullUsage: undefined,
-                            loadFailed: load.status === 'error',
-                            missing: load.status === 'missing',
+                            loadFailed: load.status === "error",
+                            missing: load.status === "missing",
                             persist: false,
                             cursor: undefined,
                         };
@@ -450,9 +542,7 @@ export function createUsageService(deps) {
                     if (fullUsage) {
                         accumulateMessagesInCompletedRange(fullUsage, entries, 0, Number.POSITIVE_INFINITY, usageOptions);
                         cursor = mergeCursorFromEntries(cursor, entries);
-                    }
-                    if (!hasResolvableApiCostMessage) {
-                        hasResolvableApiCostMessage = hasResolvableApiCostMessages(entries, modelCostMap);
+                        collectPricingKeys(entries, pricingKeys);
                     }
                     if (!load.nextBefore)
                         break;
@@ -460,7 +550,7 @@ export function createUsageService(deps) {
                 }
                 const shouldPersistFullUsage = !!fullUsage &&
                     (!session.state.usage ||
-                        shouldRecomputeUsageCache(session.state.usage, hasPricing, hasResolvableApiCostMessage));
+                        shouldRecomputeUsageCache(session.state.usage, pricingFingerprintForKeys([...pricingKeys], modelCostMap)));
                 return {
                     sessionID: session.sessionID,
                     dateKey: session.dateKey,
@@ -469,6 +559,10 @@ export function createUsageService(deps) {
                     dirty: session.state.dirty === true,
                     computed,
                     fullUsage: shouldPersistFullUsage ? fullUsage : undefined,
+                    pricingFingerprint: fullUsage
+                        ? pricingFingerprintForKeys([...pricingKeys], modelCostMap)
+                        : undefined,
+                    pricingKeys: fullUsage ? [...pricingKeys].sort() : undefined,
                     loadFailed: false,
                     missing: false,
                     persist: shouldPersistFullUsage,
@@ -488,7 +582,7 @@ export function createUsageService(deps) {
                 }
                 await Promise.all(missingSessions.map(async (missing) => {
                     const deletedFromChunk = await deleteSessionFromDayChunk(deps.statePath, missing.sessionID, missing.dateKey).catch((error) => {
-                        swallow('deleteSessionFromDayChunk')(error);
+                        swallow("deleteSessionFromDayChunk")(error);
                         return false;
                     });
                     if (!deletedFromChunk)
@@ -505,7 +599,7 @@ export function createUsageService(deps) {
                 if (item.dirty)
                     return true;
                 const lastMessageTime = item.lastMessageTime;
-                if (typeof lastMessageTime === 'number' && lastMessageTime < startAt) {
+                if (typeof lastMessageTime === "number" && lastMessageTime < startAt) {
                     return false;
                 }
                 return true;
@@ -515,14 +609,17 @@ export function createUsageService(deps) {
             }
             let dirty = false;
             const diskOnlyUpdates = [];
-            for (const { sessionID, dateKey, computed, fullUsage, persist, cursor, } of fetched) {
+            for (const { sessionID, dateKey, computed, fullUsage, pricingFingerprint, pricingKeys, persist, cursor, } of fetched) {
                 if (computed.assistantMessages > 0) {
                     computed.sessionCount = 1;
                     mergeUsage(usage, computed);
                 }
                 const memoryState = deps.state.sessions[sessionID];
                 if (persist && fullUsage && memoryState) {
-                    memoryState.usage = toCachedSessionUsage(fullUsage);
+                    memoryState.usage = toCachedSessionUsage(fullUsage, {
+                        pricingFingerprint,
+                        pricingKeys,
+                    });
                     memoryState.cursor = cursor;
                     const resolvedDateKey = deps.state.sessionDateMap[sessionID] ||
                         dateKeyFromTimestamp(memoryState.createdAt);
@@ -535,14 +632,17 @@ export function createUsageService(deps) {
                     diskOnlyUpdates.push({
                         sessionID,
                         dateKey,
-                        usage: toCachedSessionUsage(fullUsage),
+                        usage: toCachedSessionUsage(fullUsage, {
+                            pricingFingerprint,
+                            pricingKeys,
+                        }),
                         cursor,
                     });
                 }
             }
             if (diskOnlyUpdates.length > 0) {
                 const persisted = await updateSessionsInDayChunks(deps.statePath, diskOnlyUpdates).catch((error) => {
-                    swallow('updateSessionsInDayChunks')(error);
+                    swallow("updateSessionsInDayChunks")(error);
                     return false;
                 });
                 if (!persisted) {
@@ -564,6 +664,8 @@ export function createUsageService(deps) {
             calcApiCost: (message, costMap) => calcEquivalentApiCost(message, costMap),
             classifyCacheMode: (message, costMap) => classifyCacheMode(message, costMap),
             hasResolvableApiCostMessages: (entries, costMap) => hasResolvableApiCostMessages(entries, costMap),
+            pricingFingerprintForKeys: (pricingKeys, costMap) => pricingFingerprintForKeys(pricingKeys, costMap),
+            isUsageBillingCurrent: (cached, costMap) => isUsageBillingCurrent(cached, expectedPricingFingerprintForCached(cached, costMap)),
             shouldTrackFullUsage: shouldTrackFullUsageForRange,
             shouldRecomputeUsageCache,
             throwOnLoadFailure: true,
@@ -585,7 +687,7 @@ export function createUsageService(deps) {
                 }
                 await Promise.all(missingSessions.map(async (missing) => {
                     const deletedFromChunk = await deleteSessionFromDayChunk(deps.statePath, missing.sessionID, missing.dateKey).catch((error) => {
-                        swallow('deleteSessionFromDayChunk')(error);
+                        swallow("deleteSessionFromDayChunk")(error);
                         return false;
                     });
                     if (!deletedFromChunk)
@@ -603,7 +705,10 @@ export function createUsageService(deps) {
                     continue;
                 const memoryState = deps.state.sessions[item.sessionID];
                 if (memoryState) {
-                    memoryState.usage = toCachedSessionUsage(item.fullUsage);
+                    memoryState.usage = toCachedSessionUsage(item.fullUsage, {
+                        pricingFingerprint: item.pricingFingerprint,
+                        pricingKeys: item.pricingKeys,
+                    });
                     memoryState.cursor = item.cursor;
                     const resolvedDateKey = deps.state.sessionDateMap[item.sessionID] ||
                         dateKeyFromTimestamp(memoryState.createdAt);
@@ -616,14 +721,17 @@ export function createUsageService(deps) {
                     diskOnlyUpdates.push({
                         sessionID: item.sessionID,
                         dateKey: item.dateKey,
-                        usage: toCachedSessionUsage(item.fullUsage),
+                        usage: toCachedSessionUsage(item.fullUsage, {
+                            pricingFingerprint: item.pricingFingerprint,
+                            pricingKeys: item.pricingKeys,
+                        }),
                         cursor: item.cursor,
                     });
                 }
             }
             if (diskOnlyUpdates.length > 0) {
                 const persisted = await updateSessionsInDayChunks(deps.statePath, diskOnlyUpdates).catch((error) => {
-                    swallow('updateSessionsInDayChunks')(error);
+                    swallow("updateSessionsInDayChunks")(error);
                     return false;
                 });
                 if (!persisted) {
@@ -636,13 +744,16 @@ export function createUsageService(deps) {
         return result;
     };
     const summarizeForTool = async (period, sessionID, includeChildren) => {
-        if (period === 'session') {
+        if (period === "session") {
             if (!includeChildren) {
                 const session = await summarizeSessionUsageLocked(sessionID, {
                     requireEntries: true,
                 });
                 if (session.persist) {
-                    persistSessionUsage(sessionID, toCachedSessionUsage(session.usage));
+                    persistSessionUsage(sessionID, toCachedSessionUsage(session.usage, {
+                        pricingFingerprint: session.pricingFingerprint,
+                        pricingKeys: session.pricingKeys,
+                    }));
                     deps.persistence.scheduleSave();
                 }
                 return session.usage;