llm-cli-gateway 2.15.0 → 2.17.0

package/dist/job-store.d.ts

@@ -10,6 +10,7 @@ export interface JobRecord {
     cli: string;
     argsJson: string;
     outputFormat?: string | null;
+    compressResponse?: boolean | null;
     status: JobStoreStatus;
     exitCode: number | null;
     stdout: string;
@@ -52,6 +53,7 @@ export interface JobStore {
         cli: string;
         args: string[];
         outputFormat?: string;
+        compressResponse?: boolean;
         startedAt: string;
         pid: number | null;
         ownerPrincipal?: string | null;
@@ -173,6 +175,7 @@ export declare class SqliteJobStore implements JobStore, ValidationRunStore {
         cli: string;
         args: string[];
         outputFormat?: string;
+        compressResponse?: boolean;
         startedAt: string;
         pid: number | null;
         ownerPrincipal?: string | null;
@@ -236,6 +239,7 @@ export declare class MemoryJobStore implements JobStore {
         cli: string;
         args: string[];
         outputFormat?: string;
+        compressResponse?: boolean;
         startedAt: string;
         pid: number | null;
         ownerPrincipal?: string | null;
@@ -276,15 +280,23 @@ export declare class MemoryJobStore implements JobStore {
 export declare class PostgresJobStore implements JobStore, ValidationRunStore {
     private logger;
     private worker;
-    private tmpDir;
-    private nextRequestId;
+    private retiringWorker;
+    private readonly intentionallyRetiredWorkers;
+    private workerTerminationPending;
     private closed;
+    private readonly workerData;
     constructor(dsn: string, logger?: Logger, options?: {
         retentionMs?: number;
         dedupWindowMs?: number;
         leaseTtlMs?: number;
     });
+    private createWorker;
     private syncCall;
+    private ensureWorker;
+    private callWorker;
+    private retireAfterBridgeFailure;
+    private retireWorker;
+    private markWorkerRetired;
     recordStart(input: {
         id: string;
         correlationId: string;

package/dist/job-store.js

@@ -1,8 +1,8 @@
-import { chmodSync, existsSync, mkdtempSync, readFileSync, rmSync } from "fs";
+import { chmodSync, existsSync } from "fs";
 import os from "os";
 import path from "path";
 import { createHash } from "crypto";
-import { Worker } from "worker_threads";
+import { MessageChannel, receiveMessageOnPort, Worker } from "worker_threads";
 import { fileURLToPath } from "url";
 import { openDatabase } from "./sqlite-driver.js";
 import { noopLogger } from "./logger.js";
@@ -30,6 +30,8 @@ export function resolveJobRetentionMs() {
     return days * 24 * 60 * 60 * 1000;
 }
 const DEFAULT_DEDUP_WINDOW_MS = 60 * 60 * 1000;
+const POSTGRES_WORKER_OPERATION_TIMEOUT_MS = 35_000;
+const POSTGRES_WORKER_INITIALIZATION_TIMEOUT_MS = 45_000;
 export function resolveDedupWindowMs() {
     const raw = process.env.LLM_GATEWAY_DEDUP_WINDOW_MS;
     if (raw === undefined)
@@ -51,6 +53,9 @@ function rowToRecord(row) {
         cli: row.cli,
         argsJson: row.args_json,
         outputFormat: row.output_format ?? null,
+        compressResponse: row.compress_response === null || row.compress_response === undefined
+            ? null
+            : Boolean(row.compress_response),
         status: row.status,
         exitCode: row.exit_code,
         stdout: row.stdout ?? "",
@@ -99,6 +104,13 @@ function ensureJobsLeaseColumns(db) {
         db.exec("ALTER TABLE jobs ADD COLUMN lease_deadline INTEGER");
     }
 }
+function ensureJobsCompressResponseColumn(db) {
+    const cols = db.prepare("PRAGMA table_info(jobs)").all();
+    const names = new Set(cols.map(col => col?.name));
+    if (!names.has("compress_response")) {
+        db.exec("ALTER TABLE jobs ADD COLUMN compress_response INTEGER");
+    }
+}
 export function isValidationRunStore(store) {
     return (typeof store === "object" &&
         store !== null &&
@@ -143,6 +155,7 @@ export class SqliteJobStore {
         cli TEXT NOT NULL,
         args_json TEXT NOT NULL,
         output_format TEXT,
+        compress_response INTEGER,
         status TEXT NOT NULL,
         exit_code INTEGER,
         stdout TEXT,
@@ -216,6 +229,7 @@ export class SqliteJobStore {
         ensureJobsTransportColumns(this.db);
         ensureJobsLeaseColumns(this.db);
         this.db.exec("CREATE INDEX IF NOT EXISTS idx_jobs_owner_status ON jobs(owner_instance, status)");
+        ensureJobsCompressResponseColumn(this.db);
         if (process.platform !== "win32") {
             try {
                 chmodSync(dbPath, 0o600);
@@ -228,10 +242,12 @@ export class SqliteJobStore {
         this.leaseTtlMs = options.leaseTtlMs ?? DEFAULT_INSTANCE_LEASE_TTL_MS;
         this.insertStmt = this.db.prepare(`
       INSERT INTO jobs (id, correlation_id, request_key, cli, args_json, output_format,
+                        compress_response,
                         status, exit_code, stdout, stderr, output_truncated, error,
                         started_at, finished_at, pid, expires_at, owner_principal,
                         transport, http_status, payload_json, owner_instance, lease_deadline)
       VALUES (@id, @correlation_id, @request_key, @cli, @args_json, @output_format,
+              @compress_response,
               'queued', @exit_code, @stdout, @stderr, @output_truncated, @error,
               @started_at, @finished_at, @pid, @expires_at, @owner_principal,
               @transport, @http_status, @payload_json, @owner_instance,
@@ -332,6 +348,7 @@ export class SqliteJobStore {
             cli: input.cli,
             args_json: JSON.stringify(input.args),
             output_format: input.outputFormat ?? null,
+            compress_response: input.compressResponse === undefined ? null : input.compressResponse ? 1 : 0,
             exit_code: null,
             stdout: "",
             stderr: "",
@@ -624,6 +641,7 @@ export class MemoryJobStore {
             cli: input.cli,
             argsJson: JSON.stringify(input.args),
             outputFormat: input.outputFormat ?? null,
+            compressResponse: input.compressResponse ?? null,
             status: "queued",
             exitCode: null,
             stdout: "",
@@ -741,66 +759,153 @@ export class MemoryJobStore {
 }
 export class PostgresJobStore {
     logger;
-    worker;
-    tmpDir;
-    nextRequestId = 0;
+    worker = null;
+    retiringWorker = null;
+    intentionallyRetiredWorkers = new WeakSet();
+    workerTerminationPending = false;
     closed = false;
+    workerData;
     constructor(dsn, logger = noopLogger, options = {}) {
         this.logger = logger;
         if (!dsn) {
             throw new Error("PostgresJobStore requires a non-empty DSN");
         }
-        this.tmpDir = mkdtempSync(path.join(os.tmpdir(), "llm-gateway-pg-job-store-"));
-        this.worker = new Worker(resolvePostgresWorkerUrl(), {
-            execArgv: [],
-            workerData: {
-                dsn,
-                retentionMs: options.retentionMs ?? resolveJobRetentionMs(),
-                dedupWindowMs: options.dedupWindowMs ?? resolveDedupWindowMs(),
-                leaseTtlMs: options.leaseTtlMs ?? DEFAULT_INSTANCE_LEASE_TTL_MS,
-                farFutureIso: FAR_FUTURE_ISO,
-                connectionTimeoutMillis: 5000,
-            },
-        });
+        this.workerData = {
+            dsn,
+            retentionMs: options.retentionMs ?? resolveJobRetentionMs(),
+            dedupWindowMs: options.dedupWindowMs ?? resolveDedupWindowMs(),
+            leaseTtlMs: options.leaseTtlMs ?? DEFAULT_INSTANCE_LEASE_TTL_MS,
+            farFutureIso: FAR_FUTURE_ISO,
+            connectionTimeoutMillis: 5000,
+        };
         try {
-            this.syncCall("init");
+            this.ensureWorker();
         }
         catch (err) {
             this.closed = true;
-            void this.worker.terminate();
-            rmSync(this.tmpDir, { recursive: true, force: true });
+            this.retireWorker(this.worker);
             throw err;
         }
     }
+    createWorker() {
+        const worker = new Worker(resolvePostgresWorkerUrl(), {
+            execArgv: [],
+            workerData: this.workerData,
+        });
+        worker.on("message", message => {
+            if (!isPostgresWorkerDiagnostic(message))
+                return;
+            const error = new Error(message.message);
+            if (message.stack)
+                error.stack = message.stack;
+            this.logger.error(`PostgresJobStore worker ${message.kind}`, error);
+        });
+        worker.on("error", error => {
+            this.logger.error("PostgresJobStore worker crashed", error);
+            if (!this.closed && this.worker === worker)
+                this.retireWorker(worker);
+        });
+        worker.on("exit", code => {
+            const wasRetiring = this.retiringWorker === worker || this.intentionallyRetiredWorkers.has(worker);
+            if (this.worker === worker)
+                this.worker = null;
+            if (wasRetiring)
+                this.markWorkerRetired(worker);
+            if (this.closed || wasRetiring || code === 0)
+                return;
+            this.logger.error("PostgresJobStore worker exited unexpectedly", new Error(`PostgresJobStore worker exited with code ${code}`));
+        });
+        return worker;
+    }
     syncCall(method, ...args) {
-        if (this.closed && method !== "close") {
+        if (this.closed) {
             throw new Error("PostgresJobStore is closed");
         }
-        const shared = new SharedArrayBuffer(4);
-        const state = new Int32Array(shared);
-        const resultPath = path.join(this.tmpDir, `result-${process.pid}-${++this.nextRequestId}.json`);
-        this.worker.postMessage({ method, args, resultPath, shared });
-        const wait = Atomics.wait(state, 0, 0, method === "init" ? 10_000 : 30_000);
-        if (wait !== "ok" && wait !== "not-equal") {
-            throw new Error(`PostgresJobStore ${method} wait failed: ${wait}`);
+        const worker = this.ensureWorker();
+        return this.callWorker(worker, method, args);
+    }
+    ensureWorker() {
+        if (this.closed)
+            throw new Error("PostgresJobStore is closed");
+        if (this.worker)
+            return this.worker;
+        if (this.workerTerminationPending) {
+            throw new Error("PostgresJobStore is waiting for a failed worker to terminate before it can recover");
+        }
+        const worker = this.createWorker();
+        this.worker = worker;
+        try {
+            this.callWorker(worker, "init", []);
+            return worker;
         }
-        if (Atomics.load(state, 0) === 2) {
-            throw new Error(`PostgresJobStore ${method} worker could not write its result`);
+        catch (err) {
+            this.retireWorker(worker);
+            throw err;
         }
-        let payload;
+    }
+    callWorker(worker, method, args) {
+        const shared = new SharedArrayBuffer(4);
+        const state = new Int32Array(shared);
+        const { port1: workerPort, port2: responsePort } = new MessageChannel();
         try {
-            payload = JSON.parse(readFileSync(resultPath, "utf8"));
+            try {
+                worker.postMessage({ method, args, shared, responsePort: workerPort }, [workerPort]);
+            }
+            catch (err) {
+                throw this.retireAfterBridgeFailure(worker, `PostgresJobStore ${method} could not dispatch work to its worker`, err);
+            }
+            const timeoutMs = method === "init"
+                ? POSTGRES_WORKER_INITIALIZATION_TIMEOUT_MS
+                : POSTGRES_WORKER_OPERATION_TIMEOUT_MS;
+            const wait = Atomics.wait(state, 0, 0, timeoutMs);
+            if (wait === "timed-out") {
+                throw this.retireAfterBridgeFailure(worker, `PostgresJobStore ${method} timed out after ${timeoutMs}ms; the operation outcome is unknown`);
+            }
+            if (wait !== "ok" && wait !== "not-equal") {
+                throw this.retireAfterBridgeFailure(worker, `PostgresJobStore ${method} wait failed: ${wait}`);
+            }
+            if (Atomics.load(state, 0) !== 1) {
+                throw this.retireAfterBridgeFailure(worker, `PostgresJobStore ${method} worker response transport failed`);
+            }
+            const received = receiveMessageOnPort(responsePort);
+            if (!received || !isPostgresWorkerPayload(received.message)) {
+                throw this.retireAfterBridgeFailure(worker, `PostgresJobStore ${method} worker signalled without a valid response`);
+            }
+            const payload = received.message;
+            if (!payload.ok) {
+                const err = new Error(payload.error.message);
+                if (payload.error.stack)
+                    err.stack = payload.error.stack;
+                throw err;
+            }
+            return payload.value;
         }
         finally {
-            rmSync(resultPath, { force: true });
+            responsePort.close();
         }
-        if (!payload.ok) {
-            const err = new Error(payload.error.message);
-            if (payload.error.stack)
-                err.stack = payload.error.stack;
-            throw err;
-        }
-        return payload.value;
+    }
+    retireAfterBridgeFailure(worker, message, cause) {
+        this.retireWorker(worker);
+        return cause === undefined ? new Error(message) : new Error(message, { cause });
+    }
+    retireWorker(worker) {
+        if (!worker || this.retiringWorker === worker)
+            return;
+        if (this.worker === worker)
+            this.worker = null;
+        this.retiringWorker = worker;
+        this.intentionallyRetiredWorkers.add(worker);
+        this.workerTerminationPending = true;
+        void worker.terminate().then(() => this.markWorkerRetired(worker), error => {
+            this.logger.error("PostgresJobStore worker termination failed", error);
+            this.markWorkerRetired(worker);
+        });
+    }
+    markWorkerRetired(worker) {
+        if (this.retiringWorker !== worker)
+            return;
+        this.retiringWorker = null;
+        this.workerTerminationPending = false;
     }
     recordStart(input) {
         this.syncCall("recordStart", input);
@@ -883,19 +988,41 @@ export class PostgresJobStore {
     close() {
         if (this.closed)
             return;
+        const worker = this.worker;
         try {
-            this.syncCall("close");
+            if (worker)
+                this.callWorker(worker, "close", []);
         }
         catch (err) {
             this.logger.error("PostgresJobStore close failed", err);
         }
         finally {
             this.closed = true;
-            void this.worker.terminate();
-            rmSync(this.tmpDir, { recursive: true, force: true });
+            this.retireWorker(worker);
         }
     }
 }
+function isPostgresWorkerPayload(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const candidate = value;
+    if (candidate.ok === true)
+        return "value" in candidate;
+    if (!candidate.error || typeof candidate.error !== "object" || candidate.ok !== false)
+        return false;
+    const error = candidate.error;
+    return (typeof error.message === "string" &&
+        (error.stack === undefined || typeof error.stack === "string"));
+}
+function isPostgresWorkerDiagnostic(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const candidate = value;
+    return (candidate.type === "postgres-job-store-diagnostic" &&
+        typeof candidate.kind === "string" &&
+        typeof candidate.message === "string" &&
+        (candidate.stack === undefined || typeof candidate.stack === "string"));
+}
 function resolvePostgresWorkerUrl() {
     const sibling = new URL("./postgres-job-store-worker.js", import.meta.url);
     if (existsSync(fileURLToPath(sibling)))

package/dist/lcr-priors.d.ts

@@ -0,0 +1,60 @@
+import type { FlightRecorderQuery } from "./flight-recorder.js";
+import type { Confidence } from "./least-cost-types.js";
+import type { ContentType } from "./token-estimator.js";
+export type PriorsScope = "global" | "principal" | "off";
+export declare const CALIBRATION_K_MIN_SAMPLES = 5;
+export declare const CONFIDENCE_HIGH_MIN_SAMPLES = 30;
+export declare const CONFIDENCE_HIGH_MAX_SPREAD = 1.5;
+export declare const CONFIDENCE_MEDIUM_MIN_SAMPLES = 10;
+export declare const CONFIDENCE_MEDIUM_MAX_SPREAD = 3;
+export interface LcrPriorRow {
+    provider: string;
+    model: string;
+    prompt: string;
+    inputTokens: number | null;
+    outputTokens: number | null;
+    cacheReadTokens: number | null;
+    cacheCreationTokens: number | null;
+    costUsd: number | null;
+    costBasis: string | null;
+    routeEstCostUsd: number | null;
+    ownerPrincipal: string | null;
+    sessionContinued: boolean;
+}
+export interface OutputPrior {
+    median: number;
+    p90: number;
+    samples: number;
+}
+export interface CalibrationBucket {
+    k: number;
+    samples: number;
+    p10: number;
+    p50: number;
+    p90: number;
+    confidence: Confidence;
+}
+export interface AccuracyBucket {
+    provider: string;
+    model: string;
+    costBasis: string;
+    medianAccuracy: number;
+    samples: number;
+    p10: number;
+    p50: number;
+    p90: number;
+}
+export interface LcrPriors {
+    outputPriors: Map<string, OutputPrior>;
+    calibration: Map<string, CalibrationBucket>;
+    accuracyByBasis: Map<string, AccuracyBucket>;
+}
+export interface ComputeLcrPriorsOptions {
+    priorsScope: PriorsScope;
+    ownerPrincipal?: string;
+}
+export declare function confidenceFromQuality(samples: number, p10: number, p90: number): Confidence;
+export declare function lookupCalibrationK(priors: LcrPriors, contentType: ContentType, family: string): number;
+export declare function computeLcrPriors(rows: LcrPriorRow[], opts: ComputeLcrPriorsOptions): LcrPriors;
+export declare function loadLcrPriorRows(db: FlightRecorderQuery): LcrPriorRow[];
+export declare function computeLcrPriorsFromDb(db: FlightRecorderQuery, opts: ComputeLcrPriorsOptions): LcrPriors;

package/dist/lcr-priors.js

@@ -0,0 +1,190 @@
+import { estimateInputTokens, classifyContent } from "./token-estimator.js";
+import { modelIdToFamily } from "./pricing.js";
+export const CALIBRATION_K_MIN_SAMPLES = 5;
+export const CONFIDENCE_HIGH_MIN_SAMPLES = 30;
+export const CONFIDENCE_HIGH_MAX_SPREAD = 1.5;
+export const CONFIDENCE_MEDIUM_MIN_SAMPLES = 10;
+export const CONFIDENCE_MEDIUM_MAX_SPREAD = 3.0;
+function isFiniteNumber(n) {
+    return typeof n === "number" && Number.isFinite(n);
+}
+function num(n) {
+    return isFiniteNumber(n) ? n : 0;
+}
+function percentile(sortedAsc, q) {
+    const n = sortedAsc.length;
+    if (n === 0)
+        return 0;
+    if (n === 1)
+        return sortedAsc[0];
+    const idx = (n - 1) * q;
+    const lo = Math.floor(idx);
+    const hi = Math.ceil(idx);
+    const loVal = sortedAsc.at(lo) ?? 0;
+    const hiVal = sortedAsc.at(hi) ?? 0;
+    if (lo === hi)
+        return loVal;
+    return loVal + (hiVal - loVal) * (idx - lo);
+}
+const outputKey = (provider, model) => `${provider}:${model}`;
+const calibrationKey = (contentType, family) => `${contentType}:${family}`;
+const accuracyKey = (provider, model, costBasis) => `${provider}:${model}::${costBasis}`;
+function reconstructActualInput(row, family) {
+    const input = num(row.inputTokens);
+    if (family.startsWith("claude-")) {
+        return input + num(row.cacheReadTokens) + num(row.cacheCreationTokens);
+    }
+    return input;
+}
+export function confidenceFromQuality(samples, p10, p90) {
+    if (p10 <= 0)
+        return "low";
+    const spread = p90 / p10;
+    if (samples >= CONFIDENCE_HIGH_MIN_SAMPLES && spread <= CONFIDENCE_HIGH_MAX_SPREAD) {
+        return "high";
+    }
+    if (samples >= CONFIDENCE_MEDIUM_MIN_SAMPLES && spread <= CONFIDENCE_MEDIUM_MAX_SPREAD) {
+        return "medium";
+    }
+    return "low";
+}
+export function lookupCalibrationK(priors, contentType, family) {
+    const bucket = priors.calibration.get(calibrationKey(contentType, family));
+    if (!bucket)
+        return 1;
+    if (bucket.samples < CALIBRATION_K_MIN_SAMPLES)
+        return 1;
+    return bucket.k;
+}
+export function computeLcrPriors(rows, opts) {
+    const empty = {
+        outputPriors: new Map(),
+        calibration: new Map(),
+        accuracyByBasis: new Map(),
+    };
+    if (opts.priorsScope === "off")
+        return empty;
+    let scoped = rows;
+    if (opts.priorsScope === "principal") {
+        const owner = opts.ownerPrincipal;
+        if (owner === undefined)
+            return empty;
+        scoped = rows.filter(r => r.ownerPrincipal === owner);
+    }
+    const outputSamples = new Map();
+    const calibrationRatios = new Map();
+    const accuracyRatios = new Map();
+    for (const row of scoped) {
+        if (isFiniteNumber(row.outputTokens) && row.outputTokens >= 0) {
+            const key = outputKey(row.provider, row.model);
+            const arr = outputSamples.get(key) ?? [];
+            arr.push(row.outputTokens);
+            outputSamples.set(key, arr);
+        }
+        const family = modelIdToFamily(row.model);
+        if (family !== "unknown" && !row.sessionContinued && isFiniteNumber(row.inputTokens)) {
+            const base = estimateInputTokens(row.prompt, { family });
+            if (base > 0) {
+                const actual = reconstructActualInput(row, family);
+                const contentType = classifyContent(row.prompt);
+                const key = calibrationKey(contentType, family);
+                const arr = calibrationRatios.get(key) ?? [];
+                arr.push(actual / base);
+                calibrationRatios.set(key, arr);
+            }
+        }
+        if (isFiniteNumber(row.routeEstCostUsd) &&
+            isFiniteNumber(row.costUsd) &&
+            row.costUsd > 0 &&
+            row.costBasis) {
+            const key = accuracyKey(row.provider, row.model, row.costBasis);
+            const arr = accuracyRatios.get(key) ?? [];
+            arr.push(row.routeEstCostUsd / row.costUsd);
+            accuracyRatios.set(key, arr);
+        }
+    }
+    const outputPriors = new Map();
+    for (const [key, values] of outputSamples) {
+        values.sort((a, b) => a - b);
+        outputPriors.set(key, {
+            median: percentile(values, 0.5),
+            p90: percentile(values, 0.9),
+            samples: values.length,
+        });
+    }
+    const calibration = new Map();
+    for (const [key, values] of calibrationRatios) {
+        values.sort((a, b) => a - b);
+        const p10 = percentile(values, 0.1);
+        const p50 = percentile(values, 0.5);
+        const p90 = percentile(values, 0.9);
+        calibration.set(key, {
+            k: p50,
+            samples: values.length,
+            p10,
+            p50,
+            p90,
+            confidence: confidenceFromQuality(values.length, p10, p90),
+        });
+    }
+    const accuracyByBasis = new Map();
+    for (const [key, values] of accuracyRatios) {
+        values.sort((a, b) => a - b);
+        const sep = key.lastIndexOf("::");
+        const pm = key.slice(0, sep);
+        const costBasis = key.slice(sep + 2);
+        const colon = pm.indexOf(":");
+        const provider = pm.slice(0, colon);
+        const model = pm.slice(colon + 1);
+        accuracyByBasis.set(key, {
+            provider,
+            model,
+            costBasis,
+            medianAccuracy: percentile(values, 0.5),
+            samples: values.length,
+            p10: percentile(values, 0.1),
+            p50: percentile(values, 0.5),
+            p90: percentile(values, 0.9),
+        });
+    }
+    return { outputPriors, calibration, accuracyByBasis };
+}
+export function loadLcrPriorRows(db) {
+    const raw = db.queryRequests(`SELECT r.cli, r.model, r.prompt,
+            r.input_tokens, r.output_tokens,
+            r.cache_read_tokens, r.cache_creation_tokens,
+            r.cost_basis, r.owner_principal, r.session_id, r.datetime_utc,
+            m.cost_usd, m.route_est_cost_usd
+     FROM requests r
+     LEFT JOIN gateway_metadata m ON m.request_id = r.id
+     ORDER BY r.datetime_utc ASC`);
+    const seenMistralSessions = new Set();
+    return raw.map(row => {
+        let sessionContinued = false;
+        if (row.cli === "mistral" && row.session_id) {
+            if (seenMistralSessions.has(row.session_id)) {
+                sessionContinued = true;
+            }
+            else {
+                seenMistralSessions.add(row.session_id);
+            }
+        }
+        return {
+            provider: row.cli,
+            model: row.model,
+            prompt: row.prompt ?? "",
+            inputTokens: row.input_tokens,
+            outputTokens: row.output_tokens,
+            cacheReadTokens: row.cache_read_tokens,
+            cacheCreationTokens: row.cache_creation_tokens,
+            costUsd: row.cost_usd,
+            costBasis: row.cost_basis,
+            routeEstCostUsd: row.route_est_cost_usd,
+            ownerPrincipal: row.owner_principal,
+            sessionContinued,
+        };
+    });
+}
+export function computeLcrPriorsFromDb(db, opts) {
+    return computeLcrPriors(loadLcrPriorRows(db), opts);
+}

package/dist/lcr-router-env.d.ts

@@ -0,0 +1,20 @@
+import { type JobLimiterSnapshot } from "./async-job-manager.js";
+import { type LcrPriors, type PriorsScope } from "./lcr-priors.js";
+import type { FlightRecorderQuery } from "./flight-recorder.js";
+import type { PerformanceMetrics } from "./metrics.js";
+import type { ApiProviderRuntime, LeastCostConfig } from "./config.js";
+import type { RouterEnv, RouterConfig } from "./least-cost-router.js";
+export interface RouterEnvDeps {
+    performanceMetrics: PerformanceMetrics;
+    limiterSnapshot: JobLimiterSnapshot;
+    apiProviders: readonly ApiProviderRuntime[];
+    isAuthed?: (provider: string) => boolean;
+    preferCatalogPrice?: boolean;
+    flightRecorder?: FlightRecorderQuery;
+    priorsScope?: PriorsScope;
+    ownerPrincipal?: string;
+    priors?: LcrPriors;
+}
+export declare function resetLcrPriorsCacheForTest(): void;
+export declare function buildRouterEnv(deps: RouterEnvDeps): RouterEnv;
+export declare function toRouterConfig(cfg: LeastCostConfig): RouterConfig;