Luigit
repositories / pi-ext

pi-ext

bugabingas pi extensions

owned by admin

extensions/ask/__tests__/interaction.test.ts

Raw
import {
	createEventBus,
	type ExtensionContext,
} from "@earendil-works/pi-coding-agent";
import { afterEach, describe, expect, it, vi } from "vitest";
import { type AskQuestion, createAskTool } from "../ask-tool.ts";
import { type AskRequest, requestAskInteraction } from "../src/interaction.ts";

const CLAIM_WINDOW_MS = 150;
const PENDING_LIFETIME_MS = 10 * 60 * 1000;

const questions: AskQuestion[] = [
	{
		key: "database",
		header: "Database",
		question: "Which database?",
		multiSelect: false,
		options: [
			{ label: "Postgres", description: "Relational." },
			{ label: "SQLite", description: "Embedded." },
		],
	},
];

function fakeCtx(hasUI = false): ExtensionContext {
	return {
		hasUI,
		sessionManager: { getSessionId: () => "session-1" },
	} as ExtensionContext;
}

function claim(
	events: ReturnType<typeof createEventBus>,
	request: AskRequest,
): void {
	events.emit("pi-ext:ask:claim", { ...request, providerId: "voice" });
}

function answer(request: AskRequest, providerId = "voice") {
	return {
		...request,
		providerId,
		status: "answered" as const,
		answers: { database: { answers: ["Postgres"] } },
	};
}

afterEach(() => vi.useRealTimers());

describe("ask interaction bridge", () => {
	it("falls back without a provider", async () => {
		vi.useFakeTimers();
		const events = createEventBus();
		const closed: unknown[] = [];
		events.on("pi-ext:ask:closed", (value) => closed.push(value));
		const flow = requestAskInteraction({
			events,
			questions,
			ctx: fakeCtx(),
			toolCallId: "call-1",
		});

		await vi.advanceTimersByTimeAsync(CLAIM_WINDOW_MS);
		await expect(flow).resolves.toBeUndefined();
		expect(closed).toEqual([]);
	});

	it("accepts a claimed answer before checking headless UI availability", async () => {
		vi.useFakeTimers();
		const events = createEventBus();
		events.on("pi-ext:ask:request", (value) =>
			claim(events, value as AskRequest),
		);
		events.on("pi-ext:ask:claimed", (value) =>
			events.emit("pi-ext:ask:answer", answer(value as AskRequest)),
		);
		const tool = createAskTool({ events });
		const result = await (async () => {
			const pending = tool.execute(
				"call-1",
				{
					questions: [
						{
							id: "database",
							header: "Database",
							question: "Which database?",
							options: questions[0]!.options,
						},
					],
				},
				undefined,
				undefined,
				fakeCtx() as never,
			);
			await vi.advanceTimersByTimeAsync(CLAIM_WINDOW_MS);
			return await pending;
		})();
		const content = result.content[0];
		if (content?.type !== "text") throw new Error("missing text result");
		expect(JSON.parse(content.text)).toEqual({
			status: "answered",
			answers: { database: { answers: ["Postgres"] } },
		});
	});

	it("ignores stale, wrong-provider, invalid, and duplicate answers", async () => {
		vi.useFakeTimers();
		const events = createEventBus();
		const closed: unknown[] = [];
		let request: AskRequest | undefined;
		events.on("pi-ext:ask:request", (value) => {
			request = value as AskRequest;
			claim(events, request);
		});
		events.on("pi-ext:ask:closed", (value) => closed.push(value));
		const flow = requestAskInteraction({
			events,
			questions,
			ctx: fakeCtx(),
			toolCallId: "call-1",
		});
		await vi.advanceTimersByTimeAsync(CLAIM_WINDOW_MS);
		if (!request) throw new Error("request missing");

		events.emit("pi-ext:ask:answer", answer({ ...request, id: "stale" }));
		events.emit("pi-ext:ask:answer", answer(request, "other-provider"));
		events.emit("pi-ext:ask:answer", {
			...request,
			providerId: "voice",
			status: "answered",
			answers: {},
		});
		let settled = false;
		void flow.then(() => {
			settled = true;
		});
		await Promise.resolve();
		expect(settled).toBe(false);

		const valid = answer(request);
		events.emit("pi-ext:ask:answer", valid);
		events.emit("pi-ext:ask:answer", valid);
		await expect(flow).resolves.toEqual({
			status: "answered",
			answers: { database: { answers: ["Postgres"] } },
		});
		expect(closed).toHaveLength(1);
		expect(closed[0]).toMatchObject({
			providerId: "voice",
			status: "answered",
		});
	});

	it("cancels promptly on abort without falling through", async () => {
		vi.useFakeTimers();
		const events = createEventBus();
		const closed: unknown[] = [];
		const controller = new AbortController();
		events.on("pi-ext:ask:request", (value) =>
			claim(events, value as AskRequest),
		);
		events.on("pi-ext:ask:closed", (value) => closed.push(value));
		const flow = requestAskInteraction({
			events,
			questions,
			ctx: fakeCtx(),
			toolCallId: "call-1",
			signal: controller.signal,
		});
		await vi.advanceTimersByTimeAsync(CLAIM_WINDOW_MS);
		controller.abort();

		await expect(flow).resolves.toEqual({ status: "cancelled" });
		expect(closed[0]).toMatchObject({
			providerId: "voice",
			status: "cancelled",
		});
	});

	it("releases to native UI and expires pending claims honestly", async () => {
		vi.useFakeTimers();
		const releaseEvents = createEventBus();
		const released: unknown[] = [];
		releaseEvents.on("pi-ext:ask:request", (value) =>
			claim(releaseEvents, value as AskRequest),
		);
		releaseEvents.on("pi-ext:ask:claimed", (value) =>
			releaseEvents.emit("pi-ext:ask:release", {
				...(value as AskRequest),
				providerId: "voice",
			}),
		);
		releaseEvents.on("pi-ext:ask:closed", (value) => released.push(value));
		const release = requestAskInteraction({
			events: releaseEvents,
			questions,
			ctx: fakeCtx(),
			toolCallId: "call-1",
		});
		await vi.advanceTimersByTimeAsync(CLAIM_WINDOW_MS);
		await expect(release).resolves.toBeUndefined();
		expect(released[0]).toMatchObject({
			providerId: "voice",
			status: "released",
		});

		const timeoutEvents = createEventBus();
		const expired: unknown[] = [];
		timeoutEvents.on("pi-ext:ask:request", (value) =>
			claim(timeoutEvents, value as AskRequest),
		);
		timeoutEvents.on("pi-ext:ask:closed", (value) => expired.push(value));
		const timeout = requestAskInteraction({
			events: timeoutEvents,
			questions,
			ctx: fakeCtx(),
			toolCallId: "call-2",
		});
		await vi.advanceTimersByTimeAsync(PENDING_LIFETIME_MS);
		await expect(timeout).resolves.toEqual({ status: "expired" });
		expect(expired[0]).toMatchObject({
			providerId: "voice",
			status: "expired",
		});
	});
});