repositories / pi-ext
pi-ext
bugabingas pi extensions
owned by admin
extensions/ask/__tests__/interaction.test.ts
Rawimport {
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",
});
});
});