auto-model-router 0.1.0

package/test/configure-logic.test.ts

@@ -0,0 +1,151 @@
+import { describe, expect, test } from "bun:test";
+
+import { WIZARD_SECTIONS } from "../src/cli/config-wizard.ts";
+import type { FieldSpec } from "../src/cli/config-wizard.ts";
+
+import { editProfile, walkSection, type ConfigUi } from "../omp-extension/configure-logic.ts";
+
+function makeUi(script: Array<{ type: "select" | "input" | "confirm"; value?: string | boolean | undefined }>): ConfigUi {
+	const calls = script.slice();
+	return {
+		async select(_title, _options) {
+			const call = calls.shift();
+			if (call?.type !== "select") throw new Error("expected select, got " + JSON.stringify(call));
+			if (call.value === undefined) return undefined;
+			return call.value as string;
+		},
+		async input(_title, _placeholder, _initial) {
+			const call = calls.shift();
+			if (call?.type !== "input") throw new Error("expected input, got " + JSON.stringify(call));
+			if (call.value === undefined) return undefined;
+			return call.value as string;
+		},
+		async confirm() {
+			const call = calls.shift();
+			if (call?.type !== "confirm") throw new Error("expected confirm, got " + JSON.stringify(call));
+			return call.value as boolean;
+		},
+		notify(_text, _level) {},
+	};
+}
+const baseCfg = {
+	server: { host: "127.0.0.1", port: 8788, apiKey: undefined, harnessId: undefined },
+	openrouter: {
+		baseUrl: "https://openrouter.ai/api/v1",
+		title: "auto-model-router",
+		timeoutMs: 600000,
+		catalogTtlMs: 3600000,
+		catalogRefreshMs: 300000,
+	},
+	adaptiveTierFloors: true,
+	tiers: {},
+	tasks: {},
+	filters: {},
+	classifier: {},
+	escalation: {},
+	hysteresis: {},
+	cache: {},
+	budget: { onExceeded: "downgrade" },
+	profiles: [],
+	ledger: {},
+	logLevel: "info",
+} as never;
+
+const serverSection = WIZARD_SECTIONS.find((s) => s.title === "Server")!;
+
+describe("promptField via walkSection", () => {
+	test("empty answer keeps the current value (no change)", async () => {
+		const ui = makeUi([
+			{ type: "input", value: "" }, // keep host
+			{ type: "input", value: "" }, // keep port
+			{ type: "input", value: "" }, // keep apiKey
+			{ type: "input", value: "" }, // keep harnessId
+		]);
+		const answers: Record<string, unknown> = {};
+		const changed = await walkSection(ui, serverSection, baseCfg, answers);
+		expect(changed).toBe(false);
+		expect(answers).toEqual({});
+	});
+
+	test("an edit is collected under its dotted path", async () => {
+		const ui = makeUi([
+			{ type: "input", value: "127.0.0.2" }, // host
+			{ type: "input", value: "" }, // keep port
+			{ type: "input", value: "" }, // keep apiKey
+			{ type: "input", value: "" }, // keep harnessId
+		]);
+		const answers: Record<string, unknown> = {};
+		const changed = await walkSection(ui, serverSection, baseCfg, answers);
+		expect(changed).toBe(true);
+		expect(answers).toEqual({ "server.host": "127.0.0.2" });
+	});
+
+	test("cancelling a dialog aborts the walk", async () => {
+		const ui = makeUi([{ type: "input", value: undefined }]);
+		const answers: Record<string, unknown> = {};
+		const changed = await walkSection(ui, serverSection, baseCfg, answers);
+		expect(changed).toBe(false);
+		expect(answers).toEqual({});
+	});
+
+	test("CLEAR_TOKEN clears an optional field to null", async () => {
+		const ui = makeUi([
+			{ type: "input", value: "" }, // host
+			{ type: "input", value: "" }, // port
+			{ type: "input", value: "-" }, // clear apiKey
+			{ type: "input", value: "" }, // harnessId
+		]);
+		const answers: Record<string, unknown> = {};
+		const changed = await walkSection(ui, serverSection, baseCfg, answers);
+		expect(changed).toBe(true);
+		expect(answers).toEqual({ "server.apiKey": null });
+	});
+
+	test("boolean fields use the select dialog", async () => {
+		const adaptive = WIZARD_SECTIONS.find((s) => s.title === "Tiers")!;
+		const ui = makeUi([
+			{ type: "select", value: "false" }, // adaptiveTierFloors
+			{ type: "input", value: "" }, // trivial minQuality
+			{ type: "input", value: "" }, // trivial maxInputPerMtok
+			{ type: "input", value: "" }, // simple minQuality
+			{ type: "input", value: "" }, // simple maxInputPerMtok
+			{ type: "input", value: "" }, // moderate minQuality
+			{ type: "input", value: "" }, // moderate maxInputPerMtok
+			{ type: "input", value: "" }, // hard minQuality
+			{ type: "input", value: "" }, // hard maxInputPerMtok
+		]);
+		const answers: Record<string, unknown> = {};
+		await walkSection(ui, adaptive, baseCfg, answers);
+		expect(answers).toEqual({ adaptiveTierFloors: false });
+	});
+});
+
+describe("editProfile", () => {
+	test("updates a whole profile record", async () => {
+		const ui = makeUi([
+			{ type: "input", value: "auto-cheap" }, // id
+			{ type: "input", value: "Auto Cheap" }, // name
+			{ type: "select", value: "trivial" }, // minTier
+			{ type: "select", value: "simple" }, // maxTier
+			{ type: "input", value: "" }, // contextWindow keep
+			{ type: "input", value: "" }, // maxTokens keep
+		]);
+		const fields = [
+			{ path: "id", label: "Model id", kind: "string" },
+			{ path: "name", label: "Display name", kind: "string" },
+			{ path: "minTier", label: "Floor", kind: "enum", options: ["trivial", "simple", "moderate", "hard"] },
+			{ path: "maxTier", label: "Ceiling", kind: "enum", options: ["trivial", "simple", "moderate", "hard"] },
+			{ path: "contextWindow", label: "Context", kind: "number", min: 1 },
+			{ path: "maxTokens", label: "Max output", kind: "number", min: 1 },
+		] as FieldSpec[];
+		const out = await editProfile(ui, { id: "auto", name: "Auto", minTier: "trivial", maxTier: "hard", contextWindow: 400000, maxTokens: 32000 }, fields);
+		expect(out).toMatchObject({ id: "auto-cheap", name: "Auto Cheap", minTier: "trivial", maxTier: "simple", contextWindow: 400000 });
+	});
+
+	test("cancelled profile edit returns null", async () => {
+		const ui = makeUi([{ type: "input", value: undefined }]);
+		const fields = [{ path: "id", label: "id", kind: "string" }] as FieldSpec[];
+		const out = await editProfile(ui, { id: "auto" }, fields);
+		expect(out).toBeNull();
+	});
+});

