Luigit
repositories / pi-ext

pi-ext

bugabingas pi extensions

owned by admin

extensions/voice/__tests__/turn-classifier.test.ts

Raw
import { describe, expect, it, vi } from "vitest";
import { makeTurnClassifier } from "../src/turn-classifier.ts";
import { LUNA_CHAT_MODEL } from "../src/turn-policy.ts";

describe("turn classifier availability", () => {
	it("reports an unavailable classifier without invoking generation", async () => {
		const classifier = makeTurnClassifier({
			modelRegistry: { getAvailableOfType: () => [] },
		} as never);
		expect(await classifier({ text: "Hello" })).toMatchObject({
			available: false,
		});
	});

	it("selects first host classifier by default", async () => {
		const first = { provider: "fixture", id: "first" };
		const classify = vi.fn(async () => ({ stopReason: "stop", answers: {} }));
		const classifier = makeTurnClassifier({
			modelRegistry: {
				getAvailableOfType: async () => [
					first,
					{ provider: "other", id: "second" },
				],
				classify,
			},
		} as never);
		await classifier({ text: "Hello" });
		expect(classify).toHaveBeenCalledWith(
			first,
			expect.anything(),
			expect.anything(),
		);
	});

	it.each(["fixture", "https://models.example/v1"])(
		"selects only explicitly configured native model for %s",
		async (provider) => {
			const selected = { provider, id: "nested/model@revision~1" };
			const classify = vi.fn(async () => ({ stopReason: "stop", answers: {} }));
			const classifier = makeTurnClassifier(
				{
					modelRegistry: {
						getAvailableOfType: async () => [
							{ provider: "fixture", id: "other" },
							selected,
						],
						classify,
					},
				} as never,
				`${provider}/nested/model@revision~1`,
			);
			await classifier({ text: "Hello" });
			expect(classify).toHaveBeenCalledWith(
				selected,
				expect.anything(),
				expect.anything(),
			);
		},
	);

	it.each([
		"fixture/missing",
		"nested/model@revision~1",
		"https://models.example/v1/nested/mod",
		"HTTPS://models.example/v1/nested/model@revision~1",
		"https://models.example/v1/nested/model@revision~1:high",
		"/https://models.example/v1/nested/model@revision~1",
	] as const)(
		"does not substitute when explicit model is unavailable: %s",
		async (selector) => {
			const classify = vi.fn();
			const classifier = makeTurnClassifier(
				{
					modelRegistry: {
						getAvailableOfType: async () => [
							{
								provider: "https://models.example/v1",
								id: "nested/model@revision~1",
							},
						],
						classify,
					},
				} as never,
				selector,
			);
			expect(await classifier({ text: "Hello" })).toMatchObject({
				available: false,
			});
			expect(classify).not.toHaveBeenCalled();
		},
	);

	it("does not look up models when caller is already aborted", async () => {
		const lookup = vi.fn();
		const controller = new AbortController();
		controller.abort();
		const classifier = makeTurnClassifier({
			modelRegistry: { getAvailableOfType: lookup },
		} as never);
		expect(
			await classifier({ text: "Hello", signal: controller.signal }),
		).toMatchObject({
			available: false,
		});
		expect(lookup).not.toHaveBeenCalled();
	});

	it("does not classify when cancelled while model lookup is pending", async () => {
		let finishLookup!: (models: unknown[]) => void;
		const classify = vi.fn();
		const controller = new AbortController();
		const classifier = makeTurnClassifier({
			modelRegistry: {
				getAvailableOfType: () =>
					new Promise((resolve) => (finishLookup = resolve)),
				classify,
			},
		} as never);
		const result = classifier({ text: "Hello", signal: controller.signal });
		controller.abort();
		finishLookup([{ provider: "fixture", id: "model" }]);
		expect(await result).toMatchObject({ available: false });
		expect(classify).not.toHaveBeenCalled();
	});

	it("uses exact host Luna model in opt-in chat mode with bounded standalone input", async () => {
		const selected = { provider: "openai-codex", id: "gpt-6-luna" };
		const getAvailable = vi.fn(() => [
			{ provider: "other", id: "model" },
			selected,
		]);
		const streamSimple = vi.fn((_model, _context, _options) => ({
			result: async () => ({
				stopReason: "stop",
				content: [{ type: "text", text: "trailing" }],
			}),
		}));
		const nativeLookup = vi.fn();
		const classifier = makeTurnClassifier(
			{
				modelRegistry: {
					getAvailable,
					getAvailableOfType: nativeLookup,
					streamSimple,
				},
			} as never,
			LUNA_CHAT_MODEL,
		);
		const result = await classifier({
			text: `prefix${"x".repeat(4_000)}`,
			lastAgentTurn: `prefix${"y".repeat(1_000)}`,
		});
		expect(getAvailable).toHaveBeenCalledTimes(1);
		expect(nativeLookup).not.toHaveBeenCalled();
		expect(streamSimple).toHaveBeenCalledWith(
			selected,
			expect.objectContaining({
				systemPrompt: expect.any(String),
				messages: [
					expect.objectContaining({
						content: JSON.stringify({
							text: "x".repeat(4_000),
							lastAgentTurn: "y".repeat(1_000),
						}),
					}),
				],
				tools: [],
			}),
			expect.objectContaining({
				maxTokens: 8,
				signal: expect.any(AbortSignal),
			}),
		);
		expect(result).toMatchObject({
			available: true,
			choice: "trailing",
			source: "host-chat",
			model: LUNA_CHAT_MODEL,
		});
		expect(result).not.toHaveProperty("pComplete");
		expect(result).not.toHaveProperty("scores");
	});

	it("does not fall back when host Luna is missing", async () => {
		const nativeLookup = vi.fn();
		const streamSimple = vi.fn();
		const classifier = makeTurnClassifier(
			{
				modelRegistry: {
					getAvailable: () => [{ provider: "other", id: "model" }],
					getAvailableOfType: nativeLookup,
					streamSimple,
				},
			} as never,
			LUNA_CHAT_MODEL,
		);
		expect(await classifier({ text: "Hello" })).toMatchObject({
			available: false,
		});
		expect(nativeLookup).not.toHaveBeenCalled();
		expect(streamSimple).not.toHaveBeenCalled();
	});

	it.each([
		{ stopReason: "length", content: [{ type: "text", text: "complete" }] },
		{
			stopReason: "stop",
			content: [{ type: "text", text: "complete, probably" }],
		},
		{ stopReason: "stop", content: [{ type: "toolCall", name: "x" }] },
	])("rejects malformed or truncated host output %#", async (response) => {
		const classifier = makeTurnClassifier(
			{
				modelRegistry: {
					getAvailable: () => [{ provider: "openai-codex", id: "gpt-6-luna" }],
					streamSimple: () => ({ result: async () => response }),
				},
			} as never,
			LUNA_CHAT_MODEL,
		);
		expect(await classifier({ text: "Hello" })).toMatchObject({
			available: false,
		});
	});

	it("returns unavailable when cancelled during host generation", async () => {
		let finish!: (result: unknown) => void;
		const controller = new AbortController();
		const classifier = makeTurnClassifier(
			{
				modelRegistry: {
					getAvailable: () => [{ provider: "openai-codex", id: "gpt-6-luna" }],
					streamSimple: () => ({
						result: () => new Promise((resolve) => (finish = resolve)),
					}),
				},
			} as never,
			LUNA_CHAT_MODEL,
		);
		const result = classifier({ text: "Hello", signal: controller.signal });
		controller.abort();
		finish({
			stopReason: "stop",
			content: [{ type: "text", text: "complete" }],
		});
		expect(await result).toMatchObject({ available: false });
	});

	it.each([
		["auto", 500],
		[LUNA_CHAT_MODEL, 2_000],
	] as const)(
		"bounds stalled %s requests at %sms",
		async (selector, budget) => {
			vi.useFakeTimers();
			try {
				let requestSignal: AbortSignal | undefined;
				const stalled = (
					_model: unknown,
					_context: unknown,
					options: { signal: AbortSignal },
				) => {
					requestSignal = options.signal;
					return new Promise(() => {});
				};
				const classifier = makeTurnClassifier(
					{
						modelRegistry: {
							getAvailableOfType: async () => [
								{ provider: "fixture", id: "native" },
							],
							classify: stalled,
							getAvailable: () => [
								{ provider: "openai-codex", id: "gpt-6-luna" },
							],
							streamSimple: (
								model: unknown,
								context: unknown,
								options: { signal: AbortSignal },
							) => ({ result: () => stalled(model, context, options) }),
						},
					} as never,
					selector,
				);
				let settled = false;
				const pending = classifier({ text: "Hello" }).then((result) => {
					settled = true;
					return result;
				});
				await vi.advanceTimersByTimeAsync(budget - 1);
				expect(settled).toBe(false);
				await vi.advanceTimersByTimeAsync(1);
				expect(await pending).toMatchObject({ available: false });
				expect(requestSignal?.aborted).toBe(true);
			} finally {
				vi.useRealTimers();
			}
		},
	);

	it.each([
		["auto", 500],
		[LUNA_CHAT_MODEL, 2_000],
	] as const)(
		"rejects %s completion after elapsed budget even before timeout callback",
		async (selector, budget) => {
			let now = 0;
			const clock = vi.spyOn(performance, "now").mockImplementation(() => now);
			try {
				let finish!: (result: unknown) => void;
				const pendingResult = () =>
					new Promise((resolve) => {
						finish = resolve;
					});
				const classifier = makeTurnClassifier(
					{
						modelRegistry: {
							getAvailableOfType: async () => [
								{ provider: "fixture", id: "native" },
							],
							classify: pendingResult,
							getAvailable: () => [
								{ provider: "openai-codex", id: "gpt-6-luna" },
							],
							streamSimple: () => ({ result: pendingResult }),
						},
					} as never,
					selector,
				);
				const pending = classifier({ text: "Hello" });
				await Promise.resolve();
				now = budget + 1;
				finish(
					selector === "auto"
						? {
								stopReason: "stop",
								answers: {
									completion: {
										type: "choice",
										choice: "complete",
										probabilities: { complete: 1 },
									},
								},
							}
						: {
								stopReason: "stop",
								content: [{ type: "text", text: "complete" }],
							},
				);
				expect(await pending).toMatchObject({ available: false });
			} finally {
				clock.mockRestore();
			}
		},
	);

	it.each([undefined, Number.NaN, -0.1, 1.1])(
		"rejects invalid complete probability %s",
		async (probability) => {
			const classifier = makeTurnClassifier({
				modelRegistry: {
					getAvailableOfType: () => [{ provider: "fixture", id: "classifier" }],
					classify: async () => ({
						stopReason: "stop",
						answers: {
							completion: {
								type: "choice",
								choice: "complete",
								probabilities: { complete: probability },
							},
						},
					}),
				},
			} as never);
			expect(await classifier({ text: "Hello" })).toMatchObject({
				available: false,
			});
		},
	);
});