auto-model-router 0.2.2 → 0.2.8

package/test/compaction.test.ts

@@ -0,0 +1,148 @@
+import { describe, expect, test } from "bun:test";
+
+import type { CompactionConfig } from "../src/config/types.ts";
+import { planCompaction } from "../src/router/compaction.ts";
+import { parseChatRequest } from "../src/wire/openai/request.ts";
+import type { NormMessage } from "../src/wire/types.ts";
+
+const CFG: CompactionConfig = {
+	enabled: true,
+	budgetTokens: 1,
+	fitToWindow: false,
+	protectRecentTurns: 2,
+	maxToolResultBytes: 50,
+	keepHeadBytes: 10,
+	keepTailBytes: 10,
+	elideSupersededReads: true,
+	collapseDuplicateResults: true,
+};
+
+function user(text: string): NormMessage {
+	return { role: "user", text, images: 0, textBytes: Buffer.byteLength(text), toolCalls: [] };
+}
+function asst(id: string, name: string, args: string): NormMessage {
+	return { role: "assistant", text: "", images: 0, textBytes: 0, toolCalls: [{ id, name, argsJson: args }] };
+}
+function toolMsg(id: string, name: string, content: string): NormMessage {
+	return { role: "tool", text: content, images: 0, textBytes: Buffer.byteLength(content), toolCalls: [], toolCallId: id, toolName: name };
+}
+
+// Two recent turns of padding so early tool results fall outside the protected window.
+const PAD: NormMessage[] = [asst("z1", "bash", '{"command":"ls"}'), toolMsg("z1", "bash", "recent"), user("continue")];
+const big = (marker: string): string => `${marker}:${"x".repeat(200)}`;
+
+describe("planCompaction", () => {
+	test("is a no-op when disabled", () => {
+		const msgs = [user("go"), asst("c1", "read", '{"path":"a"}'), toolMsg("c1", "read", big("A")), ...PAD];
+		expect(planCompaction(msgs, { ...CFG, enabled: false }, 0, 10_000).edits).toEqual([]);
+	});
+
+	test("truncates a large stale tool result, protecting recent turns", () => {
+		const msgs = [
+			user("go"),
+			asst("c1", "read", '{"path":"a.ts"}'),
+			toolMsg("c1", "read", big("OLD")), // eligible: outside the protected window
+			asst("c2", "read", '{"path":"b.ts"}'),
+			toolMsg("c2", "read", big("RECENT")), // within protectRecentTurns=2 → protected
+			user("next"),
+		];
+		const { edits } = planCompaction(msgs, CFG, 1, 10_000);
+		expect(edits).toHaveLength(1);
+		expect(edits[0]?.index).toBe(2);
+		expect(edits[0]?.mode).toBe("truncate");
+	});
+
+	test("collapses byte-identical duplicate results, keeping the last", () => {
+		const msgs = [
+			user("go"),
+			asst("c1", "read", '{"path":"a.ts"}'),
+			toolMsg("c1", "read", big("DUP")),
+			asst("c2", "read", '{"path":"a.ts"}'),
+			toolMsg("c2", "read", big("DUP")),
+			...PAD,
+		];
+		const { edits } = planCompaction(msgs, { ...CFG, elideSupersededReads: false }, 10_000, 10_000);
+		// Only the earlier identical copy is elided; the later one survives.
+		expect(edits.map((e) => e.index)).toEqual([2]);
+		expect(edits[0]?.mode).toBe("stub");
+	});
+
+	test("elides a read superseded by a newer call to the same resource", () => {
+		const msgs = [
+			user("go"),
+			asst("c1", "read", '{"path":"a.ts"}'),
+			toolMsg("c1", "read", big("V1")),
+			asst("c2", "read", '{"path":"a.ts"}'),
+			toolMsg("c2", "read", big("V2")), // different content, same path → supersedes c1
+			...PAD,
+		];
+		const { edits } = planCompaction(msgs, { ...CFG, collapseDuplicateResults: false }, 10_000, 10_000);
+		expect(edits.map((e) => e.index)).toEqual([2]);
+		expect(edits[0]?.mode).toBe("stub");
+	});
+
+	test("different resources are not superseded", () => {
+		const msgs = [
+			user("go"),
+			asst("c1", "read", '{"path":"a.ts"}'),
+			toolMsg("c1", "read", "small"),
+			asst("c2", "read", '{"path":"b.ts"}'),
+			toolMsg("c2", "read", "small"),
+			...PAD,
+		];
+		expect(planCompaction(msgs, CFG, 10_000, 10_000).edits).toEqual([]);
+	});
+
+	test("is deterministic and idempotent on stable input", () => {
+		const msgs = [user("go"), asst("c1", "read", '{"path":"a.ts"}'), toolMsg("c1", "read", big("OLD")), ...PAD];
+		const a = planCompaction(msgs, CFG, 1, 10_000);
+		const b = planCompaction(msgs, CFG, 1, 10_000);
+		expect(a).toEqual(b);
+	});
+});
+
+describe("renderUpstreamBody applies compaction", () => {
+	function bodyWith(messages: unknown[]): Record<string, unknown> {
+		return { model: "auto", messages };
+	}
+	const MUT = {
+		slug: "x/y",
+		fallbacks: [],
+		sessionId: "s",
+		cacheBreakpointMessageIndices: [],
+		reasoning: undefined,
+		maxTokens: undefined,
+		stripAssistantReasoning: false,
+	};
+
+	test("truncates content in place with a recoverable breadcrumb, preserving pairing", () => {
+		const raw = [
+			{ role: "user", content: "go" },
+			{ role: "assistant", content: null, tool_calls: [{ id: "c1", type: "function", function: { name: "read", arguments: "{}" } }] },
+			{ role: "tool", tool_call_id: "c1", content: "HEAD" + "x".repeat(500) + "TAIL" },
+		];
+		const req = parseChatRequest(bodyWith(raw), new Headers());
+		const out = req.renderUpstreamBody({ ...MUT, compactionPlan: [{ index: 2, mode: "truncate", keepHead: 4, keepTail: 4, note: "large read result" }] });
+		const messages = out.messages as { role: string; content: unknown }[];
+		expect(messages).toHaveLength(3); // no message removed → pairing intact
+		const content = messages[2]?.content;
+		expect(typeof content).toBe("string");
+		expect(content as string).toContain("elided");
+		expect(content as string).toContain("re-run the tool to restore");
+		expect((content as string).length).toBeLessThan(510);
+		expect(content as string).toStartWith("HEAD");
+		expect(content as string).toEndWith("TAIL");
+	});
+
+	test("stub replaces the whole content with a breadcrumb", () => {
+		const raw = [
+			{ role: "user", content: "go" },
+			{ role: "assistant", content: null, tool_calls: [{ id: "c1", type: "function", function: { name: "read", arguments: "{}" } }] },
+			{ role: "tool", tool_call_id: "c1", content: "a".repeat(300) },
+		];
+		const req = parseChatRequest(bodyWith(raw), new Headers());
+		const out = req.renderUpstreamBody({ ...MUT, compactionPlan: [{ index: 2, mode: "stub", keepHead: 0, keepTail: 0, note: "identical repeated read result" }] });
+		const messages = out.messages as { content: string }[];
+		expect(messages[2]?.content).toBe("[omp-router: identical repeated read result elided to save context; re-run the tool to restore]");
+	});
+});

