auto-model-router 0.4.13 → 0.5.0

package/.omp-plugin/marketplace.json

@@ -7,14 +7,14 @@
   },
   "metadata": {
     "description": "auto-model-router: a local cost/complexity-aware model router for Oh My Pi, backed by OpenRouter",
-    "version": "0.4.13",
+    "version": "0.5.0",
     "pluginRoot": "."
   },
   "plugins": [
     {
       "name": "auto-model-router",
       "description": "Local cost/complexity-aware model router for Oh My Pi, backed by OpenRouter. Runs in-process, routes per turn by price and task complexity, with budget caps, mid-stream escalation, and cache-aware hysteresis.",
-      "version": "0.4.13",
+      "version": "0.5.0",
       "author": {
         "name": "drewappling",
         "email": "drewappling@gmail.com"

package/README.md

@@ -706,6 +706,12 @@ escalation signal, error. Three views aggregate it, all from the same
   transcript. Falls back to reading the ledger directly if the router is
   unreachable.
 - `auto-model-router report --days 7 [--harness <id>] [--json]` on the terminal.
+- `auto-model-router export --days 30 [--harness a,b] [--json]`: one row per day, harness
+  and model (dispatches, tokens, spend, escalations, errors) as CSV. Also
+  `GET /v1/router/export?days=&harness=[&format=json]`; `GET /v1/router/spend?sinceMs=&harness=`
+  gives spend over a harness set since an instant, and `GET /v1/router/feedback?days=&harness=`
+  lists verdicts by model and the recent ones with the harness that gave them. These are what
+  a front door such as the team edition reads instead of the ledger file.
 - `GET /v1/router/report?days=7&harness=<id>` for dashboards (`harness` may be
   a comma-separated set of ids, for a group).
 - `GET /v1/router/summary?harness=<id>` — the daily summary as JSON (`auto=1`
@@ -1178,6 +1184,51 @@ text, not the conversation, so a hard task that only becomes hard three tool
 calls in stays on the router (the router's own escalation still applies
 there); and the switch happens at prompt boundaries, never mid-turn.
 
+## Claude Code (Anthropic Messages API)
+
+The router also speaks the Anthropic Messages API, which is the only wire Claude Code
+uses. Point Claude Code at the router and every turn is routed like any other harness's,
+to OpenRouter, Ollama Cloud, or whatever upstream is configured:
+
+```bash
+export ANTHROPIC_BASE_URL=http://127.0.0.1:8788
+export ANTHROPIC_API_KEY=<server.apiKey, or any string when the router has no key>
+claude
+```
+
+`POST /v1/messages` (streaming and not) and `POST /v1/messages/count_tokens` are served;
+the key may arrive as `x-api-key` or as a bearer. Claude Code asks for `claude-*` model
+names, which `anthropic.models` maps to profiles (first matching glob wins):
+
+```yaml
+anthropic:
+  models:
+    "*haiku*": auto-cheap     # Claude Code's background chores
+    "claude-*": auto          # real turns; try auto-max for an opus-only feel
+```
+
+Profile ids pass through, so `ANTHROPIC_MODEL=auto-max` works too. The harness id defaults
+to `claude-code` (from the user agent) and the session id is taken from the `metadata`
+Claude Code sends, so reports, budgets and the team edition see it like any other harness.
+
+What is translated: system prompts (string or blocks), text, image, `tool_use` and
+`tool_result` blocks, custom tools and `tool_choice` (including
+`disable_parallel_tool_use`), `stop_sequences`, `thinking` budgets and `output_config.effort`
+(as reasoning effort), and back: text, `tool_use` and `thinking` blocks, the four stop
+reasons, and usage with cache read and cache creation counts. The routing summary rides on
+`message_delta` as `x_auto_model_router`.
+
+Not available through the router: Anthropic server-side tools (web search, web fetch, code
+execution) and Anthropic-schema client tools (`bash_*`, `text_editor_*`) are dropped from
+the tool list, since no upstream serves them; thinking blocks come back unsigned and are
+dropped again on replay; `count_tokens` is the router's own estimate. Client `cache_control`
+markers are replaced by the router's own breakpoint plan.
+
+Claude Code prices its own cost line from the Claude model name it asked for, so the
+figure it shows is not what was spent; the router's ledger (`/router report`, the team
+edition) is. Verified with Claude Code 2.1.263 headless (`claude -p` with the Read tool)
+routed to a DeepSeek model; the captured request is `test/fixtures/harness/claude-code.json`.
+
 ## Per-request routing policy
 
 A front door in front of the router (the team edition, or any proxy that
@@ -1223,6 +1274,7 @@ plus a harness header; the rest needs the harness's own hook API.
 | Harness | Wire | Harness id | Session id | Subagent flag | Toast | `/router` | Digest | Daily summary | Model switch |
 | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
 | omp | native provider | yes | yes | yes | yes | full hub | yes | yes | experimental |
+| Claude Code | Anthropic Messages (`/v1/messages`) | derived (`claude-code`) | from `metadata` | no | no | no | no | no | no |
 | Hermes | provider plugin | yes | yes (native plugin) | yes (native plugin) | no | text | yes (native plugin) | on demand | no |
 | Codex CLI | Responses API wire | yes | yes (from body) | yes (from body) | no | no | compaction only | no | no |
 | Aider | config only | via model settings | no | no | no | no | no tools | no | no |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "auto-model-router",
-  "version": "0.4.13",
+  "version": "0.5.0",
   "private": false,
   "description": "Local cost/complexity-aware model router for Oh My Pi, backed by OpenRouter",
   "type": "module",

package/src/cli/args.ts

@@ -30,6 +30,7 @@ const COMMANDS: Record<string, true> = {
 	serve: true,
 	stats: true,
 	report: true,
+	export: true,
 	models: true,
 	explain: true,
 	config: true,

package/src/cli/config-wizard.ts

@@ -335,6 +335,13 @@ export const WIZARD_SECTIONS: readonly SectionSpec[] = [
 			{ path: "report.dailySummary", label: "Daily summary at session start", kind: "boolean" },
 		],
 	},
+	{
+		title: "Claude Code (Anthropic Messages wire)",
+		fields: [
+			{ path: "anthropic.models.*haiku*", label: "Model names matching *haiku* route to profile", kind: "string", optional: true, hint: "e.g. auto-cheap" },
+			{ path: "anthropic.models.claude-*", label: "Model names matching claude-* route to profile", kind: "string", optional: true, hint: "e.g. auto or auto-max" },
+		],
+	},
 	{
 		title: "Harness switch",
 		fields: [

package/src/cli/export.ts

@@ -0,0 +1,29 @@
+/**
+ * `auto-model-router export`: the ledger as one row per day, harness and
+ * model (dispatches, tokens, spend, escalations, errors), CSV by default or
+ * `--json`. The same rows back `GET /v1/router/export`.
+ */
+
+import { existsSync } from "node:fs";
+import { Database } from "bun:sqlite";
+import { loadConfig } from "../config/load.ts";
+import { exportCsv, exportRows } from "../cost/views.ts";
+import { configOpts, flagInt, flagString, type CliArgs } from "./args.ts";
+
+export async function exportCommand(args: CliArgs): Promise<void> {
+	const days = flagInt(args, "days") ?? 30;
+	const harness = flagString(args, "harness") ?? "";
+	const cfg = loadConfig(configOpts(args));
+	if (!existsSync(cfg.ledger.path)) {
+		process.stdout.write(args.flags.has("json") ? "[]\n" : exportCsv([]));
+		return;
+	}
+	// Read-only: an export must never create or migrate the ledger.
+	const db = new Database(cfg.ledger.path, { readonly: true });
+	try {
+		const rows = exportRows(db, Date.now() - days * 86_400_000, harness === "" ? null : harness.split(",").map((s) => s.trim()).filter((s) => s !== ""));
+		process.stdout.write(args.flags.has("json") ? `${JSON.stringify(rows, null, 2)}\n` : exportCsv(rows));
+	} finally {
+		db.close();
+	}
+}

package/src/config/defaults.ts

@@ -335,6 +335,10 @@ export const DEFAULT_CONFIG: RouterConfig = {
 		// One transcript message per day, at the first interactive session start.
 		dailySummary: true,
 	},
+	anthropic: {
+		// haiku is what Claude Code uses for background chores; everything else is a real turn.
+		models: { "*haiku*": "auto-cheap", "claude-*": "auto" },
+	},
 	harnessSwitch: {
 		// Off: moving the harness's own model is a visible change the operator opts into.
 		enabled: false,

package/src/config/schema.ts

@@ -277,6 +277,7 @@ export const configInputSchema = z.strictObject({
 	budget: budget.optional(),
 	profiles: z.array(profile).optional(),
 	report: z.strictObject({ baselines: z.array(z.string()).optional(), dailySummary: z.boolean().optional() }).optional(),
+	anthropic: z.object({ models: z.record(z.string(), z.string()).optional() }).strict().optional(),
 	harnessSwitch: z
 		.strictObject({
 			enabled: z.boolean().optional(),

package/src/config/types.ts

@@ -620,6 +620,16 @@ export interface ReportConfig {
  * each user prompt and the harness moves its own active model to a
  * harness-native one for the mapped tiers. See omp-extension/router-switch.ts.
  */
+/** The Anthropic Messages wire (`POST /v1/messages`, Claude Code). */
+export interface AnthropicConfig {
+	/**
+	 * Which router profile a Messages `model` name means, first matching glob
+	 * wins. Claude Code asks for `claude-*` names; unmatched names pass through
+	 * so profile ids (`auto`, `auto-max`) still work.
+	 */
+	models: Record<string, string>;
+}
+
 export interface HarnessSwitchConfig {
 	enabled: boolean;
 	/**
@@ -830,6 +840,7 @@ export interface RouterConfig {
 	report: ReportConfig;
 	digest: DigestConfig;
 	harnessSwitch: HarnessSwitchConfig;
+	anthropic: AnthropicConfig;
 	profiles: ProfileConfig[];
 	ledger: LedgerConfig;
 	/**

package/src/cost/views.ts

@@ -0,0 +1,153 @@
+/**
+ * Ledger views that a front door (the team edition, a dashboard, a script)
+ * needs at a scope the report does not offer: spend since an instant over a
+ * set of harnesses, feedback verdicts with the harness that gave them, and a
+ * cost export by day, harness and model. Served by `/v1/router/spend`,
+ * `GET /v1/router/feedback` and `/v1/router/export`, exported from lib.ts, and
+ * behind `auto-model-router export`. All of them read only long-stable ledger
+ * columns and accept a read-only database handle.
+ */
+
+import type { Database } from "bun:sqlite";
+import { harnessFilter } from "./report.ts";
+
+/** `null` means every harness; an empty set matches nothing. */
+export type HarnessScope = readonly string[] | null;
+
+export interface FeedbackRow {
+	atMs: number;
+	slug: string;
+	tier: string;
+	verdict: "good" | "bad";
+	note: string;
+	/** The harness id of the judged turn (a team user id), or empty. */
+	harnessId: string;
+}
+
+export interface FeedbackByModel {
+	slug: string;
+	good: number;
+	bad: number;
+	/** Distinct harness ids that judged this model. */
+	judges: number;
+}
+
+export interface FeedbackView {
+	byModel: FeedbackByModel[];
+	recent: FeedbackRow[];
+}
+
+export interface ExportRow {
+	day: string;
+	harnessId: string;
+	slug: string;
+	provider: string;
+	dispatches: number;
+	promptTokens: number;
+	cachedTokens: number;
+	completionTokens: number;
+	spendUsd: number;
+	escalations: number;
+	errors: number;
+}
+
+const USD = "COALESCE(reported_usd, predicted_usd)";
+
+function scope(harness: HarnessScope, column: string): { sql: string[]; bind: Record<string, string> } | null {
+	if (harness === null) return { sql: [], bind: {} };
+	if (harness.length === 0) return null;
+	const f = harnessFilter(harness.join(","));
+	return { sql: f.sql.map((s) => s.replace(/^harness_id/, column)), bind: f.bind };
+}
+
+/** Spend (reported where present, predicted otherwise) since `sinceMs`, digest calls included as the ledger counts them. */
+export function spendUsdSince(db: Database, sinceMs: number, harness: HarnessScope): number {
+	const s = scope(harness, "harness_id");
+	if (s === null) return 0;
+	const where = ["created_at_ms >= $since", ...s.sql].join(" AND ");
+	const row = db.query(`SELECT COALESCE(SUM(${USD}), 0) AS usd FROM ledger WHERE ${where}`).get({ $since: sinceMs, ...s.bind }) as { usd: number };
+	return row.usd;
+}
+
+/** Verdicts since `sinceMs`, by model and the most recent 200, joined to the ledger for the judging harness. */
+export function feedbackView(db: Database, sinceMs: number, harness: HarnessScope): FeedbackView {
+	const exists = (db.query("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'feedback'").get() as { name: string } | null) !== null;
+	if (!exists) return { byModel: [], recent: [] };
+	const s = scope(harness, "l.harness_id");
+	if (s === null) return { byModel: [], recent: [] };
+	const where = ["f.created_at_ms >= $since", ...s.sql].join(" AND ");
+	const bind = { $since: sinceMs, ...s.bind };
+	const recent = (
+		db.query(`SELECT f.created_at_ms AS at_ms, f.slug, f.tier, f.verdict, f.note, COALESCE(l.harness_id, '') AS harness_id FROM feedback f LEFT JOIN ledger l ON l.id = f.ledger_id WHERE ${where} ORDER BY f.created_at_ms DESC LIMIT 200`).all(bind) as {
+			at_ms: number;
+			slug: string;
+			tier: string;
+			verdict: string;
+			note: string;
+			harness_id: string;
+		}[]
+	).map((r) => ({ atMs: r.at_ms, slug: r.slug, tier: r.tier, verdict: (r.verdict === "good" ? "good" : "bad") as "good" | "bad", note: r.note, harnessId: r.harness_id }));
+	const byModel = (
+		db
+			.query(
+				`SELECT f.slug, SUM(CASE WHEN f.verdict = 'good' THEN 1 ELSE 0 END) AS good, SUM(CASE WHEN f.verdict = 'bad' THEN 1 ELSE 0 END) AS bad, COUNT(DISTINCT COALESCE(l.harness_id, '')) AS judges
+				 FROM feedback f LEFT JOIN ledger l ON l.id = f.ledger_id WHERE ${where} GROUP BY f.slug ORDER BY bad DESC, good DESC, f.slug ASC`,
+			)
+			.all(bind) as { slug: string; good: number; bad: number; judges: number }[]
+	).map((r) => ({ slug: r.slug, good: r.good, bad: r.bad, judges: r.judges }));
+	return { byModel, recent };
+}
+
+/** One row per UTC day, harness and served model since `sinceMs`; digest calls are excluded as in the report. */
+export function exportRows(db: Database, sinceMs: number, harness: HarnessScope): ExportRow[] {
+	const s = scope(harness, "harness_id");
+	if (s === null) return [];
+	const where = ["created_at_ms >= $since", "requested_model <> 'digest'", ...s.sql].join(" AND ");
+	const rows = db
+		.query(
+			`SELECT strftime('%Y-%m-%d', created_at_ms / 1000, 'unixepoch') AS day, harness_id, COALESCE(served_slug, slug) AS slug,
+				COUNT(*) AS dispatches,
+				COALESCE(SUM(json_extract(usage, '$.promptTokens')), 0) AS prompt_tokens,
+				COALESCE(SUM(json_extract(usage, '$.cachedTokens')), 0) AS cached_tokens,
+				COALESCE(SUM(json_extract(usage, '$.completionTokens')), 0) AS completion_tokens,
+				COALESCE(SUM(${USD}), 0) AS spend,
+				SUM(CASE WHEN escalation_signal IS NOT NULL THEN 1 ELSE 0 END) AS escalations,
+				SUM(CASE WHEN error IS NOT NULL THEN 1 ELSE 0 END) AS errors
+			 FROM ledger WHERE ${where} GROUP BY day, harness_id, slug ORDER BY day ASC, harness_id ASC, spend DESC`,
+		)
+		.all({ $since: sinceMs, ...s.bind }) as { day: string; harness_id: string; slug: string; dispatches: number; prompt_tokens: number; cached_tokens: number; completion_tokens: number; spend: number; escalations: number; errors: number }[];
+	return rows.map((r) => ({
+		day: r.day,
+		harnessId: r.harness_id,
+		slug: r.slug,
+		provider: r.slug.startsWith("ollama/") ? "ollama" : "openrouter",
+		dispatches: r.dispatches,
+		promptTokens: r.prompt_tokens,
+		cachedTokens: r.cached_tokens,
+		completionTokens: r.completion_tokens,
+		spendUsd: r.spend,
+		escalations: r.escalations,
+		errors: r.errors,
+	}));
+}
+
+export const EXPORT_COLUMNS = ["day", "harness", "model", "provider", "dispatches", "prompt_tokens", "cached_tokens", "completion_tokens", "spend_usd", "escalations", "errors"] as const;
+
+export function csvCell(v: string | number): string {
+	const s = String(v);
+	return /[",\n\r]/.test(s) ? `"${s.replaceAll('"', '""')}"` : s;
+}
+
+/** CSV of export rows; spend to 6 decimals so sub-cent rows survive. */
+export function exportCsv(rows: readonly ExportRow[]): string {
+	const lines = [EXPORT_COLUMNS.join(",")];
+	for (const r of rows) lines.push([r.day, r.harnessId, r.slug, r.provider, r.dispatches, r.promptTokens, r.cachedTokens, r.completionTokens, r.spendUsd.toFixed(6), r.escalations, r.errors].map(csvCell).join(","));
+	return `${lines.join("\n")}\n`;
+}
+
+/** `?harness=a,b` → scope; absent or empty → everything. */
+export function harnessScopeParam(raw: string | null): HarnessScope {
+	if (raw === null) return null;
+	const ids = raw.split(",").map((s) => s.trim()).filter((s) => s !== "");
+	return ids.length === 0 ? null : ids;
+}

package/src/index.ts

@@ -11,6 +11,7 @@ import { join } from "node:path";
 import { parseArgv } from "./cli/args.ts";
 import { configCommand } from "./cli/config-cmd.ts";
 import { explainCommand } from "./cli/explain.ts";
+import { exportCommand } from "./cli/export.ts";
 import { modelsCommand } from "./cli/models.ts";
 import { reportCommand } from "./cli/report.ts";
 import { serveCommand } from "./cli/serve.ts";
@@ -23,6 +24,7 @@ Usage: auto-model-router <command> [options]
   serve      Run the router as a standalone process (for non-omp harnesses)
   stats      Show routed spend, per-model share, and escalation rates
   report     Usage analytics: providers, models, tiers, cost, speed, cache hit rate
+  export     One row per day, harness and model as CSV (--json for rows)
   models     Show what each complexity tier would consider, and why
   explain    Route a saved request without dispatching it, and explain the decision
   config     Interactive wizard over the router's own config.yml
@@ -73,6 +75,9 @@ async function main(): Promise<number> {
 		case "report":
 			await reportCommand(args);
 			return 0;
+		case "export":
+			await exportCommand(args);
+			return 0;
 		case "models":
 			await modelsCommand(args);
 			return 0;

package/src/lib.ts

@@ -19,6 +19,7 @@ export type { RouterConfig } from "./config/types.ts";
 export { buildUsageReport, renderUsageReport, type UsageReport, type ReportTotals } from "./cost/report.ts";
 export { buildDailySummary, renderDailySummary, type DailySummary } from "./cost/summary.ts";
 export { openDb } from "./util/sqlite.ts";
+export { spendUsdSince, feedbackView, exportRows, exportCsv, harnessScopeParam, type HarnessScope, type ExportRow, type FeedbackRow, type FeedbackByModel, type FeedbackView } from "./cost/views.ts";
 export { createLedger } from "./cost/ledger.ts";
 export { createFeedbackStore, type FeedbackStore, type FeedbackRecord } from "./cost/feedback.ts";
 export type { RequestPolicy } from "./wire/types.ts";

package/src/server/http.ts

@@ -10,6 +10,8 @@ import { createDigester } from "./digest.ts";
 import { advise } from "./advise.ts";
 import { TIER_ORDER, type Tier } from "../router/types.ts";
 import { baselinePrices, buildUsageReport, renderUsageReport } from "../cost/report.ts";
+import { exportCsv, exportRows, feedbackView, harnessScopeParam, spendUsdSince } from "../cost/views.ts";
+import { anthropicErrorResponse, countAnthropicTokens, createMessagesWire } from "../wire/anthropic/messages.ts";
 import { buildDailySummary, createKv, markSummaryShown, renderDailySummary, summaryDue, summaryHasNews, type SummaryOllama } from "../cost/summary.ts";
 import type { Ledger, ModelTrust } from "../cost/types.ts";
 import { createRouter } from "../router/index.ts";
@@ -186,6 +188,12 @@ function isLoopbackHostHeader(hostHeader: string | null): boolean {
 	return host === "127.0.0.1" || host === "localhost" || host === "::1" || host === "[::1]";
 }
 
+/** `?days=` bounded to [1, 365], `dflt` when absent or unparsable. */
+function clampDays(raw: string | null, dflt: number): number {
+	const n = raw === null ? dflt : Number.parseInt(raw, 10);
+	return Number.isInteger(n) ? Math.min(Math.max(n, 1), 365) : dflt;
+}
+
 export function startServer(cfg: RouterConfig): StartedServer {
 	const log = createLogger(cfg.logLevel);
 
@@ -327,9 +335,12 @@ export function startServer(cfg: RouterConfig): StartedServer {
 		parse(body: unknown, headers: Headers): NormRequest;
 		streaming(model: string): { sink: ResponseSink; response: Response };
 		buffered(model: string): { sink: ResponseSink; response: Promise<Response> };
+		/** How a failure before the sink exists is rendered; the OpenAI envelope when absent. */
+		error?: (err: WireError) => Response;
 	}
 	const CHAT_WIRE: Wire = { parse: parseChatRequest, streaming: createStreamingSink, buffered: createBufferedSink };
 	const RESPONSES_WIRE: Wire = { parse: parseResponsesRequest, streaming: createResponsesStreamingSink, buffered: createResponsesBufferedSink };
+	const MESSAGES_WIRE: Wire = createMessagesWire(cfg.anthropic.models);
 
 	const handleTurn = async (req: Request, wire: Wire): Promise<Response> => {
 		let normReq: NormRequest;
@@ -340,8 +351,9 @@ export function startServer(cfg: RouterConfig): StartedServer {
 			// runTurn's `finally`, so it must be released here or every malformed
 			// request permanently consumes one of maxConcurrentTurns.
 			releaseTurn();
-			if (err instanceof WireErrorException) return wireErrorResponse(err.wireError);
-			return wireErrorResponse({
+			const render = wire.error ?? wireErrorResponse;
+			if (err instanceof WireErrorException) return render(err.wireError);
+			return render({
 				status: 400,
 				code: "invalid_json",
 				message: err instanceof Error ? err.message : "request body is not valid JSON",
@@ -395,13 +407,15 @@ export function startServer(cfg: RouterConfig): StartedServer {
 				return wireErrorResponse({ status: 403, code: "forbidden", message: "invalid host" });
 			}
 
+			const url = new URL(req.url);
+			// The Messages wire renders its own error envelope; everything else speaks OpenAI's.
+			const errorResponse = url.pathname.startsWith("/v1/messages") ? anthropicErrorResponse : wireErrorResponse;
 			if (cfg.server.apiKey !== undefined && cfg.server.apiKey !== "") {
-				if (req.headers.get("authorization") !== `Bearer ${cfg.server.apiKey}`) {
-					return wireErrorResponse({ status: 401, code: "unauthorized", message: "invalid or missing bearer token" });
-				}
+				// Anthropic clients (Claude Code) present the key as x-api-key rather than a bearer.
+				const presented = req.headers.get("authorization") === `Bearer ${cfg.server.apiKey}` || req.headers.get("x-api-key") === cfg.server.apiKey;
+				if (!presented) return errorResponse({ status: 401, code: "unauthorized", message: "invalid or missing API key" });
 			}
 
-			const url = new URL(req.url);
 			try {
 				if (req.method === "POST" && url.pathname === "/v1/chat/completions") {
 					if (!acquireTurn()) {
@@ -416,18 +430,47 @@ export function startServer(cfg: RouterConfig): StartedServer {
 					}
 					return await handleTurn(req, RESPONSES_WIRE);
 				}
+				if (req.method === "POST" && url.pathname === "/v1/messages") {
+					if (!acquireTurn()) {
+						return anthropicErrorResponse({ status: 429, code: "too_many_requests", message: "too many concurrent turns" });
+					}
+					return await handleTurn(req, MESSAGES_WIRE);
+				}
+				if (req.method === "POST" && url.pathname === "/v1/messages/count_tokens") {
+					try {
+						return json({ input_tokens: countAnthropicTokens(await req.json(), cfg.anthropic.models, ledger) });
+					} catch (err) {
+						if (err instanceof WireErrorException) return anthropicErrorResponse(err.wireError);
+						return anthropicErrorResponse({ status: 400, code: "invalid_json", message: err instanceof Error ? err.message : "request body is not valid JSON" });
+					}
+				}
 				if (req.method === "GET" && url.pathname === "/v1/models") {
 					return json(renderModelList(cfg, ledger.blendedRate(cfg.ledger.blendWindowDays)));
 				}
 				if (req.method === "GET" && url.pathname === "/v1/router/stats") {
 					return json(computeStats(ledger));
 				}
+				if (req.method === "GET" && url.pathname === "/v1/router/spend") {
+					// Spend since an instant over a harness set: what a front door's
+					// budget check needs when it cannot read the ledger file.
+					const since = Number.parseInt(url.searchParams.get("sinceMs") ?? "", 10);
+					if (!Number.isFinite(since)) return wireErrorResponse({ status: 400, code: "invalid_request_error", message: "sinceMs required" });
+					return json({ sinceMs: since, usd: spendUsdSince(db, since, harnessScopeParam(url.searchParams.get("harness"))) });
+				}
+				if (req.method === "GET" && url.pathname === "/v1/router/feedback") {
+					const days = clampDays(url.searchParams.get("days"), 30);
+					return json({ days, ...feedbackView(db, Date.now() - days * 86_400_000, harnessScopeParam(url.searchParams.get("harness"))) });
+				}
+				if (req.method === "GET" && url.pathname === "/v1/router/export") {
+					const days = clampDays(url.searchParams.get("days"), 30);
+					const rows = exportRows(db, Date.now() - days * 86_400_000, harnessScopeParam(url.searchParams.get("harness")));
+					if (url.searchParams.get("format") === "json") return json({ days, rows });
+					return new Response(exportCsv(rows), { headers: { "content-type": "text/csv; charset=utf-8", "content-disposition": `attachment; filename="auto-model-router-export-${new Date().toISOString().slice(0, 10)}.csv"` } });
+				}
 				if (req.method === "GET" && url.pathname === "/v1/router/report") {
 					// Usage analytics for `/router report` and the CLI: bounded window,
 					// optional harness scope (the X-Omp-Harness header value).
-					const rawDays = url.searchParams.get("days");
-					const parsedDays = rawDays === null ? 7 : Number.parseInt(rawDays, 10);
-					const windowDays = Number.isInteger(parsedDays) ? Math.min(Math.max(parsedDays, 1), 365) : 7;
+					const windowDays = clampDays(url.searchParams.get("days"), 7);
 					const harnessId = url.searchParams.get("harness") ?? "";
 					const report = buildUsageReport(db, { windowDays, harnessId, baselines: baselinePrices(cfg.report.baselines, (s) => catalog.find(s)) });
 					// ?format=text: the rendered report for harnesses without a renderer of their own (the Hermes plugin).