package/test/cost.test.ts

@@ -0,0 +1,137 @@
+import { describe, expect, test } from "bun:test";
+
+import { normalizeCatalogModel } from "../src/catalog/openrouter-catalog.ts";
+import type { CatalogModel } from "../src/catalog/types.ts";
+import { computeCost, forecast, priceAt } from "../src/cost/forecast.ts";
+import { EMPTY_USAGE, type UsageCounts } from "../src/cost/types.ts";
+
+const FIXTURE = (await Bun.file("test/fixtures/openrouter-models.json").json()) as { data: unknown[] };
+
+function model(slug: string): CatalogModel {
+	const raw = FIXTURE.data.find((m) => typeof m === "object" && m !== null && "id" in m && m.id === slug);
+	if (raw === undefined) throw new Error(`fixture is missing ${slug}`);
+	const normalized = normalizeCatalogModel(raw);
+	if (normalized === null) throw new Error(`${slug} did not normalize`);
+	return normalized;
+}
+
+function usage(over: Partial<UsageCounts>): UsageCounts {
+	return { ...EMPTY_USAGE, ...over };
+}
+
+const SONNET = model("anthropic/claude-sonnet-4.5"); // publishes cache prices + override tiers
+const ALL = FIXTURE.data.map(normalizeCatalogModel).filter((m): m is CatalogModel => m !== null);
+
+describe("priceAt", () => {
+	test("returns the base price below every override threshold", () => {
+		expect(priceAt(SONNET, 1000).prompt).toBe(SONNET.price.prompt);
+		expect(priceAt(SONNET, 199_999).prompt).toBe(SONNET.price.prompt);
+	});
+
+	test("crosses into the long-context tier at the threshold", () => {
+		const tier = SONNET.priceTiers[0];
+		expect(tier).toBeDefined();
+		if (tier === undefined) return;
+		expect(priceAt(SONNET, tier.minPromptTokens).prompt).toBe(tier.price.prompt);
+		expect(priceAt(SONNET, tier.minPromptTokens + 1).prompt).toBeGreaterThan(SONNET.price.prompt);
+	});
+
+	test("a long conversation is dearer per token than a short one", () => {
+		// The whole reason override tiers are modelled: ignoring them
+		// underestimates long-session cost by roughly half.
+		const short = computeCost(SONNET, usage({ promptTokens: 50_000, completionTokens: 1000 }));
+		const long = computeCost(SONNET, usage({ promptTokens: 400_000, completionTokens: 1000 }));
+		expect(long.total / 400_000).toBeGreaterThan(short.total / 50_000);
+		expect(long.tierAtPromptTokens).toBe(200_000);
+		expect(short.tierAtPromptTokens).toBe(0);
+	});
+});
+
+describe("computeCost", () => {
+	test("components sum to the reported total", () => {
+		const b = computeCost(
+			SONNET,
+			usage({ promptTokens: 10_000, cachedTokens: 6000, cacheWriteTokens: 1000, completionTokens: 500, reasoningTokens: 200, images: 2 }),
+		);
+		const sum = b.freshPrompt + b.cacheRead + b.cacheWrite + b.completion + b.reasoning + b.images + b.request;
+		expect(sum).toBeCloseTo(b.total, 12);
+	});
+
+	test("prompt_tokens already includes cached tokens, so they are not billed twice", () => {
+		// 10k prompt of which 10k cached must cost far less than 10k fresh,
+		// and must not be billed as 20k.
+		const allFresh = computeCost(SONNET, usage({ promptTokens: 10_000 }));
+		const allCached = computeCost(SONNET, usage({ promptTokens: 10_000, cachedTokens: 10_000 }));
+		expect(allCached.total).toBeLessThan(allFresh.total);
+		expect(allCached.freshPrompt).toBe(0);
+		const cacheRead = SONNET.price.cacheRead;
+		expect(cacheRead).toBeDefined();
+		if (cacheRead === undefined) return;
+		expect(allCached.cacheRead).toBeCloseTo(10_000 * cacheRead, 12);
+	});
+
+	test("cache reads are cheaper than fresh prompt tokens wherever published", () => {
+		let checked = 0;
+		for (const m of ALL) {
+			const read = m.price.cacheRead;
+			if (read === undefined || read === 0) continue;
+			checked++;
+			const fresh = computeCost(m, usage({ promptTokens: 20_000 }));
+			const cached = computeCost(m, usage({ promptTokens: 20_000, cachedTokens: 20_000 }));
+			expect(cached.total).toBeLessThanOrEqual(fresh.total);
+		}
+		expect(checked).toBeGreaterThan(0);
+	});
+
+	test("reasoning tokens are a subset of completion tokens and never double-billed", () => {
+		const withReasoning = computeCost(SONNET, usage({ completionTokens: 1000, reasoningTokens: 400 }));
+		const withoutReasoning = computeCost(SONNET, usage({ completionTokens: 1000 }));
+		// Sonnet publishes no separate reasoning rate, so 1000 completion tokens
+		// cost the same whether or not 400 of them were reasoning.
+		expect(withReasoning.total).toBeCloseTo(withoutReasoning.total, 12);
+		// And never more than billing all 1400 separately would have cost.
+		const inflated = computeCost(SONNET, usage({ completionTokens: 1400 }));
+		expect(withReasoning.total).toBeLessThan(inflated.total);
+	});
+
+	test("zero usage costs nothing beyond any flat per-request fee", () => {
+		const b = computeCost(SONNET, EMPTY_USAGE);
+		expect(b.total).toBe(b.request);
+	});
+});
+
+describe("forecast", () => {
+	test("cold is never cheaper than expected, for every model in the catalog", () => {
+		// A budget guard checks the cold number, so this ordering is load-bearing:
+		// several models publish a cache-write rate BELOW their prompt rate, so
+		// the honest worst case is the max of "no cache" and "full cache write".
+		for (const m of ALL) {
+			for (const hitRate of [0, 0.5, 0.9]) {
+				const f = forecast(m, { promptTokens: 30_000, completionTokens: 800, cacheHitRate: hitRate, images: 0 });
+				expect(f.coldUsd).toBeGreaterThanOrEqual(f.expectedUsd - 1e-12);
+			}
+		}
+	});
+
+	test("a higher assumed cache hit rate lowers the expected cost", () => {
+		const cold = forecast(SONNET, { promptTokens: 50_000, completionTokens: 500, cacheHitRate: 0, images: 0 });
+		const warm = forecast(SONNET, { promptTokens: 50_000, completionTokens: 500, cacheHitRate: 0.9, images: 0 });
+		expect(warm.expectedUsd).toBeLessThan(cold.expectedUsd);
+		expect(warm.assumedCacheHitRate).toBeCloseTo(0.9, 12);
+	});
+
+	test("records the assumptions it was given", () => {
+		const f = forecast(SONNET, { promptTokens: 1234, completionTokens: 567, cacheHitRate: 0.25, images: 3 });
+		expect(f.slug).toBe(SONNET.slug);
+		expect(f.assumedPromptTokens).toBe(1234);
+		expect(f.assumedCompletionTokens).toBe(567);
+		expect(f.expectedUsd).toBeGreaterThan(0);
+	});
+
+	test("a cheap model forecasts below an expensive one for identical work", () => {
+		const cheap = model("openai/gpt-5-nano");
+		const dear = model("openai/gpt-5-pro");
+		const args = { promptTokens: 20_000, completionTokens: 1000, cacheHitRate: 0, images: 0 };
+		expect(forecast(cheap, args).expectedUsd).toBeLessThan(forecast(dear, args).expectedUsd);
+	});
+});

