@aitne/daemon 0.1.0

package/dist/core/backends/plan-presets.d.ts

@@ -0,0 +1,123 @@
+/**
+ * Process-key default-presets module.
+ *
+ * Aitne is designed to run on provider API keys (`ANTHROPIC_API_KEY` /
+ * `OPENAI_API_KEY` / `GEMINI_API_KEY` / `GOOGLE_API_KEY`). Headless-agent
+ * subscription policies (notably Anthropic's, which prohibits running
+ * the Claude Agent SDK on a Claude Pro/Max subscription) made
+ * subscription-plan-driven routing inappropriate at distribution time
+ * and were removed in 2026-04. The CLI-login fallback is still honored
+ * for backends with no configured API key, but it is not the documented
+ * operating mode.
+ *
+ * What this file does:
+ *   - Drives the seed model selection from each process key's default
+ *     tier (`getDefaultTierForProcessKey`). Lite-tier keys seed Haiku
+ *     (Claude) / gpt-5.4-mini (Codex) / flash-lite (Gemini); medium-tier
+ *     keys seed Sonnet / gpt-5.4-mini / 3.1-flash-lite-preview; high-tier keys seed
+ *     Opus / gpt-5.5 / 3.1-pro-preview.
+ *   - Exposes `setMainBackend(db, backendId)` — writes
+ *     `backend_global_defaults.default_backend` only. No preset
+ *     application, no per-process row mutation. The dashboard's main-
+ *     switch confirm dialog calls this directly.
+ *   - Exposes `applyDefaultPresets(db, options?)` — seeds every
+ *     configurable process_backend_config row at install time. Re-
+ *     callable from the dashboard "Reset to defaults" button.
+ *   - Preserves `previewMainSwitchImpact()` so the dashboard can warn
+ *     about user-pinned cross-backend rows that would survive a switch.
+ *
+ * Tier-to-model resolution lives in `model-registry.ts:defaultModelForTier`.
+ */
+import type Database from "better-sqlite3";
+import { type BackendId, type ProcessKey, type ProcessModelTier } from "@aitne/shared";
+/**
+ * Resolve the seed `(model, envelope)` for a configurable process key on
+ * the given backend. The model is selected by the process key's default
+ * tier (lite / medium / high) and the backend's per-tier canonical pick
+ * from `defaultModelForTier`.
+ */
+export declare function resolveDefaultBindingFor(backendId: BackendId, processKey: ProcessKey): {
+    model: string;
+    maxTurns: number;
+    maxBudgetUsd: number;
+};
+/**
+ * Result shape of `applyDefaultPresets`. `defaultsUpdated` matches the
+ * legacy preset return so callers (setup wizard, dashboard reset
+ * button) can decide whether to mirror the envelope into live
+ * `AgentConfig`.
+ */
+export interface ApplyDefaultPresetsResult {
+    backend: BackendId;
+    processRowsUpdated: number;
+    processRowsSkipped: number;
+    defaultsUpdated: boolean;
+}
+export interface ApplyDefaultPresetsOptions {
+    /**
+     * When true, overwrites rows regardless of `updated_by`. Setup wizard
+     * passes `true` on first install. Dashboard "Reset" button passes
+     * `false` so user-pinned rows survive.
+     */
+    force?: boolean;
+    /**
+     * When provided, also rewrites `default_backend` to this value. The
+     * dashboard main-switch flow passes the new backend; the install
+     * seeder passes the wizard-selected backend.
+     */
+    defaultBackend?: BackendId;
+}
+/**
+ * Seed `process_backend_config` rows for every configurable process
+ * key. Called from the setup wizard at first install and from the
+ * dashboard's "Reset to defaults" action.
+ *
+ * Behaviour:
+ *   - Determines the active backend from `defaults.defaultBackend` or
+ *     `backend_global_defaults.default_backend` (claude as last resort).
+ *   - Seeds each row with a model resolved by `resolveDefaultBindingFor`
+ *     (lite tier seeds Haiku on Claude / gpt-5.4-mini on Codex /
+ *     flash-lite preview on Gemini; medium tier seeds Sonnet / gpt-5.4-mini
+ *     / 3.1-flash-lite-preview; high tier seeds Opus / gpt-5.5 / 3.1-pro-preview).
+ *   - Updates `default_lite_model` / `default_medium_model` /
+ *     `default_high_model` / `default_backend` on the singleton row.
+ *   - Skips rows whose `updated_by='user'` unless `force: true`.
+ */
+export declare function applyDefaultPresets(db: Database.Database, options?: ApplyDefaultPresetsOptions): ApplyDefaultPresetsResult;
+/**
+ * Set the active main backend. Writes `default_backend` and ensures the
+ * chosen backend's `backends.enabled = 1`. Does not mutate
+ * `process_backend_config` rows or `default_lite_model` /
+ * `default_medium_model` / `default_high_model`. Callers that want a full
+ * re-seed should call `applyDefaultPresets({ defaultBackend })` afterwards.
+ *
+ * The enable bump is intentional: a backend chosen as main is the
+ * actively-routed default. Without flipping `enabled`, the wire-boundary
+ * validator (chat SSE, fallback enable check) and the
+ * `BackendStatusRow.enabled` flag stay false, leaving the dashboard in a
+ * "main backend exists but is disabled" state — a contradiction the
+ * setup wizard previously stumbled into. Idempotent: already-enabled
+ * rows just bump `updated_at`.
+ */
+export declare function setMainBackend(db: Database.Database, backendId: BackendId): void;
+/**
+ * Preview a prospective main-switch without writing. Returns the
+ * cross-backend pins the operator would keep (rows with `updated_by =
+ * 'user'` whose `main_backend` differs from the target). The dashboard
+ * shows these in the confirm dialog so the operator can decide whether
+ * to keep them or click "Reset to defaults" after switching.
+ */
+export declare function previewMainSwitchImpact(db: Database.Database, targetBackend: BackendId): {
+    preservedCrossBackendPins: Array<{
+        processKey: string;
+        pinnedBackend: BackendId;
+        pinnedModel: string;
+    }>;
+};
+/**
+ * Infer the tier of a (backend, model) pair from the model registry.
+ * Used by the dashboard's process-config card to render the tier badge
+ * next to a pinned row. Returns `null` when the model is unknown.
+ */
+export declare function inferTierForModel(backendId: BackendId, modelId: string): ProcessModelTier | null;
+//# sourceMappingURL=plan-presets.d.ts.map

