97 lines
3.9 KiB
TypeScript
97 lines
3.9 KiB
TypeScript
import { describe, expect, it } from "vitest";
|
|
import { buildAssistantDeepTurnExecutionPlan } from "../src/services/assistantDeepTurnPlanRuntimeAdapter";
|
|
|
|
describe("assistant deep turn plan runtime adapter", () => {
|
|
it("builds execution plan through extraction, enforcement and guard hints in stable order", () => {
|
|
const callOrder: string[] = [];
|
|
const byFragment = new Map<string, string[]>([["F1", ["R1"]]]);
|
|
const planInitial = [{ fragment_id: "F1", route: "store_canonical" }] as any[];
|
|
const planAfterRbp = [{ fragment_id: "F1", route: "hybrid_store_plus_live" }] as any[];
|
|
const planAfterFa = [{ fragment_id: "F1", route: "hybrid_store_plus_live", fa: true }] as any[];
|
|
const planAfterTemporal = [{ fragment_id: "F1", route: "hybrid_store_plus_live", temporal: true }] as any[];
|
|
const planAfterPolarity = [{ fragment_id: "F1", route: "hybrid_store_plus_live", temporal: true, polarity: true }] as any[];
|
|
|
|
const output = buildAssistantDeepTurnExecutionPlan({
|
|
routeSummary: { mode: "deterministic_v2", decisions: [] } as any,
|
|
normalizedPayload: { schema_version: "normalized_query_v2_0_2" } as any,
|
|
userMessage: "check tails",
|
|
claimType: "prove_settlement_closure_state",
|
|
temporalGuard: { temporal_guard_outcome: "passed" } as any,
|
|
domainPolarityGuardInitial: { polarity: "supplier_payable" } as any,
|
|
extractRequirements: () => {
|
|
callOrder.push("extract");
|
|
return {
|
|
requirements: [{ requirement_id: "R1" }] as any[],
|
|
byFragment
|
|
};
|
|
},
|
|
toExecutionPlan: (_routeSummary, _normalizedPayload, _userMessage, requirementByFragment) => {
|
|
callOrder.push("plan");
|
|
expect(requirementByFragment).toBe(byFragment);
|
|
return planInitial as any;
|
|
},
|
|
enforceRbpLiveRoutePlan: ({ executionPlan }) => {
|
|
callOrder.push("rbp");
|
|
expect(executionPlan).toBe(planInitial);
|
|
return {
|
|
executionPlan: planAfterRbp as any,
|
|
audit: { rbp: true }
|
|
};
|
|
},
|
|
enforceFaLiveRoutePlan: ({ executionPlan }) => {
|
|
callOrder.push("fa");
|
|
expect(executionPlan).toBe(planAfterRbp);
|
|
return {
|
|
executionPlan: planAfterFa as any,
|
|
audit: { fa: true }
|
|
};
|
|
},
|
|
applyTemporalHintToExecutionPlan: (executionPlan) => {
|
|
callOrder.push("temporal");
|
|
expect(executionPlan).toBe(planAfterFa);
|
|
return planAfterTemporal as any;
|
|
},
|
|
applyPolarityHintToExecutionPlan: (executionPlan) => {
|
|
callOrder.push("polarity");
|
|
expect(executionPlan).toBe(planAfterTemporal);
|
|
return planAfterPolarity as any;
|
|
}
|
|
});
|
|
|
|
expect(callOrder).toEqual(["extract", "plan", "rbp", "fa", "temporal", "polarity"]);
|
|
expect(output.requirementExtraction.byFragment).toBe(byFragment);
|
|
expect(output.executionPlan).toBe(planAfterPolarity);
|
|
expect(output.rbpRoutePlanEnforcement.audit).toEqual({ rbp: true });
|
|
expect(output.faRoutePlanEnforcement.audit).toEqual({ fa: true });
|
|
});
|
|
|
|
it("preserves empty execution plan end-to-end", () => {
|
|
const output = buildAssistantDeepTurnExecutionPlan({
|
|
routeSummary: null,
|
|
normalizedPayload: null as any,
|
|
userMessage: "noop",
|
|
claimType: "unknown",
|
|
temporalGuard: null,
|
|
domainPolarityGuardInitial: null,
|
|
extractRequirements: () => ({
|
|
requirements: [],
|
|
byFragment: new Map()
|
|
}),
|
|
toExecutionPlan: () => [],
|
|
enforceRbpLiveRoutePlan: ({ executionPlan }) => ({
|
|
executionPlan,
|
|
audit: { rbp: false }
|
|
}),
|
|
enforceFaLiveRoutePlan: ({ executionPlan }) => ({
|
|
executionPlan,
|
|
audit: { fa: false }
|
|
}),
|
|
applyTemporalHintToExecutionPlan: (executionPlan) => executionPlan,
|
|
applyPolarityHintToExecutionPlan: (executionPlan) => executionPlan
|
|
});
|
|
|
|
expect(output.executionPlan).toEqual([]);
|
|
expect(output.requirementExtraction.requirements).toEqual([]);
|
|
});
|
|
});
|