auto-model-router 0.1.0

package/test/tier-plan.test.ts

@@ -0,0 +1,302 @@
+import { describe, expect, test } from "bun:test";
+
+import { joinBenchmarks, normalizeCatalogModel } from "../src/catalog/openrouter-catalog.ts";
+import type { CatalogModel, CatalogSnapshot } from "../src/catalog/types.ts";
+import { loadConfig } from "../src/config/load.ts";
+import { buildCandidates } from "../src/router/candidates.ts";
+import { extractFeatures } from "../src/router/features.ts";
+import { computeTierPlan, effectiveQualityFloor, tierPlanFor } from "../src/router/tier-plan.ts";
+import { TIER_ORDER } from "../src/router/types.ts";
+import { parseChatRequest } from "../src/wire/openai/request.ts";
+
+const BASE = loadConfig({});
+
+/** Raw `/models`-shaped record with a controllable coding score and price. */
+function raw(id: string, coding: number | null, inPerMtok: number): Record<string, unknown> {
+	const record: Record<string, unknown> = {
+		id,
+		canonical_slug: id,
+		name: id,
+		context_length: 200_000,
+		pricing: { prompt: String(inPerMtok / 1e6), completion: String((inPerMtok * 3) / 1e6) },
+		supported_parameters: ["tools"],
+		architecture: { input_modalities: ["text"], tokenizer: "GPT" },
+		created: 1_700_000_000,
+	};
+	if (coding !== null) {
+		record.benchmarks = { artificial_analysis: { coding_index: coding, intelligence_index: coding, agentic_index: coding } };
+	}
+	return record;
+}
+
+function models(specs: ReadonlyArray<[string, number | null, number]>): CatalogModel[] {
+	const out: CatalogModel[] = [];
+	for (const [id, coding, price] of specs) {
+		const m = normalizeCatalogModel(raw(id, coding, price));
+		if (m !== null) out.push(m);
+	}
+	return out;
+}
+
+function snapshot(list: CatalogModel[]): CatalogSnapshot {
+	return { models: list, fetchedAtMs: Date.now(), keyScoped: true };
+}
+
+describe("joinBenchmarks", () => {
+	test("copies benchmarks onto key-scoped records matched by id", () => {
+		const keyScoped = [{ id: "a/one" }, { id: "b/two" }];
+		const pub = [
+			{ id: "a/one", benchmarks: { artificial_analysis: { coding_index: 70 } } },
+			{ id: "c/three", benchmarks: { artificial_analysis: { coding_index: 10 } } },
+		];
+		expect(joinBenchmarks(keyScoped, pub)).toBe(1);
+		expect(keyScoped[0]).toHaveProperty("benchmarks");
+		expect(keyScoped[1]).not.toHaveProperty("benchmarks");
+	});
+
+	test("falls back to canonical_slug", () => {
+		const keyScoped = [{ id: "vendor/model-preview", canonical_slug: "vendor/model" }];
+		const pub = [{ id: "vendor/model", benchmarks: { artificial_analysis: { coding_index: 55 } } }];
+		expect(joinBenchmarks(keyScoped, pub)).toBe(1);
+	});
+
+	test("strips a leading ~ from an alias id", () => {
+		const keyScoped = [{ id: "~vendor/model-latest" }];
+		const pub = [{ id: "vendor/model-latest", benchmarks: { artificial_analysis: { coding_index: 60 } } }];
+		expect(joinBenchmarks(keyScoped, pub)).toBe(1);
+	});
+
+	/** Reads the joined coding index off a raw record without narrowing games. */
+	function codingOf(record: unknown): number | undefined {
+		const rec = record as { benchmarks?: { artificial_analysis?: { coding_index?: number } } };
+		return rec.benchmarks?.artificial_analysis?.coding_index;
+	}
+
+	test("never overwrites benchmarks that are already present", () => {
+		const keyScoped: unknown[] = [{ id: "a/one", benchmarks: { artificial_analysis: { coding_index: 1 } } }];
+		const pub: unknown[] = [{ id: "a/one", benchmarks: { artificial_analysis: { coding_index: 99 } } }];
+		expect(joinBenchmarks(keyScoped, pub)).toBe(0);
+		expect(codingOf(keyScoped[0])).toBe(1);
+	});
+
+	test("a real id beats an alias target for the same key", () => {
+		const keyScoped: unknown[] = [{ id: "vendor/model" }];
+		const pub: unknown[] = [
+			{ id: "other/model", canonical_slug: "vendor/model", benchmarks: { artificial_analysis: { coding_index: 10 } } },
+			{ id: "vendor/model", benchmarks: { artificial_analysis: { coding_index: 80 } } },
+		];
+		joinBenchmarks(keyScoped, pub);
+		expect(codingOf(keyScoped[0])).toBe(80);
+	});
+
+	test("tolerates junk records on both sides", () => {
+		expect(joinBenchmarks([null, 7, "x"], [null, { id: "a" }])).toBe(0);
+	});
+
+	test("normalizing a joined record yields a scored model", () => {
+		const keyScoped: unknown[] = [raw("a/one", null, 1)];
+		joinBenchmarks(keyScoped, [raw("a/one", 66, 1)]);
+		const model = normalizeCatalogModel(keyScoped[0]);
+		expect(model?.quality.coding).toBe(66);
+	});
+});
+
+describe("computeTierPlan", () => {
+	test("bands ascend across tiers", () => {
+		const plan = computeTierPlan(
+			models([
+				["a/1", 10, 0.1],
+				["a/2", 30, 0.1],
+				["a/3", 50, 0.1],
+				["a/4", 70, 0.1],
+			]),
+			BASE,
+		);
+		const f = plan.floors.coding;
+		expect(f.trivial).toBe(10);
+		expect(f.simple).toBe(30);
+		expect(f.moderate).toBe(50);
+		expect(f.hard).toBe(70);
+	});
+
+	test("an all-unscored catalog yields zero floors, never an imputed score", () => {
+		const plan = computeTierPlan(
+			models([
+				["a/1", null, 0.1],
+				["a/2", null, 5],
+			]),
+			BASE,
+		);
+		for (const tier of TIER_ORDER) expect(plan.floors.coding[tier]).toBe(0);
+		expect(plan.scoredCount.coding).toBe(0);
+	});
+
+	test("every tier floor is met by at least one available model", () => {
+		const list = models([
+			["a/1", 12, 0.1],
+			["a/2", 44, 0.2],
+			["a/3", 61, 0.3],
+			["a/4", 63, 0.4],
+			["a/5", 77, 0.5],
+		]);
+		const plan = computeTierPlan(list, BASE);
+		for (const tier of TIER_ORDER) {
+			const floor = plan.floors.coding[tier];
+			expect(list.some((m) => (m.quality.coding ?? -1) >= floor), `tier ${tier} floor ${floor}`).toBe(true);
+		}
+	});
+
+	test("excludes built-in denials from the ranking", () => {
+		// The batch entry is cheap and scored, but selection can never pick it,
+		// so it must not drag the bands down.
+		const plan = computeTierPlan(
+			models([
+				["a/1:batch", 1, 0.1],
+				["~a/latest", 2, 0.1],
+				["a/2", 70, 0.1],
+			]),
+			BASE,
+		);
+		expect(plan.scoredCount.coding).toBe(1);
+		expect(plan.floors.coding.trivial).toBe(70);
+	});
+
+	test("a single scored model puts that model in every tier", () => {
+		const plan = computeTierPlan(models([["a/1", 42, 0.1]]), BASE);
+		for (const tier of TIER_ORDER) expect(plan.floors.coding[tier]).toBe(42);
+	});
+
+	test("scores each axis independently", () => {
+		const plan = computeTierPlan(models([["a/1", 30, 0.1]]), BASE);
+		expect(plan.scoredCount.coding).toBe(1);
+		expect(plan.scoredCount.agentic).toBe(1);
+		expect(plan.scoredCount.intelligence).toBe(1);
+	});
+});
+
+describe("effectiveQualityFloor", () => {
+	const plan = computeTierPlan(
+		models([
+			["a/1", 20, 0.1],
+			["a/2", 40, 0.1],
+			["a/3", 60, 0.1],
+			["a/4", 80, 0.1],
+		]),
+		BASE,
+	);
+
+	test("relaxes a floor the catalog cannot meet", () => {
+		expect(effectiveQualityFloor(95, "hard", "coding", plan)).toBe(80);
+	});
+
+	test("never tightens a floor the catalog exceeds", () => {
+		expect(effectiveQualityFloor(10, "hard", "coding", plan)).toBe(10);
+	});
+
+	test("is a no-op when configured equals adaptive", () => {
+		expect(effectiveQualityFloor(80, "hard", "coding", plan)).toBe(80);
+	});
+});
+
+describe("tierPlanFor", () => {
+	test("memoizes per snapshot object", () => {
+		const snap = snapshot(models([["a/1", 50, 0.1]]));
+		expect(tierPlanFor(snap, BASE)).toBe(tierPlanFor(snap, BASE));
+	});
+
+	test("a new snapshot recomputes, so a refresh tracks availability", () => {
+		const first = snapshot(models([["a/1", 50, 0.1]]));
+		const second = snapshot(models([["a/1", 50, 0.1], ["a/2", 90, 0.1]]));
+		expect(tierPlanFor(second, BASE)).not.toBe(tierPlanFor(first, BASE));
+		expect(tierPlanFor(second, BASE).floors.coding.hard).toBe(90);
+	});
+});
+
+describe("adaptive floors in candidate selection", () => {
+	const req = parseChatRequest(
+		{
+			model: "auto",
+			tools: [{ type: "function", function: { name: "read", description: "Read", parameters: { type: "object", properties: {} } } }],
+			messages: [{ role: "user", content: "refactor the auth module" }],
+		},
+		new Headers(),
+	);
+	const features = extractFeatures(req, 100);
+
+	// Every model scores far below the configured `hard` floor of 72.
+  const lowCatalog = snapshot(
+		models([
+			["a/1", 20, 0.05],
+			["a/2", 30, 0.06],
+			["a/3", 40, 0.07],
+			["a/4", 50, 0.08],
+		]),
+	);
+
+	function build(cfg: typeof BASE) {
+		return buildCandidates({
+			req,
+			features,
+			tier: "hard",
+			task: "coding",
+			snapshot: lowCatalog,
+			ledger: null,
+			cfg,
+			expectedCompletionTokens: 512,
+			warmSlug: null,
+		});
+	}
+
+	test("hard is empty with adaptive floors off", () => {
+		const { candidates } = build({ ...BASE, adaptiveTierFloors: false });
+		expect(candidates).toHaveLength(0);
+	});
+
+	test("hard still selects the best available with adaptive floors on", () => {
+		const { candidates } = build({ ...BASE, adaptiveTierFloors: true });
+		expect(candidates.length).toBeGreaterThan(0);
+		// The top band is the best-scoring model, not the cheapest.
+		expect(candidates.some((c) => c.model.slug === "a/4")).toBe(true);
+	});
+
+	test("adaptive floors still order the tiers apart", () => {
+		const cfg = { ...BASE, adaptiveTierFloors: true };
+		const best = (tier: "trivial" | "hard"): number => {
+			const { candidates } = buildCandidates({
+				req,
+				features,
+				tier,
+				task: "coding",
+				snapshot: lowCatalog,
+				ledger: null,
+				cfg,
+				expectedCompletionTokens: 512,
+				warmSlug: null,
+			});
+			return Math.max(...candidates.map((c) => c.model.quality.coding ?? 0));
+		};
+		// `hard` must not admit a strictly worse best-model than `trivial`.
+		expect(best("hard")).toBeGreaterThanOrEqual(best("trivial"));
+	});
+
+	test("excludeSlugs removes a model from the candidate set", () => {
+		const cfg = { ...BASE, adaptiveTierFloors: true };
+		const all = build(cfg).candidates.map((c) => c.model.slug);
+		const target = all[0];
+		expect(target).toBeDefined();
+		const { candidates, rejected } = buildCandidates({
+			req,
+			features,
+			tier: "hard",
+			task: "coding",
+			snapshot: lowCatalog,
+			ledger: null,
+			cfg,
+			expectedCompletionTokens: 512,
+			warmSlug: null,
+			excludeSlugs: [target ?? ""],
+		});
+		expect(candidates.map((c) => c.model.slug)).not.toContain(target);
+		expect(rejected.some((r) => r.slug === target && r.reason === "failed_this_turn")).toBe(true);
+	});
+});