package/test/context-bridge.test.ts

@@ -0,0 +1,337 @@
+import { describe, expect, test } from "bun:test";
+
+import type { AgentDoxClient } from "../src/context/agentdox.ts";
+import { createContextBridge } from "../src/context/bridge.ts";
+import { createContextStore } from "../src/context/store.ts";
+import type { ContextResolveInput } from "../src/context/types.ts";
+import { createLogger } from "../src/util/log.ts";
+import { openDb } from "../src/util/sqlite.ts";
+import { injectForTest } from "./helpers/inject.ts";
+
+const log = createLogger("silent");
+
+interface FakeClient extends AgentDoxClient {
+	assembleCalls: number;
+	appended: { sessionId: string; role: string; content: string; refs: string[] }[];
+	sessionsCreated: number;
+	prompt: string;
+}
+
+function mkClient(prompt = "MEMORY: player digs in 3/4 top-down"): FakeClient {
+	const c: FakeClient = {
+		assembleCalls: 0,
+		appended: [],
+		sessionsCreated: 0,
+		prompt,
+		async assemble() {
+			c.assembleCalls++;
+			return c.prompt;
+		},
+		async createSession() {
+			c.sessionsCreated++;
+			return `ses_${c.sessionsCreated}`;
+		},
+		async append(sessionId, role, content, refs) {
+			c.appended.push({ sessionId, role, content, refs });
+			return true;
+		},
+	};
+	return c;
+}
+
+type BridgeOpts = Parameters<typeof createContextBridge>[0];
+
+function mkBridge(client: AgentDoxClient, over: Partial<BridgeOpts> = {}) {
+	const db = openDb(":memory:");
+	const opts: BridgeOpts = {
+		client,
+		store: createContextStore(db),
+		log,
+		maxStalenessMs: 900_000,
+		maxBlockChars: 24_000,
+		recordTurns: true,
+		maxQueue: 64,
+		...over,
+	};
+	return { db, bridge: createContextBridge(opts) };
+}
+
+function input(over: Partial<ContextResolveInput> = {}): ContextResolveInput {
+	return {
+		scope: "ashlands",
+		conversationKey: "k1",
+		pinnedVersion: null,
+		pinnedFetchedAtMs: 0,
+		modelSwitching: false,
+		retrying: false,
+		query: "movement rules",
+		...over,
+	};
+}
+
+describe("context bridge refresh policy", () => {
+	test("fetches on the first turn, then pins without re-fetching", async () => {
+		const client = mkClient();
+		const { bridge, db } = mkBridge(client);
+		try {
+			const first = await bridge.resolve(input());
+			expect(first).not.toBeNull();
+			expect(client.assembleCalls).toBe(1);
+
+			// Steady state: same model, not retrying, not stale => no fetch, same bytes.
+			const second = await bridge.resolve(
+				input({ pinnedVersion: first?.version ?? null, pinnedFetchedAtMs: first?.fetchedAtMs ?? 0 }),
+			);
+			expect(client.assembleCalls).toBe(1);
+			expect(second?.block).toBe(first?.block ?? "");
+		} finally {
+			db.close();
+		}
+	});
+
+	test("refreshes when the model switches, because the cache is already forfeit", async () => {
+		const client = mkClient();
+		const { bridge, db } = mkBridge(client);
+		try {
+			const first = await bridge.resolve(input());
+			await bridge.resolve(
+				input({
+					pinnedVersion: first?.version ?? null,
+					pinnedFetchedAtMs: first?.fetchedAtMs ?? 0,
+					modelSwitching: true,
+				}),
+			);
+			expect(client.assembleCalls).toBe(2);
+		} finally {
+			db.close();
+		}
+	});
+
+	test("refreshes on a retry", async () => {
+		const client = mkClient();
+		const { bridge, db } = mkBridge(client);
+		try {
+			const first = await bridge.resolve(input());
+			await bridge.resolve(
+				input({
+					pinnedVersion: first?.version ?? null,
+					pinnedFetchedAtMs: first?.fetchedAtMs ?? 0,
+					retrying: true,
+				}),
+			);
+			expect(client.assembleCalls).toBe(2);
+		} finally {
+			db.close();
+		}
+	});
+
+	test("refreshes once the staleness TTL elapses", async () => {
+		const client = mkClient();
+		const { bridge, db } = mkBridge(client, { maxStalenessMs: 1_000 });
+		try {
+			const first = await bridge.resolve(input());
+			await bridge.resolve(input({ pinnedVersion: first?.version ?? null, pinnedFetchedAtMs: Date.now() - 5_000 }));
+			expect(client.assembleCalls).toBe(2);
+		} finally {
+			db.close();
+		}
+	});
+
+	test("version is a content hash, so an unchanged re-assembly keeps the cache warm", async () => {
+		const client = mkClient();
+		const { bridge, db } = mkBridge(client);
+		try {
+			const first = await bridge.resolve(input());
+			// Force a refetch; agentdox returns byte-identical content.
+			const second = await bridge.resolve(
+				input({
+					pinnedVersion: first?.version ?? null,
+					pinnedFetchedAtMs: first?.fetchedAtMs ?? 0,
+					modelSwitching: true,
+				}),
+			);
+			expect(client.assembleCalls).toBe(2);
+			expect(second?.version).toBe(first?.version ?? "");
+			expect(second?.block).toBe(first?.block ?? "");
+		} finally {
+			db.close();
+		}
+	});
+
+	test("changed content yields a new version", async () => {
+		const client = mkClient();
+		const { bridge, db } = mkBridge(client);
+		try {
+			const first = await bridge.resolve(input());
+			client.prompt = "MEMORY: player digs in 3/4 top-down; hard edges only";
+			const second = await bridge.resolve(
+				input({
+					pinnedVersion: first?.version ?? null,
+					pinnedFetchedAtMs: first?.fetchedAtMs ?? 0,
+					modelSwitching: true,
+				}),
+			);
+			expect(second?.version).not.toBe(first?.version ?? "");
+		} finally {
+			db.close();
+		}
+	});
+
+	test("an unreachable agentdox keeps serving the pinned block", async () => {
+		const client = mkClient();
+		const { bridge, db } = mkBridge(client);
+		try {
+			const first = await bridge.resolve(input());
+			client.assemble = async () => null; // agentdox goes down
+			const second = await bridge.resolve(
+				input({
+					pinnedVersion: first?.version ?? null,
+					pinnedFetchedAtMs: first?.fetchedAtMs ?? 0,
+					modelSwitching: true,
+				}),
+			);
+			expect(second?.block).toBe(first?.block ?? "");
+		} finally {
+			db.close();
+		}
+	});
+
+	test("an empty scope is inert", async () => {
+		const client = mkClient();
+		const { bridge, db } = mkBridge(client);
+		try {
+			expect(await bridge.resolve(input({ scope: "" }))).toBeNull();
+			expect(client.assembleCalls).toBe(0);
+		} finally {
+			db.close();
+		}
+	});
+
+	test("blocks survive a restart, so the same bytes are re-injected", async () => {
+		const client = mkClient();
+		const db = openDb(":memory:");
+		try {
+			const opts: BridgeOpts = {
+				client,
+				store: createContextStore(db),
+				log,
+				maxStalenessMs: 900_000,
+				maxBlockChars: 24_000,
+				recordTurns: true,
+				maxQueue: 64,
+			};
+			const first = await createContextBridge(opts).resolve(input());
+			// A "restart": brand-new bridge over the same store.
+			const after = await createContextBridge(opts).resolve(
+				input({ pinnedVersion: first?.version ?? null, pinnedFetchedAtMs: first?.fetchedAtMs ?? 0 }),
+			);
+			expect(after?.block).toBe(first?.block ?? "");
+			expect(client.assembleCalls).toBe(1);
+		} finally {
+			db.close();
+		}
+	});
+});
+
+describe("context bridge write-back", () => {
+	test("creates one session per conversation and attributes the model", async () => {
+		const client = mkClient();
+		const { bridge, db } = mkBridge(client);
+		try {
+			bridge.recordTurn({
+				scope: "ashlands",
+				conversationKey: "k1",
+				title: "movement fix",
+				userText: "fix movement",
+				assistantText: "done",
+				slug: "anthropic/claude-haiku-4.5",
+				tier: "simple",
+			});
+			bridge.recordTurn({
+				scope: "ashlands",
+				conversationKey: "k1",
+				title: "movement fix",
+				userText: "now the camera",
+				assistantText: "ok",
+				slug: "anthropic/claude-opus-4.5",
+				tier: "hard",
+			});
+			await bridge.flush();
+
+			expect(client.sessionsCreated).toBe(1);
+			expect(client.appended).toHaveLength(4);
+			const assistants = client.appended.filter((m) => m.role === "assistant");
+			expect(assistants[0]?.refs).toEqual(["model:anthropic/claude-haiku-4.5", "tier:simple"]);
+			expect(assistants[1]?.refs).toEqual(["model:anthropic/claude-opus-4.5", "tier:hard"]);
+		} finally {
+			db.close();
+		}
+	});
+
+	test("recordTurns=false writes nothing", async () => {
+		const client = mkClient();
+		const { bridge, db } = mkBridge(client, { recordTurns: false });
+		try {
+			bridge.recordTurn({
+				scope: "ashlands",
+				conversationKey: "k1",
+				title: "t",
+				userText: "u",
+				assistantText: "a",
+				slug: "x",
+				tier: "simple",
+			});
+			await bridge.flush();
+			expect(client.appended).toHaveLength(0);
+		} finally {
+			db.close();
+		}
+	});
+});
+
+describe("context injection into the wire body", () => {
+	test("appends to the last system message, leaving breakpoint indices valid", () => {
+		const body = {
+			model: "auto",
+			messages: [
+				{ role: "system", content: "you are omp" },
+				{ role: "user", content: "hi" },
+			],
+		};
+		const out = injectForTest(body, "BLOCK", [0]);
+		const msgs = out.messages as Record<string, unknown>[];
+		// No new message: the indices the core computed stay correct.
+		expect(msgs).toHaveLength(2);
+		const content = msgs[0]?.content;
+		const text = Array.isArray(content) ? JSON.stringify(content) : String(content);
+		expect(text).toContain("you are omp");
+		expect(text).toContain("BLOCK");
+		// The breakpoint landed on the system message that now carries the block.
+		expect(text).toContain("cache_control");
+	});
+
+	test("prepends a system message and shifts breakpoints when there is none", () => {
+		const body = { model: "auto", messages: [{ role: "user", content: "hi" }] };
+		const out = injectForTest(body, "BLOCK", [0]);
+		const msgs = out.messages as Record<string, unknown>[];
+		expect(msgs).toHaveLength(2);
+		expect(msgs[0]?.role).toBe("system");
+		// The user message that was index 0 is now index 1, and the breakpoint
+		// followed it — otherwise the marker would land on the injected block.
+		expect(JSON.stringify(msgs[1]?.content ?? "")).toContain("cache_control");
+	});
+
+	test("no contextBlock leaves the body untouched", () => {
+		const body = {
+			model: "auto",
+			messages: [
+				{ role: "system", content: "sys" },
+				{ role: "user", content: "hi" },
+			],
+		};
+		const out = injectForTest(body, "", [0]);
+		const msgs = out.messages as Record<string, unknown>[];
+		expect(msgs).toHaveLength(2);
+		expect(JSON.stringify(msgs)).not.toContain("project-context");
+	});
+});

