@leo000001/opencode-quota-sidebar 4.0.9 → 4.0.11

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.d.ts

@@ -1,5 +1,5 @@
-import { type Hooks, type PluginInput } from '@opencode-ai/plugin';
+import { type Hooks, type PluginInput } from "@opencode-ai/plugin";
 export declare function QuotaSidebarPlugin(input: PluginInput): Promise<Hooks>;
 export default QuotaSidebarPlugin;
-export type { QuotaSidebarConfig, QuotaSidebarState, QuotaSnapshot, QuotaStatus, SessionState, CachedSessionUsage, CachedProviderUsage, IncrementalCursor, } from './types.js';
-export type { UsageSummary } from './usage.js';
+export type { QuotaSidebarConfig, QuotaSidebarState, QuotaSnapshot, QuotaStatus, SessionState, CachedSessionUsage, CachedProviderUsage, IncrementalCursor, } from "./types.js";
+export type { UsageSummary } from "./usage.js";

package/dist/index.js

@@ -1,19 +1,19 @@
-import { renderHistoryMarkdownReport, renderMarkdownReport, resolveTitleView, renderSidebarTitle, renderToastMessage, } from './format.js';
-import { createQuotaRuntime } from './quota.js';
-import { authFilePath, dateKeyFromTimestamp, deleteSessionFromDayChunk, evictOldSessions, loadConfig, loadState, normalizeTimestampMs, quotaConfigPaths, resolveOpencodeDataDir, saveState, stateFilePath, } from './storage.js';
-import { debug, swallow } from './helpers.js';
-import { normalizeBaseTitle } from './title.js';
-import { createDescendantsResolver } from './descendants.js';
-import { createTitleRefreshScheduler } from './title_refresh.js';
-import { createQuotaSidebarTools } from './tools.js';
-import { createEventDispatcher } from './events.js';
-import { createPersistenceScheduler } from './persistence.js';
-import { createQuotaService } from './quota_service.js';
-import { createUsageService } from './usage_service.js';
-import { createTitleApplicator } from './title_apply.js';
-import { listCurrentProviderIDs } from './provider_catalog.js';
-const SHUTDOWN_HOOK_KEY = Symbol.for('opencode-quota-sidebar.shutdown-hook');
-const SHUTDOWN_CALLBACKS_KEY = Symbol.for('opencode-quota-sidebar.shutdown-callbacks');
+import { renderHistoryMarkdownReport, renderMarkdownReport, resolveTitleView, renderSidebarTitle, renderToastMessage, } from "./format.js";
+import { createQuotaRuntime } from "./quota.js";
+import { authFilePath, dateKeyFromTimestamp, deleteSessionFromDayChunk, evictOldSessions, loadConfig, loadState, normalizeTimestampMs, quotaConfigPaths, resolveOpencodeDataDir, saveState, stateFilePath, } from "./storage.js";
+import { debug, swallow } from "./helpers.js";
+import { normalizeBaseTitle } from "./title.js";
+import { createDescendantsResolver } from "./descendants.js";
+import { createTitleRefreshScheduler } from "./title_refresh.js";
+import { createQuotaSidebarTools } from "./tools.js";
+import { createEventDispatcher } from "./events.js";
+import { createPersistenceScheduler } from "./persistence.js";
+import { createQuotaService } from "./quota_service.js";
+import { createUsageService } from "./usage_service.js";
+import { createTitleApplicator } from "./title_apply.js";
+import { listCurrentProviderIDs } from "./provider_catalog.js";
+const SHUTDOWN_HOOK_KEY = Symbol.for("opencode-quota-sidebar.shutdown-hook");
+const SHUTDOWN_CALLBACKS_KEY = Symbol.for("opencode-quota-sidebar.shutdown-callbacks");
 const SESSION_ACTIVE_GRACE_MS = 15_000;
 export async function QuotaSidebarPlugin(input) {
     const quotaRuntime = createQuotaRuntime();
@@ -95,7 +95,7 @@ export async function QuotaSidebarPlugin(input) {
                 query: { directory: input.directory },
                 throwOnError: true,
             })
-                .catch(swallow('listSessionChildren'));
+                .catch(swallow("listSessionChildren"));
             return response?.data ?? [];
         },
         getParentID: (sessionID) => state.sessions[sessionID]?.parentID,
@@ -110,6 +110,7 @@ export async function QuotaSidebarPlugin(input) {
         statePath,
         client: input.client,
         directory: input.directory,
+        worktree: input.worktree,
         persistence: {
             markDirty,
             scheduleSave,
@@ -191,7 +192,7 @@ export async function QuotaSidebarPlugin(input) {
                 return;
             await titleApplicator.applyTitle(sessionID);
         },
-        onError: swallow('titleRefresh'),
+        onError: swallow("titleRefresh"),
     });
     scheduleTitleRefresh = titleRefresh.schedule;
     const startupTitleWork = Promise.resolve();
