auto-model-router 0.4.4 → 0.4.6

package/omp-extension/router-switch.ts

@@ -0,0 +1,100 @@
+/**
+ * omp extension: harness-side model switch (experimental).
+ *
+ * Before omp starts a turn on a user prompt, ask the router which tier the
+ * prompt is, and when that tier is mapped to a harness-native model in the
+ * router's `harnessSwitch.models` (a Claude subscription model, typically),
+ * move omp's active model there; when a later prompt is advised below the
+ * mapped tiers, move back to the router model we left. A model the user
+ * picked by hand is never touched.
+ *
+ * Nothing is proxied and no token leaves omp: the native turns bill the
+ * subscription, the router serves the rest and keeps the ledger for those.
+ * Off unless `harnessSwitch.enabled` is set in the router config.
+ *
+ *   # ~/.omp/agent/config.yml
+ *   extensions:
+ *     - /path/to/auto-model-router/omp-extension/router-embed.ts
+ *     - /path/to/auto-model-router/omp-extension/router-switch.ts
+ */
+
+import type { ExtensionAPI } from "@oh-my-pi/pi-coding-agent";
+
+import { EMBED_PROVIDER_ID } from "./embed-logic.ts";
+import { routerAuthHeaders, routerBaseUrl } from "./router-url.ts";
+import { DISABLED_SWITCH, decideSwitch, parseSwitchPolicy, type SwitchPolicy, type TierName } from "./switch-logic.ts";
+
+const HARNESS_ID = process.env.OMP_HARNESS_ID ?? "";
+const POLICY_TTL_MS = 60_000;
+
+export default function (pi: ExtensionAPI): void {
+	pi.setLabel("auto-model-router switch");
+
+	let policy: SwitchPolicy = DISABLED_SWITCH;
+	let policyAtMs = 0;
+	let switchedTo: string | null = null;
+	let returnTo: string | null = null;
+
+	async function refreshPolicy(): Promise<void> {
+		if (Date.now() - policyAtMs < POLICY_TTL_MS) return;
+		policyAtMs = Date.now();
+		try {
+			const res = await fetch(`${routerBaseUrl()}/v1/router/advise/policy`, { headers: routerAuthHeaders(), signal: AbortSignal.timeout(2_000) });
+			policy = res.ok ? parseSwitchPolicy(await res.json()) : DISABLED_SWITCH;
+		} catch {
+			policy = DISABLED_SWITCH;
+		}
+	}
+
+	pi.on("session_start", async () => {
+		policyAtMs = 0;
+		switchedTo = null;
+		returnTo = null;
+		await refreshPolicy();
+	});
+
+	pi.on("before_agent_start", async (event, ctx) => {
+		const e = event as { prompt?: string };
+		if (typeof e.prompt !== "string" || e.prompt.trim() === "") return undefined;
+		await refreshPolicy();
+		if (!policy.enabled) return undefined;
+		const activeModel = ctx.model;
+		const active = activeModel === undefined ? null : `${activeModel.provider}/${activeModel.id}`;
+		const activeIsRouter = activeModel?.provider === EMBED_PROVIDER_ID;
+		let advised: { tier: TierName; confidence: number };
+		try {
+			const res = await fetch(`${routerBaseUrl()}/v1/router/advise`, {
+				method: "POST",
+				headers: { ...routerAuthHeaders(), "content-type": "application/json" },
+				body: JSON.stringify({ ompSessionId: ctx.sessionManager.getSessionId(), harnessId: HARNESS_ID, text: e.prompt.slice(0, 8_000) }),
+				signal: AbortSignal.timeout(2_000),
+			});
+			if (!res.ok) return undefined;
+			advised = (await res.json()) as { tier: TierName; confidence: number };
+		} catch {
+			return undefined;
+		}
+		const decision = decideSwitch({ policy, advised, active, activeIsRouter, switchedTo, returnTo });
+		if (decision.action === "none") return undefined;
+		const [provider = "", ...rest] = decision.model.split("/");
+		const target = ctx.modelRegistry.find(provider, rest.join("/"));
+		if (target === undefined) {
+			if (ctx.hasUI) ctx.ui.notify(`router switch: ${decision.model} is not in omp's model registry`, "warn");
+			return undefined;
+		}
+		const ok = await ctx.setModel(target);
+		if (!ok) {
+			if (ctx.hasUI) ctx.ui.notify(`router switch: omp has no key for ${decision.model}`, "warn");
+			return undefined;
+		}
+		if (decision.action === "up") {
+			if (activeIsRouter) returnTo = active;
+			switchedTo = decision.model;
+		} else {
+			switchedTo = null;
+			returnTo = null;
+		}
+		if (ctx.hasUI) ctx.ui.notify(`router switch: ${decision.reason}`, "info");
+		return undefined;
+	});
+}

