pi-harness-runtime 1.1.439 → 1.1.441

package/packages/provider-router/test/provider-router.test.ts

@@ -1,405 +0,0 @@
-/**
- * Provider Router Tests (RFC-0054)
- */
-
-import { describe, it, expect, beforeEach } from "bun:test";
-import {
-	createProviderRouter,
-	type EnhancedProviderRouter,
-	DEFAULT_ROUTING_POLICY,
-	createRoutingPolicy,
-	applyStrategy,
-	calculateWeightedScore,
-	createDecision,
-	LATENCY_RANK,
-} from "../src/index.js";
-import type {
-	RoutingPolicy,
-	ProviderCandidate,
-	RoutingStrategy,
-} from "../src/index.js";
-
-describe("EnhancedProviderRouter", () => {
-	let router: EnhancedProviderRouter;
-
-	beforeEach(() => {
-		router = createProviderRouter();
-	});
-
-	describe("initialization", () => {
-		it("should initialize with default policy", () => {
-			const policy = router.getRoutingPolicy();
-			expect(policy.defaultStrategy).toBe("balanced");
-		});
-
-		it("should accept custom policy", () => {
-			const customPolicy = createRoutingPolicy({ defaultStrategy: "cheapest" });
-			const customRouter = createProviderRouter(customPolicy);
-			expect(customRouter.getRoutingPolicy().defaultStrategy).toBe("cheapest");
-		});
-	});
-
-	describe("selectProvider", () => {
-		it("should select a provider", async () => {
-			const task = {
-				id: "task-1",
-				title: "Code task",
-				description: "",
-				type: "code_generation",
-			};
-			const context = {
-				task,
-				providerStates: {},
-				quotaStates: {},
-			};
-
-			const decision = await router.selectProvider(task, context);
-
-			expect(decision.providerId).toBeDefined();
-			expect(decision.modelId).toBeDefined();
-			expect(decision.reason).toBeDefined();
-		});
-
-		it("should prefer cheapest when specified", async () => {
-			const task = {
-				id: "task-1",
-				title: "Code task",
-				description: "",
-				type: "code_generation",
-			};
-			const context = {
-				task,
-				providerStates: {},
-				quotaStates: {},
-			};
-
-			const decision = await router.selectProvider(task, context, {
-				preferCheapest: true,
-			});
-
-			expect(decision.reason).toContain("cheapest");
-		});
-
-		it("should prefer fastest when specified", async () => {
-			const task = {
-				id: "task-1",
-				title: "Code task",
-				description: "",
-				type: "code_generation",
-			};
-			const context = {
-				task,
-				providerStates: {},
-				quotaStates: {},
-			};
-
-			const decision = await router.selectProvider(task, context, {
-				preferFastest: true,
-			});
-
-			expect(decision.reason).toContain("fastest");
-		});
-
-		it("should prefer highest quality when specified", async () => {
-			const task = {
-				id: "task-1",
-				title: "Code task",
-				description: "",
-				type: "code_generation",
-			};
-			const context = {
-				task,
-				providerStates: {},
-				quotaStates: {},
-			};
-
-			const decision = await router.selectProvider(task, context, {
-				preferHighestQuality: true,
-			});
-
-			expect(decision.reason).toContain("quality");
-		});
-
-		it("should filter by max cost", async () => {
-			const task = {
-				id: "task-1",
-				title: "Code task",
-				description: "",
-				type: "code_generation",
-			};
-			const context = {
-				task,
-				providerStates: {},
-				quotaStates: {},
-			};
-
-			const decision = await router.selectProvider(task, context, {
-				maxCostPerTask: 0.00001, // Very low cost
-			});
-
-			// Should still return a decision (fallback)
-			expect(decision.providerId).toBeDefined();
-		});
-
-		it("should respect task type overrides", async () => {
-			const task = {
-				id: "task-1",
-				title: "Plan",
-				description: "",
-				type: "planning",
-			};
-			const context = {
-				task,
-				providerStates: {},
-				quotaStates: {},
-			};
-
-			const decision = await router.selectProvider(task, context);
-
-			// Planning should use best_quality strategy
-			expect(decision.reason).toContain("best_quality");
-		});
-
-		it("should filter out exhausted providers", async () => {
-			const task = {
-				id: "task-1",
-				title: "Code task",
-				description: "",
-				type: "code_generation",
-			};
-			const context = {
-				task,
-				providerStates: {},
-				quotaStates: {
-					minimax: { exhausted: true, remainingPct: 0 },
-				},
-			};
-
-			const decision = await router.selectProvider(task, context);
-
-			// Should not select minimax if exhausted
-			expect(decision.providerId).not.toBe("minimax");
-		});
-
-		it("should avoid specified providers", async () => {
-			const task = {
-				id: "task-1",
-				title: "Code task",
-				description: "",
-				type: "code_generation",
-			};
-			const context = {
-				task,
-				providerStates: {},
-				quotaStates: {},
-			};
-
-			const decision = await router.selectProvider(task, context, {
-				avoidProviders: ["minimax"],
-			});
-
-			expect(decision.providerId).not.toBe("minimax");
-		});
-
-		it("should emit selection event", async () => {
-			const events: any[] = [];
-			router.onEvent((e) => events.push(e));
-
-			const task = {
-				id: "task-1",
-				title: "Code task",
-				description: "",
-				type: "code_generation",
-			};
-			const context = {
-				task,
-				providerStates: {},
-				quotaStates: {},
-			};
-
-			await router.selectProvider(task, context);
-
-			expect(events).toContainEqual(
-				expect.objectContaining({
-					type: "router.provider_selected",
-					taskId: "task-1",
-				}),
-			);
-		});
-	});
-
-	describe("selectProviders", () => {
-		it("should select multiple providers", async () => {
-			const task = {
-				id: "task-1",
-				title: "Code task",
-				description: "",
-				type: "code_generation",
-			};
-			const context = {
-				task,
-				providerStates: {},
-				quotaStates: {},
-			};
-
-			const decisions = await router.selectProviders(task, context, 3);
-
-			expect(decisions).toHaveLength(3);
-			expect(decisions[0].providerId).not.toBe(decisions[1].providerId);
-		});
-	});
-
-	describe("setRoutingPolicy", () => {
-		it("should update policy", () => {
-			const newPolicy = createRoutingPolicy({ defaultStrategy: "fastest" });
-			router.setRoutingPolicy(newPolicy);
-
-			expect(router.getRoutingPolicy().defaultStrategy).toBe("fastest");
-		});
-
-		it("should emit policy update event", () => {
-			const events: any[] = [];
-			router.onEvent((e) => events.push(e));
-
-			const newPolicy = createRoutingPolicy({ costWeight: 50 });
-			router.setRoutingPolicy(newPolicy);
-
-			expect(events).toContainEqual(
-				expect.objectContaining({
-					type: "router.policy_updated",
-				}),
-			);
-		});
-	});
-});
-
-describe("Strategies", () => {
-	const defaultPolicy = DEFAULT_ROUTING_POLICY;
-
-	const candidates: ProviderCandidate[] = [
-		{
-			providerId: "anthropic",
-			modelId: "claude-sonnet-4",
-			capabilities: [],
-			estimatedCost: 0.003,
-			estimatedLatency: "fast",
-			qualityScore: 90,
-			remainingQuotaPct: 0.5,
-		},
-		{
-			providerId: "openai",
-			modelId: "gpt-4o-mini",
-			capabilities: [],
-			estimatedCost: 0.0006,
-			estimatedLatency: "fast",
-			qualityScore: 82,
-			remainingQuotaPct: 0.8,
-		},
-		{
-			providerId: "minimax",
-			modelId: "MiniMax-Text-01",
-			capabilities: [],
-			estimatedCost: 0.0001,
-			estimatedLatency: "fast",
-			qualityScore: 75,
-			remainingQuotaPct: 1,
-		},
-	];
-
-	describe("applyStrategy", () => {
-		it("should select cheapest with cheapest strategy", () => {
-			const selected = applyStrategy(candidates, "cheapest", defaultPolicy);
-			expect(selected.providerId).toBe("minimax");
-		});
-
-		it("should select fastest with fastest strategy", () => {
-			const selected = applyStrategy(candidates, "fastest", defaultPolicy);
-			// All have same latency, so should pick highest quality among fast
-			expect(selected.estimatedLatency).toBe("fast");
-		});
-
-		it("should select best quality with best_quality strategy", () => {
-			const selected = applyStrategy(candidates, "best_quality", defaultPolicy);
-			expect(selected.providerId).toBe("anthropic");
-		});
-
-		it("should apply balanced scoring", () => {
-			const selected = applyStrategy(candidates, "balanced", defaultPolicy);
-			expect(selected.providerId).toBeDefined();
-		});
-
-		it("should apply quota awareness", () => {
-			const selected = applyStrategy(candidates, "quota_aware", defaultPolicy);
-			// Should prefer minimax (100% quota) even though it's cheapest
-			expect(selected.providerId).toBe("minimax");
-		});
-	});
-
-	describe("calculateWeightedScore", () => {
-		it("should calculate weighted score", () => {
-			const score = calculateWeightedScore(candidates[0], defaultPolicy);
-			expect(score).toBeGreaterThan(0);
-			expect(score).toBeLessThanOrEqual(100);
-		});
-
-		it("should weight cost appropriately", () => {
-			// Use extreme cost weight to make cost the dominant factor
-			const policy = createRoutingPolicy({
-				costWeight: 100,
-				qualityWeight: 0,
-				latencyWeight: 0,
-				quotaWeight: 0,
-			});
-			const scoreAnthropic = calculateWeightedScore(candidates[0], policy);
-			const scoreMiniMax = calculateWeightedScore(candidates[2], policy);
-			expect(scoreMiniMax).toBeGreaterThan(scoreAnthropic);
-		});
-
-		it("should weight quality appropriately", () => {
-			const policy = createRoutingPolicy({ qualityWeight: 100 });
-			const scoreAnthropic = calculateWeightedScore(candidates[0], policy);
-			const scoreMiniMax = calculateWeightedScore(candidates[2], policy);
-			expect(scoreAnthropic).toBeGreaterThan(scoreMiniMax);
-		});
-	});
-
-	describe("createDecision", () => {
-		it("should create decision from candidate", () => {
-			const decision = createDecision(candidates[0], "test reason");
-			expect(decision.providerId).toBe("anthropic");
-			expect(decision.modelId).toBe("claude-sonnet-4");
-			expect(decision.reason).toBe("test reason");
-			expect(decision.estimatedCost).toBe(0.003);
-			expect(decision.confidence).toBe(0.9);
-		});
-	});
-});
-
-describe("LATENCY_RANK", () => {
-	it("should have correct ordering", () => {
-		expect(LATENCY_RANK["fast"]).toBeLessThan(LATENCY_RANK["medium"]);
-		expect(LATENCY_RANK["medium"]).toBeLessThan(LATENCY_RANK["slow"]);
-	});
-});
-
-describe("createRoutingPolicy", () => {
-	it("should merge with defaults", () => {
-		const custom = createRoutingPolicy({
-			defaultStrategy: "cheapest",
-			costWeight: 80,
-		});
-
-		expect(custom.defaultStrategy).toBe("cheapest");
-		expect(custom.costWeight).toBe(80);
-		expect(custom.qualityWeight).toBe(DEFAULT_ROUTING_POLICY.qualityWeight);
-	});
-
-	it("should merge task type overrides", () => {
-		const custom = createRoutingPolicy({
-			taskTypeOverrides: { planning: "best_quality" },
-		});
-
-		expect(custom.taskTypeOverrides["planning"]).toBe("best_quality");
-		expect(custom.taskTypeOverrides["code_generation"]).toBe("balanced");
-	});
-});