package/test/embed-logic.test.ts

@@ -5,6 +5,7 @@ import { join } from "node:path";
 
 import {
 	buildProviderConfig,
+	deriveAgentdoxScope,
 	EMBED_PORT_FILE,
 	EMBED_PROVIDER_ID,
 	embedPortPath,
@@ -105,3 +106,34 @@ describe("embed constants", () => {
 		expect(EMBED_PORT_FILE).toBe("embed.port");
 	});
 });
+
+describe("agentdox scope", () => {
+	test("derives a slug from the workspace basename", () => {
+		expect(deriveAgentdoxScope("E:/projects/Ashlands/Ashlands")).toBe("ashlands");
+		expect(deriveAgentdoxScope("/home/drew/omp-router")).toBe("omp-router");
+		expect(deriveAgentdoxScope("E:\\projects\\My Game\\")).toBe("my-game");
+		expect(deriveAgentdoxScope("")).toBe("");
+	});
+
+	test("an explicit defaultScope wins over the derived one", () => {
+		const base = {
+			server: { host: "127.0.0.1" },
+			profiles: [],
+			ledger: { fallbackBlend: { inputPerMtok: 1, outputPerMtok: 1 } },
+		};
+		const derived = buildProviderConfig(1234, { ...base, context: { enabled: true, defaultScope: "" } }, "/x/ashlands");
+		expect(derived.agentdoxScope).toBe("ashlands");
+		const explicit = buildProviderConfig(1234, { ...base, context: { enabled: true, defaultScope: "pinned" } }, "/x/ashlands");
+		expect(explicit.agentdoxScope).toBe("pinned");
+	});
+
+	test("no scope header when the bridge is off", () => {
+		const cfg = {
+			server: { host: "127.0.0.1" },
+			profiles: [],
+			ledger: { fallbackBlend: { inputPerMtok: 1, outputPerMtok: 1 } },
+			context: { enabled: false, defaultScope: "ashlands" },
+		};
+		expect(buildProviderConfig(1234, cfg, "/x/ashlands").agentdoxScope).toBeUndefined();
+	});
+});

