auto-model-router 0.1.3 → 0.2.0

package/src/router/tier-plan.ts

@@ -42,10 +42,12 @@ const AXES: readonly QualityAxis[] = ["coding", "agentic", "intelligence"];
 export type AxisFloors = Record<Tier, number>;
 
 export interface TierPlan {
-	/** Adaptive floor per axis per tier. */
+	/** Adaptive quality floor per axis per tier. */
 	floors: Record<QualityAxis, AxisFloors>;
 	/** How many available models carried a score on each axis. */
 	scoredCount: Record<QualityAxis, number>;
+	/** Adaptive input-price ceiling ($/Mtok) per tier, from the catalog's price spread. */
+	priceCeilings: Record<Tier, number>;
 }
 
 /**
@@ -89,6 +91,32 @@ function bandFloors(ascending: readonly number[]): AxisFloors {
 	return floors as AxisFloors;
 }
 
+/**
+ * Per-tier input-price ceiling ($/Mtok) from an ascending price list: quantile
+ * UPPER bounds, so each higher tier admits a larger, pricier slice. p25/p50/p75
+ * for trivial/simple/moderate, and p90 for `hard` — high enough to keep the
+ * strong models but dropping the priciest outliers. The catalog decides the
+ * dollar values, so this self-tunes to whatever models a key actually admits.
+ */
+const CEILING_QUANTILES: readonly number[] = [0.25, 0.5, 0.75, 0.9];
+
+function bandCeilings(ascending: readonly number[]): Record<Tier, number> {
+	const out: Record<string, number> = {};
+	const len = ascending.length;
+	for (let k = 0; k < TIER_ORDER.length; k++) {
+		const tier = TIER_ORDER[k];
+		if (tier === undefined) continue;
+		if (len === 0) {
+			out[tier] = Number.POSITIVE_INFINITY; // no data ⇒ no cap
+			continue;
+		}
+		const q = CEILING_QUANTILES[k] ?? 1;
+		const index = Math.min(len - 1, Math.max(0, Math.ceil(len * q) - 1));
+		out[tier] = ascending[index] ?? Number.POSITIVE_INFINITY;
+	}
+	return out as Record<Tier, number>;
+}
+
 /** Computes the adaptive plan for a set of available models. */
 export function computeTierPlan(models: readonly CatalogModel[], cfg: RouterConfig): TierPlan {
 	const floors: Record<string, AxisFloors> = {};
@@ -107,10 +135,18 @@ export function computeTierPlan(models: readonly CatalogModel[], cfg: RouterConf
 		floors[axis] = bandFloors(scores);
 		scoredCount[axis] = scores.length;
 	}
+	// Input prices ($/Mtok) of the rankable models, ascending, for the ceilings.
+	const prices: number[] = [];
+	for (const model of models) {
+		if (!isRankable(model, includeFree)) continue;
+		prices.push(model.price.prompt * 1e6);
+	}
+	prices.sort((a, b) => a - b);
 
 	return {
 		floors: floors as Record<QualityAxis, AxisFloors>,
 		scoredCount: scoredCount as Record<QualityAxis, number>,
+		priceCeilings: bandCeilings(prices),
 	};
 }
 
@@ -149,3 +185,23 @@ export function effectiveQualityFloor(
 	const adaptive = plan.floors[axis][tier];
 	return Math.min(configured, adaptive);
 }
+
+/**
+ * The input-price ceiling ($/Mtok) to actually enforce for a tier. When adaptive
+ * ceilings are off, this is just the configured value (possibly unset). When on,
+ * the catalog-derived band applies, and an explicit config can only tighten it
+ * further — never loosen it. Returns undefined for "no ceiling".
+ */
+export function effectivePriceCeiling(
+	configured: number | undefined,
+	tier: Tier,
+	plan: TierPlan,
+	enabled: boolean,
+): number | undefined {
+	if (!enabled) return configured;
+	const adaptive = plan.priceCeilings[tier];
+	const band = Number.isFinite(adaptive) ? adaptive : undefined;
+	if (configured === undefined) return band;
+	if (band === undefined) return configured;
+	return Math.min(configured, band);
+}

package/src/router/types.ts

@@ -168,6 +168,17 @@ export interface ProbePlan {
 }
 
 /** The routing decision for one turn. */
