@slkiser/opencode-quota 5.0.2 → 6.0.0-beta.1

package/dist/lib/modelsdev-pricing.js

@@ -5,323 +5,202 @@ import { writeJsonAtomic } from "./atomic-json.js";
 import { fetchWithTimeout } from "./http.js";
 import { getOpencodeRuntimeDirs } from "./opencode-runtime-paths.js";
 const SOURCE_URL = "https://models.dev/api.json";
+const UNITS = "USD per 1M tokens";
 const DEFAULT_MODELSDEV_PROVIDERS = ["anthropic", "google", "moonshotai", "openai", "xai", "zai"];
-const COST_KEYS = ["input", "output", "cache_read", "cache_write"];
-const RUNTIME_SNAPSHOT_FILENAME = "modelsdev-pricing.runtime.min.json";
-const RUNTIME_REFRESH_STATE_FILENAME = "modelsdev-pricing.refresh-state.json";
+/** The prices read from models.dev; a saved snapshot may also carry `reasoning`. */
+const API_COST_KEYS = ["input", "output", "cache_read", "cache_write"];
+const SNAPSHOT_COST_KEYS = [...API_COST_KEYS, "reasoning"];
 const DEFAULT_REFRESH_MIN_ATTEMPT_INTERVAL_MS = 6 * 60 * 60 * 1000;
 const DEFAULT_REFRESH_TIMEOUT_MS = 6_000;
 const MS_PER_DAY = 24 * 60 * 60 * 1000;
 export const DEFAULT_PRICING_SNAPSHOT_MAX_AGE_MS = 3 * 24 * 60 * 60 * 1000;
 const EMPTY_SNAPSHOT = {
-    _meta: {
-        source: "none",
-        generatedAt: 0,
-        providers: [],
-        units: "USD per 1M tokens",
-    },
+    _meta: { source: "none", generatedAt: 0, providers: [], units: UNITS },
     providers: {},
 };
-let SNAPSHOT = null;
-let SNAPSHOT_SOURCE = "bundled";
+const REFRESH_RESULTS = new Set([
+    "success",
+    "not_modified",
+    "skipped_fresh",
+    "skipped_throttled",
+    "failed",
+]);
+let LOADED = null;
 let SNAPSHOT_SELECTION = "auto";
-let MODEL_INDEX = null;
 let REFRESH_IN_FLIGHT = null;
 let PROCESS_REFRESH_CHECKED = false;
-let CONFIGURED_PRICING_SNAPSHOT_MAX_AGE_MS = DEFAULT_PRICING_SNAPSHOT_MAX_AGE_MS;
+let CONFIGURED_MAX_AGE_MS = DEFAULT_PRICING_SNAPSHOT_MAX_AGE_MS;
+/** An object or an array (an array's entries are keyed by position). */
 function asRecord(value) {
     return value && typeof value === "object" ? value : null;
 }
