faberwright 0.3.1 → 0.4.1

package/dist/onboard.js

@@ -0,0 +1,364 @@
+import pc from "picocolors";
+import { select, readSecret } from "./prompt.js";
+import { vendors, modelsForRoute, baseUrlFor, getRoute, DEFAULT_REGION, } from "./routes.js";
+import * as fs from "node:fs";
+import { loadSettings, saveSettings, settingsPath } from "./settings.js";
+import { credentialSource, saveCredential, maskCredential, credentialsPath, looksLikeKey, deleteCredential, } from "./credentials.js";
+/** First run = no settings file yet. */
+/** Where a credential comes from, so setup can point people at the right page. */
+const KEY_SOURCE = {
+    ANTHROPIC_API_KEY: "https://console.anthropic.com/settings/keys",
+    OPENAI_API_KEY: "https://platform.openai.com/api-keys",
+    BEDROCK_API_KEY: "the AWS console (Bedrock → API keys)",
+};
+export function needsOnboarding() {
+    return !hasAnySettingsFile();
+}
+/**
+ * Is this project actually ready to run?
+ *
+ * "A settings file exists" is the wrong question — a profile can name a route
+ * whose credential was never supplied, which then fails as a 401 on the first
+ * task instead of at launch. What counts as complete depends on the route:
+ *
+ *   Anthropic / OpenAI  a key, from the environment or Faber's store
+ *   Bedrock             a key OR AWS credentials it can sign with
+ *   Ollama / local      nothing — but a model id, since there are no defaults
+ *   custom endpoint     a base URL, and a key unless it's localhost
+ */
+export async function setupComplete(cfg) {
+    const route = getRoute(cfg.route);
+    if (!route)
+        return { complete: false, missing: `unknown route "${cfg.route}"`, fix: "/setup" };
+    if (!route.implemented) {
+        return { complete: false, missing: `${route.label} isn't wired up yet`, fix: "/route" };
+    }
+    if (!cfg.model)
+        return { complete: false, missing: "no model chosen", fix: "/model" };
+    if (route.needsBaseUrl && !cfg.baseUrl) {
+        return { complete: false, missing: "no endpoint URL for this route", fix: "/route" };
+    }
+    if (cfg.apiKey)
+        return { complete: true };
+    if (route.id === "bedrock") {
+        const { discoverAwsCredentials } = await import("./sigv4.js");
+        if (await discoverAwsCredentials())
+            return { complete: true }; // IAM role signs
+        return {
+            complete: false,
+            missing: "no AWS credentials and no BEDROCK_API_KEY",
+            fix: "/key set BEDROCK_API_KEY",
+        };
+    }
+    const isLocal = /^https?:\/\/(localhost|127\.0\.0\.1|\[::1\])(:|\/|$)/.test(cfg.baseUrl ?? "");
+    if (isLocal)
+        return { complete: true }; // local models need no key
+    if (!route.keyEnv)
+        return { complete: true };
+    return { complete: false, missing: `${route.keyEnv} is not set`, fix: `/key set ${route.keyEnv}` };
+}
+function hasAnySettingsFile() {
+    try {
+        return fs.existsSync(settingsPath());
+    }
+    catch {
+        return false;
+    }
+}
+/** True when we can prompt at all. */
+export function interactive() {
+    return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+/**
+ * Read a key and refuse to silently store something that isn't one. A typo
+ * saved here becomes the preferred credential and breaks every later run,
+ * which is a much worse outcome than one extra confirmation.
+ */
+async function readKey(rl, envName, promptText) {
+    const key = await readSecret(rl, promptText);
+    if (!key)
+        return undefined;
+    const problem = looksLikeKey(envName, key);
+    if (problem) {
+        console.log(pc.yellow(`  ${problem}.`));
+        const ok = await select(rl, "Save it anyway?", ["No, discard it", "Yes, save it"]);
+        if (ok === 0)
+            return undefined;
+    }
+    return key;
+}
+/**
+ * Walk vendor -> route -> region/endpoint -> model. Returns the profile it
+ * saved so the caller can report what still needs doing (e.g. an unset key).
+ */
+export async function runOnboarding(rl, opts = {}) {
+    if (opts.first) {
+        console.log();
+        console.log(pc.cyan("Welcome to Faber."));
+        console.log(pc.dim("Let's pick where your model comes from. You can change this any time with /route or /model."));
+        console.log();
+    }
+    const groups = vendors();
+    const vi = await select(rl, "Who provides the model?", groups.map((g) => g.vendor));
+    const routes = groups[vi].routes;
+    const ri = await select(rl, "How should Faber reach it?", routes.map((r) => `${r.label.padEnd(30)} ${pc.dim(r.hint)}${r.implemented ? "" : pc.yellow("  (not yet wired)")}`));
+    const route = routes[ri];
+    if (!route.implemented) {
+        console.log(pc.yellow(`${route.label} isn't wired up yet — falling back to the Anthropic API.`));
+        const fallback = groups[0].routes[0];
+        return finish(rl, fallback, {});
+    }
+    return finish(rl, route, {});
+}
+/**
+ * Make sure the route has a usable credential, prompting if not.
+ * Exported so startup can run just this step: a configured profile with a
+ * missing key should ask at launch, not fail with a 401 on the first task.
+ *
+ * Returns what the user chose to do when they have no key — the ways forward
+ * are offered as choices, because the REPL that prose would point them at
+ * never opens when setup is incomplete.
+ */
+export async function ensureCredential(rl, route, profile) {
+    if (!route.keyEnv)
+        return {};
+    const found = credentialSource(route.keyEnv);
+    if (found?.from === "store") {
+        // Running setup again usually means something needs changing — often the
+        // key itself, because it expired or was wrong. Silently reusing the saved
+        // one makes that impossible, so offer the same choice as for an
+        // environment key.
+        console.log();
+        console.log(`${route.keyEnv} is already saved on this computer (${maskCredential(found.value)}).`);
+        const choice = await select(rl, "Use it?", [
+            `Keep using it                    ${pc.dim("no change")}`,
+            `Replace it                       ${pc.dim("paste a new key")}`,
+            `Remove it                        ${pc.dim("delete the saved key and stop")}`,
+        ]);
+        if (choice === 1) {
+            const key = await readKey(rl, route.keyEnv, `  ${route.keyEnv} (hidden): `);
+            if (key) {
+                saveCredential(route.keyEnv, key);
+                console.log(pc.dim(`  replaced (${maskCredential(key)})`));
+            }
+            else {
+                console.log(pc.dim("  nothing entered — keeping the saved key"));
+            }
+        }
+        else if (choice === 2) {
+            deleteCredential(route.keyEnv);
+            console.log(pc.dim(`  removed. Run faber again to set one up.`));
+            return { switchedTo: "quit" };
+        }
+        return {};
+    }
+    if (found?.from === "environment") {
+        console.log();
+        console.log(`Found ${route.keyEnv} in your environment (${maskCredential(found.value)}).`);
+        const choice = await select(rl, "Use it?", [
+            `Yes, and remember it here        ${pc.dim("works in any shell, even without the env var")}`,
+            `Yes, but don't save it           ${pc.dim("keep reading it from the environment")}`,
+            `No, use a different key          ${pc.dim("paste another one")}`,
+        ]);
+        if (choice === 0) {
+            saveCredential(route.keyEnv, found.value);
+            console.log(pc.dim(`  kept on this computer only, at ${credentialsPath()}`));
+        }
+        else if (choice === 1) {
+            console.log(pc.dim("  not saved — Faber will read it from the environment each run"));
+        }
+        else {
+            const key = await readKey(rl, route.keyEnv, `  ${route.keyEnv} (hidden): `);
+            if (key) {
+                saveCredential(route.keyEnv, key);
+                profile.preferStoredKey = true; // an explicit choice beats the env var
+                console.log(pc.dim(`  saved (${maskCredential(key)}) — Faber will use this one, not the environment`));
+            }
+            else {
+                console.log(pc.dim("  not saved — keeping the key from your environment"));
+            }
+        }
+        return {};
+    }
+    if (route.id === "bedrock") {
+        // Bedrock can sign with an IAM role, so a key may not be needed at all.
+        const { discoverAwsCredentials } = await import("./sigv4.js");
+        const aws = await discoverAwsCredentials();
+        console.log();
+        console.log(aws
+            ? pc.dim(`  No key needed — signing with AWS credentials from ${aws.source}.`)
+            : pc.yellow(`  No AWS credentials found. Set ${route.keyEnv}, or run where an IAM role is available.`));
+        return {};
+    }
+    // No key anywhere: say where to get one, read it hidden, and if they don't
+    // have one, offer real alternatives rather than a dead end.
+    console.log();
+    console.log(`Faber needs an API key for ${route.label}.`);
+    const where = KEY_SOURCE[route.keyEnv];
+    if (where)
+        console.log(pc.dim(`  Get one at ${where}`));
+    const key = await readKey(rl, route.keyEnv, `  ${route.keyEnv} (hidden): `);
+    if (key) {
+        saveCredential(route.keyEnv, key);
+        console.log(pc.dim(`  saved (${maskCredential(key)}) — kept on this computer only, at ${credentialsPath()}`));
+        return {};
+    }
+    // No key means setup didn't complete. Nothing is written, so the next run
+    // starts over from the beginning rather than resuming into a broken state.
+    return { switchedTo: "quit" };
+}
+/** Does the provider accept this credential? Never blocks on being offline. */
+async function verifyCredential(route, profile) {
+    if (!route.keyEnv)
+        return "ok";
+    try {
+        const { LLMClient } = await import("./llm.js");
+        const { resolveCredential } = await import("./credentials.js");
+        const key = resolveCredential(route.keyEnv);
+        const baseUrl = profile.baseUrl ?? baseUrlFor(route, profile.region);
+        if (!key || !baseUrl)
+            return "unreachable";
+        process.stdout.write(pc.dim("  checking your key… "));
+        const llm = new LLMClient({
+            provider: route.wire, baseUrl, apiKey: key, model: "x", route: route.id,
+        });
+        const verdict = await llm.verifyKey();
+        process.stdout.write("\r\x1b[2K");
+        return verdict;
+    }
+    catch {
+        process.stdout.write("\r\x1b[2K");
+        return "unreachable";
+    }
+}
+/** Ask the provider which models this key can use. Empty on any failure. */
+async function discoverModels(route, profile) {
+    try {
+        const { LLMClient } = await import("./llm.js");
+        const { resolveCredential } = await import("./credentials.js");
+        const key = route.keyEnv ? resolveCredential(route.keyEnv) : undefined;
+        const baseUrl = profile.baseUrl ?? baseUrlFor(route, profile.region);
+        if (!baseUrl)
+            return [];
+        process.stdout.write(pc.dim("  checking which models your key can use… "));
+        const llm = new LLMClient({
+            provider: route.wire, baseUrl, apiKey: key, model: "x", route: route.id,
+        });
+        const models = await llm.listModels();
+        process.stdout.write("\r\x1b[2K");
+        return models;
+    }
+    catch {
+        process.stdout.write("\r\x1b[2K");
+        return [];
+    }
+}
+async function finish(rl, route, base) {
+    const profile = { ...base, route: route.id };
+    const activeRoute = route;
+    if (route.needsRegion) {
+        const ans = (await rl.question(`AWS region [${DEFAULT_REGION}]: `)).trim();
+        profile.region = ans || DEFAULT_REGION;
+    }
+    if (route.needsBaseUrl) {
+        const ans = (await rl.question("Base URL of the OpenAI-compatible endpoint: ")).trim();
+        if (ans)
+            profile.baseUrl = ans;
+    }
+    if (route.keyEnv) {
+        profile.apiKeyEnv = route.keyEnv;
+        const outcome = await ensureCredential(rl, activeRoute, profile);
+        if (outcome.switchedTo === "quit") {
+            // Nothing is written: an incomplete profile would make the next run
+            // look configured when it isn't.
+            return { profile, route: activeRoute, aborted: true };
+        }
+    }
+    // Model choice, with real ids and real prices.
+    //
+    // Aliases like "gpt" or "sonnet" hide what you're actually paying for, and
+    // the difference is not small: gpt-4o costs about 17x gpt-4o-mini. Since the
+    // credential is saved by now, ask the provider what this key can really use
+    // and show each model's rate, so nothing about the bill is implicit.
+    const { refreshPrices, priceFor, readPriceCache } = await import("./pricing.js");
+    if (!readPriceCache())
+        process.stdout.write(pc.dim("  fetching prices… "));
+    await refreshPrices(undefined, { baseUrl: profile.baseUrl ?? activeRoute.baseUrl });
+    process.stdout.write("\r\x1b[2K");
+    // Verify the credential before going further. A rejected key means setup
+    // did not succeed, so nothing is saved and the next run starts over — the
+    // same rule as skipping the key entirely.
+    const verdict = await verifyCredential(activeRoute, profile);
+    if (verdict === "rejected") {
+        if (activeRoute.keyEnv)
+            deleteCredential(activeRoute.keyEnv);
+        console.log();
+        console.log(pc.yellow(`${activeRoute.label} rejected that key.`));
+        console.log(pc.dim("  Nothing was saved. Run faber again with a working key."));
+        return { profile, route: activeRoute, aborted: true };
+    }
+    const { isChatModel, sortModels, requiresUnsupportedApi } = await import("./models.js");
+    const discovered = sortModels((await discoverModels(activeRoute, profile))
+        .filter((m) => isChatModel(m.id) && !requiresUnsupportedApi(m.id)), activeRoute.wire);
+    const fallback = modelsForRoute(activeRoute).map((m) => ({ id: m.id, name: m.blurb }));
+    const options = discovered.length ? discovered : fallback;
+    if (options.length) {
+        // Say which list this is. A built-in fallback and a live list look
+        // identical otherwise, and the user can't tell whether the models shown
+        // are the ones their key can actually reach.
+        console.log();
+        if (discovered.length) {
+            console.log(pc.dim(`  ${discovered.length} models available to this key`));
+        }
+        else {
+            const { lastModelListError } = await import("./llm.js");
+            const why = lastModelListError();
+            console.log(pc.yellow("  Couldn't list models — showing built-in defaults."));
+            console.log(pc.dim(why ? `  ${why}` : "  No response from the provider."));
+            console.log(pc.dim("  /model re-checks later."));
+        }
+        const width = Math.min(34, Math.max(...options.map((m) => m.id.length)) + 2);
+        const labels = options.map((m) => {
+            const p = priceFor(m.id);
+            const cost = p ? `$${p.in}/$${p.out} per Mtok` : "price unknown";
+            return `${m.id.padEnd(width)}${pc.dim(cost)}${m.name ? pc.dim("  " + m.name) : ""}`;
+        });
+        console.log();
+        const mi = await select(rl, "Which model? (input/output cost per million tokens)", labels);
+        profile.model = options[mi].id; // a concrete id, never an alias
+    }
+    else {
+        const hint = activeRoute.id === "ollama" ? "qwen2.5-coder" : "";
+        const ans = (await rl.question(`Model id${hint ? ` [${hint}]` : ""}: `)).trim();
+        profile.model = ans || hint || undefined;
+    }
+    const settings = loadSettings();
+    settings.profiles[settings.activeProfile] = profile;
+    saveSettings(settings);
+    const missingKeyEnv = activeRoute.keyEnv && !credentialSource(activeRoute.keyEnv)
+        ? activeRoute.keyEnv : undefined;
+    return { profile, route: activeRoute, missingKeyEnv };
+}
+/** Summary printed after onboarding, including anything still to be done. */
+export function reportSetup(r) {
+    if (r.aborted) {
+        console.log();
+        console.log(pc.yellow("Setup not completed — nothing was saved."));
+        console.log(pc.dim("  Run faber again when you have a key, or choose a local model."));
+        console.log();
+        return;
+    }
+    const url = r.profile.baseUrl ?? baseUrlFor(r.route, r.profile.region);
+    console.log();
+    console.log(`Route:    ${r.route.label}`);
+    if (url)
+        console.log(pc.dim(`Endpoint: ${url}`));
+    if (r.profile.model)
+        console.log(pc.dim(`Model:    ${r.profile.model}`));
+    if (r.missingKeyEnv) {
+        console.log();
+        console.log(pc.yellow(`One thing left — ${r.missingKeyEnv} isn't set:`));
+        console.log(pc.dim(`  /key set ${r.missingKeyEnv}`));
+    }
+    console.log();
+}

package/dist/pricing.js

@@ -0,0 +1,272 @@
+/**
+ * Model pricing.
+ *
+ * Where prices come from, best source first:
+ *   1. What you configured (env vars or a profile) — always wins.
+ *   2. The provider itself, when it publishes prices. OpenRouter's
+ *      /api/v1/models returns live per-token rates including cache read/write,
+ *      and it needs no key. That is authoritative for that route.
+ *   3. A refreshable community dataset covering everyone else.
+ *   4. A small built-in table so /usage works with zero configuration.
+ *
+ * Anthropic's and OpenAI's own /v1/models return ids and capabilities but not
+ * dollars, which is why 3 and 4 exist at all.
+ *
+ * The built-in table is deliberately small and dated. It exists so `/usage`
+ * shows real numbers out of the box; it is not the source of truth. Anything
+ * you set explicitly always wins, and `/usage --refresh-prices` pulls current
+ * figures. Prices here are $ per MILLION tokens.
+ */
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+/** Verified 2026-08. Check the vendor's pricing page before quoting these. */
+export const PRICES_AS_OF = "2026-08";
+export const BUILTIN_PRICES = {
+    "claude-fable-5": { in: 10, out: 50, cacheRead: 1, cacheWrite: 12.5 },
+    "claude-opus-5": { in: 5, out: 25, cacheRead: 0.5, cacheWrite: 6.25 },
+    "claude-sonnet-5": { in: 2, out: 10, cacheRead: 0.2, cacheWrite: 2.5 },
+    "claude-haiku-4-5-20251001": { in: 1, out: 5, cacheRead: 0.1, cacheWrite: 1.25 },
+    "claude-sonnet-4-5": { in: 3, out: 15, cacheRead: 0.3, cacheWrite: 3.75 },
+    "claude-opus-4-1": { in: 15, out: 75, cacheRead: 1.5, cacheWrite: 18.75 },
+    "gpt-4o": { in: 2.5, out: 10, cacheRead: 1.25 },
+    "gpt-4o-mini": { in: 0.15, out: 0.6, cacheRead: 0.075 },
+};
+/**
+ * Cloud routes prefix ids with a region scope and suffix a version, e.g.
+ * "us.anthropic.claude-sonnet-5" or "anthropic.claude-haiku-4-5-20251001-v1:0".
+ * Strip those so one table entry covers every deployment of a model.
+ * (Regional Bedrock endpoints do cost a little more than global — treat the
+ * result as an estimate, and pin exact prices in your profile if it matters.)
+ */
+export function normalizeModelId(id) {
+    let s = id.trim();
+    s = s.replace(/^(global|us|eu|apac|au|jp)\./, ""); // region scope
+    s = s.replace(/^anthropic\./, ""); // provider scope
+    s = s.replace(/-v\d+:\d+$/, ""); // bedrock version suffix
+    s = s.replace(/@\d{8}$/, ""); // vertex date suffix
+    return s;
+}
+function cacheFile() {
+    return path.join(os.homedir(), ".faber", "cache", "prices.json");
+}
+/**
+ * Bumped whenever the cached shape gains a field Faber relies on. A cache
+ * written by an older version is discarded rather than trusted: after adding
+ * `mode` and `supported_endpoints`, a stale file looked complete but carried
+ * neither, so Responses-only models were routed to the wrong endpoint and
+ * failed with a 404 that looked like a Faber bug.
+ */
+export const PRICE_CACHE_VERSION = 2;
+/** Wait this long before retrying after a failed refresh. */
+export const RETRY_AFTER_FAILURE_MS = 24 * 60 * 60 * 1000;
+/** How old the cached prices are, in days. undefined = never fetched. */
+export function priceAgeDays(now = Date.now()) {
+    const c = readPriceCache();
+    return c ? (now - c.fetchedAt) / 86_400_000 : undefined;
+}
+/** Prices this old are worth re-checking before they get baked into history. */
+export const STALE_AFTER_DAYS = 14;
+export function pricesAreStale(now = Date.now()) {
+    const age = priceAgeDays(now);
+    return age === undefined || age > STALE_AFTER_DAYS;
+}
+export function readPriceCache() {
+    try {
+        const raw = JSON.parse(fs.readFileSync(cacheFile(), "utf8"));
+        if (!raw.prices || typeof raw.prices !== "object")
+            return undefined;
+        if ((raw.version ?? 1) < PRICE_CACHE_VERSION)
+            return undefined; // stale shape
+        return raw;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function writePriceCache(prices, source, etag) {
+    try {
+        const f = cacheFile();
+        fs.mkdirSync(path.dirname(f), { recursive: true });
+        const now = Date.now();
+        fs.writeFileSync(f, JSON.stringify({ version: PRICE_CACHE_VERSION, fetchedAt: now, lastAttempt: now, source, etag, prices }, null, 2));
+    }
+    catch { /* best effort */ }
+}
+/** Prices were re-confirmed unchanged (a 304) — still current, nothing to store. */
+export function markPricesConfirmed(now = Date.now()) {
+    try {
+        const existing = readPriceCache();
+        if (!existing)
+            return;
+        const f = cacheFile();
+        fs.writeFileSync(f, JSON.stringify({ ...existing, fetchedAt: now, lastAttempt: now }, null, 2));
+    }
+    catch { /* best effort */ }
+}
+/**
+ * Remember that we tried, even when the fetch failed. Without this an offline
+ * machine would retry on every single launch, which is exactly the behaviour
+ * a background refresh must not have.
+ */
+export function markRefreshAttempt(now = Date.now()) {
+    try {
+        const f = cacheFile();
+        fs.mkdirSync(path.dirname(f), { recursive: true });
+        const existing = readPriceCache();
+        fs.writeFileSync(f, JSON.stringify({
+            version: PRICE_CACHE_VERSION,
+            fetchedAt: existing?.fetchedAt ?? 0,
+            lastAttempt: now,
+            source: existing?.source ?? "none",
+            etag: existing?.etag, // must survive, or conditional GET breaks
+            prices: existing?.prices ?? {},
+        }, null, 2));
+    }
+    catch { /* best effort */ }
+}
+/**
+ * Should a background refresh run now?
+ *
+ * Yes on every launch — a conditional request is ~0 bytes when nothing has
+ * changed, so there's no reason to tolerate a stale price window. The only
+ * exception is backing off after a FAILED attempt, so an offline machine
+ * isn't making a doomed request every time you start.
+ */
+export function shouldAutoRefresh(now = Date.now()) {
+    const c = readPriceCache();
+    if (!c)
+        return true; // never fetched
+    const failedRecently = c.lastAttempt !== undefined
+        && c.lastAttempt > c.fetchedAt // attempt newer than success
+        && now - c.lastAttempt < RETRY_AFTER_FAILURE_MS;
+    return !failedRecently;
+}
+const DATASET_URL = "https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_and_context_window.json";
+const OPENROUTER_MODELS_URL = "https://openrouter.ai/api/v1/models";
+/** True when this endpoint is OpenRouter, which publishes live prices. */
+export function isOpenRouter(baseUrl) {
+    return Boolean(baseUrl && /(^|\/\/)([^/]*\.)?openrouter\.ai/.test(baseUrl));
+}
+/**
+ * Live prices straight from OpenRouter. Values are USD per token as strings;
+ * we convert to per-Mtok. No API key needed for the catalogue.
+ */
+export async function fetchOpenRouterPrices(url = OPENROUTER_MODELS_URL) {
+    try {
+        const ctl = new AbortController();
+        const timer = setTimeout(() => ctl.abort(), 15000);
+        const res = await fetch(url, { signal: ctl.signal });
+        clearTimeout(timer);
+        if (!res.ok)
+            return undefined;
+        const body = await res.json();
+        const out = {};
+        const perM = (s) => {
+            const n = Number(s);
+            return Number.isFinite(n) ? Math.round(n * 1e6 * 1e6) / 1e6 : undefined;
+        };
+        for (const m of body.data ?? []) {
+            if (!m.id || !m.pricing)
+                continue;
+            const inC = perM(m.pricing["prompt"]), outC = perM(m.pricing["completion"]);
+            if (inC === undefined || outC === undefined)
+                continue;
+            const price = { in: inC, out: outC };
+            const cr = perM(m.pricing["input_cache_read"]);
+            const cw = perM(m.pricing["input_cache_write"]);
+            if (cr !== undefined)
+                price.cacheRead = cr;
+            if (cw !== undefined)
+                price.cacheWrite = cw;
+            out[m.id] = price;
+        }
+        return Object.keys(out).length ? out : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+"https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_and_context_window.json";
+export async function refreshPrices(url = DATASET_URL, opts = {}) {
+    markRefreshAttempt(); // recorded first, so a crash mid-fetch still backs off
+    // If the active endpoint publishes its own prices, that beats any dataset.
+    if (isOpenRouter(opts.baseUrl)) {
+        const live = await fetchOpenRouterPrices();
+        if (live) {
+            const merged = { ...(readPriceCache()?.prices ?? {}), ...live };
+            writePriceCache(merged, OPENROUTER_MODELS_URL);
+            return Object.keys(live).length;
+        }
+    }
+    try {
+        const ctl = new AbortController();
+        const timer = setTimeout(() => ctl.abort(), 15000);
+        // Conditional request: if the price list hasn't changed the server answers
+        // 304 with no body, so checking every launch costs ~0 bytes instead of 1.6MB.
+        const known = readPriceCache();
+        const headers = {};
+        if (known?.etag && !opts.force)
+            headers["if-none-match"] = known.etag;
+        const res = await fetch(url, { signal: ctl.signal, headers });
+        clearTimeout(timer);
+        if (res.status === 304) {
+            markPricesConfirmed();
+            return "unchanged";
+        }
+        if (!res.ok)
+            return undefined;
+        const etag = res.headers.get("etag") ?? undefined;
+        const raw = await res.json();
+        const out = {};
+        for (const [id, v] of Object.entries(raw)) {
+            const inC = v["input_cost_per_token"], outC = v["output_cost_per_token"];
+            if (typeof inC !== "number" || typeof outC !== "number")
+                continue;
+            // per-token floats round badly at 1e6 (2e-7 -> 0.19999999999999998),
+            // and these values get written to a file people read.
+            const perM = (n) => Math.round(n * 1e6 * 1e6) / 1e6;
+            const price = { in: perM(inC), out: perM(outC) };
+            if (typeof v["mode"] === "string")
+                price.mode = v["mode"];
+            const eps = v["supported_endpoints"];
+            if (Array.isArray(eps))
+                price.endpoints = eps.filter((e) => typeof e === "string");
+            const cr = v["cache_read_input_token_cost"], cw = v["cache_creation_input_token_cost"];
+            if (typeof cr === "number")
+                price.cacheRead = perM(cr);
+            if (typeof cw === "number")
+                price.cacheWrite = perM(cw);
+            out[id] = price;
+        }
+        if (!Object.keys(out).length)
+            return undefined;
+        writePriceCache(out, url, etag);
+        return Object.keys(out).length;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Price for a model. Explicit overrides win, then a refreshed dataset (exact
+ * id, then normalized), then the built-in table. Undefined means "unknown",
+ * which the ledger renders as — rather than guessing.
+ */
+export function priceFor(modelId, override) {
+    if (override?.in && override?.out)
+        return { in: override.in, out: override.out };
+    const norm = normalizeModelId(modelId);
+    const cached = readPriceCache()?.prices;
+    const hit = cached?.[modelId] ?? cached?.[norm] ?? BUILTIN_PRICES[modelId] ?? BUILTIN_PRICES[norm];
+    return hit;
+}
+/** Multipliers used when a model's exact cache prices aren't known. */
+export const CACHE_READ_RATIO = 0.1;
+export const CACHE_WRITE_RATIO = 1.25;
+export function cacheReadPrice(p) {
+    return p.cacheRead ?? p.in * CACHE_READ_RATIO;
+}
+export function cacheWritePrice(p) {
+    return p.cacheWrite ?? p.in * CACHE_WRITE_RATIO;
+}