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