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

import { describe, expect, it } from "vitest";
import { applyAssistantMcpDiscoveryResponsePolicy } from "../src/services/assistantMcpDiscoveryResponsePolicy";

function entryPoint(overrides: Record<string, unknown> = {}) {
  return {
    schema_version: "assistant_mcp_discovery_runtime_entry_point_v1",
    policy_owner: "assistantMcpDiscoveryRuntimeEntryPoint",
    entry_status: "bridge_executed",
    hot_runtime_wired: false,
    discovery_attempted: true,
    turn_input: { adapter_status: "ready" },
    bridge: {
      bridge_status: "answer_draft_ready",
      user_facing_response_allowed: true,
      business_fact_answer_allowed: true,
      requires_user_clarification: false,
      answer_draft: {
        answer_mode: "confirmed_with_bounded_inference",
        headline: "Confirmed scoped answer.",
        confirmed_lines: ["Confirmed fact"],
        inference_lines: ["Bounded inference"],
        unknown_lines: ["Unconfirmed fact"],
        limitation_lines: ["Limited source window"],
        next_step_line: null
      }
    },
    reason_codes: ["runtime_entry_point_bridge_executed"],
    ...overrides
  } as any;
}

describe("assistant MCP discovery response policy", () => {
  it("applies a guarded candidate only for unsupported current-turn boundary replies", () => {
    const result = applyAssistantMcpDiscoveryResponsePolicy({
      currentReply: "route is not wired",
      currentReplySource: "deterministic_unsupported_current_turn_boundary",
      modeDecisionReason: "unsupported_current_turn_meaning_boundary",
      addressRuntimeMeta: {
        mcpDiscoveryRuntimeEntryPoint: entryPoint()
      }
    });

    expect(result.applied).toBe(true);
    expect(result.decision).toBe("apply_candidate");
    expect(result.reply_source).toBe("mcp_discovery_response_candidate_guarded");
    expect(result.reply_text).toContain("Confirmed fact");
    expect(result.reply_text).not.toContain("query_documents");
    expect(result.reason_codes).toContain("mcp_discovery_response_policy_candidate_applied");
  });

  it("keeps the current reply when the turn is not an unsupported boundary", () => {
    const result = applyAssistantMcpDiscoveryResponsePolicy({
      currentReply: "regular chat",
      currentReplySource: "llm_chat",
      modeDecisionReason: "living_chat_signal_detected",
      addressRuntimeMeta: {
        mcpDiscoveryRuntimeEntryPoint: entryPoint()
      }
    });

    expect(result.applied).toBe(false);
    expect(result.decision).toBe("keep_current_reply");
    expect(result.reply_text).toBe("regular chat");
    expect(result.reply_source).toBe("llm_chat");
    expect(result.reason_codes).toContain("mcp_discovery_response_policy_not_unsupported_boundary");
    expect(result.reason_codes).toContain("mcp_discovery_response_policy_not_discovery_ready_chat_candidate");
  });

  it("applies a guarded candidate for discovery-ready llm chat business answers", () => {
    const result = applyAssistantMcpDiscoveryResponsePolicy({
      currentReply: "stale llm business answer",
      currentReplySource: "llm_chat",
      modeDecisionReason: "non_domain_query_indexed",
      addressRuntimeMeta: {
        mcpDiscoveryRuntimeEntryPoint: entryPoint({
          turn_input: {
            adapter_status: "ready",
            should_run_discovery: true
          }
        })
      }
    });

    expect(result.applied).toBe(true);
    expect(result.decision).toBe("apply_candidate");
    expect(result.reply_source).toBe("mcp_discovery_response_candidate_guarded");
    expect(result.reply_text).toContain("Confirmed fact");
    expect(result.reason_codes).toContain("mcp_discovery_response_policy_not_unsupported_boundary");
    expect(result.reason_codes).not.toContain("mcp_discovery_response_policy_not_discovery_ready_chat_candidate");
  });

  it("applies a guarded candidate for discovery-ready deep partial answers", () => {
    const result = applyAssistantMcpDiscoveryResponsePolicy({
      currentReply: "wrong deep partial answer",
      currentReplySource: "deep_analysis",
      addressRuntimeMeta: {
        mcpDiscoveryRuntimeEntryPoint: entryPoint({
          turn_input: {
            adapter_status: "ready",
            should_run_discovery: true
          }
        })
      }
    });

    expect(result.applied).toBe(true);
    expect(result.reply_source).toBe("mcp_discovery_response_candidate_guarded");
    expect(result.reply_text).toContain("Confirmed fact");
    expect(result.reason_codes).not.toContain("mcp_discovery_response_policy_not_discovery_ready_deep_candidate");
  });

  it("applies a guarded candidate for discovery-ready address lane answers", () => {
    const result = applyAssistantMcpDiscoveryResponsePolicy({
      currentReply: "stale exact route answer",
      currentReplySource: "address_query_runtime_v1",
      addressRuntimeMeta: {
        assistant_mcp_discovery_entry_point_v1: entryPoint({
          turn_input: {
            adapter_status: "ready",
            should_run_discovery: true
          }
        })
      }
    });

    expect(result.applied).toBe(true);
    expect(result.reply_source).toBe("mcp_discovery_response_candidate_guarded");
    expect(result.reply_text).toContain("Confirmed fact");
    expect(result.reason_codes).not.toContain("mcp_discovery_response_policy_not_discovery_ready_address_candidate");
  });

  it("keeps address lane answers when discovery was not requested for the current turn", () => {
    const result = applyAssistantMcpDiscoveryResponsePolicy({
      currentReply: "supported exact route answer",
      currentReplySource: "address_query_runtime_v1",
      addressRuntimeMeta: {
        assistant_mcp_discovery_entry_point_v1: entryPoint({
          turn_input: {
            adapter_status: "not_applicable",
            should_run_discovery: false
          }
        })
      }
    });

    expect(result.applied).toBe(false);
    expect(result.reply_text).toBe("supported exact route answer");
    expect(result.reason_codes).toContain("mcp_discovery_response_policy_not_discovery_ready_address_candidate");
  });

  it("keeps the current reply when the candidate has no grounded text", () => {
    const result = applyAssistantMcpDiscoveryResponsePolicy({
      currentReply: "route is not wired",
      currentReplySource: "deterministic_unsupported_current_turn_boundary",
      modeDecisionReason: "unsupported_current_turn_meaning_boundary",
      addressRuntimeMeta: {
        mcpDiscoveryRuntimeEntryPoint: entryPoint({
          bridge: {
            bridge_status: "unsupported",
            user_facing_response_allowed: true,
            business_fact_answer_allowed: false,
            requires_user_clarification: false,
            answer_draft: null
          }
        })
      }
    });

    expect(result.applied).toBe(false);
    expect(result.reply_text).toBe("route is not wired");
    expect(result.reason_codes).toContain("mcp_discovery_response_policy_candidate_not_eligible");
    expect(result.reason_codes).toContain("mcp_discovery_response_policy_kept_current_reply");
  });
});