package/test/embed-logic.test.ts

@@ -0,0 +1,107 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import {
+	buildProviderConfig,
+	EMBED_PORT_FILE,
+	EMBED_PROVIDER_ID,
+	embedPortPath,
+	readEmbedPort,
+	resolveEmbedPort,
+	writeEmbedPort,
+	type EmbedConfig,
+} from "../omp-extension/embed-logic.ts";
+
+describe("resolveEmbedPort", () => {
+	test("returns 0 (let the OS assign a free port) when AUTO_MODEL_ROUTER_PORT is absent", () => {
+		expect(resolveEmbedPort(undefined)).toBe(0);
+		expect(resolveEmbedPort("")).toBe(0);
+	});
+
+	test("uses an explicit valid env port verbatim", () => {
+		expect(resolveEmbedPort("8812")).toBe(8812);
+		expect(resolveEmbedPort("0")).toBe(0);
+	});
+
+	test("falls back to 0 on junk or out-of-range values", () => {
+		expect(resolveEmbedPort("notaport")).toBe(0);
+		expect(resolveEmbedPort("-1")).toBe(0);
+		expect(resolveEmbedPort("70000")).toBe(0);
+	});
+});
+
+describe("embed port file", () => {
+	let dir: string;
+
+	beforeAll(() => {
+		dir = mkdtempSync(join(tmpdir(), "omp-embed-"));
+	});
+	afterAll(() => {
+		if (dir) rmSync(dir, { recursive: true, force: true });
+	});
+
+	test("round-trips the bound port", () => {
+		const p = embedPortPath(dir);
+		expect(p).toBe(join(dir, EMBED_PORT_FILE));
+		writeEmbedPort(p, 45678);
+		expect(readEmbedPort(p)).toBe(45678);
+	});
+
+	test("returns null for a missing or malformed file", () => {
+		expect(readEmbedPort(embedPortPath(join(dir, "absent")))).toBeNull();
+		writeEmbedPort(embedPortPath(dir), -5);
+		expect(readEmbedPort(embedPortPath(dir))).toBeNull();
+		writeEmbedPort(embedPortPath(dir), 70000);
+		expect(readEmbedPort(embedPortPath(dir))).toBeNull();
+		writeEmbedPort(embedPortPath(dir), 0);
+		expect(readEmbedPort(embedPortPath(dir))).toBeNull();
+	});
+});
+
+describe("buildProviderConfig", () => {
+	const base = {
+		server: { host: "127.0.0.1" },
+		profiles: [
+			{ id: "auto", name: "Auto (auto-model-router)", contextWindow: 400_000, maxTokens: 32_000 },
+			{ id: "auto-cheap", name: "Auto Cheap (auto-model-router)", contextWindow: 400_000, maxTokens: 32_000 },
+		],
+		ledger: { fallbackBlend: { inputPerMtok: 0.2, outputPerMtok: 0.8 } },
+	};
+
+	test("builds a provider config against the actual bound port", () => {
+		const c: EmbedConfig = buildProviderConfig(45678, base);
+		expect(c.baseUrl).toBe("http://127.0.0.1:45678/v1");
+		expect(c.port).toBe(45678);
+		expect(c.host).toBe("127.0.0.1");
+		expect(c.harnessId).toBeUndefined();
+		expect(c.models).toHaveLength(2);
+		expect(c.models[0]).toMatchObject({ id: "auto", contextWindow: 400_000, maxTokens: 32_000 });
+	});
+
+	test("converts cost to USD-per-million-token and applies cache multipliers", () => {
+		const c: EmbedConfig = buildProviderConfig(45678, base);
+		// input 0.2, output 0.8, cacheRead = 0.2*0.1 = 0.02, cacheWrite = 0.2*1.25 = 0.25
+		expect(c.models[0]!.cost).toEqual({ input: 0.2, output: 0.8, cacheRead: 0.02, cacheWrite: 0.25 });
+	});
+
+	test("normalizes a wildcard listen host to loopback", () => {
+		const c: EmbedConfig = buildProviderConfig(45678, { ...base, server: { host: "0.0.0.0" } });
+		expect(c.baseUrl).toBe("http://127.0.0.1:45678/v1");
+	});
+
+	test("carries the harness id through when configured", () => {
+		const c: EmbedConfig = buildProviderConfig(45678, { ...base, server: { host: "127.0.0.1", harnessId: "prod-a" } });
+		expect(c.harnessId).toBe("prod-a");
+	});
+});
+
+describe("embed constants", () => {
+	test("provider id and dummy key stay stable", () => {
+		expect(EMBED_PROVIDER_ID).toBe("auto-model-router");
+	});
+	test("port file name is stable", () => {
+		expect(EMBED_PORT_FILE).toBe("embed.port");
+	});
+});

