122 lines
4.9 KiB
TypeScript
122 lines
4.9 KiB
TypeScript
import { describe, expect, it } from "vitest";
|
|
import {
|
|
applyAssistantDeepTurnGroundingEligibility,
|
|
applyAssistantDeepTurnRetrievalGuards
|
|
} from "../src/services/assistantDeepTurnGuardRuntimeAdapter";
|
|
|
|
describe("assistant deep turn guard runtime adapter", () => {
|
|
it("runs retrieval guards in expected order and threads outputs", () => {
|
|
const callOrder: string[] = [];
|
|
const seedResults = [{ fragment_id: "F1" }] as any[];
|
|
const afterPolarity = [{ fragment_id: "P1" }] as any[];
|
|
const afterTargeted = [{ fragment_id: "T1" }] as any[];
|
|
const afterGate = [{ fragment_id: "G1" }] as any[];
|
|
|
|
const output = applyAssistantDeepTurnRetrievalGuards({
|
|
retrievalResults: seedResults as any,
|
|
domainPolarityGuardInitial: { applied: true, polarity: "supplier_payable" } as any,
|
|
claimAnchorAudit: { claim_type: "prove_settlement_closure_state" } as any,
|
|
temporalGuard: { temporal_guard_outcome: "passed", temporal_guard_basis: "none" } as any,
|
|
focusDomainForGuards: "settlements_60_62" as any,
|
|
companyAnchors: { accounts: ["60.01"] } as any,
|
|
userMessage: "check settlements",
|
|
applyDomainPolarityGuardFn: ((input: Record<string, unknown>) => {
|
|
callOrder.push("polarity");
|
|
expect(input.retrievalResults).toBe(seedResults);
|
|
return {
|
|
retrievalResults: afterPolarity,
|
|
audit: {
|
|
applied: true,
|
|
polarity: "supplier_payable",
|
|
outcome: "passed",
|
|
reason_codes: []
|
|
}
|
|
};
|
|
}) as any,
|
|
applyTargetedEvidenceFn: ((input: Record<string, unknown>) => {
|
|
callOrder.push("targeted");
|
|
expect(input.retrievalResults).toBe(afterPolarity);
|
|
return {
|
|
retrievalResults: afterTargeted,
|
|
audit: {
|
|
targeted_evidence_hit_rate: 0.5,
|
|
reason_codes: []
|
|
}
|
|
};
|
|
}) as any,
|
|
applyEvidenceAdmissibilityGateFn: ((input: Record<string, unknown>) => {
|
|
callOrder.push("gate");
|
|
expect(input.retrievalResults).toBe(afterTargeted);
|
|
expect(input.polarity).toBe("supplier_payable");
|
|
expect(input.userMessage).toBe("check settlements");
|
|
return {
|
|
retrievalResults: afterGate,
|
|
audit: {
|
|
admissible_evidence_count: 2,
|
|
reason_codes: []
|
|
}
|
|
};
|
|
}) as any
|
|
});
|
|
|
|
expect(callOrder).toEqual(["polarity", "targeted", "gate"]);
|
|
expect(output.retrievalResults).toBe(afterGate);
|
|
expect(output.polarityGuardResult.retrievalResults).toBe(afterPolarity);
|
|
expect(output.targetedEvidenceResult.retrievalResults).toBe(afterTargeted);
|
|
expect(output.evidenceGateResult.retrievalResults).toBe(afterGate);
|
|
});
|
|
|
|
it("evaluates grounding eligibility and applies status overlay", () => {
|
|
const callOrder: string[] = [];
|
|
const groundingCheckBase = {
|
|
status: "grounded_positive",
|
|
reasons: ["base"],
|
|
route_subject_match: true
|
|
};
|
|
|
|
const output = applyAssistantDeepTurnGroundingEligibility({
|
|
groundingCheckBase,
|
|
temporalGuard: { temporal_guard_outcome: "passed", temporal_guard_basis: "none" } as any,
|
|
polarityAudit: { applied: true, outcome: "passed", polarity: "supplier_payable" } as any,
|
|
evidenceAudit: { admissible_evidence_count: 0 } as any,
|
|
claimAnchorAudit: { claim_anchor_resolution_rate: 1, missing_anchors: [], required_anchors: [] } as any,
|
|
targetedEvidenceHitRate: 0,
|
|
businessScopeResolved: ["company_specific_accounting"],
|
|
evaluateGroundedAnswerEligibilityFn: ((input: Record<string, unknown>) => {
|
|
callOrder.push("eligibility");
|
|
expect(input.targetedEvidenceHitRate).toBe(0);
|
|
return {
|
|
eligible: false,
|
|
temporal_passed: true,
|
|
eligibility_time_basis: "none",
|
|
business_scope_passed: true,
|
|
polarity_passed: true,
|
|
claim_anchors_passed: true,
|
|
claim_anchor_resolution_rate: 1,
|
|
missing_required_anchors: 0,
|
|
admissible_evidence_count: 0,
|
|
critical_contradiction: false,
|
|
outcome: "limited_or_insufficient_evidence",
|
|
grounding_mode: "limited_or_insufficient_evidence",
|
|
reason_codes: ["admissible_evidence_count_zero"]
|
|
};
|
|
}) as any,
|
|
applyEligibilityToGroundingCheckFn: ((check: Record<string, unknown>, eligibility: Record<string, unknown>) => {
|
|
callOrder.push("overlay");
|
|
expect(check.status).toBe("grounded_positive");
|
|
expect(eligibility.eligible).toBe(false);
|
|
return {
|
|
...check,
|
|
status: "no_grounded_answer",
|
|
reasons: ["base", "not_enough_evidence"]
|
|
};
|
|
}) as any
|
|
});
|
|
|
|
expect(callOrder).toEqual(["eligibility", "overlay"]);
|
|
expect(output.groundedAnswerEligibilityGuard.eligible).toBe(false);
|
|
expect(output.groundingCheck.status).toBe("no_grounded_answer");
|
|
expect(output.groundingCheck.reasons).toEqual(["base", "not_enough_evidence"]);
|
|
});
|
|
});
|