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