package/test/escalate.test.ts

@@ -0,0 +1,223 @@
+import { describe, expect, test } from "bun:test";
+import { createProbe } from "../src/router/escalate.ts";
+import type { ProbePlan } from "../src/router/types.ts";
+import type { NormMessage, NormRequest, NormTool, StreamEvent, UpstreamChunk } from "../src/wire/types.ts";
+
+const ALL_TRIGGERS: ReadonlySet<string> = new Set([
+	"malformed_tool_args",
+	"refusal",
+	"empty_completion",
+	"repeat_tool_call",
+	"missing_expected_tool_call",
+	"length_stop",
+	"upstream_error",
+]);
+
+function plan(over: Partial<ProbePlan> = {}): ProbePlan {
+	return { enabled: true, maxTokens: 24, maxHoldMs: 60_000, escalateTo: "simple", ...over };
+}
+
+function req(messages: NormMessage[] = [], over: Partial<NormRequest> = {}): NormRequest {
+	return {
+		protocol: "openai-chat",
+		conversationKey: "k",
+		harnessId: "",
+		requestedModel: "auto",
+		messages,
+		tools: [],
+		forcedToolChoice: false,
+		stream: true,
+		hasImages: false,
+		promptBytes: 0,
+		renderUpstreamBody: () => ({}),
+		...over,
+	};
+}
+
+function chunk(events: StreamEvent[]): UpstreamChunk {
+	return { raw: {}, events };
+}
+
+function text(delta: string): UpstreamChunk {
+	return chunk([{ type: "text", delta }]);
+}
+
+function toolDelta(
+	index: number,
+	fragment: { id?: string; name?: string; argsDelta?: string },
+): UpstreamChunk {
+	const ev: StreamEvent = { type: "tool_call", index, ...fragment };
+	return chunk([ev]);
+}
+
+describe("createProbe", () => {
+	test("valid tool-call JSON commits", () => {
+		const p = createProbe(plan(), req(), ALL_TRIGGERS);
+		expect(p.observe(toolDelta(0, { id: "c1", name: "read", argsDelta: '{"path":"a' }))).toBeNull();
+		const verdict = p.observe(toolDelta(0, { argsDelta: '.ts"}' }));
+		expect(verdict?.action).toBe("commit");
+	});
+
+	test("truncated tool-call JSON at stream end yields malformed_tool_args", () => {
+		// Via the finish event.
+		const p1 = createProbe(plan(), req(), ALL_TRIGGERS);
+		p1.observe(toolDelta(0, { id: "c1", name: "read", argsDelta: '{"path":"a' }));
+		const v1 = p1.observe(chunk([{ type: "finish", reason: "tool_calls" }]));
+		expect(v1?.action).toBe("escalate");
+		expect(v1).toMatchObject({ signal: "malformed_tool_args" });
+
+		// Via stream end with no finish event at all.
+		const p2 = createProbe(plan(), req(), ALL_TRIGGERS);
+		p2.observe(toolDelta(0, { id: "c1", name: "read", argsDelta: '{"path":"a' }));
+		const v2 = p2.verdictOnEnd();
+		expect(v2.action).toBe("escalate");
+		expect(v2).toMatchObject({ signal: "malformed_tool_args" });
+	});
+
+	test("a tool call identical to the previous assistant call yields repeat_tool_call", () => {
+		const history: NormMessage[] = [
+			{ role: "user", text: "read it", images: 0, textBytes: 8, toolCalls: [] },
+			{
+				role: "assistant",
+				text: "",
+				images: 0,
+				textBytes: 0,
+				toolCalls: [{ id: "c1", name: "read", argsJson: '{"path":"a.ts","line":1}' }],
+			},
+			{ role: "tool", text: "file contents", images: 0, textBytes: 13, toolCalls: [], toolCallId: "c1", toolName: "read" },
+		];
+		const p = createProbe(plan(), req(history), ALL_TRIGGERS);
+		// Same call, key order shuffled: still a loop.
+		const verdict = p.observe(toolDelta(0, { id: "c2", name: "read", argsDelta: '{"line":1,"path":"a.ts"}' }));
+		expect(verdict?.action).toBe("escalate");
+		expect(verdict).toMatchObject({ signal: "repeat_tool_call" });
+	});
+
+	test("a different tool call is not a repeat", () => {
+		const history: NormMessage[] = [
+			{
+				role: "assistant",
+				text: "",
+				images: 0,
+				textBytes: 0,
+				toolCalls: [{ id: "c1", name: "read", argsJson: '{"path":"a.ts"}' }],
+			},
+		];
+		const p = createProbe(plan(), req(history), ALL_TRIGGERS);
+		const verdict = p.observe(toolDelta(0, { id: "c2", name: "read", argsDelta: '{"path":"b.ts"}' }));
+		expect(verdict?.action).toBe("commit");
+	});
+
+	test("a disabled plan commits on the first chunk", () => {
+		const p = createProbe(plan({ enabled: false }), req(), ALL_TRIGGERS);
+		const verdict = p.observe(text("anything at all"));
+		expect(verdict?.action).toBe("commit");
+		expect(p.held()).toHaveLength(1);
+	});
+
+	test("a signal absent from triggers never fires", () => {
+		// Truncated args would be malformed_tool_args, but the trigger is off.
+		const p1 = createProbe(plan(), req(), new Set(["refusal"]));
+		p1.observe(toolDelta(0, { id: "c1", name: "read", argsDelta: '{"path":"a' }));
+		const v1 = p1.observe(chunk([{ type: "finish", reason: "tool_calls" }]));
+		expect(v1?.action).toBe("commit");
+
+		// Empty completion, but empty_completion is off.
+		const p2 = createProbe(plan(), req(), new Set(["malformed_tool_args"]));
+		p2.observe(chunk([{ type: "finish", reason: "stop" }]));
+		const v2 = p2.verdictOnEnd();
+		expect(v2.action).toBe("commit");
+	});
+
+	test("refusal openers escalate as soon as text arrives", () => {
+		const p = createProbe(plan(), req(), ALL_TRIGGERS);
+		const verdict = p.observe(text("I'm sorry, but I can't help with that request."));
+		expect(verdict?.action).toBe("escalate");
+		expect(verdict).toMatchObject({ signal: "refusal" });
+	});
+
+	test("a forced tool choice answered with prose yields missing_expected_tool_call", () => {
+		const tools: NormTool[] = [{ name: "read", description: "read a file", schemaBytes: 42 }];
+		const p = createProbe(plan(), req([], { tools, forcedToolChoice: true }), ALL_TRIGGERS);
+		p.observe(text("Sure, here is some prose instead."));
+		const verdict = p.observe(chunk([{ type: "finish", reason: "stop" }]));
+		expect(verdict?.action).toBe("escalate");
+		expect(verdict).toMatchObject({ signal: "missing_expected_tool_call" });
+	});
+
+	test("enough held text commits", () => {
+		const p = createProbe(plan({ maxTokens: 2 }), req(), ALL_TRIGGERS);
+		const verdict = p.observe(text("this is well over eight characters"));
+		expect(verdict?.action).toBe("commit");
+	});
+
+	test("an empty stop with nothing emitted yields empty_completion", () => {
+		const p = createProbe(plan(), req(), ALL_TRIGGERS);
+		const verdict = p.observe(chunk([{ type: "finish", reason: "stop" }]));
+		expect(verdict?.action).toBe("escalate");
+		expect(verdict).toMatchObject({ signal: "empty_completion" });
+	});
+
+	test("a stalled stream escalates at the hold ceiling instead of committing silence", () => {
+		let t = 0;
+		const p = createProbe(plan({ maxHoldMs: 1_000 }), req(), ALL_TRIGGERS, () => t);
+		expect(p.observe(chunk([]))).toBeNull();
+		t = 1_001;
+		const verdict = p.observe(chunk([]));
+		expect(verdict?.action).toBe("escalate");
+		expect(verdict).toMatchObject({ signal: "empty_completion" });
+	});
+
+	test("the hold ceiling still commits when content has arrived", () => {
+		let t = 0;
+		const p = createProbe(plan({ maxTokens: 1_000, maxHoldMs: 1_000 }), req(), ALL_TRIGGERS, () => t);
+		expect(p.observe(text("partial answer"))).toBeNull();
+		t = 1_001;
+		const verdict = p.observe(text(" more"));
+		expect(verdict?.action).toBe("commit");
+	});
+
+	test("a length finish on prose commits: that is the caller's max_tokens", () => {
+		// Escalating cannot fix it — the retry runs under the same cap and
+		// truncates in the same place, so it would just bill twice.
+		const p = createProbe(plan({ maxTokens: 1_000 }), req(), ALL_TRIGGERS);
+		expect(p.observe(text("a long answer that ran out of room"))).toBeNull();
+		const verdict = p.observe(chunk([{ type: "finish", reason: "length" }]));
+		expect(verdict?.action).toBe("commit");
+	});
+
+	test("a length finish that truncated tool-call arguments still escalates", () => {
+		// Structurally unusable output: another model may emit a complete call.
+		const p = createProbe(plan({ maxTokens: 1_000 }), req(), ALL_TRIGGERS);
+		expect(p.observe(toolDelta(0, { id: "c1", name: "read", argsDelta: '{"path":"a' }))).toBeNull();
+		const verdict = p.observe(chunk([{ type: "finish", reason: "length" }]));
+		expect(verdict?.action).toBe("escalate");
+	});
+
+	test("a length finish having produced nothing escalates as an empty completion", () => {
+		const p = createProbe(plan({ maxTokens: 1_000 }), req(), ALL_TRIGGERS);
+		const verdict = p.observe(chunk([{ type: "finish", reason: "length" }]));
+		expect(verdict?.action).toBe("escalate");
+		if (verdict?.action === "escalate") expect(verdict.signal).toBe("empty_completion");
+	});
+
+	test("reasoning-only output counts as alive at the hold ceiling", () => {
+		// A reasoning model that has emitted only reasoning tokens after the
+		// ceiling is working normally; escalating would discard a healthy paid
+		// generation.
+		let t = 0;
+		const p = createProbe(plan({ maxTokens: 1_000, maxHoldMs: 1_000 }), req(), ALL_TRIGGERS, () => t);
+		expect(p.observe(chunk([{ type: "reasoning", delta: "weighing options" }]))).toBeNull();
+		t = 1_001;
+		const verdict = p.observe(chunk([{ type: "reasoning", delta: " further" }]));
+		expect(verdict?.action).toBe("commit");
+	});
+
+	test("a stream that ENDS with only reasoning is still hollow", () => {
+		const p = createProbe(plan({ maxTokens: 1_000 }), req(), ALL_TRIGGERS);
+		expect(p.observe(chunk([{ type: "reasoning", delta: "thinking" }]))).toBeNull();
+		const verdict = p.verdictOnEnd();
+		expect(verdict.action).toBe("escalate");
+		if (verdict.action === "escalate") expect(verdict.signal).toBe("empty_completion");
+	});
+});