@leo000001/opencode-quota-sidebar 4.0.9 → 4.0.12

package/dist/history_usage.d.ts

@@ -1,7 +1,7 @@
-import type { AssistantMessage, Message } from '@opencode-ai/sdk';
-import { type HistoryPeriod, type PeriodRange, type SinceSpec } from './period.js';
-import { type UsageSummary } from './usage.js';
-import type { CacheCoverageMode, CachedSessionUsage, IncrementalCursor } from './types.js';
+import type { AssistantMessage, Message } from "@opencode-ai/sdk";
+import { type HistoryPeriod, type PeriodRange, type SinceSpec } from "./period.js";
+import { type UsageSummary } from "./usage.js";
+import type { CacheCoverageMode, CachedSessionUsage, IncrementalCursor } from "./types.js";
 export type HistoryDialogRow = {
     label: string;
     isCurrent: boolean;
@@ -37,19 +37,21 @@ export type HistoryPersistenceHint = {
     ranges: UsageSummary[];
     totalUsage: UsageSummary;
     fullUsage: UsageSummary | undefined;
+    pricingFingerprint?: string;
+    pricingKeys?: string[];
     persist: boolean;
     cursor: IncrementalCursor | undefined;
     missing: boolean;
     loadFailed: boolean;
 };
 export type LoadMessagesPageResult = {
-    status: 'ok';
+    status: "ok";
     entries: MessageEntry[];
     nextBefore?: string;
 } | {
-    status: 'missing';
+    status: "missing";
 } | {
-    status: 'error';
+    status: "error";
 };
 type SessionEntry = {
     sessionID: string;
@@ -74,10 +76,14 @@ export type ComputeHistoryUsageDeps = {
     classifyCacheMode: (message: AssistantMessage, modelCostMap: Record<string, unknown>) => CacheCoverageMode;
     /** Check whether a set of entries has at least one resolvable API-cost message. */
     hasResolvableApiCostMessages: (entries: MessageEntry[], modelCostMap: Record<string, unknown>) => boolean;
+    /** Build a pricing fingerprint from provider/model keys and current rates. */
+    pricingFingerprintForKeys: (pricingKeys: string[], modelCostMap: Record<string, unknown>) => string;
+    /** Whether cached usage still matches current billing + pricing semantics. */
+    isUsageBillingCurrent: (cached: CachedSessionUsage | undefined, modelCostMap: Record<string, unknown>) => boolean;
     /** Whether the cached usage for a session needs a full recompute. */
-    shouldTrackFullUsage: (cached: CachedSessionUsage | undefined, hasPricing: boolean) => boolean;
+    shouldTrackFullUsage: (cached: CachedSessionUsage | undefined, modelCostMap: Record<string, unknown>) => boolean;
     /** Whether cached usage needs recompute (for persistence decision). */
-    shouldRecomputeUsageCache: (cached: CachedSessionUsage, hasPricing: boolean, hasResolvableApiCostMessage: boolean) => boolean;
+    shouldRecomputeUsageCache: (cached: CachedSessionUsage, pricingFingerprint: string | undefined) => boolean;
     throwOnLoadFailure?: boolean;
 };
 /**

package/dist/history_usage.js

@@ -1,6 +1,6 @@
-import { parseSince, periodRanges, } from './period.js';
-import { mapConcurrent } from './helpers.js';
-import { accumulateMessagesAcrossCompletedRanges, accumulateMessagesInCompletedRange, emptyUsageSummary, fromCachedSessionUsage, mergeCursorFromEntries, mergeUsage, USAGE_BILLING_CACHE_VERSION, } from './usage.js';
+import { parseSince, periodRanges, } from "./period.js";
+import { mapConcurrent } from "./helpers.js";
+import { accumulateMessagesAcrossCompletedRanges, accumulateMessagesInCompletedRange, emptyUsageSummary, fromCachedSessionUsage, mergeCursorFromEntries, mergeUsage, } from "./usage.js";
 // ── Constants ──────────────────────────────────────────────────────────────
 const RANGE_USAGE_CONCURRENCY = 5;
 // ── Core ───────────────────────────────────────────────────────────────────
@@ -11,7 +11,7 @@ function filterRangeSessions(sessions, startAt, endAt) {
         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;
@@ -24,13 +24,13 @@ function pageLatestTimestamp(entries) {
     for (const entry of entries) {
         const info = entry.info;
         const completed = info.time?.completed;
-        if (typeof completed === 'number' && Number.isFinite(completed)) {
+        if (typeof completed === "number" && Number.isFinite(completed)) {
             if (completed > latest)
                 latest = completed;
             continue;
         }
         const created = info.time?.created;
-        if (typeof created === 'number' && Number.isFinite(created)) {
+        if (typeof created === "number" && Number.isFinite(created)) {
             if (created > latest)
                 latest = created;
         }
@@ -55,19 +55,19 @@ function rangeIndexForTimestamp(ranges, timestamp) {
     }
     return -1;
 }
-function canUseCurrentSessionCache(cached, session, ranges) {
+function canUseCurrentSessionCache(cached, session, ranges, deps, modelCostMap) {
     if (!cached)
         return undefined;
-    if (cached.billingVersion !== USAGE_BILLING_CACHE_VERSION)
+    if (!deps.isUsageBillingCurrent(cached, modelCostMap))
         return undefined;
     if (session.state.dirty === true)
         return undefined;
     const lastMessageTime = session.state.cursor?.lastMessageTime;
-    if (typeof lastMessageTime !== 'number' ||
+    if (typeof lastMessageTime !== "number" ||
         !Number.isFinite(lastMessageTime)) {
         return undefined;
     }
-    if (typeof session.state.createdAt !== 'number' ||
+    if (typeof session.state.createdAt !== "number" ||
         !Number.isFinite(session.state.createdAt)) {
         return undefined;
     }
@@ -107,13 +107,12 @@ export async function computeHistoryUsage(deps, period, rawSince) {
     const endAt = ranges[ranges.length - 1].endAt;
     const sessions = filterRangeSessions(deps.sessions, startAt, endAt);
     const modelCostMap = await deps.getModelCostMap();
-    const hasPricing = Object.keys(modelCostMap).length > 0;
     if (sessions.length > 0) {
         const fetched = await mapConcurrent(sessions, RANGE_USAGE_CONCURRENCY, async (session) => {
             const cachedHit = canUseCurrentSessionCache(session.state.usage, session, rows.map((row) => ({
                 startAt: row.range.startAt,
                 endAt: row.range.endAt,
-            })));
+            })), deps, modelCostMap);
             if (cachedHit) {
                 const rangeUsage = rows.map(() => emptyUsageSummary());
                 rangeUsage[cachedHit.index] = cachedHit.usage;
@@ -137,14 +136,14 @@ export async function computeHistoryUsage(deps, period, rawSince) {
             };
             const rangeUsage = rows.map(() => emptyUsageSummary());
             const totalUsage = emptyUsageSummary();
-            const trackFullUsage = deps.shouldTrackFullUsage(session.state.usage, hasPricing);
+            const trackFullUsage = deps.shouldTrackFullUsage(session.state.usage, modelCostMap);
             const fullUsage = trackFullUsage ? emptyUsageSummary() : undefined;
             let cursor;
-            let hasResolvable = false;
+            const pricingKeys = new Set();
             let before;
             while (true) {
                 const load = await deps.loadMessagesPage(session.sessionID, before);
-                if (load.status !== 'ok') {
+                if (load.status !== "ok") {
                     return {
                         sessionID: session.sessionID,
                         dateKey: session.dateKey,
@@ -153,8 +152,8 @@ export async function computeHistoryUsage(deps, period, rawSince) {
                         ranges: rows.map(() => emptyUsageSummary()),
                         totalUsage: emptyUsageSummary(),
                         fullUsage: undefined,
-                        loadFailed: load.status === 'error',
-                        missing: load.status === 'missing',
+                        loadFailed: load.status === "error",
+                        missing: load.status === "missing",
                         persist: false,
                         cursor: undefined,
                     };
@@ -169,9 +168,11 @@ export async function computeHistoryUsage(deps, period, rawSince) {
                 if (fullUsage) {
                     accumulateMessagesInCompletedRange(fullUsage, entries, 0, Number.POSITIVE_INFINITY, usageOptions);
                     cursor = mergeCursorFromEntries(cursor, entries);
-                }
-                if (!hasResolvable) {
-                    hasResolvable = deps.hasResolvableApiCostMessages(entries, modelCostMap);
+                    for (const { info } of entries) {
+                        if (info.role !== "assistant")
+                            continue;
+                        pricingKeys.add(`${info.providerID}:${info.modelID}`);
+                    }
                 }
                 // `session.messages(limit, before)` pages from newest to oldest.
                 // When we are only computing range usage (no full-session persistence),
@@ -195,9 +196,12 @@ export async function computeHistoryUsage(deps, period, rawSince) {
             if (totalUsage.assistantMessages > 0) {
                 totalUsage.sessionCount = 1;
             }
+            const pricingFingerprint = fullUsage
+                ? deps.pricingFingerprintForKeys([...pricingKeys], modelCostMap)
+                : undefined;
             const shouldPersist = !!fullUsage &&
                 (!session.state.usage ||
-                    deps.shouldRecomputeUsageCache(session.state.usage, hasPricing, hasResolvable));
+                    deps.shouldRecomputeUsageCache(session.state.usage, pricingFingerprint));
             return {
                 sessionID: session.sessionID,
                 dateKey: session.dateKey,
@@ -206,6 +210,8 @@ export async function computeHistoryUsage(deps, period, rawSince) {
                 ranges: rangeUsage,
                 totalUsage,
                 fullUsage: shouldPersist ? fullUsage : undefined,
+                pricingFingerprint,
+                pricingKeys: fullUsage ? [...pricingKeys].sort() : undefined,
                 loadFailed: false,
                 missing: false,
                 persist: shouldPersist,
@@ -218,7 +224,7 @@ export async function computeHistoryUsage(deps, period, rawSince) {
             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;

package/dist/index.js

@@ -110,6 +110,7 @@ export async function QuotaSidebarPlugin(input) {
         statePath,
         client: input.client,
         directory: input.directory,
+        worktree: input.worktree,
         persistence: {
             markDirty,
             scheduleSave,
@@ -120,6 +121,15 @@ export async function QuotaSidebarPlugin(input) {
     const summarizeSessionUsageForDisplay = usageService.summarizeSessionUsageForDisplay;
     const summarizeForTool = usageService.summarizeForTool;
     const summarizeHistoryForTool = usageService.summarizeHistoryUsage;
+    const listCurrentProviderIDsSafe = async () => {
+        return listCurrentProviderIDs({
+            client: input.client,
+            directory: input.directory,
+        }).catch((error) => {
+            debug(`listCurrentProviderIDs failed: ${String(error)}`);
+            return undefined;
+        });
+    };
     const activeSessionUntil = new Map();
     let lastTuiSessionID;
     const markSessionActive = (sessionID, now = Date.now()) => {
@@ -181,6 +191,7 @@ export async function QuotaSidebarPlugin(input) {
         getTitleView: () => resolveTitleView({ config }),
         getQuotaSnapshots,
         summarizeSessionUsageForDisplay,
+        listCurrentProviderIDs: listCurrentProviderIDsSafe,
         scheduleParentRefreshIfSafe,
         isSessionActive,
         restoreConcurrency: RESTORE_TITLE_CONCURRENCY,
@@ -269,7 +280,10 @@ export async function QuotaSidebarPlugin(input) {
         }
         expiryToastInflight.add(sessionID);
         try {
-            const quotas = await getQuotaSnapshots([], { allowDefault: true });
+            const allowedProviderIDs = await listCurrentProviderIDsSafe();
+            if (!allowedProviderIDs || allowedProviderIDs.size === 0)
+                return;
+            const quotas = await getQuotaSnapshots([...allowedProviderIDs]);
             const nowMs = Date.now();
             const expiryLines = quotas
                 .filter((item) => item.status === 'ok')

package/dist/models_dev_pricing.d.ts

@@ -0,0 +1,6 @@
+import { type ModelCostRates } from "./cost.js";
+import type { OpenCodePricingModel } from "./opencode_pricing.js";
+export declare function modelsDevHasProvider(providerID: string): boolean;
+export declare function loadModelsDevPricingModels(requests: OpenCodePricingModel[]): Promise<OpenCodePricingModel[]>;
+export declare function clearModelsDevPricingCache(): void;
+export declare function modelsDevCostToRates(cost: OpenCodePricingModel["cost"]): ModelCostRates | undefined;

package/dist/models_dev_pricing.js

@@ -0,0 +1,226 @@
+import { debug, mapConcurrent } from "./helpers.js";
+import { canonicalPricingProviderID, modelCostLookupKeys, } from "./cost.js";
+const MODELS_DEV_RAW_BASE_URL = "https://raw.githubusercontent.com/anomalyco/models.dev/dev/providers";
+const MODELS_DEV_TIMEOUT_MS = 10_000;
+const MODELS_DEV_POSITIVE_TTL_MS = 6 * 60 * 60 * 1000;
+const MODELS_DEV_NEGATIVE_TTL_MS = 60 * 60 * 1000;
+const MODELS_DEV_PARSE_MISS_TTL_MS = 10 * 60 * 1000;
+const MODELS_DEV_REQUEST_CONCURRENCY = 4;
+const fileCache = new Map();
+function modelsDevProviderDirs(providerID) {
+    const canonical = canonicalPricingProviderID(providerID);
+    if (canonical === "openai")
+        return ["openai"];
+    if (canonical === "anthropic")
+        return ["anthropic"];
+    if (canonical === "moonshotai")
+        return ["moonshotai", "kimi-for-coding"];
+    if (canonical === "minimax") {
+        return ["minimax-cn-coding-plan", "minimax-coding-plan", "minimax"];
+    }
+    if (canonical === "zhipu") {
+        return ["zai-coding-plan", "zai", "zhipuai-coding-plan", "zhipuai"];
+    }
+    return [];
+}
+function stripInlineComment(line) {
+    let inString = false;
+    let escaping = false;
+    let output = "";
+    for (const char of line) {
+        if (char === '"' && !escaping)
+            inString = !inString;
+        if (char === "#" && !inString)
+            break;
+        output += char;
+        if (escaping) {
+            escaping = false;
+        }
+        else if (char === "\\") {
+            escaping = true;
+        }
+    }
+    return output.trim();
+}
+function parseTomlNumber(raw) {
+    const parsed = Number(raw.replace(/_/g, "").trim());
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+function parseModelsDevCost(text) {
+    const rates = {};
+    const contextRates = {};
+    let section = "";
+    for (const rawLine of text.split(/\r?\n/)) {
+        const line = stripInlineComment(rawLine);
+        if (!line)
+            continue;
+        const sectionMatch = /^\[([^\]]+)\]$/.exec(line);
+        if (sectionMatch) {
+            section = sectionMatch[1] || "";
+            continue;
+        }
+        const kvMatch = /^([A-Za-z0-9_.-]+)\s*=\s*(.+)$/.exec(line);
+        if (!kvMatch)
+            continue;
+        const key = kvMatch[1];
+        const value = parseTomlNumber(kvMatch[2] || "");
+        if (value === undefined)
+            continue;
+        if (section === "cost") {
+            rates[key] = value;
+            continue;
+        }
+        if (section === "cost.context_over_200k") {
+            contextRates[key] = value;
+        }
+    }
+    const hasBase = (rates.input || 0) > 0 ||
+        (rates.output || 0) > 0 ||
+        (rates.cache_read || 0) > 0 ||
+        (rates.cache_write || 0) > 0;
+    if (!hasBase)
+        return undefined;
+    const hasContext = (contextRates.input || 0) > 0 ||
+        (contextRates.output || 0) > 0 ||
+        (contextRates.cache_read || 0) > 0 ||
+        (contextRates.cache_write || 0) > 0;
+    return {
+        input: rates.input || 0,
+        output: rates.output || 0,
+        cache_read: rates.cache_read || 0,
+        cache_write: rates.cache_write || 0,
+        ...(hasContext
+            ? {
+                context_over_200k: {
+                    input: contextRates.input || 0,
+                    output: contextRates.output || 0,
+                    cache_read: contextRates.cache_read || 0,
+                    cache_write: contextRates.cache_write || 0,
+                },
+            }
+            : {}),
+    };
+}
+function modelsDevModelCandidates(model) {
+    const candidates = new Set();
+    for (const stem of [model.modelID, model.modelKey].filter((value) => Boolean(value))) {
+        for (const key of modelCostLookupKeys(model.providerID, stem)) {
+            const separator = key.indexOf(":");
+            const candidate = separator >= 0 ? key.slice(separator + 1) : key;
+            if (!candidate || candidate.includes("/"))
+                continue;
+            candidates.add(candidate);
+        }
+    }
+    return [...candidates];
+}
+async function fetchModelsDevCost(url) {
+    const cached = fileCache.get(url);
+    if (cached && cached.expiresAt > Date.now())
+        return cached.cost;
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), MODELS_DEV_TIMEOUT_MS);
+    timeout.unref?.();
+    try {
+        const response = await fetch(url, { signal: controller.signal });
+        if (response.status === 404) {
+            fileCache.set(url, {
+                expiresAt: Date.now() + MODELS_DEV_NEGATIVE_TTL_MS,
+                cost: null,
+            });
+            return null;
+        }
+        if (!response.ok) {
+            debug(`models.dev fetch failed ${response.status} for ${url}`);
+            return undefined;
+        }
+        const parsed = parseModelsDevCost(await response.text());
+        fileCache.set(url, {
+            expiresAt: Date.now() +
+                (parsed ? MODELS_DEV_POSITIVE_TTL_MS : MODELS_DEV_PARSE_MISS_TTL_MS),
+            cost: parsed || null,
+        });
+        return parsed || null;
+    }
+    catch (error) {
+        debug(`models.dev fetch error for ${url}: ${String(error)}`);
+        return undefined;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+export function modelsDevHasProvider(providerID) {
+    return modelsDevProviderDirs(providerID).length > 0;
+}
+export async function loadModelsDevPricingModels(requests) {
+    const resolved = new Map();
+    const entries = await mapConcurrent(requests, MODELS_DEV_REQUEST_CONCURRENCY, async (request) => {
+        const dirs = modelsDevProviderDirs(request.providerID);
+        if (dirs.length === 0)
+            return undefined;
+        const candidates = modelsDevModelCandidates(request);
+        if (candidates.length === 0)
+            return undefined;
+        let found = undefined;
+        for (const dir of dirs) {
+            for (const candidate of candidates) {
+                const url = `${MODELS_DEV_RAW_BASE_URL}/${dir}/models/${candidate}.toml`;
+                const cost = await fetchModelsDevCost(url);
+                if (cost === undefined || cost === null)
+                    continue;
+                found = cost;
+                break;
+            }
+            if (found)
+                break;
+        }
+        if (!found)
+            return undefined;
+        return {
+            key: `${request.providerID}:${request.modelID}`,
+            model: {
+                providerKey: request.providerKey,
+                providerID: request.providerID,
+                modelID: request.modelID,
+                modelKey: request.modelKey,
+                cost: found,
+                options: request.options,
+                headers: request.headers,
+                api: request.api,
+                limit: request.limit,
+            },
+        };
+    });
+    for (const entry of entries) {
+        if (!entry)
+            continue;
+        resolved.set(entry.key, entry.model);
+    }
+    return [...resolved.values()];
+}
+export function clearModelsDevPricingCache() {
+    fileCache.clear();
+}
+export function modelsDevCostToRates(cost) {
+    if (!cost || typeof cost !== "object")
+        return undefined;
+    const record = cost;
+    const context = record.context_over_200k && typeof record.context_over_200k === "object"
+        ? record.context_over_200k
+        : undefined;
+    return {
+        input: Number(record.input || 0),
+        output: Number(record.output || 0),
+        cacheRead: Number(record.cache_read || 0),
+        cacheWrite: Number(record.cache_write || 0),
+        contextOver200k: context
+            ? {
+                input: Number(context.input || 0),
+                output: Number(context.output || 0),
+                cacheRead: Number(context.cache_read || 0),
+                cacheWrite: Number(context.cache_write || 0),
+            }
+            : undefined,
+    };
+}

package/dist/opencode_pricing.d.ts

@@ -0,0 +1,14 @@
+export type OpenCodePricingModel = {
+    providerKey?: string;
+    providerID: string;
+    modelID: string;
+    modelKey?: string;
+    cost?: unknown;
+    options?: Record<string, unknown>;
+    headers?: Record<string, unknown>;
+    api?: Record<string, unknown>;
+    limit?: Record<string, unknown>;
+};
+export declare function parseJsonc(text: string): unknown;
+export declare function extractOpenCodePricingModels(config: unknown): OpenCodePricingModel[];
+export declare function loadOpenCodePricingModels(paths: string[]): Promise<OpenCodePricingModel[]>;