package/dist/core/backends/plan-presets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan-presets.d.ts","sourceRoot":"","sources":["../../../src/core/backends/plan-presets.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,OAAO,KAAK,QAAQ,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAIL,KAAK,SAAS,EAEd,KAAK,UAAU,EACf,KAAK,gBAAgB,EACtB,MAAM,eAAe,CAAC;AA8BvB;;;;;GAKG;AACH,wBAAgB,wBAAwB,CACtC,SAAS,EAAE,SAAS,EACpB,UAAU,EAAE,UAAU,GACrB;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,CAAA;CAAE,CAQ3D;AAED;;;;;GAKG;AACH,MAAM,WAAW,yBAAyB;IACxC,OAAO,EAAE,SAAS,CAAC;IACnB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,kBAAkB,EAAE,MAAM,CAAC;IAC3B,eAAe,EAAE,OAAO,CAAC;CAC1B;AAED,MAAM,WAAW,0BAA0B;IACzC;;;;OAIG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB;;;;OAIG;IACH,cAAc,CAAC,EAAE,SAAS,CAAC;CAC5B;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,mBAAmB,CACjC,EAAE,EAAE,QAAQ,CAAC,QAAQ,EACrB,OAAO,GAAE,0BAA+B,GACvC,yBAAyB,CA0E3B;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,CAC5B,EAAE,EAAE,QAAQ,CAAC,QAAQ,EACrB,SAAS,EAAE,SAAS,GACnB,IAAI,CA6BN;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CACrC,EAAE,EAAE,QAAQ,CAAC,QAAQ,EACrB,aAAa,EAAE,SAAS,GACvB;IACD,yBAAyB,EAAE,KAAK,CAAC;QAC/B,UAAU,EAAE,MAAM,CAAC;QACnB,aAAa,EAAE,SAAS,CAAC;QACzB,WAAW,EAAE,MAAM,CAAC;KACrB,CAAC,CAAC;CACJ,CA6BA;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,SAAS,EACpB,OAAO,EAAE,MAAM,GACd,gBAAgB,GAAG,IAAI,CAGzB"}

package/dist/core/backends/plan-presets.js