package/test/toast-logic.test.ts

@@ -0,0 +1,160 @@
+import { describe, expect, test } from "bun:test";
+
+import { parse as parseYaml } from "yaml";
+
+import {
+	DEFAULT_ROUTER_URL,
+	newestId,
+	resolveRouterUrl,
+	selectToasts,
+	toToastText,
+	type ToastDecision,
+} from "../omp-extension/toast-logic.ts";
+
+describe("resolveRouterUrl", () => {
+	const resolve = (env: string | undefined, text: string | null): string =>
+		resolveRouterUrl(env, text, parseYaml);
+
+	test("the embed port file wins over AUTO_MODEL_ROUTER_PORT and the config", () => {
+		// The embedded router binds a free OS-assigned port and writes it to the
+		// port file; the toast must poll that actual address, not a stale config.
+		expect(resolveRouterUrl(undefined, "server:\n  port: 8788\n", parseYaml, "8812", 45678)).toBe(
+			"http://127.0.0.1:45678",
+		);
+	});
+
+	test("AUTO_MODEL_ROUTER_URL still beats the embed port file", () => {
+		expect(resolveRouterUrl("http://host:9999", "server:\n  port: 8788\n", parseYaml, "8812", 45678)).toBe(
+			"http://host:9999",
+		);
+	});
+
+	test("an embed port file of null falls back to AUTO_MODEL_ROUTER_PORT", () => {
+		expect(resolveRouterUrl(undefined, "server:\n  port: 8788\n", parseYaml, "8812", null)).toBe("http://127.0.0.1:8812");
+	});
+
+	test("AUTO_MODEL_ROUTER_URL still beats AUTO_MODEL_ROUTER_PORT", () => {
+		expect(resolveRouterUrl("http://host:9999", "server:\n  port: 8788\n", parseYaml, "8812")).toBe("http://host:9999");
+	});
+
+	test("an invalid AUTO_MODEL_ROUTER_PORT falls back to the config port", () => {
+		expect(resolveRouterUrl(undefined, "server:\n  port: 8788\n", parseYaml, "notaport")).toBe("http://127.0.0.1:8788");
+		expect(resolveRouterUrl(undefined, "server:\n  port: 8788\n", parseYaml, "70000")).toBe("http://127.0.0.1:8788");
+	});
+
+	test("AUTO_MODEL_ROUTER_PORT with no config uses loopback", () => {
+		expect(resolveRouterUrl(undefined, null, parseYaml, "8812")).toBe("http://127.0.0.1:8812");
+	});
+
+	test("reads host and port from the router's own config", () => {
+		// The bug this prevents: defaulting to 8788 polls whatever else owns that
+		// port once the router has been moved, and toasts silently never appear.
+		expect(resolve(undefined, "server:\n  host: 127.0.0.1\n  port: 8788\n")).toBe("http://127.0.0.1:8788");
+	});
+
+	test("a port-only config keeps the loopback default host", () => {
+		expect(resolve(undefined, "server:\n  port: 8790\n")).toBe("http://127.0.0.1:8790");
+	});
+
+	test("a wildcard listen address becomes loopback", () => {
+		expect(resolve(undefined, "server:\n  host: 0.0.0.0\n  port: 8788\n")).toBe("http://127.0.0.1:8788");
+		expect(resolve(undefined, "server:\n  host: '::'\n  port: 8788\n")).toBe("http://127.0.0.1:8788");
+	});
+
+	test("falls back when there is no config, no server block, or junk", () => {
+		expect(resolve(undefined, null)).toBe(DEFAULT_ROUTER_URL);
+		expect(resolve(undefined, "")).toBe(DEFAULT_ROUTER_URL);
+		expect(resolve(undefined, "logLevel: debug\n")).toBe(DEFAULT_ROUTER_URL);
+		expect(resolve(undefined, "server: 5\n")).toBe(DEFAULT_ROUTER_URL);
+	});
+
+	test("ignores a non-integer or non-positive port", () => {
+		expect(resolve(undefined, "server:\n  port: 0\n")).toBe(DEFAULT_ROUTER_URL);
+		expect(resolve(undefined, "server:\n  port: notaport\n")).toBe(DEFAULT_ROUTER_URL);
+	});
+
+	test("an empty env override does not shadow the config", () => {
+		expect(resolve("", "server:\n  port: 8788\n")).toBe("http://127.0.0.1:8788");
+	});
+});
+
+function dec(partial: Partial<ToastDecision>): ToastDecision {
+	return {
+		id: "d1",
+		slug: "meta/muse-glimmer-30b",
+		servedSlug: null,
+		tier: "trivial",
+		reportedUsd: 0.0000123,
+		wasted: false,
+		harnessId: "",
+		...partial,
+	};
+}
+
+describe("selectToasts", () => {
+	test("toasts nothing on the first tick (lastSeenId null)", () => {
+		const entries = [dec({ id: "a" }), dec({ id: "b" })];
+		expect(selectToasts(entries, null)).toEqual([]);
+	});
+
+	test("toasts only entries newer than the last-seen id, oldest first", () => {
+		// newest-first order: d3 is newest, d1 oldest
+		const entries = [dec({ id: "d3", slug: "x/c" }), dec({ id: "d2", slug: "x/b" }), dec({ id: "d1", slug: "x/a" })];
+		const toasts = selectToasts(entries, "d1");
+		expect(toasts).toHaveLength(2);
+		// oldest→newest emission order
+		expect(toasts[0]?.model).toBe("x/b");
+		expect(toasts[1]?.model).toBe("x/c");
+	});
+
+	test("skips wasted (abandoned escalation) entries", () => {
+		const entries = [dec({ id: "d2", slug: "served", wasted: false }), dec({ id: "d1", wasted: true })];
+		// both newer than lastSeenId ""; only the non-wasted one toasts
+		expect(selectToasts(entries, "")).toHaveLength(1);
+		const withPrior = [dec({ id: "d3", slug: "real", wasted: false }), dec({ id: "d2", wasted: true }), dec({ id: "d1", slug: "prior" })];
+		const out = selectToasts(withPrior, "d1");
+		expect(out).toHaveLength(1);
+		expect(out[0]?.model).toBe("real");
+	});
+
+	test("empty input yields no toasts and null newest id", () => {
+		expect(selectToasts([], "x")).toEqual([]);
+		expect(newestId([])).toBeNull();
+	});
+
+	test("filters to the requesting harness when one is set", () => {
+		const entries = [
+			dec({ id: "d3", slug: "mine", harnessId: "harness-a" }),
+			dec({ id: "d2", slug: "other", harnessId: "harness-b" }),
+			dec({ id: "d1", slug: "prior", harnessId: "harness-a" }),
+		];
+		// Only harness-a entries newer than d1 toast; harness-b is excluded.
+		const toasts = selectToasts(entries, "d1", "harness-a");
+		expect(toasts).toHaveLength(1);
+		expect(toasts[0]?.model).toBe("mine");
+	});
+
+	test("empty harness id toasts every harness", () => {
+		const entries = [
+			dec({ id: "d2", slug: "a", harnessId: "harness-a" }),
+			dec({ id: "d1", slug: "b", harnessId: "harness-b" }),
+		];
+		expect(selectToasts(entries, "", "")).toHaveLength(2);
+	});
+});
+
+describe("toToastText", () => {
+	test("prefers servedSlug when present, else slug", () => {
+		expect(toToastText(dec({ slug: "s/one", servedSlug: "s/real" }))).toContain("s/real");
+		expect(toToastText(dec({ slug: "s/one", servedSlug: null }))).toContain("s/one");
+	});
+
+	test("includes cost when reported, omits otherwise", () => {
+		expect(toToastText(dec({ reportedUsd: 0.5 }))).toContain("$0.50000");
+		expect(toToastText(dec({ reportedUsd: null }))).not.toContain("$");
+	});
+
+	test("renders model [tier]", () => {
+		expect(toToastText(dec({ slug: "q/w", tier: "hard", reportedUsd: null }))).toBe("q/w [hard]");
+	});
+});