package/omp-extension/switch-logic.ts

@@ -0,0 +1,81 @@
+/**
+ * Pure decision logic behind the harness-side model switch (router-switch.ts):
+ * given the router's advice for a prompt and what model omp is on, say whether
+ * to move up to a harness-native model, back to the router, or stay put.
+ * Free of omp types so it is unit-testable.
+ */
+
+export const TIERS = ["trivial", "simple", "moderate", "hard"] as const;
+export type TierName = (typeof TIERS)[number];
+
+export interface SwitchPolicy {
+	enabled: boolean;
+	/** Tier → harness model (`provider/id`) that serves that tier and above, up to the next configured tier. */
+	models: Partial<Record<TierName, string>>;
+	/** Advice below this confidence never moves the model. */
+	minConfidence: number;
+}
+
+export const DISABLED_SWITCH: SwitchPolicy = { enabled: false, models: {}, minConfidence: 1 };
+
+export function parseSwitchPolicy(raw: unknown): SwitchPolicy {
+	if (raw === null || typeof raw !== "object") return DISABLED_SWITCH;
+	const r = raw as Record<string, unknown>;
+	const models: Partial<Record<TierName, string>> = {};
+	if (r.models !== null && typeof r.models === "object") {
+		for (const t of TIERS) {
+			const v = (r.models as Record<string, unknown>)[t];
+			if (typeof v === "string" && v.includes("/")) models[t] = v;
+		}
+	}
+	return {
+		enabled: r.enabled === true,
+		models,
+		minConfidence: typeof r.minConfidence === "number" ? r.minConfidence : 0.6,
+	};
+}
+
+/** The harness model configured for the highest tier at or below `tier`, if any. */
+export function nativeModelFor(policy: SwitchPolicy, tier: TierName): string | undefined {
+	for (let i = TIERS.indexOf(tier); i >= 0; i--) {
+		const m = policy.models[TIERS[i]!];
+		if (m !== undefined) return m;
+	}
+	return undefined;
+}
+
+export interface SwitchInput {
+	policy: SwitchPolicy;
+	advised: { tier: TierName; confidence: number };
+	/** omp's active model as `provider/id`, or null when none. */
+	active: string | null;
+	/** True when the active model belongs to the router's provider. */
+	activeIsRouter: boolean;
+	/** The harness model this extension last switched TO, if omp is still on it. */
+	switchedTo: string | null;
+	/** The router model omp was on before the switch, to return to. */
+	returnTo: string | null;
+}
+
+export type SwitchDecision =
+	| { action: "up"; model: string; reason: string }
+	| { action: "back"; model: string; reason: string }
+	| { action: "none"; reason: string };
+
+export function decideSwitch(input: SwitchInput): SwitchDecision {
+	const { policy, advised, active, activeIsRouter, switchedTo, returnTo } = input;
+	if (!policy.enabled) return { action: "none", reason: "harnessSwitch.enabled is off" };
+	const onOurSwitch = switchedTo !== null && active === switchedTo;
+	// The user picked something else by hand: never fight a manual choice.
+	if (!activeIsRouter && !onOurSwitch) return { action: "none", reason: `active model ${active ?? "(none)"} was chosen by the user` };
+	const native = nativeModelFor(policy, advised.tier);
+	if (native === undefined) {
+		if (onOurSwitch && returnTo !== null) return { action: "back", model: returnTo, reason: `${advised.tier} work: back to the router` };
+		return { action: "none", reason: `${advised.tier} work stays on the router` };
+	}
+	if (advised.confidence < policy.minConfidence) {
+		return { action: "none", reason: `${advised.tier} at confidence ${advised.confidence.toFixed(2)} < ${policy.minConfidence}` };
+	}
+	if (active === native) return { action: "none", reason: `already on ${native}` };
+	return { action: "up", model: native, reason: `${advised.tier} work (confidence ${advised.confidence.toFixed(2)}) → ${native}` };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "auto-model-router",
-  "version": "0.4.4",
+  "version": "0.4.6",
   "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,14 @@ export const WIZARD_SECTIONS: readonly SectionSpec[] = [
 			{ path: "report.dailySummary", label: "Daily summary at session start", kind: "boolean" },
 		],
 	},
