NODEDC_1C/llm_normalizer/backend/tests/assistantDeepTurnAnalysisRuntimeAdapter.test.ts

import { describe, expect, it, vi } from "vitest";
import { runAssistantDeepTurnAnalysisRuntime } from "../src/services/assistantDeepTurnAnalysisRuntimeAdapter";

describe("assistant deep turn analysis runtime adapter", () => {
  it("orchestrates deep pipeline steps in deterministic order", async () => {
    const callOrder: string[] = [];

    const runContextRuntime = vi.fn(() => {
      callOrder.push("context");
      return {
        companyAnchors: { accounts: ["60.01"] },
        focusDomainForGuards: "settlements_60_62",
        temporalGuard: { primary_period_window: { from: "2020-07-01", to: "2020-07-31" } },
        domainPolarityGuardInitial: { polarity: "supplier_payable" },
        claimAnchorAudit: { claim_type: "prove_settlement_closure_state" },
        businessScopeResolution: { business_scope_resolved: ["company_specific_accounting"] },
        resolvedRouteSummary: { mode: "deterministic_v2", decisions: [] as any[] } as any,
        liveTemporalHint: {
          as_of_date: "2020-07-31",
          period_from: null,
          period_to: null,
          source: "analysis_context"
        }
      };
    });
    const runExecutionPlanRuntime = vi.fn((input) => {
      callOrder.push("plan");
      expect(input.claimAnchorAudit.claim_type).toBe("prove_settlement_closure_state");
      return {
        requirementExtraction: {
          requirements: [{ id: "R1" }],
          byFragment: new Map<string, string[]>([["F1", ["R1"]]])
        },
        executionPlan: [{ fragment_id: "F1" }],
        rbpRoutePlanEnforcement: { executionPlan: [{ fragment_id: "F1" }], audit: { rbp: true } },
        faRoutePlanEnforcement: { executionPlan: [{ fragment_id: "F1" }], audit: { fa: true } }
      } as any;
    });
    const runRetrievalRuntime = vi.fn(async (input) => {
      callOrder.push("retrieval");
      expect(input.liveTemporalHint?.as_of_date).toBe("2020-07-31");
      return {
        retrievalCalls: [{ fragment_id: "F1", route: "store_canonical" }],
        retrievalResultsRaw: [{ fragment_id: "F1", route: "store_canonical", raw_result: {} }],
        retrievalResults: [{ fragment_id: "F1", requirement_ids: ["R1"] }]
      } as any;
    });
    const runGuardRuntime = vi.fn((input) => {
      callOrder.push("guard");
      expect(input.retrievalResults[0].fragment_id).toBe("F1");
      return {
        retrievalResults: [{ fragment_id: "F1-guarded", requirement_ids: ["R1"] }],
        polarityGuardResult: { audit: { polarity: "supplier_payable" } },
        targetedEvidenceResult: {
          audit: {
            targeted_evidence_hit_rate: 0.5
          }
        },
        evidenceGateResult: {
          audit: {
            admissible_evidence_count: 3
          }
        }
      } as any;
    });
    const runGroundingRuntime = vi.fn((input) => {
      callOrder.push("grounding");
      expect(input.claimType).toBe("prove_settlement_closure_state");
      expect(input.targetedEvidenceHitRate).toBe(0.5);
      expect(input.businessScopeResolved).toEqual(["company_specific_accounting"]);
      return {
        rbpLiveRouteAudit: { routed: 1 },
        faLiveRouteAudit: { routed: 1 },
        coverageEvaluation: {
          requirements: [{ id: "R1" }],
          coverage: { requirements_total: 1, requirements_covered: 1 }
        },
        groundedAnswerEligibilityGuard: { eligible: true },
        groundingCheck: { status: "grounded", reasons: [] }
      } as any;
    });
    const runCompositionRuntime = vi.fn((input) => {
      callOrder.push("composition");
      expect(input.retrievalResults[0].fragment_id).toBe("F1-guarded");
      return {
        questionTypeClass: "causal_trace",
        composition: { reply_type: "factual", answer: "ok" }
      } as any;
    });

    const runtime = await runAssistantDeepTurnAnalysisRuntime({
      userMessage: "where closure failed",
      runContextRuntime,
      runExecutionPlanRuntime,
      runRetrievalRuntime,
      runGuardRuntime,
      runGroundingRuntime,
      runCompositionRuntime
    });

    expect(callOrder).toEqual(["context", "plan", "retrieval", "guard", "grounding", "composition"]);
    expect(runtime.retrievalResults[0].fragment_id).toBe("F1-guarded");
    expect(runtime.questionTypeClass).toBe("causal_trace");
    expect(runtime.composition.reply_type).toBe("factual");
  });

  it("passes null business scope when not resolved", async () => {
    const runGroundingRuntime = vi.fn(() => ({
      rbpLiveRouteAudit: {},
      faLiveRouteAudit: {},
      coverageEvaluation: { requirements: [], coverage: {} },
      groundedAnswerEligibilityGuard: {},
      groundingCheck: { status: "no_grounded_answer", reasons: [] }
    }));

    await runAssistantDeepTurnAnalysisRuntime({
      userMessage: "question",
      runContextRuntime: () =>
        ({
          companyAnchors: {},
          focusDomainForGuards: null,
          temporalGuard: {},
          domainPolarityGuardInitial: {},
          claimAnchorAudit: { claim_type: "unknown" },
          businessScopeResolution: {},
          resolvedRouteSummary: null,
          liveTemporalHint: null
        }) as any,
      runExecutionPlanRuntime: () =>
        ({
          requirementExtraction: { requirements: [], byFragment: new Map() },
          executionPlan: [],
          rbpRoutePlanEnforcement: { executionPlan: [], audit: {} },
          faRoutePlanEnforcement: { executionPlan: [], audit: {} }
        }) as any,
      runRetrievalRuntime: async () =>
        ({
          retrievalCalls: [],
          retrievalResultsRaw: [],
          retrievalResults: []
        }) as any,
      runGuardRuntime: () =>
        ({
          retrievalResults: [],
          polarityGuardResult: { audit: {} },
          targetedEvidenceResult: { audit: { targeted_evidence_hit_rate: null } },
          evidenceGateResult: { audit: {} }
        }) as any,
      runGroundingRuntime: runGroundingRuntime as any,
      runCompositionRuntime: () =>
        ({
          questionTypeClass: "single_fact_lookup",
          composition: { reply_type: "partial_coverage" }
        }) as any
    });

    expect(runGroundingRuntime).toHaveBeenCalledWith(
      expect.objectContaining({
        routeSummary: null,
        businessScopeResolved: null
      })
    );
  });
});