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, 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", }); }); });