auto-model-router 0.4.14 → 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.14",
+    "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.14",
+      "version": "0.5.0",
       "author": {
         "name": "drewappling",
         "email": "drewappling@gmail.com"

package/README.md

@@ -1184,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
@@ -1229,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.14",
+  "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/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/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/server/http.ts

@@ -11,6 +11,7 @@ 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";
@@ -334,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;
@@ -347,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",
@@ -402,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()) {
@@ -423,6 +430,20 @@ 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)));
 				}