@@ -0,0 +1,235 @@
+/**
+ * Process-key default-presets module.
+ *
+ * Aitne is designed to run on provider API keys (`ANTHROPIC_API_KEY` /
+ * `OPENAI_API_KEY` / `GEMINI_API_KEY` / `GOOGLE_API_KEY`). Headless-agent
+ * subscription policies (notably Anthropic's, which prohibits running
+ * the Claude Agent SDK on a Claude Pro/Max subscription) made
+ * subscription-plan-driven routing inappropriate at distribution time
+ * and were removed in 2026-04. The CLI-login fallback is still honored
+ * for backends with no configured API key, but it is not the documented
+ * operating mode.
+ *
+ * What this file does:
+ *   - Drives the seed model selection from each process key's default
+ *     tier (`getDefaultTierForProcessKey`). Lite-tier keys seed Haiku
+ *     (Claude) / gpt-5.4-mini (Codex) / flash-lite (Gemini); medium-tier
+ *     keys seed Sonnet / gpt-5.4-mini / 3.1-flash-lite-preview; high-tier keys seed
+ *     Opus / gpt-5.5 / 3.1-pro-preview.
+ *   - Exposes `setMainBackend(db, backendId)` — writes
+ *     `backend_global_defaults.default_backend` only. No preset
+ *     application, no per-process row mutation. The dashboard's main-
+ *     switch confirm dialog calls this directly.
+ *   - Exposes `applyDefaultPresets(db, options?)` — seeds every
+ *     configurable process_backend_config row at install time. Re-
+ *     callable from the dashboard "Reset to defaults" button.
+ *   - Preserves `previewMainSwitchImpact()` so the dashboard can warn
+ *     about user-pinned cross-backend rows that would survive a switch.
+ *
+ * Tier-to-model resolution lives in `model-registry.ts:defaultModelForTier`.
+ */
+import { CONFIGURABLE_PROCESS_KEYS, getDefaultTierForProcessKey, isBackendId, } from "@aitne/shared";
+import { createLogger } from "../../logging.js";
+import { DEFAULT_CLAUDE_HIGH_MODEL, DEFAULT_CLAUDE_LITE_MODEL, DEFAULT_CLAUDE_MEDIUM_MODEL, defaultModelForTier, findRegisteredModel, } from "./model-registry.js";
+import { setProcessBackendConfig } from "./process-config-cascade.js";
+const logger = createLogger("default-presets");
+/**
+ * Per-execution envelope applied to seeded rows. Used to bound the
+ * worst-case dispatch cost; operators can widen them per-row from the
+ * dashboard. The "lite" envelope is intentionally tighter — these tasks
+ * are short-shaped tool sequences, not free-form chat. The "high"
+ * envelope is generous because a high-tier seed implies the task is
+ * one-shot, generative, and benefits from extra reasoning room.
+ */
+const ENVELOPE_BY_TIER = {
+    lite: { maxTurns: 20, maxBudgetUsd: 0.2 },
+    medium: { maxTurns: 50, maxBudgetUsd: 1.0 },
+    high: { maxTurns: 80, maxBudgetUsd: 3.0 },
+};
+/**
+ * Resolve the seed `(model, envelope)` for a configurable process key on
+ * the given backend. The model is selected by the process key's default
+ * tier (lite / medium / high) and the backend's per-tier canonical pick
+ * from `defaultModelForTier`.
+ */
+export function resolveDefaultBindingFor(backendId, processKey) {
+    const tier = getDefaultTierForProcessKey(processKey);
+    const envelope = ENVELOPE_BY_TIER[tier];
+    return {
+        model: defaultModelForTier(backendId, tier),
+        maxTurns: envelope.maxTurns,
+        maxBudgetUsd: envelope.maxBudgetUsd,
+    };
+}
+/**
+ * Seed `process_backend_config` rows for every configurable process
+ * key. Called from the setup wizard at first install and from the
+ * dashboard's "Reset to defaults" action.
+ *
+ * Behaviour:
+ *   - Determines the active backend from `defaults.defaultBackend` or
+ *     `backend_global_defaults.default_backend` (claude as last resort).
+ *   - Seeds each row with a model resolved by `resolveDefaultBindingFor`
+ *     (lite tier seeds Haiku on Claude / gpt-5.4-mini on Codex /
+ *     flash-lite preview on Gemini; medium tier seeds Sonnet / gpt-5.4-mini
+ *     / 3.1-flash-lite-preview; high tier seeds Opus / gpt-5.5 / 3.1-pro-preview).
+ *   - Updates `default_lite_model` / `default_medium_model` /
+ *     `default_high_model` / `default_backend` on the singleton row.
+ *   - Skips rows whose `updated_by='user'` unless `force: true`.
+ */
+export function applyDefaultPresets(db, options = {}) {
+    const targetBackend = options.defaultBackend ?? readActiveBackend(db) ?? "claude";
+    let processRowsUpdated = 0;
+    let processRowsSkipped = 0;
+    const transaction = db.transaction(() => {
+        db.prepare(`INSERT INTO backend_global_defaults (
+         singleton,
+         default_backend,
+         default_lite_model,
+         default_medium_model,
+         default_high_model,
+         updated_at
+       ) VALUES (1, ?, ?, ?, ?, CURRENT_TIMESTAMP)
+       ON CONFLICT(singleton) DO UPDATE SET
+         default_backend = excluded.default_backend,
+         default_lite_model = excluded.default_lite_model,
+         default_medium_model = excluded.default_medium_model,
+         default_high_model = excluded.default_high_model,
+         updated_at = CURRENT_TIMESTAMP`).run(targetBackend, liteModelFor(targetBackend), mediumModelFor(targetBackend), highModelFor(targetBackend));
+        for (const processKey of CONFIGURABLE_PROCESS_KEYS) {
+            const existing = db
+                .prepare(`SELECT updated_by FROM process_backend_config WHERE process_key = ?`)
+                .get(processKey);
+            if (existing && existing.updated_by === "user" && !options.force) {
+                processRowsSkipped += 1;
+                continue;
+            }
+            const binding = resolveDefaultBindingFor(targetBackend, processKey);
+            setProcessBackendConfig(db, {
+                processKey,
+                mainBackend: targetBackend,
+                mainModel: binding.model,
+                fallbackBackend: null,
+                fallbackModel: null,
+                maxTurns: binding.maxTurns,
+                maxBudgetUsd: binding.maxBudgetUsd,
+                updatedBy: "preset",
+            });
+            processRowsUpdated += 1;
+        }
+    });
+    transaction();
+    logger.info({
+        backend: targetBackend,
+        processRowsUpdated,
+        processRowsSkipped,
+        force: options.force === true,
+    }, "Applied default process presets");
+    return {
+        backend: targetBackend,
+        processRowsUpdated,
+        processRowsSkipped,
+        defaultsUpdated: true,
+    };
+}
+/**
+ * Set the active main backend. Writes `default_backend` and ensures the
+ * chosen backend's `backends.enabled = 1`. Does not mutate
+ * `process_backend_config` rows or `default_lite_model` /
+ * `default_medium_model` / `default_high_model`. Callers that want a full
+ * re-seed should call `applyDefaultPresets({ defaultBackend })` afterwards.
+ *
+ * The enable bump is intentional: a backend chosen as main is the
+ * actively-routed default. Without flipping `enabled`, the wire-boundary
+ * validator (chat SSE, fallback enable check) and the
+ * `BackendStatusRow.enabled` flag stay false, leaving the dashboard in a
+ * "main backend exists but is disabled" state — a contradiction the
+ * setup wizard previously stumbled into. Idempotent: already-enabled
+ * rows just bump `updated_at`.
+ */
+export function setMainBackend(db, backendId) {
+    const tx = db.transaction(() => {
+        db.prepare(`INSERT INTO backend_global_defaults (
+         singleton,
+         default_backend,
+         default_lite_model,
+         default_medium_model,
+         default_high_model,
+         updated_at
+       ) VALUES (1, ?, ?, ?, ?, CURRENT_TIMESTAMP)
+       ON CONFLICT(singleton) DO UPDATE SET
+         default_backend = excluded.default_backend,
+         updated_at = CURRENT_TIMESTAMP`).run(backendId, liteModelFor(backendId), mediumModelFor(backendId), highModelFor(backendId));
+        db.prepare(`UPDATE backends
+          SET enabled = 1,
+              updated_at = CURRENT_TIMESTAMP
+        WHERE id = ?`).run(backendId);
+    });
+    tx();
+}
+/**
+ * Preview a prospective main-switch without writing. Returns the
+ * cross-backend pins the operator would keep (rows with `updated_by =
+ * 'user'` whose `main_backend` differs from the target). The dashboard
+ * shows these in the confirm dialog so the operator can decide whether
+ * to keep them or click "Reset to defaults" after switching.
+ */
+export function previewMainSwitchImpact(db, targetBackend) {
+    const rows = db
+        .prepare(`SELECT process_key, main_backend, main_model
+         FROM process_backend_config
+        WHERE updated_by = 'user'`)
+        .all();
+    const preservedCrossBackendPins = [];
+    for (const row of rows) {
+        if (!isBackendId(row.main_backend))
+            continue;
+        if (row.main_backend === targetBackend)
+            continue;
+        preservedCrossBackendPins.push({
+            processKey: row.process_key,
+            pinnedBackend: row.main_backend,
+            pinnedModel: row.main_model,
+        });
+    }
+    return { preservedCrossBackendPins };
+}
+/**
+ * Infer the tier of a (backend, model) pair from the model registry.
+ * Used by the dashboard's process-config card to render the tier badge
+ * next to a pinned row. Returns `null` when the model is unknown.
+ */
+export function inferTierForModel(backendId, modelId) {
+    const model = findRegisteredModel(backendId, modelId);
+    return model?.tier ?? null;
+}
+// ── Internal helpers ────────────────────────────────────────────────────
+function readActiveBackend(db) {
+    try {
+        const row = db
+            .prepare(`SELECT default_backend FROM backend_global_defaults WHERE singleton = 1`)
+            .get();
+        if (!row || !isBackendId(row.default_backend))
+            return null;
+        return row.default_backend;
+    }
+    catch {
+        return null;
+    }
+}
+function liteModelFor(backendId) {
+    if (backendId === "claude")
+        return DEFAULT_CLAUDE_LITE_MODEL;
+    return defaultModelForTier(backendId, "lite");
+}
+function mediumModelFor(backendId) {
+    if (backendId === "claude")
+        return DEFAULT_CLAUDE_MEDIUM_MODEL;
+    return defaultModelForTier(backendId, "medium");
+}
+function highModelFor(backendId) {
+    if (backendId === "claude")
+        return DEFAULT_CLAUDE_HIGH_MODEL;
+    return defaultModelForTier(backendId, "high");
+}
+//# sourceMappingURL=plan-presets.js.map

