@leo000001/opencode-quota-sidebar 1.13.8 → 2.0.0

package/dist/cost.d.ts

@@ -1,6 +1,7 @@
 import type { AssistantMessage } from '@opencode-ai/sdk';
+import type { CacheCoverageMode } from './types.js';
 export declare const SUBSCRIPTION_API_COST_PROVIDERS: Set<string>;
-export declare function canonicalApiCostProviderID(providerID: string, npmPackage?: string): string;
+export declare function canonicalApiCostProviderID(providerID: string): string;
 export type ModelCostRates = {
     input: number;
     output: number;
@@ -13,8 +14,8 @@ export type ModelCostRates = {
         cacheWrite: number;
     };
 };
-export declare function openAIServiceTierFromMessage(message: AssistantMessage): string | undefined;
 export declare function modelCostKey(providerID: string, modelID: string): string;
 export declare function parseModelCostRates(value: unknown): ModelCostRates | undefined;
 export declare function guessModelCostDivisor(rates: ModelCostRates): 1 | 1000000;
-export declare function calcEquivalentApiCostForMessage(message: AssistantMessage, rates: ModelCostRates, canonicalProviderID?: string, serviceTier?: string | undefined): number;
+export declare function cacheCoverageModeFromRates(rates: ModelCostRates | undefined): CacheCoverageMode;
+export declare function calcEquivalentApiCostForMessage(message: AssistantMessage, rates: ModelCostRates): number;

package/dist/cost.js

@@ -5,20 +5,7 @@ function normalizeKnownProviderID(providerID) {
         return 'github-copilot';
     return providerID;
 }