@@ -199,11 +200,11 @@ export async function QuotaSidebarPlugin(input) {
         await Promise.race([
             startupTitleWork,
             new Promise((resolve) => setTimeout(resolve, 5_000)),
-        ]).catch(swallow('shutdown:startupTitleWork'));
+        ]).catch(swallow("shutdown:startupTitleWork"));
         await titleRefresh
             .waitForQuiescence()
-            .catch(swallow('shutdown:titleQuiescence'));
-        await flushSave().catch(swallow('shutdown:flushSave'));
+            .catch(swallow("shutdown:titleQuiescence"));
+        await flushSave().catch(swallow("shutdown:flushSave"));
     };
     const processWithHook = process;
     const shutdownCallbacks = (processWithHook[SHUTDOWN_CALLBACKS_KEY] ||=
@@ -211,10 +212,10 @@ export async function QuotaSidebarPlugin(input) {
     shutdownCallbacks.add(shutdown);
     if (!processWithHook[SHUTDOWN_HOOK_KEY]) {
         processWithHook[SHUTDOWN_HOOK_KEY] = true;
-        process.once('beforeExit', () => {
+        process.once("beforeExit", () => {
             void Promise.allSettled(Array.from(shutdownCallbacks).map((callback) => callback()));
         });
-        for (const signal of ['SIGINT', 'SIGTERM']) {
+        for (const signal of ["SIGINT", "SIGTERM"]) {
             process.once(signal, () => {
                 void Promise.allSettled(Array.from(shutdownCallbacks).map((callback) => callback())).finally(() => {
                     process.kill(process.pid, signal);
@@ -231,12 +232,12 @@ export async function QuotaSidebarPlugin(input) {
             body: {
                 title: `Quota ${period}`,
                 message,
-                variant: 'info',
+                variant: "info",
                 duration: config.toast.durationMs,
             },
             throwOnError: true,
         })
-            .catch(swallow('showToast'));
+            .catch(swallow("showToast"));
     };
     const expiryAlertText = (iso, nowMs = Date.now()) => {
         if (!iso)
@@ -250,7 +251,7 @@ export async function QuotaSidebarPlugin(input) {
             return undefined;
         const value = new Date(timestamp);
         const now = new Date(nowMs);
-        const two = (num) => `${num}`.padStart(2, '0');
+        const two = (num) => `${num}`.padStart(2, "0");
         const hhmm = `${two(value.getHours())}:${two(value.getMinutes())}`;
         const sameDay = value.getFullYear() === now.getFullYear() &&
             value.getMonth() === now.getMonth() &&
@@ -272,7 +273,7 @@ export async function QuotaSidebarPlugin(input) {
             const quotas = await getQuotaSnapshots([], { allowDefault: true });
             const nowMs = Date.now();
             const expiryLines = quotas
-                .filter((item) => item.status === 'ok')
+                .filter((item) => item.status === "ok")
                 .map((item) => ({
                 label: item.shortLabel || item.label,
                 value: expiryAlertText(item.expiresAt, nowMs),
@@ -287,10 +288,10 @@ export async function QuotaSidebarPlugin(input) {
             markDirty(dateKey);
             scheduleSave();
             const body = [
-                'Expiry Soon',
+                "Expiry Soon",
                 ...expiryLines.map((item) => `${item.label} ${item.value}`),
-            ].join('\n');
-            await showToast('session', body);
+            ].join("\n");
+            await showToast("session", body);
         }
         catch (error) {
             debug(`expiry toast check failed: ${String(error)}`);
@@ -328,7 +329,7 @@ export async function QuotaSidebarPlugin(input) {
             });
         },
         onSessionDeleted: async (session) => {
-            await flushSave().catch(swallow('onSessionDeleted:flushSave'));
+            await flushSave().catch(swallow("onSessionDeleted:flushSave"));
             descendantsResolver.invalidateForAncestors(session.parentID);
             descendantsResolver.invalidateForAncestors(session.id);
             usageService.forgetSession(session.id);
@@ -342,7 +343,7 @@ export async function QuotaSidebarPlugin(input) {
             delete state.sessionDateMap[session.id];
             markDirty(dateKey);
             scheduleSave();
-            const deletedFromChunk = await deleteSessionFromDayChunk(statePath, session.id, dateKey).catch(swallow('deleteSessionFromDayChunk'));
+            const deletedFromChunk = await deleteSessionFromDayChunk(statePath, session.id, dateKey).catch(swallow("deleteSessionFromDayChunk"));
             if (deletedFromChunk) {
                 delete state.deletedSessionDateMap[session.id];
                 scheduleSave();
@@ -371,9 +372,9 @@ export async function QuotaSidebarPlugin(input) {
         onAssistantMessageUpdated: async (message) => {
             const now = Date.now();
             const completed = message.time.completed;
-            if (typeof completed !== 'number' || !Number.isFinite(completed)) {
+            if (typeof completed !== "number" || !Number.isFinite(completed)) {
                 const created = message.time.created;
-                if (typeof created === 'number' &&
+                if (typeof created === "number" &&
                     Number.isFinite(created) &&
                     created < now - SESSION_ACTIVE_GRACE_MS) {
                     return;

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[]>;