package/test/escalate.test.ts

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

package/test/exploration.test.ts

@@ -2,7 +2,7 @@ import { describe, expect, test } from "bun:test";
 
 import { normalizeCatalogModel } from "../src/catalog/openrouter-catalog.ts";
 import type { CatalogModel, CatalogSnapshot } from "../src/catalog/types.ts";
-import { loadConfig } from "../src/config/load.ts";
+import { DEFAULT_CONFIG } from "../src/config/defaults.ts";
 import type { ExplorationConfig, ProfileConfig, RouterConfig } from "../src/config/types.ts";
 import { scoreHeuristic } from "../src/router/classify.ts";
 import { extractFeatures } from "../src/router/features.ts";
@@ -15,7 +15,9 @@ const FIXTURE = (await Bun.file("test/fixtures/openrouter-models.json").json())
 const MODELS: CatalogModel[] = FIXTURE.data.map(normalizeCatalogModel).filter((m): m is CatalogModel => m !== null);
 const SNAPSHOT: CatalogSnapshot = { models: MODELS, fetchedAtMs: Date.now() };
 
-const BASE = loadConfig({});
+// Shipped defaults, not loadConfig({}) — the latter merges the live home
+// config.yml and makes this suite depend on the developer's local settings.
+const BASE = DEFAULT_CONFIG;
 const PROFILE: ProfileConfig = {
 	id: "auto",
 	name: "Auto",
@@ -52,6 +54,8 @@ function state(over: Partial<ConversationState> = {}): ConversationState {
 		lastPromptTokens: 0,
 		cacheWarmSlug: null,
 		cacheWarmAtMs: 0,
+		contextVersion: null,
+		contextFetchedAtMs: 0,
 		updatedAtMs: NOW,
 		...over,
 	};