package/dist/core/backends/plan-presets.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan-presets.js","sourceRoot":"","sources":["../../../src/core/backends/plan-presets.ts"],"names":[],"mappings":"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"}

package/dist/core/backends/price-fetcher.d.ts

@@ -0,0 +1,48 @@
+import type { BackendCostSource, BackendId, BackendModel, BackendUsage } from "@aitne/shared";
+import type Database from "better-sqlite3";
+interface LiteLLMPriceEntry {
+    input_cost_per_token?: number;
+    output_cost_per_token?: number;
+    cache_read_input_token_cost?: number;
+    cache_creation_input_token_cost?: number;
+    supports_prompt_caching?: boolean;
+    max_input_tokens?: number;
+    max_output_tokens?: number;
+    input_cost_threshold_tokens?: number;
+    input_cost_per_token_above_threshold?: number;
+    output_cost_per_token_above_threshold?: number;
+    cache_read_input_token_cost_above_threshold?: number;
+    cache_creation_input_token_cost_above_threshold?: number;
+}
+interface PricingDataSourceStatus {
+    source: "litellm" | "hardcoded";
+    fetchedAt: string | null;
+    lastAttemptAt: string | null;
+    lastError: string | null;
+    stale: boolean;
+    sourceUrl: string;
+}
+interface EstimatedUsageCost {
+    costSource: Exclude<BackendCostSource, "sdk">;
+    costUsd: number;
+}
+export declare class PriceFetcher {
+    private readonly db?;
+    readonly cachePath: string;
+    readonly sourceUrl = "https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_and_context_window.json";
+    constructor(dataDir: string, db?: Database.Database | undefined);
+    getStatus(): PricingDataSourceStatus;
+    refresh(): Promise<PricingDataSourceStatus>;
+    getPriceEntry(modelId: string): LiteLLMPriceEntry | null;
+    estimateUsageCost(params: {
+        backendId: BackendId;
+        modelId: string;
+        usage: BackendUsage;
+        fallbackModel?: BackendModel;
+    }): EstimatedUsageCost;
+    private readCache;
+    private writeCache;
+    private writeStatus;
+}
+export {};
+//# sourceMappingURL=price-fetcher.d.ts.map