+	{
+		title: "Harness switch",
+		fields: [
+			{ path: "harnessSwitch.enabled", label: "Switch omp's model for mapped tiers (experimental)", kind: "boolean" },
+			{ path: "harnessSwitch.minConfidence", label: "Minimum advice confidence to switch", kind: "number", min: 0, max: 1 },
+			...TIER_NAMES.map((t): FieldSpec => ({ path: `harnessSwitch.models.${t}`, label: `${t}: harness model (provider/id)`, kind: "string", optional: true, hint: "e.g. anthropic/claude-opus-4-8" })),
+		],
+	},
 	{
 		title: "Ledger",
 		fields: [

package/src/config/defaults.ts

@@ -309,6 +309,20 @@ export const DEFAULT_CONFIG: RouterConfig = {
 		maxOutputTokens: 700,
 		maxCostUsd: 0.02,
 		timeoutMs: 25_000,
+		// Hermes, Cline/Roo/Kilo, Codex and OpenCode spellings of the same tools.
+		toolAliases: {
+			read_file: "read",
+			search_files: "grep",
+			list_files: "ls",
+			list_dir: "ls",
+			list: "ls",
+			terminal: "bash",
+			execute_command: "bash",
+			execute_code: "bash",
+			shell: "bash",
+			web_extract: "web_fetch",
+			fetch_url: "web_fetch",
+		},
 	},
 	report: {
 		// The frontier pair most omp users would otherwise run on.
@@ -316,6 +330,12 @@ export const DEFAULT_CONFIG: RouterConfig = {
 		// One transcript message per day, at the first interactive session start.
 		dailySummary: true,
 	},
+	harnessSwitch: {
+		// Off: moving the harness's own model is a visible change the operator opts into.
+		enabled: false,
+		models: {},
+		minConfidence: 0.6,
+	},
 	budget: {
 		// No caps by default; at a configured ceiling, downgrade rather than fail.
 		onExceeded: "downgrade",

package/src/config/schema.ts

@@ -277,6 +277,13 @@ 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(),
+	harnessSwitch: z
+		.strictObject({
+			enabled: z.boolean().optional(),
+			models: z.record(tier, z.string().regex(/^[^/]+\/.+$/, "provider/id")).optional(),
+			minConfidence: z.number().min(0).max(1).optional(),
+		})
+		.optional(),
 	digest: z
 		.strictObject({
 			enabled: z.boolean().optional(),
@@ -289,6 +296,7 @@ export const configInputSchema = z.strictObject({
 			maxOutputTokens: z.number().int().positive().optional(),
 			maxCostUsd: z.number().nonnegative().optional(),
 			timeoutMs: z.number().int().positive().optional(),
+			toolAliases: z.record(z.string(), z.string()).optional(),
 		})
 		.optional(),
 	ledger: ledger.optional(),

package/src/config/types.ts

@@ -587,6 +587,14 @@ export interface DigestConfig {
 	/** Skip when the digest itself would cost more than this, USD. */
 	maxCostUsd: number;
 	timeoutMs: number;
+	/**
+	 * Harness tool names → the canonical names `tools` lists (read, grep,
+	 * glob, bash, ls, web_fetch, …). Hermes calls its reader `read_file`,
+	 * Cline `execute_command`, OpenCode `webfetch`; the alias table lets one
+	 * `tools` list serve every harness. Lower-case keys; unknown names pass
+	 * through unchanged.
+	 */
+	toolAliases: Record<string, string>;
 }
 
 /** Usage-report options. */
@@ -607,6 +615,25 @@ export interface ReportConfig {
 	dailySummary: boolean;
 }
 
+/**
+ * Harness-side model switch (experimental): the router advises a tier for
+ * 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.
+ */
+export interface HarnessSwitchConfig {
+	enabled: boolean;
+	/**
+	 * Tier → harness model as `provider/id` in the harness's own registry
+	 * (e.g. `hard: anthropic/claude-opus-4-8`). A tier serves itself and every
+	 * tier above it up to the next mapped one; unmapped low tiers stay on the
+	 * router. Turns on a native model bill the harness's own provider (a
+	 * subscription, typically) and never reach the ledger.
+	 */
+	models: Partial<Record<"trivial" | "simple" | "moderate" | "hard", string>>;
+	/** Advice below this heuristic confidence leaves the model where it is. */
+	minConfidence: number;
+}
+
 export interface BudgetConfig {
 	/** Reject or downgrade when a turn's cold forecast exceeds this, USD. */
 	perTurnUsd?: number;
@@ -802,6 +829,7 @@ export interface RouterConfig {
 	budget: BudgetConfig;
 	report: ReportConfig;
 	digest: DigestConfig;
+	harnessSwitch: HarnessSwitchConfig;
 	profiles: ProfileConfig[];
 	ledger: LedgerConfig;
 	/**

package/src/server/advise.ts

@@ -0,0 +1,82 @@
+/**
+ * Harness-side model switch: the router advises a tier for a prompt BEFORE
+ * the harness dispatches it, so the harness can move its active model to one
+ * the router cannot proxy (a Claude subscription model, say) for hard work
+ * and back to the router for the rest.
+ *
+ * Why this shape: proxying a subscription upstream would mean translating
+ * the OpenAI wire to that provider's and carrying its OAuth token through a
+ * third-party process. Advising is cheaper and keeps the token where it
+ * belongs. The cost of a native turn lands on the subscription, not the
+ * ledger; the router only sees the turns it serves.
+ *
+ * The advice is the heuristic classifier over the user's prompt text alone
+ * (the harness has not built the request yet), plus the session's last
+ * routed tier for context. No adjudicator call, no dispatch, nothing recorded.
+ */
+
+import type { RouterConfig } from "../config/types.ts";
+import type { Ledger } from "../cost/types.ts";
+import { scoreHeuristic } from "../router/classify.ts";
+import { extractFeatures } from "../router/features.ts";
+import { estimateTokens } from "../tokens/estimate.ts";
+import type { TaskType, Tier } from "../router/types.ts";
+import type { NormRequest } from "../wire/types.ts";
+
+export interface AdviseRequest {
+	ompSessionId: string;
+	harnessId: string;
+	/** The user's prompt as submitted. */
+	text: string;
+}
+
+export interface Advice {
+	tier: Tier;
+	task: TaskType;
+	confidence: number;
+	score: number;
+	reasons: string[];
+	/** The tier this session's last routed turn ran at, when the router served one. */
+	lastTier: Tier | null;
+}
+
+const SYSTEM_STUB = "You are a coding agent.";
+
+function requestOf(req: AdviseRequest): NormRequest {
+	const text = req.text;
+	return {
+		protocol: "openai-chat",
+		conversationKey: `advise:${req.ompSessionId}`,
+		harnessId: req.harnessId,
+		ompSessionId: req.ompSessionId,
+		agentdoxScope: "",
+		isSubagent: false,
+		requestedModel: "auto",
+		messages: [
+			{ role: "system", text: SYSTEM_STUB, images: 0, textBytes: Buffer.byteLength(SYSTEM_STUB), toolCalls: [] },
+			{ role: "user", text, images: 0, textBytes: Buffer.byteLength(text), toolCalls: [] },
+		],
+		tools: [],
+		forcedToolChoice: false,
+		stream: false,
+		hasImages: false,
+		promptBytes: Buffer.byteLength(SYSTEM_STUB) + Buffer.byteLength(text),
+		renderUpstreamBody: () => ({}),
+	};
+}
+
+/** Classifies a prompt the way the first turn of a conversation would be, without dispatching anything. */
+export function advise(cfg: RouterConfig, ledger: Ledger | null, req: AdviseRequest): Advice {
+	const norm = requestOf(req);
+	const features = extractFeatures(norm, estimateTokens(norm.promptBytes, "unknown", ledger));
+	const cls = scoreHeuristic(features, cfg);
+	const last = req.ompSessionId === "" ? null : (ledger?.latestForSession?.(req.ompSessionId)?.tier ?? null);
+	return {
+		tier: cls.tier,
+		task: cls.task,
+		confidence: cls.confidence,
+		score: cls.score,
+		reasons: cls.reasons,
+		lastTier: last === null ? null : (last as Tier),
+	};
+}

package/src/server/digest.ts

@@ -67,10 +67,16 @@ const DIGEST_SYSTEM = `You condense tool output for a coding agent that is mid-t
 const tierIdx = (t: string): number => TIER_ORDER.indexOf(t as Tier);
 
 /** Whether a session's current model is expensive enough for a digest to pay off. */
+/** The canonical tool name a harness-specific one maps to (`digest.toolAliases`); lower-cased. */
+export function canonicalTool(cfg: Pick<DigestConfig, "toolAliases">, toolName: string): string {
+	const lower = toolName.toLowerCase();
+	return cfg.toolAliases[lower] ?? lower;
+}
+
 export function digestApplies(cfg: DigestConfig, toolName: string, bytes: number, isError: boolean, currentTier: string | null): { ok: true } | { ok: false; reason: string } {
 	if (!cfg.enabled) return { ok: false, reason: "digest disabled" };
 	if (isError) return { ok: false, reason: "error results are never digested" };
-	if (!cfg.tools.includes(toolName.toLowerCase())) return { ok: false, reason: `tool ${toolName} not in digest.tools` };
+	if (!cfg.tools.includes(canonicalTool(cfg, toolName))) return { ok: false, reason: `tool ${toolName} not in digest.tools` };
 	if (bytes < cfg.minBytes) return { ok: false, reason: `${bytes} bytes < minBytes ${cfg.minBytes}` };
 	if (bytes > cfg.maxBytes) return { ok: false, reason: `${bytes} bytes > maxBytes ${cfg.maxBytes}` };
 	if (currentTier === null) return { ok: false, reason: "no routed turn in this session yet" };

package/src/server/http.ts

@@ -7,9 +7,10 @@ import { createFeedbackStore, type Verdict } from "../cost/feedback.ts";
 import { createLedger } from "../cost/ledger.ts";
 import { createSessionOverrides } from "./overrides.ts";
 import { createDigester } from "./digest.ts";
+import { advise } from "./advise.ts";
 import { TIER_ORDER, type Tier } from "../router/types.ts";
-import { baselinePrices, buildUsageReport } from "../cost/report.ts";
-import { buildDailySummary, createKv, markSummaryShown, summaryDue, summaryHasNews, type SummaryOllama } from "../cost/summary.ts";
+import { baselinePrices, buildUsageReport, renderUsageReport } from "../cost/report.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";
 import { createConversationStore } from "../router/state.ts";
@@ -413,7 +414,29 @@ export function startServer(cfg: RouterConfig): StartedServer {
 					const parsedDays = rawDays === null ? 7 : Number.parseInt(rawDays, 10);
 					const windowDays = Number.isInteger(parsedDays) ? Math.min(Math.max(parsedDays, 1), 365) : 7;
 					const harnessId = url.searchParams.get("harness") ?? "";
-					return json(buildUsageReport(db, { windowDays, harnessId, baselines: baselinePrices(cfg.report.baselines, (s) => catalog.find(s)) }));
+					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).
+					if (url.searchParams.get("format") === "text") return new Response(renderUsageReport(report), { headers: { "content-type": "text/plain; charset=utf-8" } });
+					return json(report);
+				}
+				if (req.method === "GET" && url.pathname === "/v1/router/advise/policy") {
+					const h = cfg.harnessSwitch;
+					return json({ enabled: h.enabled, models: h.models, minConfidence: h.minConfidence });
+				}
+				if (req.method === "POST" && url.pathname === "/v1/router/advise") {
+					// Harness-side switch: classify a prompt before the harness builds
+					// the request. Heuristic only; nothing is dispatched or recorded.
+					const body = (await req.json().catch(() => null)) as Record<string, unknown> | null;
+					if (body === null || typeof body.text !== "string") {
+						return wireErrorResponse({ status: 400, code: "invalid_request_error", message: "text required" });
+					}
+					return json(
+						advise(cfg, ledger, {
+							ompSessionId: typeof body.ompSessionId === "string" ? body.ompSessionId : "",
+							harnessId: typeof body.harnessId === "string" ? body.harnessId : "",
+							text: body.text.slice(0, 16_000),
+						}),
+					);
 				}
 				if (req.method === "GET" && url.pathname === "/v1/router/summary") {
 					// The last 24 hours in a few lines. `auto=1` is the session-start
@@ -436,6 +459,7 @@ export function startServer(cfg: RouterConfig): StartedServer {
 					});
 					if (auto && !summaryHasNews(summary)) return json({ due: false, reason: "nothing to report", summary: null });
 					if (auto) markSummaryShown(kv, harnessId);
+					if (url.searchParams.get("format") === "text") return new Response(renderDailySummary(summary), { headers: { "content-type": "text/plain; charset=utf-8" } });
 					return json({ due: true, summary });
 				}
 				if (req.method === "GET" && url.pathname === "/v1/router/decisions") {
@@ -480,7 +504,7 @@ export function startServer(cfg: RouterConfig): StartedServer {
 				}
 				if (req.method === "GET" && url.pathname === "/v1/router/digest/policy") {
 					const d = cfg.digest;
-					return json({ enabled: d.enabled, minBytes: d.minBytes, maxBytes: d.maxBytes, tools: d.tools, fromTier: d.fromTier });
+					return json({ enabled: d.enabled, minBytes: d.minBytes, maxBytes: d.maxBytes, tools: d.tools, toolAliases: d.toolAliases, fromTier: d.fromTier });
 				}
 				if (req.method === "POST" && url.pathname === "/v1/router/digest") {
 					const body = (await req.json().catch(() => null)) as Record<string, unknown> | null;

package/src/wire/openai/request.ts

@@ -213,6 +213,9 @@ function applyCompaction(messages: Record<string, unknown>[], edits: readonly Co
 	}
 }
 
+/** Request parameters that exist only on OpenAI's own platform; dropped before dispatch. */
+export const OPENAI_ONLY_PARAMS: readonly string[] = ["store", "prompt_cache_key", "safety_identifier", "service_tier", "metadata", "web_search_options"];
+
 function renderUpstreamBody(
 	original: Record<string, unknown>,
 	m: UpstreamMutations,
@@ -227,6 +230,10 @@ function renderUpstreamBody(
 	body.stream = true;
 	// OpenRouter returns usage unconditionally and the parameter is deprecated.
 	delete body.stream_options;
+	// OpenAI-platform-only parameters other harnesses send (Codex, Aider,
+	// Cline): storage, cache keys, tiers and abuse ids mean nothing upstream
+	// and some providers reject unknown fields.
+	for (const key of OPENAI_ONLY_PARAMS) delete body[key];
 
 	if (m.maxTokens !== undefined) {
 		// Respect whichever max-token spelling the client used.

package/test/config-wizard.test.ts

@@ -142,7 +142,7 @@ describe("validateField", () => {
 
 describe("WIZARD_SECTIONS coverage", () => {
 	/** Leaves that are edited as whole records/arrays rather than fields. */
-	const RECORD_PATHS = new Set(["ollama.prices", "ollama.twins", "profiles"]);
+	const RECORD_PATHS = new Set(["ollama.prices", "ollama.twins", "digest.toolAliases", "profiles"]);
 
 	function leaves(obj: unknown, prefix = ""): string[] {
 		if (typeof obj !== "object" || obj === null || Array.isArray(obj)) return [prefix];
@@ -172,6 +172,7 @@ describe("WIZARD_SECTIONS coverage", () => {
 			]),
 			...["coding", "vision", "documentation", "data", "chat"].flatMap((t) => [`tasks.${t}.minQuality`, `tasks.${t}.requireImage`, `tasks.${t}.prefer`]),
 			...["trivial", "simple", "moderate", "hard"].map((t) => `exploration.rates.${t}`),
+			...["trivial", "simple", "moderate", "hard"].map((t) => `harnessSwitch.models.${t}`),
 		]);
 		const known = new Set(leaves(DEFAULT_CONFIG));
 		const unknown = WIZARD_SECTIONS.flatMap((s) => s.fields.map((f) => f.path)).filter((p) => !known.has(p) && !KNOWN_OPTIONAL.has(p));

package/test/failover.test.ts

@@ -77,7 +77,8 @@ function mkConfig(escalation: Partial<EscalationConfig> = {}): RouterConfig {
 		compaction: { enabled: false, budgetTokens: 40_000, floorRatio: 1, fitToWindow: true, protectRecentTurns: 4, maxToolResultBytes: 4_096, keepHeadBytes: 512, keepTailBytes: 512, elideSupersededReads: true, collapseDuplicateResults: true, replanGrowthRatio: 1, digestToolResults: false, digestMaxPerTurn: 2 },
 		budget: { onExceeded: "downgrade" },
 		report: { baselines: [], dailySummary: false },
-		digest: { enabled: false, minBytes: 12_000, maxBytes: 400_000, tools: ["read"], fromTier: "moderate", tier: "simple", model: "", maxOutputTokens: 700, maxCostUsd: 0.02, timeoutMs: 25_000 },
+		harnessSwitch: { enabled: false, models: {}, minConfidence: 0.6 },
+		digest: { enabled: false, minBytes: 12_000, maxBytes: 400_000, tools: ["read"], fromTier: "moderate", tier: "simple", model: "", maxOutputTokens: 700, maxCostUsd: 0.02, timeoutMs: 25_000, toolAliases: {} },
 		profiles: [],
 		ledger: { path: ":memory:", blendWindowDays: 7, blendMinSamples: 20, fallbackBlend: { inputPerMtok: 1, outputPerMtok: 4 }, conversationTtlMs: 86_400_000 , retentionDays: 0,},
 		adaptiveTierFloors: true,

package/test/harness-requests.test.ts

@@ -0,0 +1,137 @@
+import { describe, expect, test } from "bun:test";
+
+import { DEFAULT_CONFIG } from "../src/config/defaults.ts";
+import { canonicalTool, digestApplies } from "../src/server/digest.ts";
+import { OPENAI_ONLY_PARAMS, parseChatRequest } from "../src/wire/openai/request.ts";
+import type { UpstreamMutations } from "../src/wire/types.ts";
+import { parsePolicy, shouldSend } from "../omp-extension/digest-logic.ts";
+
+/**
+ * Request shapes the config-only harnesses send to an OpenAI-compatible
+ * endpoint, as each harness documents them: the router must parse them,
+ * keep their tool calls and headers, and drop the OpenAI-platform-only
+ * parameters before dispatch. These are representative bodies, not captured
+ * traffic; a harness release that changes its shape belongs here as a new case.
+ */
+
+const MUT: UpstreamMutations = { slug: "x/y", fallbacks: [], sessionId: "s", cacheBreakpointMessageIndices: [], reasoning: undefined, maxTokens: undefined, stripAssistantReasoning: false };
+
+const TOOL = (name: string) => ({ type: "function", function: { name, description: name, parameters: { type: "object", properties: { path: { type: "string" } } } } });
+
+const HARNESSES: Record<string, { headers: Record<string, string>; body: Record<string, unknown>; toolCall?: string }> = {
+	codex: {
+		headers: { "X-Omp-Harness": "codex" },
+		body: {
+			model: "auto",
+			messages: [
+				{ role: "developer", content: "You are Codex." },
+				{ role: "user", content: "fix the failing test" },
+				{ role: "assistant", content: null, tool_calls: [{ id: "call_1", type: "function", function: { name: "shell", arguments: '{"command":["cat","x.ts"]}' } }] },
+				{ role: "tool", tool_call_id: "call_1", content: "export const x = 1;" },
+			],
+			tools: [TOOL("shell"), TOOL("apply_patch")],
+			stream: true,
+			store: false,
+			prompt_cache_key: "session-abc",
+			reasoning_effort: "medium",
+			parallel_tool_calls: false,
+		},
+		toolCall: "shell",
+	},
+	aider: {
+		headers: { "X-Omp-Harness": "aider" },
+		body: { model: "auto", messages: [{ role: "system", content: "Act as an expert software developer." }, { role: "user", content: "add a retry helper" }], stream: true, temperature: 0, extra_body: {} },
+	},
+	cline: {
+		headers: { "X-Omp-Harness": "cline" },
+		body: {
+			model: "auto",
+			messages: [
+				{ role: "system", content: "You are Cline." },
+				{ role: "user", content: [{ type: "text", text: "<task>rename the helper</task>" }] },
+				{ role: "assistant", content: null, tool_calls: [{ id: "c1", type: "function", function: { name: "read_file", arguments: '{"path":"src/a.ts"}' } }] },
+				{ role: "tool", tool_call_id: "c1", content: [{ type: "text", text: "line 1\nline 2" }] },
+			],
+			tools: [TOOL("read_file"), TOOL("execute_command"), TOOL("search_files")],
+			stream: true,
+			stream_options: { include_usage: true },
+			temperature: 0,
+		},
+		toolCall: "read_file",
+	},
+	opencode: {
+		headers: { "X-Omp-Harness": "opencode" },
+		body: {
+			model: "auto",
+			messages: [{ role: "system", content: "opencode" }, { role: "user", content: "list the tests" }],
+			tools: [TOOL("read"), TOOL("bash"), TOOL("glob"), TOOL("webfetch")],
+			stream: true,
+			stream_options: { include_usage: true },
+			max_tokens: 8192,
+			service_tier: "auto",
+		},
+	},
+	hermes: {
+		headers: { "X-Omp-Harness": "hermes", "X-Omp-Session": "hermes-session-1", "X-Omp-Subagent": "1" },
+		body: {
+			model: "auto",
+			messages: [
+				{ role: "system", content: "You are Hermes." },
+				{ role: "user", content: "summarise the repo" },
+				{ role: "assistant", content: null, tool_calls: [{ id: "h1", type: "function", function: { name: "read_file", arguments: '{"path":"README.md"}' } }] },
+				{ role: "tool", tool_call_id: "h1", content: '{"content":"# repo","path":"README.md"}' },
+			],
+			tools: [TOOL("read_file"), TOOL("terminal"), TOOL("search_files"), TOOL("delegate_task")],
+			stream: true,
+			max_tokens: 4096,
+		},
+		toolCall: "read_file",
+	},
+};
+
+describe("config-only harness request shapes", () => {
+	for (const [name, h] of Object.entries(HARNESSES)) {
+		test(`${name}: parses, keeps headers and tool calls, and drops OpenAI-only parameters`, () => {
+			const req = parseChatRequest(structuredClone(h.body), new Headers(h.headers));
+			expect(req.harnessId).toBe(name);
+			expect(req.requestedModel).toBe("auto");
+			expect(req.messages.length).toBe((h.body.messages as unknown[]).length);
+			if (h.toolCall !== undefined) {
+				const assistant = req.messages.find((m) => m.role === "assistant");
+				expect(assistant?.toolCalls[0]?.name).toBe(h.toolCall);
+				expect(req.messages.find((m) => m.role === "tool")?.toolCallId).toBeDefined();
+			}
+			const out = req.renderUpstreamBody(MUT);
+			for (const key of OPENAI_ONLY_PARAMS) expect(key in out).toBe(false);
+			expect("stream_options" in out).toBe(false);
+			expect(out.model).toBe("x/y");
+			expect(out.stream).toBe(true);
+			// Parameters every provider understands survive.
+			if ("temperature" in h.body) expect(out.temperature).toBe(h.body.temperature);
+			if ("tools" in h.body) expect((out.tools as unknown[]).length).toBe((h.body.tools as unknown[]).length);
+		});
+	}
+
+	test("hermes headers carry session and subagent identity", () => {
+		const req = parseChatRequest(structuredClone(HARNESSES.hermes!.body), new Headers(HARNESSES.hermes!.headers));
+		expect(req.ompSessionId).toBe("hermes-session-1");
+		expect(req.isSubagent).toBe(true);
+	});
+});
+
+describe("digest tool aliases across harnesses", () => {
+	const d = { ...DEFAULT_CONFIG.digest, enabled: true, minBytes: 10, maxBytes: 10_000 };
+	test("harness spellings map onto the canonical tools list on both sides", () => {
+		for (const [alias, canonical] of [["read_file", "read"], ["search_files", "grep"], ["terminal", "bash"], ["execute_command", "bash"], ["shell", "bash"], ["list_files", "ls"], ["web_extract", "web_fetch"], ["READ_FILE", "read"]] as const) {
+			expect(canonicalTool(d, alias)).toBe(canonical);
+			expect(digestApplies(d, alias, 500, false, "hard").ok).toBe(true);
+		}
+		expect(canonicalTool(d, "write_file")).toBe("write_file");
+		expect(digestApplies(d, "write_file", 500, false, "hard").ok).toBe(false);
+		// The policy the router publishes carries the aliases, and the client gate honours them.
+		const policy = parsePolicy({ enabled: true, minBytes: 10, maxBytes: 10_000, tools: d.tools, toolAliases: d.toolAliases, fromTier: "moderate" });
+		expect(shouldSend(policy, "search_files", false, "x".repeat(100), false)).toBe(true);
+		expect(shouldSend(policy, "delegate_task", false, "x".repeat(100), false)).toBe(false);
+		expect(parsePolicy({ enabled: true }).toolAliases).toEqual({});
+	});
+});