package/packages/provider-selector/test/selector.test.ts

@@ -1,192 +0,0 @@
-/**
- * Provider Selector Tests (RFC-0012)
- */
-
-import { describe, it, expect } from "bun:test";
-import {
-	selectProvider,
-	rank,
-	compareCost,
-	compareLatency,
-	filterByCapability,
-	filterByRegion,
-} from "../src/index.js";
-import type { Provider } from "../src/index.js";
-
-const makeProvider = (overrides?: Partial<Provider>): Provider => ({
-	id: "p1",
-	name: "Provider 1",
-	baseURL: "https://api.example.com",
-	capabilities: ["text"],
-	region: "us",
-	inputCostPer1M: 1.0,
-	outputCostPer1M: 3.0,
-	latencyMs: 500,
-	qualityScore: 80,
-	maxContextTokens: 128000,
-	available: true,
-	...overrides,
-});
-
-const PROVIDERS: Provider[] = [
-	makeProvider({
-		id: "cheap",
-		name: "Cheap",
-		inputCostPer1M: 0.1,
-		latencyMs: 200,
-		qualityScore: 60,
-	}),
-	makeProvider({
-		id: "fast",
-		name: "Fast",
-		inputCostPer1M: 2.0,
-		latencyMs: 50,
-		qualityScore: 90,
-	}),
-	makeProvider({
-		id: "quality",
-		name: "Quality",
-		inputCostPer1M: 5.0,
-		latencyMs: 800,
-		qualityScore: 98,
-	}),
-];
-
-describe("selectProvider", () => {
-	it("selects a provider", () => {
-		const result = selectProvider(PROVIDERS);
-		expect(result).not.toBeNull();
-		expect(result!.provider.available).toBe(true);
-	});
-
-	it("returns null for empty list", () => {
-		expect(selectProvider([])).toBeNull();
-	});
-
-	it("returns null when none available", () => {
-		const unavailable = PROVIDERS.map((p) => ({ ...p, available: false }));
-		expect(selectProvider(unavailable)).toBeNull();
-	});
-
-	it("prefers cheapest for cost criteria", () => {
-		const result = selectProvider(PROVIDERS, "cost");
-		expect(result!.provider.id).toBe("cheap");
-	});
-
-	it("prefers fastest for latency criteria", () => {
-		const result = selectProvider(PROVIDERS, "latency");
-		expect(result!.provider.id).toBe("fast");
-	});
-
-	it("prefers high quality for quality criteria", () => {
-		const result = selectProvider(PROVIDERS, "quality");
-		expect(result!.score).toBeGreaterThan(0.8);
-	});
-
-	it("includes alternatives", () => {
-		const result = selectProvider(PROVIDERS);
-		expect(result!.alternatives.length).toBeGreaterThan(0);
-	});
-
-	it("includes reason", () => {
-		const result = selectProvider(PROVIDERS);
-		expect(result!.reason).toContain("score:");
-	});
-});
-
-describe("rank", () => {
-	it("returns sorted providers", () => {
-		const ranked = rank(PROVIDERS);
-		expect(ranked.length).toBe(3);
-		expect(ranked[0].available).toBe(true);
-	});
-
-	it("uses criteria for ranking", () => {
-		const byCost = rank(PROVIDERS, "cost");
-		const byLatency = rank(PROVIDERS, "latency");
-		expect(byCost[0].id).not.toBe(byLatency[0].id);
-	});
-
-	it("filters unavailable", () => {
-		const mixed = [
-			...PROVIDERS,
-			{ ...PROVIDERS[0], id: "down", available: false },
-		];
-		expect(rank(mixed).length).toBe(3);
-	});
-});
-
-describe("compareCost", () => {
-	it("negative when a is cheaper", () => {
-		const cheap = makeProvider({
-			id: "c",
-			inputCostPer1M: 0.5,
-			outputCostPer1M: 1.0,
-		});
-		const expensive = makeProvider({
-			id: "e",
-			inputCostPer1M: 5.0,
-			outputCostPer1M: 10.0,
-		});
-		expect(compareCost(cheap, expensive)).toBeLessThan(0);
-	});
-
-	it("positive when a is more expensive", () => {
-		const cheap = makeProvider({
-			id: "c",
-			inputCostPer1M: 0.5,
-			outputCostPer1M: 1.0,
-		});
-		const expensive = makeProvider({
-			id: "e",
-			inputCostPer1M: 5.0,
-			outputCostPer1M: 10.0,
-		});
-		expect(compareCost(expensive, cheap)).toBeGreaterThan(0);
-	});
-});
-
-describe("compareLatency", () => {
-	it("negative when a is faster", () => {
-		const fast = makeProvider({ id: "f", latencyMs: 50 });
-		const slow = makeProvider({ id: "s", latencyMs: 500 });
-		expect(compareLatency(fast, slow)).toBeLessThan(0);
-	});
-});
-
-describe("filterByCapability", () => {
-	it("filters to matching capability", () => {
-		const mixed = [
-			makeProvider({ id: "t", capabilities: ["text"] }),
-			makeProvider({ id: "tv", capabilities: ["text", "vision"] }),
-		];
-		expect(filterByCapability(mixed, "vision")).toHaveLength(1);
-		expect(filterByCapability(mixed, "vision")[0].id).toBe("tv");
-	});
-});
-
-describe("filterByRegion", () => {
-	it("filters by region", () => {
-		const mixed = [
-			makeProvider({ id: "us1", region: "us" }),
-			makeProvider({ id: "eu1", region: "eu" }),
-		];
-		expect(filterByRegion(mixed, "us")).toHaveLength(1);
-	});
-
-	it("global returns all", () => {
-		const mixed = [
-			makeProvider({ region: "us" }),
-			makeProvider({ region: "eu" }),
-		];
-		expect(filterByRegion(mixed, "global")).toHaveLength(2);
-	});
-
-	it("global regions always match", () => {
-		const mixed = [
-			makeProvider({ id: "g", region: "global" }),
-			makeProvider({ id: "us", region: "us" }),
-		];
-		expect(filterByRegion(mixed, "eu")).toHaveLength(1);
-	});
-});