package/dist/core/backends/price-fetcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"price-fetcher.d.ts","sourceRoot":"","sources":["../../../src/core/backends/price-fetcher.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,iBAAiB,EACjB,SAAS,EACT,YAAY,EACZ,YAAY,EACb,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,QAAQ,MAAM,gBAAgB,CAAC;AAc3C,UAAU,iBAAiB;IACzB,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,2BAA2B,CAAC,EAAE,MAAM,CAAC;IACrC,+BAA+B,CAAC,EAAE,MAAM,CAAC;IACzC,uBAAuB,CAAC,EAAE,OAAO,CAAC;IAClC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,2BAA2B,CAAC,EAAE,MAAM,CAAC;IACrC,oCAAoC,CAAC,EAAE,MAAM,CAAC;IAC9C,qCAAqC,CAAC,EAAE,MAAM,CAAC;IAC/C,2CAA2C,CAAC,EAAE,MAAM,CAAC;IACrD,+CAA+C,CAAC,EAAE,MAAM,CAAC;CAC1D;AAOD,UAAU,uBAAuB;IAC/B,MAAM,EAAE,SAAS,GAAG,WAAW,CAAC;IAChC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,KAAK,EAAE,OAAO,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,UAAU,kBAAkB;IAC1B,UAAU,EAAE,OAAO,CAAC,iBAAiB,EAAE,KAAK,CAAC,CAAC;IAC9C,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,qBAAa,YAAY;IAMrB,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;IALtB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,SAAS,iGAAsB;gBAGtC,OAAO,EAAE,MAAM,EACE,EAAE,CAAC,EAAE,QAAQ,CAAC,QAAQ,YAAA;IAKzC,SAAS,IAAI,uBAAuB;IAgB9B,OAAO,IAAI,OAAO,CAAC,uBAAuB,CAAC;IAkCjD,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,iBAAiB,GAAG,IAAI;IASxD,iBAAiB,CAAC,MAAM,EAAE;QACxB,SAAS,EAAE,SAAS,CAAC;QACrB,OAAO,EAAE,MAAM,CAAC;QAChB,KAAK,EAAE,YAAY,CAAC;QACpB,aAAa,CAAC,EAAE,YAAY,CAAC;KAC9B,GAAG,kBAAkB;IA2CtB,OAAO,CAAC,SAAS;IA2BjB,OAAO,CAAC,UAAU;IAKlB,OAAO,CAAC,WAAW;CAMpB"}