+/**
+ * A turn that was deliberately routed below its classified tier, so the
+ * ledger witnesses whether the cheaper model would have sufficed.
+ */
+export interface Exploration {
+	/** Tier the classifier actually chose. */
+	from: Tier;
+	/** Tier routed instead, exactly one step cheaper. */
+	to: Tier;
+}
+
 export interface Decision {
 	slug: string;
 	/** Same-tier fallbacks for OpenRouter's `models[]` array; transient-error only. */
@@ -191,6 +202,8 @@ export interface Decision {
 	/** Filtered-out models with cause. Retained for `explain`. */
 	rejected: Rejection[];
 	reasons: string[];
+	/** Set when epsilon-greedy exploration deliberately routed below the classified tier. */
+	explored: Exploration | null;
 	/** Budget guard forced a cheaper tier than the classifier asked for. */
 	budgetDowngraded: boolean;
 }

package/src/server/turn.ts

@@ -12,6 +12,7 @@ import type { CatalogSource } from "../catalog/types.ts";
 import type { RouterConfig } from "../config/types.ts";
 import { EMPTY_USAGE, type Ledger, type UsageCounts } from "../cost/types.ts";
 import { createProbe, type Probe } from "../router/escalate.ts";
+import { resolveHoldTurns } from "../router/explore.ts";
 import {
 	TIER_ORDER,
 	type ConversationStore,
@@ -141,11 +142,19 @@ export async function runTurn(
 				turn: turnNumber,
 				requestedModel: req.requestedModel,
 				harnessId: req.harnessId,
+				ompSessionId: req.ompSessionId,
 				slug: decision.slug,
 				servedSlug,
 				tier: decision.tier,
 				classificationSource: decision.classification.source,
 				reasons: decision.reasons,
+				features: decision.features,
+				score: decision.classification.score,
+				confidence: decision.classification.confidence,
+				task: decision.classification.task,
+				classifierReasons: decision.classification.reasons,
+				exploredFrom: decision.explored?.from ?? null,
+				holdArm: resolveHoldTurns(config, req.conversationKey, escalations > 0).arm,
 				predictedUsd: decision.forecast.expectedUsd,
 				reportedUsd,
 				usage,
@@ -357,8 +366,7 @@ export async function runTurn(
 		// actually easy.
 		const tierChanged = prevTier !== decision.tier;
 		if (tierChanged || escalations > 0) {
-			state.stickyUntilTurn =
-				turnNumber + (escalations > 0 ? config.hysteresis.holdTurnsAfterEscalation : config.hysteresis.holdTurns);
+			state.stickyUntilTurn = turnNumber + resolveHoldTurns(config, req.conversationKey, escalations > 0).turns;
 		}
 		// Reported cost is authoritative; fall back to the forecast so the
 		// budget guard still works when the provider omits cost.

package/src/util/sqlite.ts

@@ -18,7 +18,7 @@ import { mkdirSync } from "node:fs";
 import { dirname } from "node:path";
 
 /** Bump when a migration is added; guarded below so reopening never regresses it. */
-const USER_VERSION = 4;
+const USER_VERSION = 10;
 
 const MIGRATIONS = `
 CREATE TABLE IF NOT EXISTS catalog_cache (
@@ -29,6 +29,18 @@ CREATE TABLE IF NOT EXISTS catalog_cache (
   key_scoped INTEGER NOT NULL DEFAULT 0
 );
 
+CREATE TABLE IF NOT EXISTS benchmark_cache (
+  id INTEGER PRIMARY KEY CHECK (id = 1),
+  payload TEXT NOT NULL,
+  fetched_at_ms INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS local_scores (
+  id INTEGER PRIMARY KEY CHECK (id = 1),
+  payload TEXT NOT NULL,
+  fetched_at_ms INTEGER NOT NULL
+);
+
 CREATE TABLE IF NOT EXISTS ledger (
   id TEXT PRIMARY KEY,
   created_at_ms INTEGER NOT NULL,
@@ -37,6 +49,7 @@ CREATE TABLE IF NOT EXISTS ledger (
   turn INTEGER NOT NULL,
   requested_model TEXT NOT NULL,
   harness_id TEXT NOT NULL DEFAULT '',
+  omp_session_id TEXT NOT NULL DEFAULT '',
   slug TEXT NOT NULL,
   served_slug TEXT,
   tier TEXT NOT NULL,
@@ -118,6 +131,67 @@ END
 WHERE error IS NOT NULL;
 `;
 
+// v5: ledger gains omp_session_id, so the toast extension can scope decisions to
+// its own omp session. Before this, the only scoping was per-harness, so two
+// interactive omp sessions of the same harness (the default: empty) each
+// surfaced the other's routing toasts from the shared ledger. Existing rows
+// backfill to '' (unknown session), matching the no-header default.
+const MIGRATE_V5 = `
+ALTER TABLE ledger ADD COLUMN omp_session_id TEXT NOT NULL DEFAULT '';
+`;
+
+// v6: classifier INPUTS. Before this the ledger recorded only what routing
+// decided (tier, slug, cost, escalation) and never what it decided FROM, so a
+// turn could not be replayed, and no weight could be fit offline. `features`
+// is the verbatim feature vector as JSON; `score` and `confidence` are the
+// classifier's own outputs, kept alongside because they are cheap and make
+// weight drift detectable when the scorer changes under a fixed feature set.
+// `classifier_reasons` is the per-feature breakdown, which `select.ts` drops
+// from the decision trail on every path except a hysteresis hold.
+//
+// All nullable with no backfill: pre-v6 rows genuinely lack these inputs and
+// NULL says so honestly. A DEFAULT would invent data that was never observed.
+const MIGRATE_V6 = `
+ALTER TABLE ledger ADD COLUMN features TEXT;
+ALTER TABLE ledger ADD COLUMN score REAL;
+ALTER TABLE ledger ADD COLUMN confidence REAL;
+ALTER TABLE ledger ADD COLUMN task TEXT;
+ALTER TABLE ledger ADD COLUMN classifier_reasons TEXT;
+`;
+
+// v7: records epsilon-greedy exploration. `explored_from` is the tier the
+// classifier actually chose on a turn we deliberately routed one step
+// cheaper; NULL means the turn was routed normally.
+//
+// This is the counterfactual the ledger could never observe before. Natural
+// traffic only reveals UNDER-routing, because a tier that was too low
+// escalates and leaves a trace, while a tier that was too high looks
+// indistinguishable from a tier that was exactly right.
+const MIGRATE_V7 = `
+ALTER TABLE ledger ADD COLUMN explored_from TEXT;
+`;
+
+// v8: records the hold-length arm a conversation was assigned by hold
+// exploration. NULL means the conversation was not part of the experiment.
+//
+// Recorded on EVERY turn of the conversation, not only the turns a hold
+// actually affects, so arms can be compared on total conversation cost
+// rather than on the subset the treatment happened to touch.
+const MIGRATE_V8 = `
+ALTER TABLE ledger ADD COLUMN hold_arm INTEGER;
+`;
+
+// v9: benchmark_cache holds the external benchmark feeds (Artificial Analysis,
+// BenchLM) that backfill quality scores OpenRouter leaves unpublished. It is a
+// whole new table, created idempotently by the MIGRATIONS block above, so there
+// is no ALTER guard here — the version bump alone records that the schema now
+// includes it.
+
+// v10: local_scores holds calibrated scores from our OWN eval harness
+// (src/eval), a `local`-source feed applied only when benchmarks.useLocalScores
+// is on. Another new table via the idempotent MIGRATIONS block; version bump
+// only, no ALTER guard.
+
 export function openDb(path: string): Database {
 	// ":memory:" has no parent directory to create.
 	if (path !== ":memory:") mkdirSync(dirname(path), { recursive: true });
@@ -134,6 +208,10 @@ export function openDb(path: string): Database {
 		const ledgerCols = db.query("PRAGMA table_info(ledger)").all() as { name: string }[];
 		if (!ledgerCols.some((c) => c.name === "harness_id")) db.exec(MIGRATE_V3);
 		if (!ledgerCols.some((c) => c.name === "error_kind")) db.exec(MIGRATE_V4);
+		if (!ledgerCols.some((c) => c.name === "omp_session_id")) db.exec(MIGRATE_V5);
+		if (!ledgerCols.some((c) => c.name === "features")) db.exec(MIGRATE_V6);
+		if (!ledgerCols.some((c) => c.name === "explored_from")) db.exec(MIGRATE_V7);
+		if (!ledgerCols.some((c) => c.name === "hold_arm")) db.exec(MIGRATE_V8);
 		db.exec(`PRAGMA user_version = ${USER_VERSION}`);
 	}
 	return db;

package/src/wire/openai/request.ts

@@ -204,6 +204,10 @@ export function parseChatRequest(body: unknown, headers: Headers): NormRequest {
 	// this via the provider block's `headers:` override; absent ⇒ single harness.
 	const harnessId = (headers.get("x-omp-harness") ?? "").trim();
 
+	// omp UI session id for per-session toast scoping. The embed extension sets
+	// this header to ctx.sessionManager.getSessionId(); absent ⇒ unknown session.
+	const ompSessionId = (headers.get("x-omp-session") ?? "").trim();
+
 	if (typeof b.model !== "string" || b.model.length === 0) {
 		throw invalidRequest("model must be a non-empty string");
 	}
@@ -262,6 +266,7 @@ export function parseChatRequest(body: unknown, headers: Headers): NormRequest {
 		protocol: "openai-chat",
 		conversationKey,
 		harnessId,
+		ompSessionId,
 		requestedModel,
 		messages,
 		tools,

package/src/wire/types.ts

@@ -68,6 +68,13 @@ export interface NormRequest {
 	 * client sends no header (single-harness default).
 	 */
 	harnessId: string;
+	/**
+	 * omp UI session id from the `X-Omp-Session` request header, when the client
+	 * sends one. Scopes toasts to a single interactive session so concurrent
+	 * sessions sharing one router don't surface each other's choices. Empty when
+	 * the client sends no header.
+	 */
+	ompSessionId: string;
 	/** Virtual model the client selected, e.g. `auto`, `auto-cheap`, `auto-max`. */
 	requestedModel: string;
 	messages: NormMessage[];

package/test/benchmark-feeds.test.ts

@@ -0,0 +1,222 @@
+import { describe, expect, test } from "bun:test";
+
+import { normalizeCatalogModel } from "../src/catalog/openrouter-catalog.ts";
+import {
+	applyFeedScores,
+	fetchBenchlmScores,
+	normalizeModelKey,
+	parseAaModels,
+	parseBenchlmModels,
+	refreshFeedScores,
+	type FeedScore,
+	type FetchLike,
+} from "../src/catalog/benchmark-feeds.ts";
+import { loadConfig } from "../src/config/load.ts";
+import type { RouterConfig } from "../src/config/types.ts";
+import { openDb } from "../src/util/sqlite.ts";
+
+/** A bare OpenRouter `/models` record, optionally pre-scored. */
+function raw(id: string, benchmarks?: Record<string, unknown>): Record<string, unknown> {
+	const record: Record<string, unknown> = {
+		id,
+		canonical_slug: id,
+		name: id,
+		context_length: 131_072,
+		pricing: { prompt: "0.0000003", completion: "0.0000011" },
+		supported_parameters: ["tools"],
+		architecture: { input_modalities: ["text"], tokenizer: "Other" },
+		created: 1_700_000_000,
+	};
+	if (benchmarks !== undefined) record.benchmarks = benchmarks;
+	return record;
+}
+
+function aaScore(over: Partial<FeedScore> & { key: string }): FeedScore {
+	return { creator: "", source: "artificial_analysis", ...over };
+}
+function blScore(over: Partial<FeedScore> & { key: string }): FeedScore {
+	return { creator: "", source: "benchlm", ...over };
+}
+
+describe("normalizeModelKey", () => {
+	test("strips provider, tilde, and release words but keeps the parameter size", () => {
+		expect(normalizeModelKey("z-ai/glm-5.3-flash")).toBe("glm-5-3-flash");
+		expect(normalizeModelKey("~deepseek/deepseek-v4-flash-latest")).toBe("deepseek-v4-flash");
+		expect(normalizeModelKey("meta/muse-glimmer-30b")).toBe("muse-glimmer-30b");
+		// The feed's own display spelling collapses onto the same key.
+		expect(normalizeModelKey("Muse Glimmer 30B")).toBe("muse-glimmer-30b");
+		expect(normalizeModelKey("MiniMax M3")).toBe("minimax-m3");
+	});
+});
+
+describe("parseAaModels", () => {
+	test("reads the three indices, keeps in-range values, and skips empty rows", () => {
+		const body = {
+			data: [
+				{
+					slug: "glm-5.3-flash",
+					model_creator: { slug: "z-ai" },
+					evaluations: {
+						artificial_analysis_coding_index: 61.2,
+						artificial_analysis_intelligence_index: 58.4,
+						artificial_analysis_agentic_index: 150, // out of range → dropped
+					},
+				},
+				{ slug: "no-evals", model_creator: { slug: "x" }, evaluations: {} },
+			],
+		};
+		const parsed = parseAaModels(body);
+		expect(parsed).toHaveLength(1);
+		expect(parsed[0]).toMatchObject({ key: "glm-5-3-flash", creator: "z-ai", coding: 61.2, intelligence: 58.4 });
+		expect(parsed[0]?.agentic).toBeUndefined();
+	});
+});
+
+describe("parseBenchlmModels", () => {
+	test("maps categories to axes, drops estimated rows, and ignores out-of-range", () => {
+		const body = {
+			models: [
+				{
+					model: "Muse Glimmer 30B",
+					creator: "Meta",
+					evidenceStatus: "supported",
+					categoryScores: { coding: 55, reasoning: 52, agentic: 48 },
+				},
+				{
+					model: "Guessed Model",
+					creator: "x",
+					evidenceStatus: "estimated",
+					categoryScores: { coding: 90 },
+				},
+			],
+		};
+		const parsed = parseBenchlmModels(body);
+		expect(parsed).toHaveLength(1);
+		expect(parsed[0]).toMatchObject({ key: "muse-glimmer-30b", coding: 55, intelligence: 52, agentic: 48 });
+	});
+});
+
+describe("applyFeedScores", () => {
+	test("fills the real gap models and reaches normalizeCatalogModel", () => {
+		const catalog = [
+			raw("meta/muse-glimmer-30b"),
+			raw("z-ai/glm-5.3-flash"),
+			// Already scored by OpenRouter on coding; a feed must not overwrite it.
+			raw("google/gemini-3.7-flash", { artificial_analysis: { coding_index: 76.1 } }),
+		];
+		const feeds: FeedScore[] = [
+			aaScore({ key: "glm-5-3-flash", creator: "z-ai", coding: 61, intelligence: 58 }),
+			aaScore({ key: "gemini-3-7-flash", creator: "google", coding: 40, intelligence: 63 }),
+			blScore({ key: "muse-glimmer-30b", creator: "meta", coding: 55, agentic: 48 }),
+			blScore({ key: "glm-5-3-flash", creator: "z-ai", agentic: 44 }),
+		];
+
+		const result = applyFeedScores(catalog, feeds);
+
+		// muse-glimmer: was empty, gains coding + agentic from BenchLM.
+		const muse = normalizeCatalogModel(catalog[0]);
+		expect(muse?.quality).toEqual({ coding: 55, agentic: 48 });
+
+		// glm: coding + intelligence from AA (stronger), agentic from BenchLM.
+		const glm = normalizeCatalogModel(catalog[1]);
+		expect(glm?.quality).toEqual({ coding: 61, intelligence: 58, agentic: 44 });
+
+		// gemini: published coding survives untouched; intelligence filled from AA.
+		const gemini = normalizeCatalogModel(catalog[2]);
+		expect(gemini?.quality.coding).toBe(76.1);
+		expect(gemini?.quality.intelligence).toBe(63);
+
+		// Provenance recorded, counts add up.
+		const museBench = catalog[0]?.benchmarks;
+		expect(museBench).toMatchObject({ fill_sources: { coding: "benchlm", agentic: "benchlm" } });
+		expect(result.modelsFilled).toBe(3);
+		expect(result.sources.artificial_analysis).toBe(3); // glm coding+intel, gemini intel
+		expect(result.sources.benchlm).toBe(3); // muse coding+agentic, glm agentic
+	});
+
+	test("AA wins over BenchLM for the same axis", () => {
+		const catalog = [raw("z-ai/glm-5.3-flash")];
+		const feeds: FeedScore[] = [
+			blScore({ key: "glm-5-3-flash", creator: "z-ai", coding: 10 }),
+			aaScore({ key: "glm-5-3-flash", creator: "z-ai", coding: 61 }),
+		];
+		applyFeedScores(catalog, feeds);
+		expect(normalizeCatalogModel(catalog[0])?.quality.coding).toBe(61);
+	});
+
+	test("never fuzzy-matches a different model", () => {
+		const catalog = [raw("meta/muse-glimmer-30b")];
+		// Same family, different model — must not lend its score.
+		const feeds: FeedScore[] = [aaScore({ key: "muse-spark-1-2", creator: "meta", coding: 72 })];
+		const result = applyFeedScores(catalog, feeds);
+		expect(result.modelsFilled).toBe(0);
+		expect(normalizeCatalogModel(catalog[0])?.quality).toEqual({});
+	});
+
+	test("a shared key with conflicting creators fills only the creator that matches", () => {
+		const catalog = [raw("z-ai/glm-5.3-flash")];
+		const feeds: FeedScore[] = [
+			aaScore({ key: "glm-5-3-flash", creator: "someone-else", coding: 5 }),
+			aaScore({ key: "glm-5-3-flash", creator: "z-ai", coding: 61 }),
+		];
+		applyFeedScores(catalog, feeds);
+		expect(normalizeCatalogModel(catalog[0])?.quality.coding).toBe(61);
+	});
+});
+
+describe("refreshFeedScores", () => {
+	function cfgWith(over: Partial<RouterConfig["benchmarks"]>): RouterConfig {
+		const base = loadConfig({});
+		return { ...base, benchmarks: { ...base.benchmarks, ...over } };
+	}
+
+	test("fetches once, then serves the cache within the TTL", async () => {
+		const db = openDb(":memory:");
+		let calls = 0;
+		const fakeFetch: FetchLike = async (url) => {
+			calls += 1;
+			const u = String(url);
+			if (u.includes("benchlm")) {
+				return Response.json({
+					models: [
+						{ model: "MiniMax M3", creator: "MiniMax", evidenceStatus: "supported", categoryScores: { coding: 58 } },
+					],
+				});
+			}
+			return Response.json({ data: [] });
+		};
+
+		const cfg = cfgWith({ enabled: true, artificialAnalysisApiKey: "", benchlm: true, refreshMs: 1_000_000 });
+		const first = await refreshFeedScores(cfg, db, { fetchImpl: fakeFetch, now: 1000 });
+		expect(first).toHaveLength(1);
+		expect(first[0]).toMatchObject({ key: "minimax-m3", coding: 58, source: "benchlm" });
+		expect(calls).toBe(1); // AA skipped (no key), BenchLM fetched once
+
+		const second = await refreshFeedScores(cfg, db, { fetchImpl: fakeFetch, now: 2000 });
+		expect(second).toHaveLength(1);
+		expect(calls).toBe(1); // within TTL → no new fetch
+		db.close();
+	});
+
+	test("falls back to the stale cache when a refresh returns nothing", async () => {
+		const db = openDb(":memory:");
+		const seed = [{ key: "minimax-m3", creator: "minimax", coding: 58, source: "benchlm" }];
+		db.query("INSERT INTO benchmark_cache (id, payload, fetched_at_ms) VALUES (1, ?, ?)").run(JSON.stringify(seed), 0);
+		const emptyFetch: FetchLike = async () => Response.json({ models: [] });
+		const cfg = cfgWith({ enabled: true, artificialAnalysisApiKey: "", benchlm: true, refreshMs: 10 });
+		const got = await refreshFeedScores(cfg, db, { fetchImpl: emptyFetch, now: 1_000_000 });
+		expect(got).toHaveLength(1);
+		expect(got[0]).toMatchObject({ key: "minimax-m3", coding: 58 });
+		db.close();
+	});
+});
+
+// fetchBenchlmScores over a fake fetch: the keyless path parses end to end.
+test("fetchBenchlmScores parses a keyless leaderboard response", async () => {
+	const fake: FetchLike = async () =>
+		Response.json({
+			models: [{ model: "GLM 5.3 Flash", creator: "Z-AI", evidenceStatus: "supported", categoryScores: { coding: 61, reasoning: 58 } }],
+		});
+	const scores = await fetchBenchlmScores({ fetchImpl: fake });
+	expect(scores).toEqual([{ key: "glm-5-3-flash", creator: "z-ai", coding: 61, intelligence: 58, source: "benchlm" }]);
+});

package/test/escalate.test.ts

@@ -22,6 +22,7 @@ function req(messages: NormMessage[] = [], over: Partial<NormRequest> = {}): Nor
 		protocol: "openai-chat",
 		conversationKey: "k",
 		harnessId: "",
+		ompSessionId: "",
 		requestedModel: "auto",
 		messages,
 		tools: [],