-function canonicalProviderByNpmPackage(npmPackage) {
-    const normalized = npmPackage.trim().toLowerCase();
-    if (normalized === '@ai-sdk/openai')
-        return 'openai';
-    if (normalized === '@ai-sdk/anthropic')
-        return 'anthropic';
-    return undefined;
-}
-export function canonicalApiCostProviderID(providerID, npmPackage) {
-    const byPackage = typeof npmPackage === 'string'
-        ? canonicalProviderByNpmPackage(npmPackage)
-        : undefined;
-    if (byPackage)
-        return byPackage;
+export function canonicalApiCostProviderID(providerID) {
     const normalized = normalizeKnownProviderID(providerID);
     if (SUBSCRIPTION_API_COST_PROVIDERS.has(normalized))
         return normalized;
@@ -32,11 +19,6 @@ export function canonicalApiCostProviderID(providerID, npmPackage) {
     }
     return normalized;
 }
-export function openAIServiceTierFromMessage(message) {
-    const info = message;
-    return (info.providerMetadata?.openai?.serviceTier ??
-        info.providerMetadata?.openai?.service_tier);
-}
 export function modelCostKey(providerID, modelID) {
     return `${providerID}:${modelID}`;
 }
@@ -96,20 +78,27 @@ export function guessModelCostDivisor(rates) {
         ? MODEL_COST_DIVISOR_PER_MILLION
         : MODEL_COST_DIVISOR_PER_TOKEN;
 }
-export function calcEquivalentApiCostForMessage(message, rates, canonicalProviderID = message.providerID, serviceTier = openAIServiceTierFromMessage(message)) {
+export function cacheCoverageModeFromRates(rates) {
+    if (!rates)
+        return 'none';
+    if (rates.cacheWrite > 0)
+        return 'read-write';
+    if (rates.cacheRead > 0)
+        return 'read-only';
+    return 'none';
+}
+export function calcEquivalentApiCostForMessage(message, rates) {
     const effectiveRates = message.tokens.input > 200_000 && rates.contextOver200k
         ? rates.contextOver200k
         : rates;
-    const priorityMultiplier = canonicalProviderID === 'openai' && serviceTier === 'priority' ? 2 : 1;
     // For providers that expose reasoning tokens separately, they are still
     // billed as output/completion tokens (same unit price). Our UI also merges
     // reasoning into the single Output statistic, so API cost should match that.
     const billedOutput = message.tokens.output + message.tokens.reasoning;
-    const rawCost = (message.tokens.input * effectiveRates.input +
+    const rawCost = message.tokens.input * effectiveRates.input +
         billedOutput * effectiveRates.output +
         message.tokens.cache.read * effectiveRates.cacheRead +
-        message.tokens.cache.write * effectiveRates.cacheWrite) *
-        priorityMultiplier;
+        message.tokens.cache.write * effectiveRates.cacheWrite;
     const divisor = guessModelCostDivisor(effectiveRates);
     const normalized = rawCost / divisor;
     return Number.isFinite(normalized) && normalized > 0 ? normalized : 0;

package/dist/format.d.ts

@@ -1,5 +1,5 @@
 import type { QuotaSidebarConfig, QuotaSnapshot } from './types.js';
-import type { UsageSummary } from './usage.js';
+import { type UsageSummary } from './usage.js';
 /**
  * Render sidebar title with multi-line token breakdown.
  *

package/dist/format.js

@@ -1,3 +1,4 @@
+import { getCacheCoverageMetrics } from './usage.js';
 import { canonicalProviderID, collapseQuotaSnapshots, displayShortLabel, quotaDisplayLabel, } from './quota_render.js';
 import { stripAnsi } from './title.js';
 /** M6 fix: handle negative, NaN, Infinity gracefully. */
@@ -147,6 +148,11 @@ function formatApiCostValue(value) {
 function formatApiCostLine(value) {
     return `${formatApiCostValue(value)} as API cost`;
 }
+function formatPercent(value, decimals = 1) {
+    const safe = Number.isFinite(value) && value >= 0 ? value : 0;
+    const pct = (safe * 100).toFixed(decimals);
+    return `${pct.replace(/\.0+$/, '').replace(/(\.\d*[1-9])0+$/, '$1')}%`;
+}
 function alignPairs(pairs, indent = '  ') {
     if (pairs.length === 0)
         return [];
@@ -191,6 +197,7 @@ function compactQuotaInline(quota) {
 function renderSingleLineTitle(baseTitle, usage, quotas, config, width) {
     const baseBudget = Math.min(16, Math.max(8, Math.floor(width * 0.35)));
     const base = fitLine(baseTitle, baseBudget);
+    const cacheMetrics = getCacheCoverageMetrics(usage);
     const segments = [
         `Input ${sidebarNumber(usage.input)}  Output ${sidebarNumber(usage.output)}`,
     ];
@@ -200,6 +207,12 @@ function renderSingleLineTitle(baseTitle, usage, quotas, config, width) {
     if (usage.cacheWrite > 0) {
         segments.push(`Cache Write ${sidebarNumber(usage.cacheWrite)}`);
     }
+    if (cacheMetrics.cacheCoverage !== undefined) {
+        segments.push(`Cache Coverage ${formatPercent(cacheMetrics.cacheCoverage, 0)}`);
+    }
+    if (cacheMetrics.cacheReadCoverage !== undefined) {
+        segments.push(`Cache Read Coverage ${formatPercent(cacheMetrics.cacheReadCoverage, 0)}`);
+    }
     if (config.sidebar.showCost && usage.apiCost > 0) {
         segments.push(formatApiCostLine(usage.apiCost));
     }
@@ -229,6 +242,7 @@ export function renderSidebarTitle(baseTitle, usage, quotas, config) {
     if (config.sidebar.multilineTitle !== true) {
         return renderSingleLineTitle(safeBaseTitle, usage, quotas, config, width);
     }
+    const cacheMetrics = getCacheCoverageMetrics(usage);
     const lines = [];
     lines.push(fitLine(safeBaseTitle, width));
     lines.push('');
@@ -242,6 +256,12 @@ export function renderSidebarTitle(baseTitle, usage, quotas, config) {
     if (usage.cacheWrite > 0) {
         lines.push(fitLine(`Cache Write ${sidebarNumber(usage.cacheWrite)}`, width));
     }
+    if (cacheMetrics.cacheCoverage !== undefined) {
+        lines.push(fitLine(`Cache Coverage ${formatPercent(cacheMetrics.cacheCoverage, 0)}`, width));
+    }
+    if (cacheMetrics.cacheReadCoverage !== undefined) {
+        lines.push(fitLine(`Cache Read Coverage ${formatPercent(cacheMetrics.cacheReadCoverage, 0)}`, width));
+    }
     if (config.sidebar.showCost && usage.apiCost > 0) {
         lines.push(fitLine(formatApiCostLine(usage.apiCost), width));
     }
@@ -419,6 +439,7 @@ function periodLabel(period) {
 }
 export function renderMarkdownReport(period, usage, quotas, options) {
     const showCost = options?.showCost !== false;
+    const cacheMetrics = getCacheCoverageMetrics(usage);
     const mdCell = (value) => sanitizeLine(value).replace(/\|/g, '\\|');
     const rightCodeSubscriptionProviderIDs = new Set(collapseQuotaSnapshots(quotas)
         .filter((quota) => quota.adapterID === 'rightcode')
@@ -506,6 +527,14 @@ export function renderMarkdownReport(period, usage, quotas, options) {
         `- Sessions: ${usage.sessionCount}`,
         `- Assistant messages: ${usage.assistantMessages}`,
         `- Tokens: input ${usage.input}, output ${usage.output}, cache_read ${usage.cacheRead}, cache_write ${usage.cacheWrite}, total ${usage.total}`,
+        ...(cacheMetrics.cacheCoverage !== undefined
+            ? [`- Cache Coverage: ${formatPercent(cacheMetrics.cacheCoverage, 1)}`]
+            : []),
+        ...(cacheMetrics.cacheReadCoverage !== undefined
+            ? [
+                `- Cache Read Coverage: ${formatPercent(cacheMetrics.cacheReadCoverage, 1)}`,
+            ]
+            : []),
         ...(showCost
             ? [
                 `- Measured cost: ${measuredCostSummaryValue()}`,
@@ -533,6 +562,7 @@ export function renderMarkdownReport(period, usage, quotas, options) {
 export function renderToastMessage(period, usage, quotas, options) {
     const width = Math.max(24, Math.floor(options?.width || 56));
     const showCost = options?.showCost !== false;
+    const cacheMetrics = getCacheCoverageMetrics(usage);
     const lines = [];
     lines.push(fitLine(`${periodLabel(period)} - Total ${shortNumber(usage.total)}`, width));
     lines.push('');
@@ -553,6 +583,18 @@ export function renderToastMessage(period, usage, quotas, options) {
             value: shortNumber(usage.cacheWrite),
         });
     }
+    if (cacheMetrics.cacheCoverage !== undefined) {
+        tokenPairs.push({
+            label: 'Cache Coverage',
+            value: formatPercent(cacheMetrics.cacheCoverage, 1),
+        });
+    }
+    if (cacheMetrics.cacheReadCoverage !== undefined) {
+        tokenPairs.push({
+            label: 'Cache Read Coverage',
+            value: formatPercent(cacheMetrics.cacheReadCoverage, 1),
+        });
+    }
     if (showCost) {
         if (usage.apiCost > 0) {
             tokenPairs.push({

package/dist/storage_parse.js

@@ -28,6 +28,38 @@ function parseProviderUsage(value) {
         assistantMessages: asNumber(value.assistantMessages, 0),
     };
 }
+function parseCacheUsageBucket(value) {
+    if (!isRecord(value))
+        return undefined;
+    return {
+        input: asNumber(value.input, 0),
+        cacheRead: asNumber(value.cacheRead, 0),
+        cacheWrite: asNumber(value.cacheWrite, 0),
+        assistantMessages: asNumber(value.assistantMessages, 0),
+    };
+}
+function parseCacheUsageBuckets(value) {
+    if (!isRecord(value))
+        return undefined;
+    const readOnly = parseCacheUsageBucket(value.readOnly);
+    const readWrite = parseCacheUsageBucket(value.readWrite);
+    if (!readOnly && !readWrite)
+        return undefined;
+    return {
+        readOnly: readOnly || {
+            input: 0,
+            cacheRead: 0,
+            cacheWrite: 0,
+            assistantMessages: 0,
+        },
+        readWrite: readWrite || {
+            input: 0,
+            cacheRead: 0,
+            cacheWrite: 0,
+            assistantMessages: 0,
+        },
+    };
+}
 function parseCachedUsage(value) {
     if (!isRecord(value))
         return undefined;
@@ -50,6 +82,7 @@ function parseCachedUsage(value) {
         cost: asNumber(value.cost, 0),
         apiCost: asNumber(value.apiCost, 0),
         assistantMessages: asNumber(value.assistantMessages, 0),
+        cacheBuckets: parseCacheUsageBuckets(value.cacheBuckets),
         providers,
     };
 }

package/dist/title.js

@@ -10,6 +10,8 @@ function isStrongDecoratedDetail(line) {
         return true;
     if (/^Cache\s+(Read|Write)\s+\S+/.test(line))
         return true;
+    if (/^Cache(?:\s+Read)?\s+Coverage\s+\S+/.test(line))
+        return true;
     if (/^\$\S+\s+as API cost\b/.test(line))
         return true;
     // Single-line compact mode compatibility.

package/dist/types.d.ts

@@ -36,6 +36,17 @@ export type SessionTitleState = {
     baseTitle: string;
     lastAppliedTitle?: string;
 };
+export type CacheCoverageMode = 'none' | 'read-only' | 'read-write';
+export type CacheUsageBucket = {
+    input: number;
+    cacheRead: number;
+    cacheWrite: number;
+    assistantMessages: number;
+};
+export type CacheUsageBuckets = {
+    readOnly: CacheUsageBucket;
+    readWrite: CacheUsageBucket;
+};
 export type CachedProviderUsage = {
     input: number;
     output: number;
@@ -61,6 +72,8 @@ export type CachedSessionUsage = {
     /** Equivalent API billing cost (USD) computed from model pricing. */
     apiCost: number;
     assistantMessages: number;
+    /** Cache coverage buckets grouped by model cache behavior. */
+    cacheBuckets?: CacheUsageBuckets;
     providers: Record<string, CachedProviderUsage>;
 };
 /** Tracks incremental aggregation cursor for a session (P1). */

package/dist/usage.d.ts

@@ -1,6 +1,6 @@
 import type { AssistantMessage, Message } from '@opencode-ai/sdk';
-import type { CachedSessionUsage, IncrementalCursor } from './types.js';
-export declare const USAGE_BILLING_CACHE_VERSION = 2;
+import type { CacheCoverageMode, CacheUsageBuckets, CachedSessionUsage, IncrementalCursor } from './types.js';
+export declare const USAGE_BILLING_CACHE_VERSION = 3;
 export type ProviderUsage = {
     providerID: string;
     input: number;
@@ -26,11 +26,18 @@ export type UsageSummary = {
     apiCost: number;
     assistantMessages: number;
     sessionCount: number;
+    cacheBuckets?: CacheUsageBuckets;
     providers: Record<string, ProviderUsage>;
 };
 export type UsageOptions = {
     /** Equivalent API cost calculator for the message. */
     calcApiCost?: (message: AssistantMessage) => number;
+    /** Cache-behavior classifier for the message model/provider. */
+    classifyCacheMode?: (message: AssistantMessage) => CacheCoverageMode;
+};
+export declare function getCacheCoverageMetrics(usage: Pick<UsageSummary, 'input' | 'cacheRead' | 'cacheWrite' | 'assistantMessages' | 'cacheBuckets'>): {
+    cacheCoverage: number | undefined;
+    cacheReadCoverage: number | undefined;
 };
 export declare function emptyUsageSummary(): UsageSummary;
 export declare function summarizeMessages(entries: Array<{

package/dist/usage.js

@@ -1,4 +1,94 @@
-export const USAGE_BILLING_CACHE_VERSION = 2;
+export const USAGE_BILLING_CACHE_VERSION = 3;
+function emptyCacheUsageBucket() {
+    return {
+        input: 0,
+        cacheRead: 0,
+        cacheWrite: 0,
+        assistantMessages: 0,
+    };
+}
+function emptyCacheUsageBuckets() {
+    return {
+        readOnly: emptyCacheUsageBucket(),
+        readWrite: emptyCacheUsageBucket(),
+    };
+}
+function cloneCacheUsageBucket(bucket) {
+    return {
+        input: bucket?.input ?? 0,
+        cacheRead: bucket?.cacheRead ?? 0,
+        cacheWrite: bucket?.cacheWrite ?? 0,
+        assistantMessages: bucket?.assistantMessages ?? 0,
+    };
+}
+function cloneCacheUsageBuckets(buckets) {
+    if (!buckets)
+        return undefined;
+    return {
+        readOnly: cloneCacheUsageBucket(buckets?.readOnly),
+        readWrite: cloneCacheUsageBucket(buckets?.readWrite),
+    };
+}
+function mergeCacheUsageBucket(target, source) {
+    if (!source)
+        return target;
+    target.input += source.input;
+    target.cacheRead += source.cacheRead;
+    target.cacheWrite += source.cacheWrite;
+    target.assistantMessages += source.assistantMessages;
+    return target;
+}
+function addMessageCacheUsage(target, message) {
+    target.input += message.tokens.input;
+    target.cacheRead += message.tokens.cache.read;
+    target.cacheWrite += message.tokens.cache.write;
+    target.assistantMessages += 1;
+}
+function fallbackCacheUsageBuckets(usage) {
+    if (usage.cacheWrite > 0) {
+        return {
+            readOnly: emptyCacheUsageBucket(),
+            readWrite: {
+                input: usage.input,
+                cacheRead: usage.cacheRead,
+                cacheWrite: usage.cacheWrite,
+                assistantMessages: usage.assistantMessages,
+            },
+        };
+    }
+    if (usage.cacheRead > 0) {
+        return {
+            readOnly: {
+                input: usage.input,
+                cacheRead: usage.cacheRead,
+                cacheWrite: 0,
+                assistantMessages: usage.assistantMessages,
+            },
+            readWrite: emptyCacheUsageBucket(),
+        };
+    }
+    return undefined;
+}
+function resolvedCacheUsageBuckets(usage) {
+    return (cloneCacheUsageBuckets(usage.cacheBuckets || fallbackCacheUsageBuckets(usage)) ||
+        emptyCacheUsageBuckets());
+}
+export function getCacheCoverageMetrics(usage) {
+    const buckets = resolvedCacheUsageBuckets(usage);
+    const readWritePromptSurface = buckets.readWrite.input +
+        buckets.readWrite.cacheRead +
+        buckets.readWrite.cacheWrite;
+    const readOnlyPromptSurface = buckets.readOnly.input + buckets.readOnly.cacheRead;
+    return {
+        cacheCoverage: readWritePromptSurface > 0
+            ? (buckets.readWrite.cacheRead + buckets.readWrite.cacheWrite) /
+                readWritePromptSurface
+            : undefined,
+        cacheReadCoverage: readOnlyPromptSurface > 0
+            ? buckets.readOnly.cacheRead / readOnlyPromptSurface
+            : undefined,
+    };
+}
 export function emptyUsageSummary() {
     return {
         input: 0,
@@ -11,6 +101,7 @@ export function emptyUsageSummary() {
         apiCost: 0,
         assistantMessages: 0,
         sessionCount: 0,
+        cacheBuckets: emptyCacheUsageBuckets(),
         providers: {},
     };
 }
@@ -69,6 +160,15 @@ function addMessageUsage(target, message, options) {
     provider.apiCost += apiCost;
     provider.assistantMessages += 1;
     target.providers[message.providerID] = provider;
+    const cacheMode = options?.classifyCacheMode?.(message) || 'none';
+    if (cacheMode === 'read-only') {
+        const buckets = (target.cacheBuckets ||= emptyCacheUsageBuckets());
+        addMessageCacheUsage(buckets.readOnly, message);
+    }
+    else if (cacheMode === 'read-write') {
+        const buckets = (target.cacheBuckets ||= emptyCacheUsageBuckets());
+        addMessageCacheUsage(buckets.readWrite, message);
+    }
 }
 export function summarizeMessages(entries, startAt = 0, sessionCount = 1, options) {
     const summary = emptyUsageSummary();
@@ -276,6 +376,12 @@ export function mergeUsage(target, source, options) {
     target.apiCost += source.apiCost;
     target.assistantMessages += source.assistantMessages;
     target.sessionCount += source.sessionCount;
+    const targetBuckets = (target.cacheBuckets ||= emptyCacheUsageBuckets());
+    const sourceBuckets = source.cacheBuckets;
+    if (sourceBuckets) {
+        mergeCacheUsageBucket(targetBuckets.readOnly, sourceBuckets.readOnly);
+        mergeCacheUsageBucket(targetBuckets.readWrite, sourceBuckets.readWrite);
+    }
     for (const provider of Object.values(source.providers)) {
         const existing = target.providers[provider.providerID] ||
             emptyProviderUsage(provider.providerID);
@@ -321,12 +427,14 @@ export function toCachedSessionUsage(summary) {
         cost: summary.cost,
         apiCost: summary.apiCost,
         assistantMessages: summary.assistantMessages,
+        cacheBuckets: cloneCacheUsageBuckets(summary.cacheBuckets),
         providers,
     };
 }
 export function fromCachedSessionUsage(cached, sessionCount = 1) {
     // Merge cached reasoning into output for a single output metric.
     const mergedOutputValue = cached.output + cached.reasoning;
+    const cacheBuckets = cloneCacheUsageBuckets(cached.cacheBuckets);
     return {
         input: cached.input,
         output: mergedOutputValue,
@@ -338,6 +446,7 @@ export function fromCachedSessionUsage(cached, sessionCount = 1) {
         apiCost: cached.apiCost || 0,
         assistantMessages: cached.assistantMessages,
         sessionCount,
+        cacheBuckets,
         providers: Object.entries(cached.providers).reduce((acc, [providerID, provider]) => {
             acc[providerID] = {
                 providerID,

package/dist/usage_service.js

@@ -1,5 +1,5 @@
 import { TtlValueCache } from './cache.js';
-import { calcEquivalentApiCostForMessage, canonicalApiCostProviderID, modelCostKey, openAIServiceTierFromMessage, parseModelCostRates, SUBSCRIPTION_API_COST_PROVIDERS, } from './cost.js';
+import { cacheCoverageModeFromRates, calcEquivalentApiCostForMessage, canonicalApiCostProviderID, modelCostKey, parseModelCostRates, SUBSCRIPTION_API_COST_PROVIDERS, } from './cost.js';
 import { dateKeyFromTimestamp, scanSessionsByCreatedRange, updateSessionsInDayChunks, } from './storage.js';
 import { periodStart } from './period.js';
 import { debug, isRecord, mapConcurrent, swallow } from './helpers.js';
@@ -30,7 +30,7 @@ export function createUsageService(deps) {
             return cached;
         const providerClient = deps.client;
         if (!providerClient.provider?.list) {
-            return modelCostCache.set({ rates: {}, providerAliases: {}, modelServiceTiers: {} }, 30_000);
+            return modelCostCache.set({}, 30_000);
         }
         const response = await providerClient.provider
             .list({
@@ -45,61 +45,13 @@ export function createUsageService(deps) {
             Array.isArray(response.data.all)
             ? response.data.all
             : [];
-        const providerAliases = all.reduce((acc, provider) => {
+        const map = all.reduce((acc, provider) => {
             if (!isRecord(provider))
                 return acc;
-            if (typeof provider.id !== 'string')
-                return acc;
-            const canonical = canonicalApiCostProviderID(provider.id, typeof provider.npm === 'string' ? provider.npm : undefined);
-            if (!SUBSCRIPTION_API_COST_PROVIDERS.has(canonical))
-                return acc;
-            acc[provider.id] = canonical;
-            return acc;
-        }, {});
-        const modelServiceTiers = all.reduce((acc, provider) => {
-            if (!isRecord(provider))
-                return acc;
-            const providerID = typeof provider.id === 'string'
-                ? (providerAliases[provider.id] ??
-                    canonicalApiCostProviderID(provider.id, typeof provider.npm === 'string' ? provider.npm : undefined))
-                : undefined;
-            if (!providerID)
-                return acc;
-            if (!SUBSCRIPTION_API_COST_PROVIDERS.has(providerID))
-                return acc;
-            const models = provider.models;
-            if (!isRecord(models))
-                return acc;
-            for (const [modelKey, modelValue] of Object.entries(models)) {
-                if (!isRecord(modelValue))
-                    continue;
-                const options = isRecord(modelValue.options)
-                    ? modelValue.options
-                    : undefined;
-                const serviceTier = typeof options?.serviceTier === 'string'
-                    ? options.serviceTier
-                    : undefined;
-                if (!serviceTier)
-                    continue;
-                const modelID = typeof modelValue.id === 'string' ? modelValue.id : modelKey;
-                acc[modelCostKey(providerID, modelID)] = serviceTier;
-                if (modelKey !== modelID) {
-                    acc[modelCostKey(providerID, modelKey)] = serviceTier;
-                }
-            }
-            return acc;
-        }, {});
-        const rates = all.reduce((acc, provider) => {
-            if (!isRecord(provider))
-                return acc;
-            const providerID = typeof provider.id === 'string'
-                ? (providerAliases[provider.id] ??
-                    canonicalApiCostProviderID(provider.id, typeof provider.npm === 'string' ? provider.npm : undefined))
-                : undefined;
-            if (!providerID)
-                return acc;
-            if (!SUBSCRIPTION_API_COST_PROVIDERS.has(providerID))
+            const rawProviderID = typeof provider.id === 'string' ? provider.id : undefined;
+            if (!rawProviderID)
                 return acc;
+            const canonicalProviderID = canonicalApiCostProviderID(rawProviderID);
             const models = provider.models;
             if (!isRecord(models))
                 return acc;
@@ -110,22 +62,27 @@ export function createUsageService(deps) {
                 if (!rates)
                     continue;
                 const modelID = typeof modelValue.id === 'string' ? modelValue.id : modelKey;
-                acc[modelCostKey(providerID, modelID)] = rates;
+                acc[modelCostKey(rawProviderID, modelID)] = rates;
                 if (modelKey !== modelID) {
-                    acc[modelCostKey(providerID, modelKey)] = rates;
+                    acc[modelCostKey(rawProviderID, modelKey)] = rates;
+                }
+                if (canonicalProviderID !== rawProviderID) {
+                    acc[modelCostKey(canonicalProviderID, modelID)] = rates;
+                    if (modelKey !== modelID) {
+                        acc[modelCostKey(canonicalProviderID, modelKey)] = rates;
+                    }
                 }
             }
             return acc;
         }, {});
-        return modelCostCache.set({ rates, providerAliases, modelServiceTiers }, Math.max(30_000, deps.config.quota.refreshMs));
+        return modelCostCache.set(map, Math.max(30_000, deps.config.quota.refreshMs));
     };
     const calcEquivalentApiCost = (message, modelCostMap) => {
-        const providerID = typeof modelCostMap.providerAliases[message.providerID] === 'string'
-            ? modelCostMap.providerAliases[message.providerID]
-            : canonicalApiCostProviderID(message.providerID);
+        const providerID = canonicalApiCostProviderID(message.providerID);
         if (!SUBSCRIPTION_API_COST_PROVIDERS.has(providerID))
             return 0;
-        const rates = modelCostMap.rates[modelCostKey(providerID, message.modelID)];
+        const rates = modelCostMap[modelCostKey(message.providerID, message.modelID)] ||
+            modelCostMap[modelCostKey(providerID, message.modelID)];
         if (!rates) {
             const key = modelCostKey(providerID, message.modelID);
             if (!missingApiCostRateKeys.has(key)) {
@@ -134,9 +91,31 @@ export function createUsageService(deps) {
             }
             return 0;
         }
-        const serviceTier = openAIServiceTierFromMessage(message) ??
-            modelCostMap.modelServiceTiers[modelCostKey(providerID, message.modelID)];
-        return calcEquivalentApiCostForMessage(message, rates, providerID, serviceTier);
+        return calcEquivalentApiCostForMessage(message, rates);
+    };
+    const classifyCacheMode = (message, modelCostMap) => {
+        const canonicalProviderID = canonicalApiCostProviderID(message.providerID);
+        const baseRates = modelCostMap[modelCostKey(message.providerID, message.modelID)] ||
+            modelCostMap[modelCostKey(canonicalProviderID, message.modelID)];
+        const effectiveRates = baseRates &&
+            message.tokens.input + message.tokens.cache.read > 200_000 &&
+            baseRates.contextOver200k
+            ? baseRates.contextOver200k
+            : baseRates;
+        const fromRates = cacheCoverageModeFromRates(effectiveRates);
+        if (fromRates !== 'none')
+            return fromRates;
+        if (message.tokens.cache.write > 0)
+            return 'read-write';
+        if (message.tokens.cache.read <= 0)
+            return 'none';
+        if (canonicalProviderID === 'anthropic' ||
+            message.modelID.toLowerCase().includes('claude')) {
+            return 'read-write';
+        }
+        if (canonicalProviderID === 'openai')
+            return 'read-only';
+        return 'none';
     };
     const isFiniteNumber = (value) => typeof value === 'number' && Number.isFinite(value);
     const decodeTokens = (value) => {
@@ -192,34 +171,12 @@ export function createUsageService(deps) {
             tokens,
         };
     };
-    const extractProviderMetadata = (parts) => {
-        if (!Array.isArray(parts))
-            return undefined;
-        for (const part of parts) {
-            if (!isRecord(part))
-                continue;
-            const meta = part.metadata;
-            if (isRecord(meta))
-                return meta;
-            const stateMeta = isRecord(part.state)
-                ? part.state?.metadata
-                : undefined;
-            if (isRecord(stateMeta))
-                return stateMeta;
-        }
-        return undefined;
-    };
     const decodeMessageEntry = (value) => {
         if (!isRecord(value))
             return undefined;
         const decoded = decodeMessageInfo(value.info);
         if (!decoded)
             return undefined;
-        const metadata = extractProviderMetadata(value.parts);
-        if (metadata && decoded.role === 'assistant') {
-            const msg = decoded;
-            msg.providerMetadata = metadata;
-        }
         return { info: decoded };
     };
     const decodeMessageEntries = (value) => {
@@ -292,6 +249,7 @@ export function createUsageService(deps) {
         }
         const { usage, cursor } = summarizeMessagesIncremental(entries, sessionState?.usage, sessionState?.cursor, forceRescan, {
             calcApiCost: (message) => calcEquivalentApiCost(message, modelCostMap),
+            classifyCacheMode: (message) => classifyCacheMode(message, modelCostMap),
         });
         usage.sessionCount = 1;
         // Update cursor in state
@@ -448,6 +406,7 @@ export function createUsageService(deps) {
                 }
                 const { usage: computed, cursor } = summarizeMessagesIncremental(entries, undefined, undefined, true, {
                     calcApiCost: (message) => calcEquivalentApiCost(message, modelCostMap),
+                    classifyCacheMode: (message) => classifyCacheMode(message, modelCostMap),
                 });
                 return {
                     sessionID: session.sessionID,

package/package.json

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