@leo000001/opencode-quota-sidebar 2.0.0 → 2.0.1

package/dist/usage_service.js

@@ -1,9 +1,15 @@
 import { TtlValueCache } from './cache.js';
 import { cacheCoverageModeFromRates, calcEquivalentApiCostForMessage, canonicalApiCostProviderID, modelCostKey, parseModelCostRates, SUBSCRIPTION_API_COST_PROVIDERS, } from './cost.js';
-import { dateKeyFromTimestamp, scanSessionsByCreatedRange, updateSessionsInDayChunks, } from './storage.js';
+import { dateKeyFromTimestamp, scanAllSessions, updateSessionsInDayChunks, } from './storage.js';
 import { periodStart } from './period.js';
 import { debug, isRecord, mapConcurrent, swallow } from './helpers.js';
-import { emptyUsageSummary, fromCachedSessionUsage, mergeUsage, summarizeMessagesIncremental, toCachedSessionUsage, USAGE_BILLING_CACHE_VERSION, } from './usage.js';
+import { emptyUsageSummary, fromCachedSessionUsage, mergeUsage, summarizeMessagesInCompletedRange, summarizeMessagesIncremental, toCachedSessionUsage, USAGE_BILLING_CACHE_VERSION, } from './usage.js';
+const READ_ONLY_CACHE_PROVIDERS = new Set([
+    'openai',
+    'github-copilot',
+    'venice',
+    'openrouter',
+]);
 export function createUsageService(deps) {
     const forceRescanSessions = new Set();
     const dirtyGeneration = new Map();
@@ -12,6 +18,8 @@ export function createUsageService(deps) {
         dirtyGeneration.set(sessionID, (dirtyGeneration.get(sessionID) || 0) + 1);
     };
     const isDirty = (sessionID) => {
+        if (deps.state.sessions[sessionID]?.dirty)
+            return true;
         return ((dirtyGeneration.get(sessionID) || 0) !==
             (cleanGeneration.get(sessionID) || 0));
     };
@@ -109,13 +117,19 @@ export function createUsageService(deps) {
             return 'read-write';
         if (message.tokens.cache.read <= 0)
             return 'none';
+        const rawProviderID = message.providerID.toLowerCase();
+        if (READ_ONLY_CACHE_PROVIDERS.has(canonicalProviderID) ||
+            READ_ONLY_CACHE_PROVIDERS.has(rawProviderID)) {
+            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 === 'openai')
-            return 'read-only';
-        return 'none';
+        // Last resort: if the message has cache.read tokens from an unknown provider,
+        // treat it as read-only (the safer default — avoids inflating Cache Coverage).
+        return 'read-only';
     };
     const isFiniteNumber = (value) => typeof value === 'number' && Number.isFinite(value);
     const decodeTokens = (value) => {
@@ -145,10 +159,6 @@ export function createUsageService(deps) {
             return undefined;
         if (typeof value.role !== 'string')
             return undefined;
-        if (typeof value.providerID !== 'string')
-            return undefined;
-        if (typeof value.modelID !== 'string')
-            return undefined;
         if (!isRecord(value.time))
             return undefined;
         if (!isFiniteNumber(value.time.created))
@@ -157,6 +167,19 @@ export function createUsageService(deps) {
             !isFiniteNumber(value.time.completed)) {
             return undefined;
         }
+        if (value.role !== 'assistant') {
+            return {
+                ...value,
+                time: {
+                    created: value.time.created,
+                    completed: value.time.completed,
+                },
+            };
+        }
+        if (typeof value.providerID !== 'string')
+            return undefined;
+        if (typeof value.modelID !== 'string')
+            return undefined;
         const tokens = decodeTokens(value.tokens);
         if (!tokens)
             return undefined;
@@ -222,6 +245,21 @@ export function createUsageService(deps) {
             return false;
         return cached.billingVersion === USAGE_BILLING_CACHE_VERSION;
     };
+    const hasStaleZeroApiCost = (cached, modelCostMap) => {
+        if (!cached)
+            return false;
+        if (cached.apiCost > 0)
+            return false;
+        return Object.entries(cached.providers).some(([providerID, provider]) => {
+            if (provider.apiCost > 0)
+                return false;
+            const canonicalProviderID = canonicalApiCostProviderID(providerID);
+            if (!SUBSCRIPTION_API_COST_PROVIDERS.has(canonicalProviderID))
+                return false;
+            return Object.keys(modelCostMap).some((key) => key.startsWith(`${providerID}:`) ||
+                key.startsWith(`${canonicalProviderID}:`));
+        });
+    };
     const summarizeSessionUsage = async (sessionID, generationAtStart) => {
         const entries = await loadSessionEntries(sessionID);
         const sessionState = deps.state.sessions[sessionID];
@@ -240,7 +278,8 @@ export function createUsageService(deps) {
         }
         const modelCostMap = await getModelCostMap();
         const staleBillingCache = Boolean(sessionState?.usage) &&
-            !isUsageBillingCurrent(sessionState?.usage);
+            (!isUsageBillingCurrent(sessionState?.usage) ||
+                hasStaleZeroApiCost(sessionState?.usage, modelCostMap));
         const forceRescan = forceRescanSessions.has(sessionID) || staleBillingCache;
         if (forceRescan)
             forceRescanSessions.delete(sessionID);
@@ -255,6 +294,7 @@ export function createUsageService(deps) {
         // Update cursor in state
         if (sessionState) {
             sessionState.cursor = cursor;
+            sessionState.dirty = false;
         }
         if ((dirtyGeneration.get(sessionID) || 0) === generationAtStart) {
             cleanGeneration.set(sessionID, generationAtStart);
@@ -290,11 +330,16 @@ export function createUsageService(deps) {
     const summarizeSessionUsageForDisplay = async (sessionID, includeChildren) => {
         const root = await summarizeSessionUsageLocked(sessionID);
         const usage = root.usage;
+        let dirty = false;
         if (root.persist) {
             persistSessionUsage(sessionID, toCachedSessionUsage(usage));
+            dirty = true;
         }
-        if (!includeChildren)
+        if (!includeChildren) {
+            if (dirty)
+                deps.persistence.scheduleSave();
             return usage;
+        }
         const descendantIDs = await deps.descendantsResolver.listDescendantSessionIDs(sessionID, {
             maxDepth: deps.config.sidebar.childrenMaxDepth,
             maxSessions: deps.config.sidebar.childrenMaxSessions,
@@ -323,6 +368,7 @@ export function createUsageService(deps) {
                 const child = await summarizeSessionUsageLocked(childID);
                 if (child.persist) {
                     persistSessionUsage(childID, toCachedSessionUsage(child.usage));
+                    dirty = true;
                 }
                 return child.usage;
             });
@@ -330,15 +376,17 @@ export function createUsageService(deps) {
                 mergeUsage(merged, childUsage, { includeCost: false });
             }
         }
+        if (dirty)
+            deps.persistence.scheduleSave();
         return merged;
     };
     const RANGE_USAGE_CONCURRENCY = 5;
     const summarizeRangeUsage = async (period) => {
         const startAt = periodStart(period);
+        const endAt = Date.now();
         await deps.persistence.flushSave();
-        const sessions = await scanSessionsByCreatedRange(deps.statePath, startAt, Date.now(), deps.state);
+        const sessions = await scanAllSessions(deps.statePath, deps.state);
         const usage = emptyUsageSummary();
-        usage.sessionCount = sessions.length;
         const modelCostMap = await getModelCostMap();
         const hasPricing = Object.keys(modelCostMap).length > 0;
         const hasAnySubscriptionProvider = (cached) => {
@@ -367,62 +415,78 @@ export function createUsageService(deps) {
                 return false;
             return true;
         };
-        const needsFetch = [];
-        for (const session of sessions) {
-            if (session.state.usage) {
-                if (shouldRecomputeUsageCache(session.state.usage)) {
-                    needsFetch.push(session);
-                }
-                else {
-                    mergeUsage(usage, fromCachedSessionUsage(session.state.usage, 0));
-                }
-            }
-            else {
-                needsFetch.push(session);
-            }
-        }
-        if (needsFetch.length > 0) {
-            const fetched = await mapConcurrent(needsFetch, RANGE_USAGE_CONCURRENCY, async (session) => {
+        if (sessions.length > 0) {
+            const fetched = await mapConcurrent(sessions, RANGE_USAGE_CONCURRENCY, async (session) => {
                 const entries = await loadSessionEntries(session.sessionID);
                 if (!entries) {
-                    if (session.state.usage) {
-                        return {
-                            sessionID: session.sessionID,
-                            dateKey: session.dateKey,
-                            computed: fromCachedSessionUsage(session.state.usage, 1),
-                            persist: false,
-                            cursor: session.state.cursor,
-                        };
-                    }
-                    const empty = emptyUsageSummary();
-                    empty.sessionCount = 1;
                     return {
                         sessionID: session.sessionID,
                         dateKey: session.dateKey,
-                        computed: empty,
+                        createdAt: session.state.createdAt,
+                        lastMessageTime: session.state.cursor?.lastMessageTime,
+                        computed: emptyUsageSummary(),
+                        fullUsage: undefined,
+                        loadFailed: true,
                         persist: false,
                         cursor: undefined,
                     };
                 }
-                const { usage: computed, cursor } = summarizeMessagesIncremental(entries, undefined, undefined, true, {
+                const computed = summarizeMessagesInCompletedRange(entries, startAt, endAt, 0, {
+                    calcApiCost: (message) => calcEquivalentApiCost(message, modelCostMap),
+                    classifyCacheMode: (message) => classifyCacheMode(message, modelCostMap),
+                });
+                const shouldPersistFullUsage = !session.state.usage || shouldRecomputeUsageCache(session.state.usage);
+                if (!shouldPersistFullUsage) {
+                    return {
+                        sessionID: session.sessionID,
+                        dateKey: session.dateKey,
+                        createdAt: session.state.createdAt,
+                        lastMessageTime: session.state.cursor?.lastMessageTime,
+                        computed,
+                        fullUsage: undefined,
+                        loadFailed: false,
+                        persist: false,
+                        cursor: session.state.cursor,
+                    };
+                }
+                const { usage: fullUsage, cursor } = summarizeMessagesIncremental(entries, undefined, undefined, true, {
                     calcApiCost: (message) => calcEquivalentApiCost(message, modelCostMap),
                     classifyCacheMode: (message) => classifyCacheMode(message, modelCostMap),
                 });
                 return {
                     sessionID: session.sessionID,
                     dateKey: session.dateKey,
+                    createdAt: session.state.createdAt,
+                    lastMessageTime: cursor.lastMessageTime,
                     computed,
+                    fullUsage,
+                    loadFailed: false,
                     persist: true,
                     cursor,
                 };
             });
+            const failedLoads = fetched.filter((item) => {
+                if (!item.loadFailed)
+                    return false;
+                const lastMessageTime = item.lastMessageTime;
+                if (typeof lastMessageTime === 'number' && lastMessageTime < startAt) {
+                    return false;
+                }
+                return true;
+            });
+            if (failedLoads.length > 0) {
+                throw new Error(`range usage unavailable: failed to load ${failedLoads.length} session(s)`);
+            }
             let dirty = false;
             const diskOnlyUpdates = [];
-            for (const { sessionID, dateKey, computed, persist, cursor } of fetched) {
-                mergeUsage(usage, { ...computed, sessionCount: 0 });
+            for (const { sessionID, dateKey, computed, fullUsage, persist, cursor } of fetched) {
+                if (computed.assistantMessages > 0) {
+                    computed.sessionCount = 1;
+                    mergeUsage(usage, computed);
+                }
                 const memoryState = deps.state.sessions[sessionID];
-                if (persist && memoryState) {
-                    memoryState.usage = toCachedSessionUsage(computed);
+                if (persist && fullUsage && memoryState) {
+                    memoryState.usage = toCachedSessionUsage(fullUsage);
                     memoryState.cursor = cursor;
                     const resolvedDateKey = deps.state.sessionDateMap[sessionID] ||
                         dateKeyFromTimestamp(memoryState.createdAt);
@@ -430,11 +494,11 @@ export function createUsageService(deps) {
                     deps.persistence.markDirty(resolvedDateKey);
                     dirty = true;
                 }
-                else if (persist) {
+                else if (persist && fullUsage) {
                     diskOnlyUpdates.push({
                         sessionID,
                         dateKey,
-                        usage: toCachedSessionUsage(computed),
+                        usage: toCachedSessionUsage(fullUsage),
                         cursor,
                     });
                 }
@@ -455,6 +519,15 @@ export function createUsageService(deps) {
     };
     const markSessionDirty = (sessionID) => {
         bumpDirty(sessionID);
+        const sessionState = deps.state.sessions[sessionID];
+        if (sessionState && !sessionState.dirty) {
+            sessionState.dirty = true;
+            const dateKey = deps.state.sessionDateMap[sessionID] ||
+                dateKeyFromTimestamp(sessionState.createdAt);
+            deps.state.sessionDateMap[sessionID] = dateKey;
+            deps.persistence.markDirty(dateKey);
+            deps.persistence.scheduleSave();
+        }
     };
     const markForceRescan = (sessionID) => {
         forceRescanSessions.add(sessionID);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leo000001/opencode-quota-sidebar",
-  "version": "2.0.0",
+  "version": "2.0.1",
   "description": "OpenCode plugin that shows quota and token usage in session titles",
   "type": "module",
   "main": "dist/index.js",