auto-model-router 0.30.3 → 0.32.0

package/src/cost/blended.ts

@@ -26,6 +26,13 @@ const OUTPUT_TO_INPUT_PRIOR = 5;
 const CACHE_READ_TO_INPUT_PRIOR = 0.1;
 const CACHE_WRITE_TO_INPUT_PRIOR = 1.25;
 
+/** One window row, already parsed, whichever engine produced it. */
+export interface BlendSample {
+	usage: UsageCounts;
+	reportedUsd: number;
+	breakdown: CostBreakdown;
+}
+
 export function computeBlendedRate(db: Database, cfg: RouterConfig, windowDays: number): BlendedRate | null {
 	const sinceMs = Date.now() - windowDays * 86_400_000;
 	// We own the schema; row shape fixed by util/sqlite.ts and cost/ledger.ts.
@@ -35,7 +42,23 @@ export function computeBlendedRate(db: Database, cfg: RouterConfig, windowDays:
 			 WHERE created_at_ms >= ? AND reported_usd IS NOT NULL AND cost_breakdown IS NOT NULL`,
 		)
 		.all(sinceMs) as BlendRow[];
+	return foldBlendSamples(
+		rows.map((row) => ({
+			usage: JSON.parse(row.usage) as UsageCounts,
+			reportedUsd: row.reported_usd,
+			breakdown: JSON.parse(row.cost_breakdown) as CostBreakdown,
+		})),
+		cfg,
+		windowDays,
+	);
+}
 
+/**
+ * The apportioning itself, over already-parsed rows. Pure so both the local
+ * and the shared-database ledger produce the same blend from the same window
+ * instead of each carrying a copy of the arithmetic.
+ */
+export function foldBlendSamples(samples: readonly BlendSample[], cfg: RouterConfig, windowDays: number): BlendedRate | null {
 	let sampleCount = 0;
 	let inputUsd = 0;
 	let inputTokens = 0;
@@ -46,22 +69,20 @@ export function computeBlendedRate(db: Database, cfg: RouterConfig, windowDays:
 	let cacheWriteUsd = 0;
 	let cacheWriteTokens = 0;
 
-	for (const row of rows) {
-		const usage = JSON.parse(row.usage) as UsageCounts;
-		const split = JSON.parse(row.cost_breakdown) as CostBreakdown;
+	for (const { usage, reportedUsd, breakdown: split } of samples) {
 		const tokenSplit = split.freshPrompt + split.cacheRead + split.cacheWrite + split.completion + split.reasoning;
 		// Entries whose usage produced no token-billed cost (pure image/request
 		// billing) carry no price signal per token; skip them.
 		if (tokenSplit <= 0) continue;
 		const freshTokens = Math.max(usage.promptTokens - usage.cachedTokens - usage.cacheWriteTokens, 0);
 
-		inputUsd += (row.reported_usd * split.freshPrompt) / tokenSplit;
+		inputUsd += (reportedUsd * split.freshPrompt) / tokenSplit;
 		inputTokens += freshTokens;
-		outputUsd += (row.reported_usd * (split.completion + split.reasoning)) / tokenSplit;
+		outputUsd += (reportedUsd * (split.completion + split.reasoning)) / tokenSplit;
 		outputTokens += usage.completionTokens;
-		cacheReadUsd += (row.reported_usd * split.cacheRead) / tokenSplit;
+		cacheReadUsd += (reportedUsd * split.cacheRead) / tokenSplit;
 		cacheReadTokens += usage.cachedTokens;
-		cacheWriteUsd += (row.reported_usd * split.cacheWrite) / tokenSplit;
+		cacheWriteUsd += (reportedUsd * split.cacheWrite) / tokenSplit;
 		cacheWriteTokens += usage.cacheWriteTokens;
 		sampleCount += 1;
 	}

package/src/cost/feedback.ts

@@ -7,7 +7,7 @@
  * judged, so it aggregates by served model, tier and task.
  */
 
-import type { Database } from "bun:sqlite";
+import { num, type SqlDb } from "../util/sql.ts";
 
 export type Verdict = "good" | "bad";
 
@@ -25,57 +25,53 @@ export interface FeedbackCounts {
 	bad: number;
 }
 
+/** Asynchronous throughout: the store may be a shared database, not a file. */
 export interface FeedbackStore {
-	record(rec: FeedbackRecord, nowMs?: number): string;
+	record(rec: FeedbackRecord, nowMs?: number): Promise<string>;
 	/** Verdict counts per served slug since `sinceMs`. */
-	countsBySlug(sinceMs: number, harnessId?: string): Map<string, FeedbackCounts>;
+	countsBySlug(sinceMs: number, harnessId?: string): Promise<Map<string, FeedbackCounts>>;
 	/** Verdicts for one ledger row (a user may re-judge). */
-	forLedgerId(ledgerId: string): Array<{ verdict: Verdict; note: string; createdAtMs: number }>;
+	forLedgerId(ledgerId: string): Promise<Array<{ verdict: Verdict; note: string; createdAtMs: number }>>;
 }
 
-export function createFeedbackStore(db: Database): FeedbackStore {
-	const insert = db.query(
-		`INSERT INTO feedback (id, ledger_id, omp_session_id, slug, tier, verdict, note, created_at_ms)
-		 VALUES ($id, $ledgerId, $ompSessionId, $slug, $tier, $verdict, $note, $createdAtMs)`,
-	);
-	const bySlug = db.query(
-		`SELECT f.slug, f.verdict, COUNT(*) AS n FROM feedback f
-		 LEFT JOIN ledger l ON l.id = f.ledger_id
-		 WHERE f.created_at_ms >= $since AND ($harness = '' OR l.harness_id = $harness)
-		 GROUP BY f.slug, f.verdict`,
-	);
-	const forRow = db.query("SELECT verdict, note, created_at_ms FROM feedback WHERE ledger_id = ? ORDER BY created_at_ms DESC");
+export function createFeedbackStore(db: SqlDb): FeedbackStore {
+	const { sql } = db;
 	return {
-		record(rec, nowMs = Date.now()) {
+		async record(rec, nowMs = Date.now()) {
 			const id = crypto.randomUUID();
-			insert.run({
-				$id: id,
-				$ledgerId: rec.ledgerId,
-				$ompSessionId: rec.ompSessionId,
-				$slug: rec.slug,
-				$tier: rec.tier,
-				$verdict: rec.verdict,
-				$note: rec.note.slice(0, 500),
-				$createdAtMs: nowMs,
-			});
+			await sql`
+				INSERT INTO feedback (id, ledger_id, omp_session_id, slug, tier, verdict, note, created_at_ms)
+				VALUES (${id}, ${rec.ledgerId}, ${rec.ompSessionId}, ${rec.slug}, ${rec.tier}, ${rec.verdict},
+					${rec.note.slice(0, 500)}, ${nowMs})`;
 			return id;
 		},
-		countsBySlug(sinceMs, harnessId = "") {
+
+		async countsBySlug(sinceMs, harnessId = "") {
 			const out = new Map<string, FeedbackCounts>();
-			for (const r of bySlug.all({ $since: sinceMs, $harness: harnessId }) as { slug: string; verdict: string; n: number }[]) {
+			// An empty harness means "every harness"; the join only matters when
+			// scoping, because the judging harness lives on the ledger row.
+			const rows = await db.query<{ slug: string; verdict: string; n: unknown }>(
+				`SELECT f.slug, f.verdict, COUNT(*) AS n FROM feedback f
+				 LEFT JOIN ledger l ON l.id = f.ledger_id
+				 WHERE f.created_at_ms >= $since AND ($harness = '' OR l.harness_id = $harness)
+				 GROUP BY f.slug, f.verdict`,
+				{ since: sinceMs, harness: harnessId },
+			);
+			for (const r of rows) {
 				const c = out.get(r.slug) ?? { good: 0, bad: 0 };
-				if (r.verdict === "good") c.good += r.n;
-				else c.bad += r.n;
+				if (r.verdict === "good") c.good += num(r.n);
+				else c.bad += num(r.n);
 				out.set(r.slug, c);
 			}
 			return out;
 		},
-		forLedgerId(ledgerId) {
-			return (forRow.all(ledgerId) as { verdict: Verdict; note: string; created_at_ms: number }[]).map((r) => ({
-				verdict: r.verdict,
-				note: r.note,
-				createdAtMs: r.created_at_ms,
-			}));
+
+		async forLedgerId(ledgerId) {
+			const rows = await db.query<{ verdict: Verdict; note: string; created_at_ms: unknown }>(
+				"SELECT verdict, note, created_at_ms FROM feedback WHERE ledger_id = $id ORDER BY created_at_ms DESC",
+				{ id: ledgerId },
+			);
+			return rows.map((r) => ({ verdict: r.verdict, note: r.note, createdAtMs: num(r.created_at_ms) }));
 		},
 	};
 }