package/dist/core/backends/price-fetcher.js

@@ -0,0 +1,248 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { readRuntimeState, writeRuntimeState } from "../../db/runtime-state.js";
+import { estimateCostForUsage, findRegisteredModel } from "./model-registry.js";
+const CACHE_TTL_MS = 24 * 60 * 60 * 1000;
+const PRICING_STATUS_KEY = "pricing_data_source_status";
+const LITELLM_SOURCE_URL = "https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_and_context_window.json";
+export class PriceFetcher {
+    db;
+    cachePath;
+    sourceUrl = LITELLM_SOURCE_URL;
+    constructor(dataDir, db) {
+        this.db = db;
+        this.cachePath = join(dataDir, "cache", "model-prices.json");
+    }
+    getStatus() {
+        const cache = this.readCache();
+        const persisted = this.db
+            ? readRuntimeState(this.db, PRICING_STATUS_KEY)
+            : null;
+        return {
+            source: cache ? "litellm" : "hardcoded",
+            fetchedAt: cache?.fetchedAt ?? null,
+            lastAttemptAt: persisted?.lastAttemptAt ?? cache?.fetchedAt ?? null,
+            lastError: persisted?.lastError ?? null,
+            stale: cache ? Date.now() - Date.parse(cache.fetchedAt) > CACHE_TTL_MS : true,
+            sourceUrl: this.sourceUrl,
+        };
+    }
+    async refresh() {
+        const attemptedAt = new Date().toISOString();
+        try {
+            const response = await fetch(this.sourceUrl, {
+                signal: AbortSignal.timeout(30_000),
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}`);
+            }
+            const json = await response.json();
+            if (!json || typeof json !== "object" || Array.isArray(json)) {
+                throw new Error("Invalid LiteLLM pricing payload");
+            }
+            this.writeCache({
+                fetchedAt: attemptedAt,
+                prices: json,
+            });
+            this.writeStatus({
+                lastAttemptAt: attemptedAt,
+                lastError: null,
+            });
+        }
+        catch (error) {
+            this.writeStatus({
+                lastAttemptAt: attemptedAt,
+                lastError: error instanceof Error ? error.message : "Unknown fetch error",
+            });
+        }
+        return this.getStatus();
+    }
+    getPriceEntry(modelId) {
+        const cache = this.readCache();
+        if (!cache) {
+            return null;
+        }
+        return normalizePriceEntry(cache.prices[modelId]);
+    }
+    estimateUsageCost(params) {
+        const fallbackModel = params.fallbackModel
+            ?? findRegisteredModel(params.backendId, params.modelId);
+        const priceEntry = this.getPriceEntry(params.modelId);
+        // Models flagged `pricingTrusted` use the registry as the authoritative
+        // source — LiteLLM's community data is ignored for these. Used when
+        // upstream is known to lag (e.g. newest Opus tier).
+        if (fallbackModel?.pricingTrusted) {
+            return {
+                costSource: "hardcoded",
+                costUsd: estimateCostForUsage(fallbackModel, params.usage),
+            };
+        }
+        if (priceEntry) {
+            const pricedModel = applyPriceEntry(fallbackModel ?? {
+                backendId: params.backendId,
+                modelId: params.modelId,
+                label: params.modelId,
+                displayName: params.modelId,
+                tier: params.fallbackModel?.tier ?? "medium",
+                available: true,
+            }, priceEntry);
+            return {
+                costSource: fallbackModel && !isUsageFullyCoveredByPriceEntry(priceEntry, params.usage)
+                    ? "hardcoded"
+                    : "litellm",
+                costUsd: estimateCostForUsage(pricedModel, params.usage),
+            };
+        }
+        return {
+            costSource: "hardcoded",
+            costUsd: estimateCostForUsage(fallbackModel, params.usage),
+        };
+    }
+    readCache() {
+        if (!existsSync(this.cachePath)) {
+            return null;
+        }
+        try {
+            const raw = readFileSync(this.cachePath, "utf8");
+            const parsed = JSON.parse(raw);
+            if (!parsed
+                || typeof parsed !== "object"
+                || typeof parsed.fetchedAt !== "string"
+                || !parsed.prices
+                || typeof parsed.prices !== "object"
+                || Array.isArray(parsed.prices)) {
+                return null;
+            }
+            return {
+                fetchedAt: parsed.fetchedAt,
+                prices: parsed.prices,
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    writeCache(payload) {
+        mkdirSync(dirname(this.cachePath), { recursive: true });
+        writeFileSync(this.cachePath, JSON.stringify(payload, null, 2));
+    }
+    writeStatus(status) {
+        if (!this.db) {
+            return;
+        }
+        writeRuntimeState(this.db, PRICING_STATUS_KEY, status);
+    }
+}
+function normalizePriceEntry(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return null;
+    }
+    const raw = value;
+    const aboveThreshold = readAboveThresholdPricing(raw);
+    const normalized = {
+        input_cost_per_token: readOptionalNumber(raw.input_cost_per_token),
+        output_cost_per_token: readOptionalNumber(raw.output_cost_per_token),
+        cache_read_input_token_cost: readOptionalNumber(raw.cache_read_input_token_cost),
+        cache_creation_input_token_cost: readOptionalNumber(raw.cache_creation_input_token_cost),
+        supports_prompt_caching: typeof raw.supports_prompt_caching === "boolean"
+            ? raw.supports_prompt_caching
+            : undefined,
+        max_input_tokens: readOptionalNumber(raw.max_input_tokens),
+        max_output_tokens: readOptionalNumber(raw.max_output_tokens),
+        ...aboveThreshold,
+    };
+    if (normalized.input_cost_per_token === undefined
+        && normalized.output_cost_per_token === undefined
+        && normalized.cache_read_input_token_cost === undefined
+        && normalized.cache_creation_input_token_cost === undefined
+        && normalized.input_cost_per_token_above_threshold === undefined
+        && normalized.output_cost_per_token_above_threshold === undefined
+        && normalized.cache_read_input_token_cost_above_threshold === undefined
+        && normalized.cache_creation_input_token_cost_above_threshold === undefined) {
+        return null;
+    }
+    return normalized;
+}
+function readAboveThresholdPricing(raw) {
+    const result = {};
+    for (const [key, value] of Object.entries(raw)) {
+        const match = /^(input_cost_per_token|output_cost_per_token|cache_read_input_token_cost|cache_creation_input_token_cost)_above_(\d+)k_tokens$/.exec(key);
+        const price = readOptionalNumber(value);
+        if (!match || price === undefined) {
+            continue;
+        }
+        result.input_cost_threshold_tokens = Number.parseInt(match[2], 10) * 1000;
+        if (match[1] === "input_cost_per_token") {
+            result.input_cost_per_token_above_threshold = price;
+        }
+        else if (match[1] === "output_cost_per_token") {
+            result.output_cost_per_token_above_threshold = price;
+        }
+        else if (match[1] === "cache_read_input_token_cost") {
+            result.cache_read_input_token_cost_above_threshold = price;
+        }
+        else if (match[1] === "cache_creation_input_token_cost") {
+            result.cache_creation_input_token_cost_above_threshold = price;
+        }
+    }
+    return result;
+}
+function applyPriceEntry(model, entry) {
+    return {
+        ...model,
+        supportsPromptCaching: entry.supports_prompt_caching ?? model.supportsPromptCaching,
+        usdPer1kIn: perTokenToPer1k(entry.input_cost_per_token) ?? model.usdPer1kIn,
+        usdPer1kOut: perTokenToPer1k(entry.output_cost_per_token) ?? model.usdPer1kOut,
+        usdPer1kCacheRead: perTokenToPer1k(entry.cache_read_input_token_cost) ?? model.usdPer1kCacheRead,
+        usdPer1kCacheCreate: perTokenToPer1k(entry.cache_creation_input_token_cost) ?? model.usdPer1kCacheCreate,
+        inputCostThresholdTokens: entry.input_cost_threshold_tokens ?? model.inputCostThresholdTokens,
+        usdPer1kInAboveThreshold: perTokenToPer1k(entry.input_cost_per_token_above_threshold)
+            ?? model.usdPer1kInAboveThreshold,
+        usdPer1kOutAboveThreshold: perTokenToPer1k(entry.output_cost_per_token_above_threshold)
+            ?? model.usdPer1kOutAboveThreshold,
+        usdPer1kCacheReadAboveThreshold: perTokenToPer1k(entry.cache_read_input_token_cost_above_threshold)
+            ?? model.usdPer1kCacheReadAboveThreshold,
+        usdPer1kCacheCreateAboveThreshold: perTokenToPer1k(entry.cache_creation_input_token_cost_above_threshold)
+            ?? model.usdPer1kCacheCreateAboveThreshold,
+        maxInputTokens: entry.max_input_tokens ?? model.maxInputTokens,
+        maxOutputTokens: entry.max_output_tokens ?? model.maxOutputTokens,
+    };
+}
+function perTokenToPer1k(value) {
+    return value === undefined ? undefined : value * 1000;
+}
+function isUsageFullyCoveredByPriceEntry(entry, usage) {
+    if (usage.outputTokens > 0 && entry.output_cost_per_token === undefined) {
+        return false;
+    }
+    if (usage.cacheReadInputTokens > 0 && entry.cache_read_input_token_cost === undefined) {
+        return false;
+    }
+    if (usage.cacheCreationInputTokens > 0 && entry.cache_creation_input_token_cost === undefined) {
+        return false;
+    }
+    const thresholdInputTokens = usage.inputTokens
+        + usage.cacheReadInputTokens
+        + usage.cacheCreationInputTokens;
+    if (thresholdInputTokens <= 0) {
+        return true;
+    }
+    if (usage.inputTokens > 0 && entry.input_cost_per_token === undefined) {
+        return false;
+    }
+    if (entry.input_cost_threshold_tokens !== undefined
+        && thresholdInputTokens > entry.input_cost_threshold_tokens
+        && ((usage.inputTokens > 0 && entry.input_cost_per_token_above_threshold === undefined)
+            || (usage.outputTokens > 0 && entry.output_cost_per_token_above_threshold === undefined)
+            || (usage.cacheReadInputTokens > 0
+                && entry.cache_read_input_token_cost_above_threshold === undefined)
+            || (usage.cacheCreationInputTokens > 0
+                && entry.cache_creation_input_token_cost_above_threshold === undefined))) {
+        return false;
+    }
+    return true;
+}
+function readOptionalNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+//# sourceMappingURL=price-fetcher.js.map