package/test/tokens.test.ts

@@ -0,0 +1,160 @@
+import { describe, expect, test } from "bun:test";
+
+import { loadConfig } from "../src/config/load.ts";
+import { createLedger } from "../src/cost/ledger.ts";
+import { EMPTY_USAGE, type LedgerEntry } from "../src/cost/types.ts";
+import { DEFAULT_BYTES_PER_TOKEN, estimatePromptTokens, estimateTokens } from "../src/tokens/estimate.ts";
+import { openDb } from "../src/util/sqlite.ts";
+import { parseChatRequest } from "../src/wire/openai/request.ts";
+
+const cfg = loadConfig({});
+
+function entry(over: Partial<LedgerEntry>): LedgerEntry {
+	return {
+		id: crypto.randomUUID(),
+		createdAtMs: Date.now(),
+		conversationKey: "k",
+		sessionId: "omp-k",
+		turn: 1,
+		requestedModel: "auto",
+		harnessId: "",
+		slug: "openai/gpt-5-mini",
+		servedSlug: "openai/gpt-5-mini",
+		tier: "simple",
+		classificationSource: "heuristic",
+		reasons: [],
+		predictedUsd: 0.001,
+		reportedUsd: 0.001,
+		usage: EMPTY_USAGE,
+		attempt: 0,
+		escalationSignal: null,
+		latencyMs: 100,
+		ttftMs: 50,
+		finishReason: "stop",
+		wasted: false,
+		upstreamGenerationId: null,
+		error: null,
+		...over,
+	};
+}
+
+describe("estimateTokens", () => {
+	test("uses the default ratio for an unknown tokenizer family", () => {
+		expect(estimateTokens(3600, "no-such-tokenizer", null)).toBe(Math.ceil(3600 / DEFAULT_BYTES_PER_TOKEN));
+	});
+
+	test("scales linearly with byte count and never goes negative", () => {
+		expect(estimateTokens(0, "gpt", null)).toBe(0);
+		const small = estimateTokens(1000, "gpt", null);
+		const large = estimateTokens(10_000, "gpt", null);
+		expect(large).toBeGreaterThan(small);
+	});
+
+	test("a code-dense family estimates more tokens for the same bytes", () => {
+		// BPE tokenizers emit more tokens per character on code than on prose,
+		// so a lower bytes-per-token ratio must yield a higher token count.
+		expect(estimateTokens(10_000, "deepseek", null)).toBeGreaterThan(estimateTokens(10_000, "gpt", null));
+	});
+
+	test("is case-insensitive about the tokenizer name", () => {
+		expect(estimateTokens(5000, "Claude", null)).toBe(estimateTokens(5000, "claude", null));
+	});
+});
+
+describe("ledger calibration", () => {
+	test("a calibrated ratio replaces the family default once enough samples land", () => {
+		const db = openDb(":memory:");
+		try {
+			const ledger = createLedger(db, cfg);
+			expect(ledger.tokenRatio("claude")).toBeNull();
+
+			const req = parseChatRequest(
+				{ model: "auto", messages: [{ role: "user", content: "x".repeat(4000) }] },
+				new Headers(),
+			);
+
+			// The real prompt turned out to be far more token-dense than 3.6
+			// bytes/token; the ledger must converge on the measurement.
+			const observedTokens = Math.round(req.promptBytes / 2);
+			for (let i = 0; i < 30; i++) {
+				estimatePromptTokens(req, "claude", ledger);
+				ledger.record(
+					entry({
+						conversationKey: req.conversationKey,
+						usage: { ...EMPTY_USAGE, promptTokens: observedTokens, completionTokens: 10 },
+					}),
+				);
+			}
+
+			const ratio = ledger.tokenRatio("claude");
+			expect(ratio).not.toBeNull();
+			if (ratio === null) return;
+			expect(ratio).toBeCloseTo(2, 1);
+
+			// And the estimate now follows the measurement, not the default.
+			const calibrated = estimateTokens(4000, "claude", ledger);
+			expect(calibrated).toBeGreaterThan(estimateTokens(4000, "claude", null));
+		} finally {
+			db.close();
+		}
+	});
+
+	test("an uncalibrated family still falls back to its default", () => {
+		const db = openDb(":memory:");
+		try {
+			const ledger = createLedger(db, cfg);
+			expect(ledger.tokenRatio("gemini")).toBeNull();
+			expect(estimateTokens(3600, "gemini", ledger)).toBe(estimateTokens(3600, "gemini", null));
+		} finally {
+			db.close();
+		}
+	});
+});
+
+describe("estimatePromptTokens", () => {
+	test("counts tool schemas, not just message text", () => {
+		const bare = parseChatRequest({ model: "auto", messages: [{ role: "user", content: "hi" }] }, new Headers());
+		const withTools = parseChatRequest(
+			{
+				model: "auto",
+				messages: [{ role: "user", content: "hi" }],
+				tools: [
+					{
+						type: "function",
+						function: {
+							name: "bash",
+							description: "Run a shell command and return its output",
+							parameters: { type: "object", properties: { command: { type: "string" } }, required: ["command"] },
+						},
+					},
+				],
+			},
+			new Headers(),
+		);
+		expect(estimatePromptTokens(withTools, "gpt", null)).toBeGreaterThan(estimatePromptTokens(bare, "gpt", null));
+	});
+
+	test("charges a per-image allowance on top of text", () => {
+		const text = parseChatRequest(
+			{ model: "auto", messages: [{ role: "user", content: [{ type: "text", text: "describe" }] }] },
+			new Headers(),
+		);
+		const withImage = parseChatRequest(
+			{
+				model: "auto",
+				messages: [
+					{
+						role: "user",
+						content: [
+							{ type: "text", text: "describe" },
+							{ type: "image_url", image_url: { url: "data:image/png;base64,AAAA" } },
+						],
+					},
+				],
+			},
+			new Headers(),
+		);
+		// An image costs far more than the handful of bytes its URL adds.
+		expect(estimatePromptTokens(withImage, "gpt", null)).toBeGreaterThan(estimatePromptTokens(text, "gpt", null) + 500);
+	});
+});