@leo000001/opencode-quota-sidebar 2.0.7 → 2.0.9

package/dist/cost.d.ts

@@ -1,6 +1,6 @@
 import type { AssistantMessage } from '@opencode-ai/sdk';
 import type { CacheCoverageMode } from './types.js';
-export declare const SUBSCRIPTION_API_COST_PROVIDERS: Set<string>;
+export declare const API_COST_ENABLED_PROVIDERS: Set<string>;
 export declare function canonicalApiCostProviderID(providerID: string): string;
 export type ModelCostRates = {
     input: number;
@@ -15,6 +15,7 @@ export type ModelCostRates = {
     };
 };
 export declare function modelCostKey(providerID: string, modelID: string): string;
+export declare function modelCostLookupKeys(providerID: string, modelID: string): string[];
 export declare function parseModelCostRates(value: unknown): ModelCostRates | undefined;
 export declare function guessModelCostDivisor(rates: ModelCostRates): 1 | 1000000;
 export declare function cacheCoverageModeFromRates(rates: ModelCostRates | undefined): CacheCoverageMode;

package/dist/cost.js

@@ -1,5 +1,13 @@
 import { asNumber, isRecord } from './helpers.js';
-export const SUBSCRIPTION_API_COST_PROVIDERS = new Set(['openai', 'anthropic']);
+export const API_COST_ENABLED_PROVIDERS = new Set([
+    'openai',
+    'anthropic',
+    'kimi-for-coding',
+]);
+const MODEL_COST_RATE_ALIASES = {
+    'kimi-for-coding:k2p5': ['moonshotai-cn:kimi-k2.5'],
+    'kimi-for-coding:kimi-k2-thinking': ['moonshotai-cn:kimi-k2-thinking'],
+};
 function normalizeKnownProviderID(providerID) {
     if (providerID.startsWith('github-copilot'))
         return 'github-copilot';
@@ -7,7 +15,7 @@ function normalizeKnownProviderID(providerID) {
 }
 export function canonicalApiCostProviderID(providerID) {
     const normalized = normalizeKnownProviderID(providerID);
-    if (SUBSCRIPTION_API_COST_PROVIDERS.has(normalized))
+    if (API_COST_ENABLED_PROVIDERS.has(normalized))
         return normalized;
     const lowered = providerID.toLowerCase();
     if (lowered.includes('copilot'))
@@ -22,6 +30,24 @@ export function canonicalApiCostProviderID(providerID) {
 export function modelCostKey(providerID, modelID) {
     return `${providerID}:${modelID}`;
 }
+export function modelCostLookupKeys(providerID, modelID) {
+    const keys = [];
+    const canonicalProviderID = canonicalApiCostProviderID(providerID);
+    const push = (key) => {
+        if (!keys.includes(key))
+            keys.push(key);
+    };
+    push(modelCostKey(providerID, modelID));
+    if (canonicalProviderID !== providerID) {
+        push(modelCostKey(canonicalProviderID, modelID));
+    }
+    for (const key of [...keys]) {
+        for (const alias of MODEL_COST_RATE_ALIASES[key] || []) {
+            push(alias);
+        }
+    }
+    return keys;
+}
 export function parseModelCostRates(value) {
     if (!isRecord(value))
         return undefined;

package/dist/usage.d.ts

@@ -6,7 +6,7 @@ import type { CacheCoverageMetrics, CacheCoverageMode, CacheUsageBuckets, Cached
  * fields).  This is distinct from the plugin *state* version managed by the
  * persistence layer; billing version only governs usage-cache staleness.
  */
-export declare const USAGE_BILLING_CACHE_VERSION = 4;
+export declare const USAGE_BILLING_CACHE_VERSION = 5;
 export type ProviderUsage = {
     providerID: string;
     input: number;

package/dist/usage.js

@@ -4,7 +4,7 @@
  * fields).  This is distinct from the plugin *state* version managed by the
  * persistence layer; billing version only governs usage-cache staleness.
  */
-export const USAGE_BILLING_CACHE_VERSION = 4;
+export const USAGE_BILLING_CACHE_VERSION = 5;
 function emptyCacheUsageBucket() {
     return {
         input: 0,

package/dist/usage_service.js

@@ -1,8 +1,8 @@
 import { TtlValueCache } from './cache.js';
-import { cacheCoverageModeFromRates, calcEquivalentApiCostForMessage, canonicalApiCostProviderID, modelCostKey, parseModelCostRates, SUBSCRIPTION_API_COST_PROVIDERS, } from './cost.js';
-import { dateKeyFromTimestamp, scanAllSessions, updateSessionsInDayChunks, } from './storage.js';
+import { API_COST_ENABLED_PROVIDERS, cacheCoverageModeFromRates, calcEquivalentApiCostForMessage, canonicalApiCostProviderID, modelCostLookupKeys, modelCostKey, parseModelCostRates, } from './cost.js';
+import { deleteSessionFromDayChunk, dateKeyFromTimestamp, scanAllSessions, updateSessionsInDayChunks, } from './storage.js';
 import { periodStart } from './period.js';
-import { debug, isRecord, mapConcurrent, swallow } from './helpers.js';
+import { debug, debugError, isRecord, mapConcurrent, swallow, } from './helpers.js';
 import { emptyUsageSummary, fromCachedSessionUsage, mergeUsage, summarizeMessagesInCompletedRange, summarizeMessagesIncremental, toCachedSessionUsage, USAGE_BILLING_CACHE_VERSION, } from './usage.js';
 const READ_ONLY_CACHE_PROVIDERS = new Set([
     'openai',
@@ -87,10 +87,11 @@ export function createUsageService(deps) {
     };
     const calcEquivalentApiCost = (message, modelCostMap) => {
         const providerID = canonicalApiCostProviderID(message.providerID);
-        if (!SUBSCRIPTION_API_COST_PROVIDERS.has(providerID))
+        if (!API_COST_ENABLED_PROVIDERS.has(providerID))
             return 0;
-        const rates = modelCostMap[modelCostKey(message.providerID, message.modelID)] ||
-            modelCostMap[modelCostKey(providerID, message.modelID)];
+        const rates = modelCostLookupKeys(message.providerID, message.modelID)
+            .map((key) => modelCostMap[key])
+            .find(Boolean);
         if (!rates) {
             const key = modelCostKey(providerID, message.modelID);
             if (!missingApiCostRateKeys.has(key)) {
@@ -103,8 +104,9 @@ export function createUsageService(deps) {
     };
     const classifyCacheMode = (message, modelCostMap) => {
         const canonicalProviderID = canonicalApiCostProviderID(message.providerID);
-        const baseRates = modelCostMap[modelCostKey(message.providerID, message.modelID)] ||
-            modelCostMap[modelCostKey(canonicalProviderID, message.modelID)];
+        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
@@ -218,18 +220,81 @@ export function createUsageService(deps) {
             return undefined;
         return decoded;
     };
-    const loadSessionEntries = async (sessionID) => {
-        const response = await deps.client.session
-            .messages({
-            path: { id: sessionID },
-            query: { directory: deps.directory },
-            throwOnError: true,
-        })
-            .catch(swallow('loadSessionEntries'));
-        if (!response)
+    const errorStatusCode = (value, seen = new Set()) => {
+        if (!isRecord(value) || seen.has(value))
             return undefined;
-        const data = response.data;
-        return decodeMessageEntries(data);
+        seen.add(value);
+        const status = value.status;
+        if (typeof status === 'number' && Number.isFinite(status))
+            return status;
+        const statusCode = value.statusCode;
+        if (typeof statusCode === 'number' && Number.isFinite(statusCode)) {
+            return statusCode;
+        }
+        return (errorStatusCode(value.response, seen) ||
+            errorStatusCode(value.cause, seen) ||
+            errorStatusCode(value.error, seen));
+    };
+    const errorText = (value, seen = new Set()) => {
+        if (!value || seen.has(value))
+            return '';
+        if (typeof value === 'string')
+            return value;
+        if (typeof value === 'number' || typeof value === 'boolean')
+            return `${value}`;
+        if (value instanceof Error) {
+            seen.add(value);
+            return [
+                value.message,
+                errorText(value.cause, seen),
+            ]
+                .filter(Boolean)
+                .join('\n');
+        }
+        if (!isRecord(value))
+            return '';
+        seen.add(value);
+        return [
+            typeof value.message === 'string' ? value.message : '',
+            typeof value.error === 'string' ? value.error : '',
+            typeof value.detail === 'string' ? value.detail : '',
+            typeof value.title === 'string' ? value.title : '',
+            errorText(value.response, seen),
+            errorText(value.data, seen),
+            errorText(value.cause, seen),
+        ]
+            .filter(Boolean)
+            .join('\n');
+    };
+    const isMissingSessionError = (error) => {
+        const status = errorStatusCode(error);
+        if (status === 404 || status === 410)
+            return true;
+        const text = errorText(error).toLowerCase();
+        if (!text)
+            return false;
+        return (/\b(session|conversation)\b.*\b(not found|missing|deleted|does not exist)\b/.test(text) ||
+            /\b(not found|missing|deleted|does not exist)\b.*\b(session|conversation)\b/.test(text));
+    };
+    const loadSessionEntries = async (sessionID) => {
+        try {
+            const response = await deps.client.session.messages({
+                path: { id: sessionID },
+                query: { directory: deps.directory },
+                throwOnError: true,
+            });
+            const data = response.data;
+            const entries = decodeMessageEntries(data);
+            if (!entries)
+                return { status: 'error' };
+            return { status: 'ok', entries };
+        }
+        catch (error) {
+            debugError(`loadSessionEntries ${sessionID}`, error);
+            return {
+                status: isMissingSessionError(error) ? 'missing' : 'error',
+            };
+        }
     };
     const persistSessionUsage = (sessionID, usage) => {
         const sessionState = deps.state.sessions[sessionID];
@@ -246,23 +311,9 @@ 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, options) => {
-        const entries = await loadSessionEntries(sessionID);
+        const load = await loadSessionEntries(sessionID);
+        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.
@@ -281,9 +332,7 @@ export function createUsageService(deps) {
             return { usage: empty, persist: false };
         }
         const modelCostMap = await getModelCostMap();
-        const staleBillingCache = Boolean(sessionState?.usage) &&
-            (!isUsageBillingCurrent(sessionState?.usage) ||
-                hasStaleZeroApiCost(sessionState?.usage, modelCostMap));
+        const staleBillingCache = Boolean(sessionState?.usage) && !isUsageBillingCurrent(sessionState?.usage);
         const forceRescan = forceRescanSessions.has(sessionID) || staleBillingCache;
         if (forceRescan)
             forceRescanSessions.delete(sessionID);
@@ -406,7 +455,7 @@ export function createUsageService(deps) {
                 return true;
             return providerIDs.some((providerID) => {
                 const canonical = canonicalApiCostProviderID(providerID);
-                return SUBSCRIPTION_API_COST_PROVIDERS.has(canonical);
+                return API_COST_ENABLED_PROVIDERS.has(canonical);
             });
         };
         const shouldRecomputeUsageCache = (cached) => {
@@ -426,8 +475,8 @@ export function createUsageService(deps) {
         };
         if (sessions.length > 0) {
             const fetched = await mapConcurrent(sessions, RANGE_USAGE_CONCURRENCY, async (session) => {
-                const entries = await loadSessionEntries(session.sessionID);
-                if (!entries) {
+                const load = await loadSessionEntries(session.sessionID);
+                if (load.status !== 'ok') {
                     return {
                         sessionID: session.sessionID,
                         dateKey: session.dateKey,
@@ -436,16 +485,19 @@ export function createUsageService(deps) {
                         dirty: session.state.dirty === true,
                         computed: emptyUsageSummary(),
                         fullUsage: undefined,
-                        loadFailed: true,
+                        loadFailed: load.status === 'error',
+                        missing: load.status === 'missing',
                         persist: false,
                         cursor: undefined,
                     };
                 }
+                const entries = load.entries;
                 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);
+                const shouldPersistFullUsage = !session.state.usage ||
+                    shouldRecomputeUsageCache(session.state.usage);
                 if (!shouldPersistFullUsage) {
                     return {
                         sessionID: session.sessionID,
@@ -456,6 +508,7 @@ export function createUsageService(deps) {
                         computed,
                         fullUsage: undefined,
                         loadFailed: false,
+                        missing: false,
                         persist: false,
                         cursor: session.state.cursor,
                     };
@@ -473,10 +526,35 @@ export function createUsageService(deps) {
                     computed,
                     fullUsage,
                     loadFailed: false,
+                    missing: false,
                     persist: true,
                     cursor,
                 };
             });
+            const missingSessions = fetched.filter((item) => item.missing);
+            if (missingSessions.length > 0) {
+                let stateChanged = false;
+                for (const missing of missingSessions) {
+                    deps.state.deletedSessionDateMap[missing.sessionID] = missing.dateKey;
+                    delete deps.state.sessions[missing.sessionID];
+                    delete deps.state.sessionDateMap[missing.sessionID];
+                    deps.persistence.markDirty(missing.dateKey);
+                    forgetSession(missing.sessionID);
+                    stateChanged = true;
+                }
+                await Promise.all(missingSessions.map(async (missing) => {
+                    const deletedFromChunk = await deleteSessionFromDayChunk(deps.statePath, missing.sessionID, missing.dateKey).catch((error) => {
+                        swallow('deleteSessionFromDayChunk')(error);
+                        return false;
+                    });
+                    if (!deletedFromChunk)
+                        return;
+                    delete deps.state.deletedSessionDateMap[missing.sessionID];
+                    stateChanged = true;
+                }));
+                if (stateChanged)
+                    deps.persistence.scheduleSave();
+            }
             const failedLoads = fetched.filter((item) => {
                 if (!item.loadFailed)
                     return false;
@@ -493,7 +571,7 @@ 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, persist, cursor, } of fetched) {
                 if (computed.assistantMessages > 0) {
                     computed.sessionCount = 1;
                     mergeUsage(usage, computed);

package/package.json

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