-function sortRecordByKeys(obj) {
-    const out = {};
-    for (const key of Object.keys(obj).sort((a, b) => a.localeCompare(b))) {
-        out[key] = obj[key];
-    }
-    return out;
+/** Sorted by key, so a saved snapshot reads and diffs in a stable order. */
+function sortByKey(record) {
+    return Object.fromEntries(Object.entries(record).sort(([a], [b]) => a.localeCompare(b)));
 }
-function pricingSnapshotDaysToMs(days) {
-    if (typeof days !== "number" || !Number.isFinite(days) || days <= 0) {
-        return DEFAULT_PRICING_SNAPSHOT_MAX_AGE_MS;
+/** The finite prices among `keys`; null when there are none. */
+function pickCosts(raw, keys) {
+    const record = asRecord(raw);
+    const picked = {};
+    for (const key of keys) {
+        const value = record?.[key];
+        if (typeof value === "number" && Number.isFinite(value))
+            picked[key] = value;
     }
-    return Math.floor(days * MS_PER_DAY);
+    return Object.keys(picked).length > 0 ? picked : null;
 }
-export function getPricingRefreshPolicy() {
-    return {
-        enabled: true,
-        maxAgeMs: CONFIGURED_PRICING_SNAPSHOT_MAX_AGE_MS,
-        minAttemptIntervalMs: DEFAULT_REFRESH_MIN_ATTEMPT_INTERVAL_MS,
-        timeoutMs: DEFAULT_REFRESH_TIMEOUT_MS,
-    };
+function withProviders(meta, providers) {
+    const sorted = sortByKey(providers);
+    return { _meta: { ...meta, providers: Object.keys(sorted) }, providers: sorted };
 }
-export function setPricingSnapshotAutoRefresh(days) {
-    CONFIGURED_PRICING_SNAPSHOT_MAX_AGE_MS = pricingSnapshotDaysToMs(days);
+/** A snapshot of the providers with at least one priced model. */
+function makeSnapshot(meta, modelsByProvider, costOf) {
+    const providers = {};
+    for (const [providerId, modelsRaw] of modelsByProvider) {
+        const models = {};
+        for (const [modelId, model] of Object.entries(asRecord(modelsRaw) ?? {})) {
+            const cost = costOf(model);
+            if (cost)
+                models[modelId] = cost;
+        }
+        if (Object.keys(models).length > 0)
+            providers[providerId] = sortByKey(models);
+    }
+    return withProviders(meta, providers);
 }
+/** A saved snapshot (bundled or runtime); null when it has no valid date. */
 function normalizeSnapshot(raw) {
-    const root = asRecord(raw);
-    if (!root)
+    const meta = asRecord(asRecord(raw)?._meta);
+    const providers = asRecord(asRecord(raw)?.providers);
+    const generatedAt = Number(meta?.generatedAt);
+    if (!meta || !providers || !Number.isFinite(generatedAt) || generatedAt <= 0)
         return null;
-    const metaRaw = asRecord(root._meta);
-    const providersRaw = asRecord(root.providers);
-    if (!metaRaw || !providersRaw)
-        return null;
-    const generatedAt = Number(metaRaw.generatedAt);
-    if (!Number.isFinite(generatedAt) || generatedAt <= 0)
-        return null;
-    const providers = {};
-    for (const providerId of Object.keys(providersRaw)) {
-        const modelsRaw = asRecord(providersRaw[providerId]);
-        if (!modelsRaw)
-            continue;
-        const models = {};
-        for (const modelId of Object.keys(modelsRaw)) {
-            const modelRaw = asRecord(modelsRaw[modelId]);
-            if (!modelRaw)
-                continue;
-            const buckets = {};
-            const input = modelRaw.input;
-            const output = modelRaw.output;
-            const cacheRead = modelRaw.cache_read;
-            const cacheWrite = modelRaw.cache_write;
-            const reasoning = modelRaw.reasoning;
-            if (typeof input === "number" && Number.isFinite(input))
-                buckets.input = input;
-            if (typeof output === "number" && Number.isFinite(output))
-                buckets.output = output;
-            if (typeof cacheRead === "number" && Number.isFinite(cacheRead))
-                buckets.cache_read = cacheRead;
-            if (typeof cacheWrite === "number" && Number.isFinite(cacheWrite)) {
-                buckets.cache_write = cacheWrite;
-            }
-            if (typeof reasoning === "number" && Number.isFinite(reasoning))
-                buckets.reasoning = reasoning;
-            if (Object.keys(buckets).length > 0) {
-                models[modelId] = buckets;
+    return makeSnapshot({
+        source: typeof meta.source === "string" && meta.source ? meta.source : SOURCE_URL,
+        generatedAt: Math.trunc(generatedAt),
+        units: typeof meta.units === "string" && meta.units ? meta.units : UNITS,
+    }, Object.entries(providers), (model) => pickCosts(model, SNAPSHOT_COST_KEYS));
+}
+function buildSnapshotFromApi(apiRaw, providerIDs, generatedAt) {
+    const api = asRecord(apiRaw) ?? {};
+    return makeSnapshot({ source: SOURCE_URL, generatedAt, units: UNITS }, providerIDs.map((providerID) => [providerID, asRecord(api[providerID])?.models]), (model) => pickCosts(asRecord(model)?.cost, API_COST_KEYS));
+}
+/**
+ * models.dev drops retired models from its list. Keep their last known price so
+ * older usage still gets a cost. `current` wins, then `previous` in the order given.
+ * Callers list the user's runtime snapshot before the bundled one: its prices come
+ * from the user's own last download, while the bundled file's date only says when
+ * the file was rewritten, not when a kept model's price was last seen.
+ */
+function keepRetiredModels(current, previous, providerIDs) {
+    const providers = { ...current.providers };
+    for (const providerID of providerIDs) {
+        const models = { ...providers[providerID] };
+        for (const snapshot of previous) {
+            for (const [modelID, cost] of Object.entries(snapshot?.providers[providerID] ?? {})) {
+                models[modelID] ??= cost;
             }
         }
-        if (Object.keys(models).length > 0) {
-            providers[providerId] = sortRecordByKeys(models);
-        }
+        if (Object.keys(models).length > 0)
+            providers[providerID] = sortByKey(models);
     }
-    const providerList = Object.keys(providers).sort((a, b) => a.localeCompare(b));
-    return {
-        _meta: {
-            source: typeof metaRaw.source === "string" && metaRaw.source ? metaRaw.source : SOURCE_URL,
-            generatedAt: Math.trunc(generatedAt),
-            providers: providerList,
-            units: typeof metaRaw.units === "string" && metaRaw.units ? metaRaw.units : "USD per 1M tokens",
-        },
-        providers: sortRecordByKeys(providers),
-    };
+    return withProviders(current._meta, providers);
 }
-function loadBundledSnapshotSync(override) {
-    if (override) {
-        return normalizeSnapshot(override) ?? EMPTY_SNAPSHOT;
-    }
+function readSnapshotFile(path) {
     try {
-        const url = new URL("../data/modelsdev-pricing.min.json", import.meta.url);
-        const raw = readFileSync(url, "utf-8");
-        return normalizeSnapshot(JSON.parse(raw)) ?? EMPTY_SNAPSHOT;
+        return normalizeSnapshot(JSON.parse(readFileSync(path, "utf-8")));
     }
     catch {
-        return EMPTY_SNAPSHOT;
+        return null;
     }
 }
+function loadBundledSnapshot(override) {
+    const bundled = override
+        ? normalizeSnapshot(override)
+        : readSnapshotFile(new URL("../data/modelsdev-pricing.min.json", import.meta.url));
+    return bundled ?? EMPTY_SNAPSHOT;
+}
+function loadRuntimeSnapshot(runtimeDirs) {
+    return readSnapshotFile(getRuntimePricingSnapshotPath(runtimeDirs));
+}
+/** "bundled" pins the shipped file, "runtime" prefers the downloaded one, "auto" takes the newer. */
+function chooseSnapshot(selection, runtimeDirs, bundledOverride) {
+    const bundled = loadBundledSnapshot(bundledOverride);
+    const runtime = selection === "bundled" ? null : loadRuntimeSnapshot(runtimeDirs);
+    if (runtime &&
+        (selection === "runtime" || runtime._meta.generatedAt >= bundled._meta.generatedAt)) {
+        // A runtime snapshot saved by an older version may lack models that models.dev stopped
+        // listing; the bundled file fills them until its next refresh.
+        const snapshot = keepRetiredModels(runtime, [bundled], DEFAULT_MODELSDEV_PROVIDERS);
+        return { snapshot, source: "runtime" };
+    }
+    return { snapshot: bundled, source: bundled === EMPTY_SNAPSHOT ? "empty" : "bundled" };
+}
+function reloadSnapshot(selection = SNAPSHOT_SELECTION, runtimeDirs, bundledOverride) {
+    LOADED = chooseSnapshot(selection, runtimeDirs, bundledOverride);
+    return LOADED;
+}
+function loaded() {
+    return LOADED ?? reloadSnapshot();
+}
+function pricedProviders() {
+    return loaded().snapshot.providers;
+}
 export function getRuntimePricingSnapshotPath(runtimeDirs) {
-    const dirs = runtimeDirs ?? getOpencodeRuntimeDirs();
-    return join(dirs.cacheDir, "opencode-quota", RUNTIME_SNAPSHOT_FILENAME);
+    const { cacheDir } = runtimeDirs ?? getOpencodeRuntimeDirs();
+    return join(cacheDir, "opencode-quota", "modelsdev-pricing.runtime.min.json");
 }
 export function getRuntimePricingRefreshStatePath(runtimeDirs) {
-    const dirs = runtimeDirs ?? getOpencodeRuntimeDirs();
-    return join(dirs.cacheDir, "opencode-quota", RUNTIME_REFRESH_STATE_FILENAME);
+    const { cacheDir } = runtimeDirs ?? getOpencodeRuntimeDirs();
+    return join(cacheDir, "opencode-quota", "modelsdev-pricing.refresh-state.json");
 }
-function loadRuntimeSnapshotSync(runtimeDirs) {
-    const path = getRuntimePricingSnapshotPath(runtimeDirs);
-    try {
-        const raw = readFileSync(path, "utf-8");
-        return normalizeSnapshot(JSON.parse(raw));
-    }
-    catch {
-        return null;
-    }
+export function getPricingRefreshPolicy() {
+    return {
+        enabled: true,
+        maxAgeMs: CONFIGURED_MAX_AGE_MS,
+        minAttemptIntervalMs: DEFAULT_REFRESH_MIN_ATTEMPT_INTERVAL_MS,
+        timeoutMs: DEFAULT_REFRESH_TIMEOUT_MS,
+    };
 }
-function hasSnapshotData(snapshot) {
-    return snapshot._meta.generatedAt > 0;
+/** Days after which the snapshot counts as stale; not a positive number means the default. */
+export function setPricingSnapshotAutoRefresh(days) {
+    CONFIGURED_MAX_AGE_MS =
+        Number.isFinite(days) && days > 0
+            ? Math.floor(days * MS_PER_DAY)
+            : DEFAULT_PRICING_SNAPSHOT_MAX_AGE_MS;
 }
-function chooseSnapshot(params) {
-    const bundled = loadBundledSnapshotSync(params?.bootstrapSnapshotOverride);
-    const runtime = loadRuntimeSnapshotSync(params?.runtimeDirs);
-    const selection = params?.selection ?? SNAPSHOT_SELECTION;
-    if (selection === "bundled") {
-        if (hasSnapshotData(bundled)) {
-            return { snapshot: bundled, source: "bundled" };
-        }
-        return { snapshot: EMPTY_SNAPSHOT, source: "empty" };
-    }
-    if (selection === "runtime") {
-        if (runtime) {
-            return { snapshot: runtime, source: "runtime" };
-        }
-        if (hasSnapshotData(bundled)) {
-            return { snapshot: bundled, source: "bundled" };
-        }
-        return { snapshot: EMPTY_SNAPSHOT, source: "empty" };
+function normalizeRefreshState(raw) {
+    const record = asRecord(raw);
+    const updatedAt = Number(record?.updatedAt);
+    if (!record || Number(record.version) !== 1 || !Number.isFinite(updatedAt) || updatedAt <= 0) {
+        return null;
     }
-    if (runtime && runtime._meta.generatedAt >= bundled._meta.generatedAt) {
-        return { snapshot: runtime, source: "runtime" };
+    const state = { version: 1, updatedAt: Math.trunc(updatedAt) };
+    for (const key of ["lastAttemptAt", "lastSuccessAt", "lastFailureAt"]) {
+        const at = Number(record[key]);
+        if (Number.isFinite(at) && at > 0)
+            state[key] = Math.trunc(at);
     }
-    if (hasSnapshotData(bundled)) {
-        return { snapshot: bundled, source: "bundled" };
+    if (typeof record.lastResult === "string" && REFRESH_RESULTS.has(record.lastResult)) {
+        state.lastResult = record.lastResult;
     }
-    return { snapshot: EMPTY_SNAPSHOT, source: "empty" };
-}
-function setSnapshot(snapshot, source) {
-    SNAPSHOT = snapshot;
-    SNAPSHOT_SOURCE = source;
-    MODEL_INDEX = null;
-}
-function applySnapshotSelection(params) {
-    const selected = chooseSnapshot(params);
-    setSnapshot(selected.snapshot, selected.source);
-    return selected;
-}
-function ensureLoaded() {
-    if (SNAPSHOT)
-        return SNAPSHOT;
-    const selected = applySnapshotSelection();
-    return selected.snapshot;
-}
-function ensureModelIndex() {
-    if (MODEL_INDEX)
-        return MODEL_INDEX;
-    const snap = ensureLoaded();
-    const idx = new Map();
-    for (const providerId of Object.keys(snap.providers)) {
-        const models = snap.providers[providerId] ?? {};
-        for (const modelId of Object.keys(models)) {
-            const existing = idx.get(modelId);
-            if (existing)
-                existing.push(providerId);
-            else
-                idx.set(modelId, [providerId]);
-        }
+    for (const key of ["lastError", "etag", "lastModified"]) {
+        const text = record[key];
+        if (typeof text === "string" && text)
+            state[key] = text;
     }
-    MODEL_INDEX = idx;
-    return idx;
+    return state;
 }
-function normalizeRefreshState(raw) {
-    const obj = asRecord(raw);
-    if (!obj)
-        return null;
-    const version = Number(obj.version);
-    const updatedAt = Number(obj.updatedAt);
-    if (version !== 1 || !Number.isFinite(updatedAt) || updatedAt <= 0)
-        return null;
-    const out = {
-        version: 1,
-        updatedAt: Math.trunc(updatedAt),
-    };
-    const lastAttemptAt = Number(obj.lastAttemptAt);
-    const lastSuccessAt = Number(obj.lastSuccessAt);
-    const lastFailureAt = Number(obj.lastFailureAt);
-    if (Number.isFinite(lastAttemptAt) && lastAttemptAt > 0)
-        out.lastAttemptAt = Math.trunc(lastAttemptAt);
-    if (Number.isFinite(lastSuccessAt) && lastSuccessAt > 0)
-        out.lastSuccessAt = Math.trunc(lastSuccessAt);
-    if (Number.isFinite(lastFailureAt) && lastFailureAt > 0)
-        out.lastFailureAt = Math.trunc(lastFailureAt);
-    if (typeof obj.lastResult === "string") {
-        const allowed = new Set([
-            "success",
-            "not_modified",
-            "skipped_fresh",
-            "skipped_throttled",
-            "failed",
-        ]);
-        if (allowed.has(obj.lastResult)) {
-            out.lastResult = obj.lastResult;
-        }
-    }
-    if (typeof obj.lastError === "string" && obj.lastError)
-        out.lastError = obj.lastError;
-    if (typeof obj.etag === "string" && obj.etag)
-        out.etag = obj.etag;
-    if (typeof obj.lastModified === "string" && obj.lastModified)
-        out.lastModified = obj.lastModified;
-    return out;
-}
-async function readRefreshState(path) {
+export async function readPricingRefreshState(runtimeDirs) {
     try {
-        const raw = await readFile(path, "utf-8");
+        const raw = await readFile(getRuntimePricingRefreshStatePath(runtimeDirs), "utf-8");
         return normalizeRefreshState(JSON.parse(raw));
     }
     catch {
         return null;
     }
 }
-export async function readPricingRefreshState(runtimeDirs) {
-    return await readRefreshState(getRuntimePricingRefreshStatePath(runtimeDirs));
-}
-function makeDefaultRefreshState(nowMs) {
-    return {
-        version: 1,
-        updatedAt: nowMs,
-    };
-}
-function pickCostBuckets(rawCost) {
-    const obj = asRecord(rawCost);
-    if (!obj)
-        return null;
-    const picked = {};
-    for (const key of COST_KEYS) {
-        const value = obj[key];
-        if (typeof value === "number" && Number.isFinite(value)) {
-            picked[key] = value;
-        }
-    }
-    return Object.keys(picked).length > 0 ? picked : null;
-}
-function buildSnapshotFromApi(apiRaw, providerIDs, generatedAt) {
-    const api = asRecord(apiRaw) ?? {};
-    const providers = {};
-    for (const providerID of providerIDs) {
-        const providerNode = asRecord(api[providerID]);
-        const models = asRecord(providerNode?.models);
-        if (!models)
-            continue;
-        const pricedModels = {};
-        for (const modelID of Object.keys(models)) {
-            const modelNode = asRecord(models[modelID]);
-            const cost = pickCostBuckets(modelNode?.cost);
-            if (cost) {
-                pricedModels[modelID] = cost;
-            }
-        }
-        if (Object.keys(pricedModels).length > 0) {
-            providers[providerID] = sortRecordByKeys(pricedModels);
-        }
-    }
-    const providerList = Object.keys(providers).sort((a, b) => a.localeCompare(b));
-    return {
-        _meta: {
-            generatedAt,
-            providers: providerList,
-            source: SOURCE_URL,
-            units: "USD per 1M tokens",
-        },
-        providers: sortRecordByKeys(providers),
-    };
-}
-function countPricedModels(snapshot) {
-    let total = 0;
-    for (const models of Object.values(snapshot.providers)) {
-        total += Object.keys(models).length;
-    }
-    return total;
-}
-function getErrorMessage(error) {
-    return error instanceof Error ? error.message : String(error);
-}
-async function fetchModelsDevSnapshot(params) {
+async function fetchModelsDev(params) {
     const headers = new Headers();
     if (params.state.etag)
         headers.set("If-None-Match", params.state.etag);
@@ -332,293 +211,183 @@ async function fetchModelsDevSnapshot(params) {
         timeoutMs: params.timeoutMs,
         fetchFn: params.fetchFn,
         consume: async (response) => {
-            const responseMetadata = {
-                etag: response.headers.get("etag") ?? undefined,
-                lastModified: response.headers.get("last-modified") ?? undefined,
-            };
-            if (response.status === 304) {
-                return { kind: "not_modified", ...responseMetadata };
-            }
+            const etag = response.headers.get("etag") ?? undefined;
+            const lastModified = response.headers.get("last-modified") ?? undefined;
+            if (response.status === 304)
+                return { kind: "not_modified", etag, lastModified };
             if (!response.ok) {
                 throw new Error(`Failed to fetch ${SOURCE_URL}: ${response.status} ${response.statusText}`);
             }
-            return {
-                kind: "success",
-                api: await response.json(),
-                ...responseMetadata,
-            };
+            return { kind: "success", api: await response.json(), etag, lastModified };
         },
     });
 }
+function skipped(reason, state) {
+    return { attempted: false, updated: false, reason, state };
+}
+/**
+ * Downloads new models.dev prices when the snapshot is stale: once per process (unless
+ * forced), at most every few hours across processes (the refresh state file remembers the
+ * last attempt), one download at a time. A failure keeps the snapshot in use.
+ */
 export async function maybeRefreshPricingSnapshot(opts = {}) {
-    if (REFRESH_IN_FLIGHT)
-        return REFRESH_IN_FLIGHT;
-    REFRESH_IN_FLIGHT = (async () => {
-        const nowMs = opts.nowMs ?? Date.now();
-        const policy = getPricingRefreshPolicy();
-        const maxAgeMs = opts.maxAgeMs ?? policy.maxAgeMs;
-        const minAttemptIntervalMs = opts.minAttemptIntervalMs ?? policy.minAttemptIntervalMs;
-        const timeoutMs = opts.timeoutMs ?? policy.timeoutMs;
-        const runtimeDirs = opts.runtimeDirs;
-        const snapshotPath = getRuntimePricingSnapshotPath(runtimeDirs);
-        const statePath = getRuntimePricingRefreshStatePath(runtimeDirs);
-        const force = opts.force === true;
-        const selection = opts.snapshotSelection ?? SNAPSHOT_SELECTION;
-        const allowRefreshWhenSelectionBundled = opts.allowRefreshWhenSelectionBundled === true;
-        const previousState = (await readRefreshState(statePath)) ?? makeDefaultRefreshState(nowMs);
-        const runtimeSnapshotBeforeRefresh = loadRuntimeSnapshotSync(runtimeDirs);
-        applySnapshotSelection({
-            runtimeDirs,
-            bootstrapSnapshotOverride: opts.bootstrapSnapshotOverride,
-            selection,
-        });
-        if (selection === "bundled" && !allowRefreshWhenSelectionBundled) {
-            return {
-                attempted: false,
-                updated: false,
-                reason: "selection_bundled",
-                state: {
-                    ...previousState,
-                    updatedAt: nowMs,
-                },
-            };
-        }
-        if (!force && PROCESS_REFRESH_CHECKED) {
-            return {
-                attempted: false,
-                updated: false,
-                reason: "already_checked_this_process",
-                state: previousState,
-            };
-        }
-        PROCESS_REFRESH_CHECKED = true;
-        const health = getPricingSnapshotHealth({ nowMs, maxAgeMs });
-        if (!force && !policy.enabled) {
-            return {
-                attempted: false,
-                updated: false,
-                reason: "disabled",
-                state: {
-                    ...previousState,
-                    updatedAt: nowMs,
-                    lastResult: "skipped_fresh",
-                },
-            };
-        }
-        if (!force && !health.stale) {
-            return {
-                attempted: false,
-                updated: false,
-                reason: "fresh",
-                state: {
-                    ...previousState,
-                    updatedAt: nowMs,
-                    lastResult: "skipped_fresh",
-                },
-            };
-        }
-        if (!force &&
-            previousState.lastAttemptAt &&
-            nowMs - previousState.lastAttemptAt < minAttemptIntervalMs) {
-            return {
-                attempted: false,
-                updated: false,
-                reason: "throttled",
-                state: {
-                    ...previousState,
-                    updatedAt: nowMs,
-                    lastResult: "skipped_throttled",
-                },
-            };
-        }
-        const attemptingState = {
+    REFRESH_IN_FLIGHT ??= refreshPricingSnapshot(opts).finally(() => {
+        REFRESH_IN_FLIGHT = null;
+    });
+    return REFRESH_IN_FLIGHT;
+}
+async function refreshPricingSnapshot(opts) {
+    const nowMs = opts.nowMs ?? Date.now();
+    const policy = getPricingRefreshPolicy();
+    const force = opts.force === true;
+    const { runtimeDirs, bootstrapSnapshotOverride: bundledOverride } = opts;
+    const selection = opts.snapshotSelection ?? SNAPSHOT_SELECTION;
+    const previousState = (await readPricingRefreshState(runtimeDirs)) ?? {
+        version: 1,
+        updatedAt: nowMs,
+    };
+    const runtimeBefore = loadRuntimeSnapshot(runtimeDirs);
+    const bundled = loadBundledSnapshot(bundledOverride);
+    reloadSnapshot(selection, runtimeDirs, bundledOverride);
+    if (selection === "bundled" && opts.allowRefreshWhenSelectionBundled !== true) {
+        return skipped("selection_bundled", { ...previousState, updatedAt: nowMs });
+    }
+    if (!force && PROCESS_REFRESH_CHECKED) {
+        return skipped("already_checked_this_process", previousState);
+    }
+    PROCESS_REFRESH_CHECKED = true;
+    const maxAgeMs = opts.maxAgeMs ?? policy.maxAgeMs;
+    if (!force && !getPricingSnapshotHealth({ nowMs, maxAgeMs }).stale) {
+        return skipped("fresh", { ...previousState, updatedAt: nowMs, lastResult: "skipped_fresh" });
+    }
+    const minAttemptIntervalMs = opts.minAttemptIntervalMs ?? policy.minAttemptIntervalMs;
+    const lastAttemptAt = previousState.lastAttemptAt;
+    if (!force && lastAttemptAt && nowMs - lastAttemptAt < minAttemptIntervalMs) {
+        return skipped("throttled", {
             ...previousState,
-            version: 1,
             updatedAt: nowMs,
-            lastAttemptAt: nowMs,
-        };
-        try {
-            const fetchResult = await fetchModelsDevSnapshot({
-                timeoutMs,
-                state: attemptingState,
-                fetchFn: opts.fetchFn,
-            });
-            if (fetchResult.kind === "not_modified") {
-                const baseSnapshot = runtimeSnapshotBeforeRefresh ?? ensureLoaded();
-                const refreshedSnapshot = {
-                    _meta: {
-                        ...baseSnapshot._meta,
-                        generatedAt: nowMs,
-                    },
-                    providers: baseSnapshot.providers,
-                };
-                await writeJsonAtomic(snapshotPath, refreshedSnapshot, { trailingNewline: true });
-                applySnapshotSelection({
-                    runtimeDirs,
-                    bootstrapSnapshotOverride: opts.bootstrapSnapshotOverride,
-                    selection,
-                });
-                const nextState = {
-                    ...attemptingState,
-                    updatedAt: nowMs,
-                    lastSuccessAt: nowMs,
-                    lastResult: "not_modified",
-                    lastError: undefined,
-                    etag: fetchResult.etag ?? attemptingState.etag,
-                    lastModified: fetchResult.lastModified ?? attemptingState.lastModified,
-                };
-                try {
-                    await writeJsonAtomic(statePath, nextState, { trailingNewline: true });
-                }
-                catch {
-                    // best effort; keep refreshed in-memory/runtime snapshot active
-                }
-                return {
-                    attempted: true,
-                    updated: true,
-                    state: nextState,
-                };
-            }
-            const snapshot = buildSnapshotFromApi(fetchResult.api, opts.providerAllowlist ?? DEFAULT_MODELSDEV_PROVIDERS, nowMs);
-            if (countPricedModels(snapshot) === 0) {
-                throw new Error("Refusing to persist empty pricing snapshot from models.dev");
-            }
-            await writeJsonAtomic(snapshotPath, snapshot, { trailingNewline: true });
-            applySnapshotSelection({
-                runtimeDirs,
-                bootstrapSnapshotOverride: opts.bootstrapSnapshotOverride,
-                selection,
-            });
-            const nextState = {
-                ...attemptingState,
-                updatedAt: nowMs,
-                lastSuccessAt: nowMs,
-                lastResult: "success",
-                lastError: undefined,
-                etag: fetchResult.etag ?? attemptingState.etag,
-                lastModified: fetchResult.lastModified ?? attemptingState.lastModified,
-            };
-            try {
-                await writeJsonAtomic(statePath, nextState, { trailingNewline: true });
-            }
-            catch {
-                // best effort; snapshot has already been updated
-            }
-            return {
-                attempted: true,
-                updated: true,
-                state: nextState,
-            };
+            lastResult: "skipped_throttled",
+        });
+    }
+    const attempting = {
+        ...previousState,
+        version: 1,
+        updatedAt: nowMs,
+        lastAttemptAt: nowMs,
+    };
+    const providerIDs = opts.providerAllowlist ?? DEFAULT_MODELSDEV_PROVIDERS;
+    let next;
+    try {
+        const timeoutMs = opts.timeoutMs ?? policy.timeoutMs;
+        const fetched = await fetchModelsDev({ timeoutMs, state: attempting, fetchFn: opts.fetchFn });
+        let snapshot;
+        if (fetched.kind === "not_modified") {
+            // The same prices, confirmed now; also heals snapshots saved before retired models were kept.
+            const base = runtimeBefore ?? loaded().snapshot;
+            const confirmed = { _meta: { ...base._meta, generatedAt: nowMs }, providers: base.providers };
+            snapshot = keepRetiredModels(confirmed, [bundled], providerIDs);
         }
-        catch (error) {
-            const errorMessage = getErrorMessage(error);
-            const nextState = {
-                ...attemptingState,
-                updatedAt: nowMs,
-                lastFailureAt: nowMs,
-                lastResult: "failed",
-                lastError: errorMessage,
-            };
-            try {
-                await writeJsonAtomic(statePath, nextState, { trailingNewline: true });
-            }
-            catch {
-                // best effort; report original fetch/refresh error
+        else {
+            const fresh = buildSnapshotFromApi(fetched.api, providerIDs, nowMs);
+            if (Object.keys(fresh.providers).length === 0) {
+                throw new Error("Refusing to persist empty pricing snapshot from models.dev");
             }
-            return {
-                attempted: true,
-                updated: false,
-                error: errorMessage,
-                state: nextState,
-            };
+            snapshot = keepRetiredModels(fresh, [runtimeBefore, bundled], providerIDs);
         }
-    })().finally(() => {
-        REFRESH_IN_FLIGHT = null;
-    });
-    return REFRESH_IN_FLIGHT;
+        await writeJsonAtomic(getRuntimePricingSnapshotPath(runtimeDirs), snapshot, {
+            trailingNewline: true,
+        });
+        reloadSnapshot(selection, runtimeDirs, bundledOverride);
+        next = {
+            ...attempting,
+            lastSuccessAt: nowMs,
+            lastResult: fetched.kind,
+            lastError: undefined,
+            etag: fetched.etag ?? attempting.etag,
+            lastModified: fetched.lastModified ?? attempting.lastModified,
+        };
+    }
+    catch (error) {
+        const lastError = error instanceof Error ? error.message : String(error);
+        next = { ...attempting, lastFailureAt: nowMs, lastResult: "failed", lastError };
+    }
+    // Best effort: the snapshot in use and the result stay right without the state file.
+    await writeJsonAtomic(getRuntimePricingRefreshStatePath(runtimeDirs), next, {
+        trailingNewline: true,
+    }).catch(() => { });
+    return next.lastResult === "failed"
+        ? { attempted: true, updated: false, error: next.lastError, state: next }
+        : { attempted: true, updated: true, state: next };
 }
 export function setPricingSnapshotSelection(selection) {
     if (SNAPSHOT_SELECTION === selection)
         return;
     SNAPSHOT_SELECTION = selection;
-    SNAPSHOT = null;
-    MODEL_INDEX = null;
+    LOADED = null;
 }
 export function getPricingSnapshotSelection() {
     return SNAPSHOT_SELECTION;
 }
 export function getPricingSnapshotMeta() {
-    return ensureLoaded()._meta;
+    return loaded().snapshot._meta;
 }
 export function getPricingSnapshotSource() {
-    ensureLoaded();
-    return SNAPSHOT_SOURCE;
+    return loaded().source;
 }
 export function getPricingSnapshotHealth(opts) {
     const generatedAt = getPricingSnapshotMeta().generatedAt;
-    const nowMs = opts?.nowMs ?? Date.now();
     const maxAgeMs = opts?.maxAgeMs ?? DEFAULT_PRICING_SNAPSHOT_MAX_AGE_MS;
-    const ageMs = Math.max(0, nowMs - generatedAt);
-    return {
-        generatedAt,
-        ageMs,
-        maxAgeMs,
-        stale: ageMs > maxAgeMs,
-    };
+    const ageMs = Math.max(0, (opts?.nowMs ?? Date.now()) - generatedAt);
+    return { generatedAt, ageMs, maxAgeMs, stale: ageMs > maxAgeMs };
 }
 export function hasProvider(providerId) {
-    return !!ensureLoaded().providers[providerId];
-}
-export function isModelsDevProviderId(providerId) {
-    return hasProvider(providerId);
+    return !!pricedProviders()[providerId];
 }
 export function hasModel(providerId, modelId) {
-    const p = ensureLoaded().providers[providerId];
-    if (!p)
-        return false;
-    return !!p[modelId];
-}
-/**
- * Infer the snapshot provider that owns a modelId.
- * Returns null when model is not found or is ambiguous across providers.
- */
-export function inferProviderForModelId(modelId) {
-    const providers = listProvidersForModelId(modelId);
-    if (!providers || providers.length !== 1)
-        return null;
-    return providers[0] ?? null;
-}
-export function getProviderModelCount(providerId) {
-    return Object.keys(ensureLoaded().providers[providerId] || {}).length;
+    return !!pricedProviders()[providerId]?.[modelId];
 }
 export function listProviders() {
-    return Object.keys(ensureLoaded().providers);
+    return Object.keys(pricedProviders());
 }
 export function listModelsForProvider(providerId) {
-    return Object.keys(ensureLoaded().providers[providerId] ?? {});
+    return Object.keys(pricedProviders()[providerId] ?? {});
 }
 export function listProvidersForModelId(modelId) {
-    const providers = ensureModelIndex().get(modelId) ?? [];
-    return [...providers].sort((a, b) => a.localeCompare(b));
+    const providers = pricedProviders();
+    return Object.keys(providers)
+        .filter((providerId) => Object.hasOwn(providers[providerId] ?? {}, modelId))
+        .sort((a, b) => a.localeCompare(b));
+}
+let BUNDLED_IDS = null;
+/** The provider and model ids of the price list shipped in this package, never a downloaded one. */
+function bundledIds() {
+    if (!BUNDLED_IDS) {
+        const { providers } = loadBundledSnapshot();
+        BUNDLED_IDS = {
+            providers: new Set(Object.keys(providers)),
+            models: new Set(Object.values(providers).flatMap((models) => Object.keys(models))),
+        };
+    }
+    return BUNDLED_IDS;
+}
+/** True when the shipped price list has this provider id. */
+export function isBundledPricingProviderId(providerId) {
+    return bundledIds().providers.has(providerId);
+}
+/** True when the shipped price list has this model id under any provider. */
+export function isBundledPricingModelId(modelId) {
+    return bundledIds().models.has(modelId);
 }
 export function lookupCost(providerId, modelId) {
-    const p = ensureLoaded().providers[providerId];
-    if (!p)
-        return null;
-    const c = p[modelId];
-    if (!c)
-        return null;
-    return c;
+    return pricedProviders()[providerId]?.[modelId] ?? null;
 }
 export function hasCost(providerId, modelId) {
     return lookupCost(providerId, modelId) != null;
 }
 export function __resetPricingSnapshotForTests() {
-    SNAPSHOT = null;
-    SNAPSHOT_SOURCE = "bundled";
+    LOADED = null;
     SNAPSHOT_SELECTION = "auto";
-    CONFIGURED_PRICING_SNAPSHOT_MAX_AGE_MS = DEFAULT_PRICING_SNAPSHOT_MAX_AGE_MS;
-    MODEL_INDEX = null;
+    CONFIGURED_MAX_AGE_MS = DEFAULT_PRICING_SNAPSHOT_MAX_AGE_MS;
     REFRESH_IN_FLIGHT = null;
     PROCESS_REFRESH_CHECKED = false;
 }