mike-backend / backend /tests /unit /assistantClassifier.test.ts
bardd's picture
Deploy Mike backend-only Space (part 2)
cdd4fb2 verified
Raw History Blame Contribute Delete
5.59 kB
import { test, describe, it } from "node:test";
import assert from "node:assert";
import {
classifyAssistantTurn,
buildSafeFallbackOutput,
MIN_ROUTER_FALLBACK_REMAINING_MS,
type RouterInferenceExecutor,
} from "../../src/lib/assistantRouting/classifier";
import type { AssistantRoutingContextV2 } from "../../src/lib/assistantRouting/types";
function ctx(overrides: Partial<AssistantRoutingContextV2> = {}): AssistantRoutingContextV2 {
return {
schemaVersion: 2,
surface: "assistant_chat",
requestedMode: "auto",
currentDate: "2026-01-01",
latestUserMessage: "Add a comment and redline the clause",
recentConversation: [],
displayedDocument: {
documentId: "doc1",
filename: "agreement.docx",
fileType: "docx",
editable: true,
revisionId: null,
},
attachedDocuments: [],
projectDocumentCount: 0,
selectedWorkflow: null,
focusedDocumentExcerpt: null,
mutationIntentHint: true,
confirmationPresented: false,
...overrides,
};
}
const validOutput = JSON.stringify({
schemaVersion: 2,
operations: ["comment_documents", "edit_documents"],
webNeed: "required",
targetScopes: ["displayed_document"],
ambiguities: [],
reasonCodes: ["document_comment_request", "document_edit_request"],
});
describe("assistantRouting/classifier", () => {
it("succeeds on primary", async () => {
const executor: RouterInferenceExecutor = async () => validOutput;
const r = await classifyAssistantTurn({
context: ctx(),
deadlineAt: Date.now() + 10_000,
executor,
candidates: [{ model: "primary", featureId: "assistant-turn-routing" }],
});
assert.equal(r.usedFallback, false);
assert.equal(r.model, "primary");
assert.deepEqual(r.output.operations, ["comment_documents", "edit_documents"]);
});
it("falls back when primary is invalid and fallback succeeds", async () => {
let calls = 0;
const executor: RouterInferenceExecutor = async () => {
calls++;
return calls === 1 ? "not json at all" : validOutput;
};
const r = await classifyAssistantTurn({
context: ctx(),
deadlineAt: Date.now() + 10_000,
executor,
candidates: [
{ model: "primary", featureId: "assistant-turn-routing" },
{ model: "fallback", featureId: "assistant-turn-routing" },
],
});
assert.equal(r.usedFallback, true);
assert.equal(r.model, "fallback");
});
it("does not attempt fallback when remaining deadline too small", async () => {
let calls = 0;
const executor: RouterInferenceExecutor = async () => {
calls++;
return "garbage";
};
const r = await classifyAssistantTurn({
context: ctx(),
deadlineAt: Date.now() + (MIN_ROUTER_FALLBACK_REMAINING_MS - 50),
executor,
candidates: [
{ model: "primary", featureId: "assistant-turn-routing" },
{ model: "fallback", featureId: "assistant-turn-routing" },
],
});
// Only primary attempted; fallback skipped; safe fallback returned.
assert.equal(calls, 1);
assert.equal(r.usedFallback, true);
assert.equal(r.model, null);
});
it("returns safe fallback when all candidates fail", async () => {
const executor: RouterInferenceExecutor = async () => {
throw new Error("boom");
};
const r = await classifyAssistantTurn({
context: ctx(),
deadlineAt: Date.now() + 10_000,
executor,
candidates: [
{ model: "primary", featureId: "assistant-turn-routing" },
{ model: "fallback", featureId: "assistant-turn-routing" },
],
});
assert.equal(r.usedFallback, true);
assert.equal(r.model, null);
assert.deepEqual(r.output.operations, ["answer"]);
assert.equal(r.output.webNeed, "not_needed");
});
it("does not chain a second semantic decision from first output", async () => {
// Even if primary returns valid output but with extra noise that fails
// validation, fallback is independent (gets original context, not a
// refinement). Verify fallback output does not depend on primary text.
let primarySeen: string | null = null;
const executor: RouterInferenceExecutor = async ({ user }) => {
if (!primarySeen) {
primarySeen = user;
return "```bad";
}
// Fallback must receive the SAME user payload (original context).
assert.equal(user, primarySeen);
return validOutput;
};
const r = await classifyAssistantTurn({
context: ctx(),
deadlineAt: Date.now() + 10_000,
executor,
candidates: [
{ model: "primary", featureId: "assistant-turn-routing" },
{ model: "fallback", featureId: "assistant-turn-routing" },
],
});
assert.equal(r.usedFallback, true);
});
it("safe fallback flags empty request ambiguity", () => {
const out = buildSafeFallbackOutput(ctx({ latestUserMessage: "" }));
assert.ok(out.ambiguities.includes("empty_request"));
});
});