import pytest import time from types import SimpleNamespace from app.config.ai_prompts import PROMPT_AI_PMO_QA, PROMPT_RAG_QUERY_SEMANTICS from app.services.adaptive_rag_service.mixin_answer_entry import AdaptiveRAGAnswerEntryMixin from app.services.adaptive_rag_service.mixin_answer_mainline import AdaptiveRAGAnswerMainlineMixin from app.services.adaptive_rag_service.mixin_answer_payload import AdaptiveRAGAnswerPayloadMixin from app.services.adaptive_rag_service.mixin_answer_precheck import AdaptiveRAGAnswerPrecheckMixin from app.services.adaptive_rag_service.mixin_answer_retrieval import AdaptiveRAGAnswerRetrievalMixin from app.services.adaptive_rag_service.mixin_conversation_utils_a_p1 import AdaptiveRAGConversationUtilsAMixinP1 from app.services.adaptive_rag_service.mixin_deep_guard_answer import AdaptiveRAGDeepGuardAnswerMixin from app.services.adaptive_rag_service.mixin_deep_guard_rules import AdaptiveRAGDeepGuardRulesMixin from app.services.adaptive_rag_service.mixin_core_intent import AdaptiveRAGCoreIntentMixin from app.services.adaptive_rag_service.mixin_deterministic_query_core import ( AdaptiveRAGDeterministicQueryCoreMixin, ) from app.services.adaptive_rag_service.mixin_manifest_feature_p2 import AdaptiveRAGManifestFeatureMixinP2 from app.services.adaptive_rag_service.mixin_manifest_feature_p1 import AdaptiveRAGManifestFeatureMixinP1 from app.services.adaptive_rag_service.mixin_multistep_core import AdaptiveRAGMultiStepCoreMixin from app.services.adaptive_rag_service.mixin_multistep_flow import AdaptiveRAGMultiStepFlowMixin from app.services.adaptive_rag_service.mixin_query_route_gateway import AdaptiveRAGQueryRouteGatewayMixin from app.services.adaptive_rag_service.mixin_requirement_ack_core import AdaptiveRAGRequirementAckCoreMixin from app.services.adaptive_rag_service.mixin_retrieval_router_db import AdaptiveRAGRetrievalRouterDBMixin from app.services.adaptive_rag_service.mixin_retrieval_vector import AdaptiveRAGRetrievalVectorMixin from app.services.adaptive_rag_service.mixin_followup_anchor import FollowupAnchorResolution from app.services.adaptive_rag_service.mixin_followup_anchor import AdaptiveRAGFollowupAnchorMixin from app.services.adaptive_rag_service.mixin_fast_answer_project_main import AdaptiveRAGFastAnswerProjectMainMixin from app.services.adaptive_rag_service.mixin_fast_answer_project_utils import AdaptiveRAGFastAnswerProjectUtilsMixin from app.services.adaptive_rag_service.internal_query_context import InternalContextPacket from app.services.adaptive_rag_service.mixin_target_resolution import AdaptiveRAGTargetResolutionMixin from app.services.adaptive_rag_service.shared_part_02 import RetrievedItem from app.services.adaptive_rag_service.shared_part_02 import ACTION_MODE_READ, DEEP_RETRIEVAL_STEPS, DEEP_VECTOR_TOP_K from app.services.ai_pmo.workflow_semantic_planner import WorkflowSemanticPlanner def _make_internal_context_packet( *, query_type: str, answer_contract: str, target_ref: str | None = None, ) -> InternalContextPacket: target_resolution = {} if target_ref: target_resolution = { "target_entity_type": "project", "target_ref": target_ref, "resolution_mode": "deterministic", "confidence": 0.96, } return InternalContextPacket.model_validate( { "packet_version": "v1", "question": "", "scope": { "tenant_id": 1, "project_id": None, "session_id": 11, "conversation_scope_key": None, "reply_to_message_id": None, "root_message_id": None, }, "route_decision": { "route_mode": "internal", "effective_source_policy": "internal", }, "operation_contract": { "query_type": query_type, }, "target_resolution": target_resolution, "query_plan": { "plan_version": "v2", "query_type": query_type, "entity_type": "project", "answer_contract": answer_contract, "target_ref": target_ref, "filters": [], }, "executor_summary": {}, "verifier_summary": {}, "uncertainties": [], } ) class _FakeAdaptiveRAGService( AdaptiveRAGAnswerEntryMixin, AdaptiveRAGAnswerMainlineMixin, ): def __init__(self) -> None: self.db = object() self.tenant_id = 9 self.ack_calls = 0 self.base_calls = 0 self.base_kwargs: dict[str, object] = {} def _normalize_thinking_mode(self, thinking_mode: str) -> str: return "deep" if str(thinking_mode or "").strip().lower() == "deep" else "normal" async def _prepare_answer_runtime(self, **kwargs): clean_q = str(kwargs.get("clean_q") or "").strip() action_mode = str(kwargs.get("action_mode") or "").strip().lower() return { "session_id": 101, "turn_index": 2, "context_session_id": 101, "conversation": [], "state_row": None, "resolved_question": clean_q, "effective_q": clean_q, "rewrite_meta": {"mode": "direct"}, "query_type": "explain", "effective_action_mode": action_mode, "anchor_resolution": None, } async def _handle_ack_first_requirement(self, **kwargs): self.ack_calls += 1 _ = kwargs return {"answer": "ack-required", "processing_stage": "ack_only"} async def _execute_base_answer_mainline(self, **kwargs): self.base_calls += 1 self.base_kwargs = dict(kwargs) return {"answer": "base-answer", "processing_stage": "qa"} @pytest.mark.asyncio async def test_answer_entry_read_mainline_skips_requirement_ack() -> None: service = _FakeAdaptiveRAGService() result = await service.answer_question( question="现在有哪些阻塞？", asked_by=1, asked_via="pmflow_manual", action_mode="read", sync_requirement=True, ) assert result["processing_stage"] == "qa" assert service.ack_calls == 0 assert service.base_calls == 1 @pytest.mark.asyncio async def test_answer_entry_write_mode_uses_requirement_ack_gate() -> None: service = _FakeAdaptiveRAGService() result = await service.answer_question( question="请同步写入一条风险", asked_by=1, asked_via="pmflow_manual", action_mode="write", sync_requirement=True, ) assert result["processing_stage"] == "ack_only" assert service.ack_calls == 1 assert service.base_calls == 0 @pytest.mark.asyncio async def test_answer_entry_high_accuracy_channel_respects_requested_normal_mode() -> None: service = _FakeAdaptiveRAGService() result = await service.answer_question( question="最近有哪些项目？", asked_by=1, asked_via="pmflow", thinking_mode="normal", sync_requirement=True, ) assert result["processing_stage"] == "qa" assert service.ack_calls == 0 assert service.base_calls == 1 assert service.base_kwargs["active_thinking_mode"] == "normal" assert service.base_kwargs["deep_thinking"] is False assert int(service.base_kwargs["deep_retrieval_steps"]) == DEEP_RETRIEVAL_STEPS assert int(service.base_kwargs["deep_vector_top_k"]) == DEEP_VECTOR_TOP_K @pytest.mark.asyncio async def test_answer_entry_forwards_consultant_mode_preference_to_mainline() -> None: service = _FakeAdaptiveRAGService() result = await service.answer_question( question="这个方案怎么做更稳妥？", asked_by=1, asked_via="pmflow", thinking_mode="normal", consultant_mode_preference="advise", ) assert result["processing_stage"] == "qa" assert service.base_calls == 1 assert service.base_kwargs["consultant_mode_preference"] == "advise" @pytest.mark.asyncio async def test_answer_entry_mixed_request_skips_requirement_ack_gate() -> None: service = _FakeAdaptiveRAGService() result = await service.answer_question( question="现在进展如何，并且新增任务确认流", asked_by=1, asked_via="pmflow_manual", action_mode="read_write", sync_requirement=True, message_intent="mixed", ) assert result["processing_stage"] == "qa" assert service.ack_calls == 0 assert service.base_calls == 1 assert service.base_kwargs["active_thinking_mode"] == "normal" assert service.base_kwargs["deep_thinking"] is False @pytest.mark.asyncio async def test_answer_entry_feishu_write_mode_still_goes_base_mainline() -> None: service = _FakeAdaptiveRAGService() result = await service.answer_question( question="请在飞书里补一条风险", asked_by=1, asked_via="feishu", action_mode="write", sync_requirement=True, ) assert result["processing_stage"] == "qa" assert service.ack_calls == 0 assert service.base_calls == 1 assert service.base_kwargs["active_thinking_mode"] == "normal" assert service.base_kwargs["deep_thinking"] is False assert int(service.base_kwargs["deep_retrieval_steps"]) == DEEP_RETRIEVAL_STEPS assert int(service.base_kwargs["deep_vector_top_k"]) == DEEP_VECTOR_TOP_K @pytest.mark.asyncio async def test_requirement_ack_auto_mode_respects_structured_query_bundle(monkeypatch: pytest.MonkeyPatch) -> None: class _ModeService(AdaptiveRAGRequirementAckCoreMixin): pass async def _fake_aplan_message(cls, *, message_text: str, source_system: str, metadata=None): _ = (cls, message_text, source_system, metadata) return WorkflowSemanticPlanner.deserialize_bundle( { "bundle_id": "semantic-test", "semantic_version": "v1", "source_system": "adaptive_rag_ack", "primary_workflow": "query_flow", "workflows": [ { "workflow_type": "query_flow", "workflow_action": "answer", "target_scope": "global", "operation_codes": ["query.answer"], "requires_confirmation": False, "confidence": 0.91, "clarification_needed": False, "metadata": {}, } ], "message_gate": "auto", "reply_contract": {"mode": "text", "template_key": "workflow_bundle", "summary": "query_flow"}, "diagnostics": {"message_intent": "question"}, } ) monkeypatch.setattr(WorkflowSemanticPlanner, "aplan_message", classmethod(_fake_aplan_message)) mode = await _ModeService._resolve_action_mode_async( requested_mode="auto", question="先不要创建任务，告诉我当前进展和风险", effective_question="先不要创建任务，告诉我当前进展和风险", asked_via="pmflow_manual", ) assert mode == ACTION_MODE_READ def test_query_runtime_planner_prefers_fast_path_for_list_question_even_if_requested_deep() -> None: class _FakePlannerService(AdaptiveRAGAnswerMainlineMixin): pass service = _FakePlannerService() decision = service._plan_query_runtime( question="现在有哪些项目？", effective_question="现在有哪些项目？", query_type="list", requested_thinking_mode="deep", enforce_scene_prompt_only=False, ) assert decision.answer_mode == "fast_path" assert decision.thinking_mode == "normal" assert decision.allow_fast_path is True def test_query_runtime_planner_bypasses_fast_path_when_consultant_mode_preference_present() -> None: class _FakePlannerService(AdaptiveRAGAnswerMainlineMixin): pass service = _FakePlannerService() decision = service._plan_query_runtime( question="现在有哪些项目？", effective_question="现在有哪些项目？", query_type="list", requested_thinking_mode="normal", enforce_scene_prompt_only=False, consultant_mode_preference="advise", ) assert decision.answer_mode == "retrieval_normal" assert decision.thinking_mode == "normal" assert decision.allow_fast_path is False def test_query_runtime_planner_ignores_legacy_consultant_mode_for_internal_existence_query() -> None: class _FakePlannerService(AdaptiveRAGAnswerMainlineMixin): pass service = _FakePlannerService() decision = service._plan_query_runtime( question="当前系统内是否有为采购经理提出的需求？", effective_question="当前系统内是否有为采购经理提出的需求？", query_type="existence", requested_thinking_mode="normal", enforce_scene_prompt_only=False, consultant_mode_preference="analytical", ) assert decision.answer_mode == "fast_path" assert decision.thinking_mode == "normal" assert decision.allow_fast_path is True def test_query_runtime_planner_prefers_fast_path_for_existence_question() -> None: class _FakePlannerService(AdaptiveRAGAnswerMainlineMixin): pass service = _FakePlannerService() decision = service._plan_query_runtime( question="系统里有没有A股项目？", effective_question="系统里有没有A股项目？", query_type="existence", requested_thinking_mode="normal", enforce_scene_prompt_only=False, ) assert decision.answer_mode == "fast_path" assert decision.thinking_mode == "normal" assert decision.allow_fast_path is True def test_internal_query_plan_builds_project_existence_contract() -> None: class _FakePlannerService( AdaptiveRAGAnswerMainlineMixin, AdaptiveRAGFastAnswerProjectUtilsMixin, ): pass service = _FakePlannerService() plan = service._build_internal_query_plan( question="系统里有没有A股项目？", project_id=None, query_semantics={ "query_type": "existence", "subject_focus": "project", "scope_hint": "global", "effective_source_policy": "internal", }, ) assert plan is not None assert plan["query_type"] == "existence" assert plan["entity_type"] == "project" assert plan["answer_contract"] == "yes_no_with_evidence" assert plan["retrieval_policy"]["facts_first"] is True assert plan["filters"] == [] def test_operation_contract_preserves_structured_existence_before_target_resolution() -> None: class _FakeService( AdaptiveRAGTargetResolutionMixin, AdaptiveRAGAnswerMainlineMixin, ): pass service = _FakeService() contract = service._build_operation_contract( question="帮我看看系统里面有没有开票系统。", query_semantics={ "query_type": "existence", "effective_source_policy": "internal", "object_mentions": ["开票系统"], }, ) assert contract["query_type"] == "existence" assert contract["answer_contract"] == "yes_no_with_evidence" assert contract["object_mentions"] == ["开票系统"] def test_operation_contract_promotes_model_config_reference_to_status() -> None: class _FakeService( AdaptiveRAGTargetResolutionMixin, AdaptiveRAGAnswerMainlineMixin, ): pass service = _FakeService() contract = service._build_operation_contract( question="我们系统当前接的是哪个模型配置？", query_semantics={ "query_type": "existence", "effective_source_policy": "internal", "object_mentions": ["模型配置"], "query_profile": { "referenced_objects": ["system_config", "model_routing"], }, }, ) assert contract["query_type"] == "status" assert contract["answer_contract"] == "entity_snapshot" assert contract["object_mentions"] == ["模型配置"] @pytest.mark.asyncio async def test_internal_target_resolution_prefers_project_candidate_for_existence_query() -> None: class _FakeService(AdaptiveRAGTargetResolutionMixin): def __init__(self) -> None: self.db = object() self.tenant_id = 1 async def _collect_internal_target_candidates(self, **kwargs): _ = kwargs return [ { "target_entity_type": "project", "target_ref": "project:6", "resolved_label": "自动开票系统", "score": 0.96, "source_kind": "semantic_facts", }, { "target_entity_type": "feature", "target_ref": "feature:/invoice", "resolved_label": "开票系统", "score": 0.82, "source_kind": "feature_catalog", }, ] service = _FakeService() resolution = await service._resolve_internal_target( question="帮我看看系统里面有没有开票系统。", project_id=None, query_semantics={"effective_source_policy": "internal"}, system_snapshot={}, operation_contract={ "query_type": "existence", "answer_contract": "yes_no_with_evidence", "object_mentions": ["开票系统"], }, ) assert resolution["target_entity_type"] == "project" assert resolution["target_ref"] == "project:6" assert resolution["resolved_label"] == "自动开票系统" assert resolution["resolution_mode"] == "deterministic" @pytest.mark.asyncio async def test_internal_target_resolution_prefers_session_followup_project_binding_before_semantic_filter() -> None: class _FakeService(AdaptiveRAGTargetResolutionMixin): def __init__(self) -> None: self.db = object() self.tenant_id = 1 async def _collect_internal_target_candidates(self, **kwargs): _ = kwargs return [] service = _FakeService() resolution = await service._resolve_internal_target( question="围绕“采购经理每日实时库存上报服务”回答：那个需求是否存在系统？", project_id=None, query_semantics={ "effective_source_policy": "internal", "subject_focus": "project", "query_profile": { "needs_private_context": True, "needs_freshness": False, "referenced_objects": ["project_object"], }, "session_followup_context": { "rewrite_mode": "state_subject", "last_subject": "采购经理每日实时库存上报服务", "last_entity_ids": [123], }, }, system_snapshot={}, operation_contract={ "query_type": "existence", "answer_contract": "yes_no_with_evidence", "object_mentions": ["采购经理每日实时库存上报服务"], }, ) assert resolution["target_entity_type"] == "project" assert resolution["target_ref"] == "project:123" assert resolution["resolved_label"] == "采购经理每日实时库存上报服务" assert resolution["resolution_mode"] == "deterministic" assert resolution["binding_source"] == "session_followup_context" def test_config_target_candidates_require_structured_referenced_objects() -> None: class _FakeService(AdaptiveRAGTargetResolutionMixin): pass service = _FakeService() rows = service._collect_config_target_candidates( query_semantics={ "query_profile": { "referenced_objects": ["system_config", "model_routing"], } }, operation_contract={ "object_mentions": ["当前模型配置"], }, ) assert len(rows) == 1 assert rows[0]["target_ref"] == "config:model_routing" assert rows[0]["resolved_label"] == "当前模型配置" def test_internal_query_runtime_metrics_include_contract_and_resolution_summaries() -> None: class _FakeService(AdaptiveRAGTargetResolutionMixin): pass service = _FakeService() metrics = service._inject_internal_query_runtime_summaries( retrieval_metrics={"db_query_ms": 12}, query_semantics={ "operation_contract": { "query_type": "existence", "answer_contract": "yes_no_with_evidence", "object_mentions": ["开票系统"], }, "target_resolution": { "target_entity_type": "project", "target_ref": "project:6", "resolved_label": "自动开票系统", "resolution_mode": "deterministic", "confidence": 0.96, }, "query_plan": { "plan_version": "v2", "query_type": "existence", "entity_type": "project", "target_ref": "project:6", "answer_contract": "yes_no_with_evidence", "filters": [{"field": "project_id", "operator": "equals", "value": 6}], }, }, ) assert metrics["db_query_ms"] == 12 assert metrics["operation_contract_summary"]["query_type"] == "existence" assert metrics["target_resolution_summary"]["target_ref"] == "project:6" assert metrics["query_plan_summary"]["plan_version"] == "v2" def test_internal_query_plan_uses_resolved_project_target_ref() -> None: class _FakePlannerService( AdaptiveRAGAnswerMainlineMixin, AdaptiveRAGFastAnswerProjectUtilsMixin, ): pass service = _FakePlannerService() plan = service._build_internal_query_plan( question="帮我看看系统里面有没有开票系统。", project_id=None, query_semantics={ "query_type": "explain", "subject_focus": "feature", "scope_hint": "global", "effective_source_policy": "internal", }, operation_contract={ "query_type": "existence", "answer_contract": "yes_no_with_evidence", "object_mentions": ["开票系统"], }, target_resolution={ "target_entity_type": "project", "target_ref": "project:6", "resolved_label": "自动开票系统", "resolution_mode": "deterministic", }, ) assert plan is not None assert plan["plan_version"] == "v2" assert plan["query_type"] == "existence" assert plan["entity_type"] == "project" assert plan["target_ref"] == "project:6" assert plan["filters"][0]["field"] == "project_id" assert plan["filters"][0]["value"] == 6 def test_internal_query_plan_skips_lexical_project_filter_fallback() -> None: class _FakePlannerService(AdaptiveRAGAnswerMainlineMixin): @staticmethod def _extract_project_lookup_keyword(question: str) -> str: # pragma: no cover - should not be called raise AssertionError(f"lexical keyword fallback should be skipped: {question}") @staticmethod def _extract_query_terms(question: str, *, preferred: str = "") -> list[str]: # pragma: no cover - should not be called raise AssertionError(f"lexical term fallback should be skipped: {question}, {preferred}") service = _FakePlannerService() plan = service._build_internal_query_plan( question="系统里有没有A股项目？", project_id=None, query_semantics={ "query_type": "existence", "subject_focus": "project", "scope_hint": "global", "effective_source_policy": "internal", }, operation_contract={ "query_type": "existence", "answer_contract": "yes_no_with_evidence", "object_mentions": [], }, ) assert plan is not None assert plan["filters"] == [] @pytest.mark.asyncio async def test_deterministic_query_prefers_project_created_at_answer() -> None: calls: list[str] = [] class _FakeDeterministicService(AdaptiveRAGDeterministicQueryCoreMixin): def __init__(self) -> None: self.db = object() self.tenant_id = 1 async def _try_fast_project_created_at_answer( self, *, clean_q: str, project_id, query_semantics=None, internal_context_packet=None, ): calls.append("created_at") _ = (clean_q, project_id, query_semantics, internal_context_packet) return {"answer": "创建于 2026-03-01 09:30。", "sources": [], "missing_fields": []} async def _try_fast_project_progress_answer( self, *, clean_q: str, project_id, query_semantics=None, internal_context_packet=None, ): calls.append("progress") _ = (clean_q, project_id, query_semantics, internal_context_packet) return {"answer": "进度回答", "sources": []} async def _try_fast_project_existence_answer( self, *, clean_q: str, project_id, query_semantics=None, internal_context_packet=None, ): calls.append("existence") _ = (clean_q, project_id, query_semantics, internal_context_packet) return {"answer": "存在性回答", "sources": []} service = _FakeDeterministicService() result = await service._run_deterministic_query( question="他是什么时候创建的？", project_id=7, query_type="status", internal_context_packet=_make_internal_context_packet( query_type="status", answer_contract="entity_snapshot", target_ref="project:7", ), ) assert result is not None assert "创建于 2026-03-01 09:30" in str(result["answer"]) assert calls[0] == "created_at" @pytest.mark.asyncio async def test_deterministic_query_runs_project_existence_for_existence_type() -> None: calls: list[str] = [] class _FakeDeterministicService(AdaptiveRAGDeterministicQueryCoreMixin): def __init__(self) -> None: self.db = object() self.tenant_id = 1 async def _try_fast_project_existence_answer( self, *, clean_q: str, project_id, query_semantics=None, internal_context_packet=None, ): calls.append("existence") _ = (clean_q, project_id, query_semantics, internal_context_packet) return {"answer": "有，匹配到 1 个项目。", "sources": []} service = _FakeDeterministicService() result = await service._run_deterministic_query( question="系统里有没有A股项目？", project_id=None, query_type="existence", query_semantics={"subject_focus": "project"}, internal_context_packet=_make_internal_context_packet( query_type="existence", answer_contract="yes_no_with_evidence", ), ) assert result is not None assert "匹配到 1 个项目" in str(result["answer"]) assert calls == ["existence"] @pytest.mark.asyncio async def test_deterministic_query_defers_internal_project_existence_to_semantic_snapshot() -> None: calls: list[str] = [] class _FakeDeterministicService(AdaptiveRAGDeterministicQueryCoreMixin): def __init__(self) -> None: self.db = object() self.tenant_id = 1 async def _try_fast_project_existence_answer(self, *, clean_q: str, project_id, query_semantics=None): calls.append("existence") _ = (clean_q, project_id, query_semantics) return {"answer": "有，匹配到 1 个项目。", "sources": []} service = _FakeDeterministicService() result = await service._run_deterministic_query( question="系统里有没有采购经理每日实时库存上报服务？", project_id=None, query_type="existence", query_semantics={ "subject_focus": "project", "source_policy": "internal", "effective_source_policy": "internal", "operation_contract": { "query_type": "existence", "answer_contract": "yes_no_with_evidence", "object_mentions": ["采购经理每日实时库存上报服务"], }, }, ) assert result is None assert calls == [] @pytest.mark.asyncio async def test_project_existence_answer_prefers_resolved_project_target() -> None: class _ScalarResult: def __init__(self, row): self._row = row def scalar_one_or_none(self): return self._row class _FakeSession: def __init__(self, row): self._row = row async def execute(self, stmt): _ = stmt return _ScalarResult(self._row) project_row = SimpleNamespace( id=72, title="企业知识库问答AI项目", name="企业知识库问答AI项目", status="active", ) class _FakeService(AdaptiveRAGFastAnswerProjectMainMixin, AdaptiveRAGFastAnswerProjectUtilsMixin): def __init__(self) -> None: self.db = _FakeSession(project_row) self.tenant_id = 1 service = _FakeService() result = await service._try_fast_project_existence_answer( clean_q="系统里有没有知识库？", project_id=None, query_semantics={ "query_type": "existence", "subject_focus": "unknown", "target_resolution": { "target_entity_type": "project", "target_ref": "project:72", "resolved_label": "企业知识库问答AI项目", }, }, ) assert result is not None assert "#72 企业知识库问答AI项目" in str(result["answer"]) assert result["sources"][0]["metadata"]["project_id"] == 72 @pytest.mark.asyncio async def test_project_existence_answer_uses_structured_mentions_without_lexical_extractors() -> None: class _FakeService( AdaptiveRAGFastAnswerProjectMainMixin, AdaptiveRAGFastAnswerProjectUtilsMixin, ): def __init__(self) -> None: self.db = object() self.tenant_id = 1 @staticmethod def _extract_project_lookup_keyword(question: str) -> str: # pragma: no cover - should not be called raise AssertionError(f"lexical keyword fallback should be skipped: {question}") @staticmethod def _extract_query_terms(question: str, *, preferred: str = "") -> list[str]: # pragma: no cover - should not be called raise AssertionError(f"lexical term fallback should be skipped: {question}, {preferred}") async def _try_fast_project_existence_answer_from_semantic_facts(self, *, query_terms: list[str], project_id): assert query_terms == ["A股项目"] assert project_id is None return { "answer": "有，当前匹配到 1 个相关项目：\n#101 A股趋势打分工具（状态:active）", "sources": [{"metadata": {"table": "semantic_facts", "match_count": 1}}], } async def _search_projects_by_keyword(self, *, keyword: str, project_id, limit: int): # pragma: no cover - should not be called raise AssertionError(f"text fallback should be skipped: {keyword}, {project_id}, {limit}") service = _FakeService() result = await service._try_fast_project_existence_answer( clean_q="系统里有没有A股项目？", project_id=None, query_semantics={ "query_type": "existence", "subject_focus": "project", "scope_hint": "global", "operation_contract": { "query_type": "existence", "object_mentions": ["A股项目"], }, }, ) assert result is not None assert "#101 A股趋势打分工具" in str(result["answer"]) @pytest.mark.asyncio async def test_execute_mainline_skips_snapshot_direct_for_project_existence_target() -> None: class _FakeContextCache: async def get_system_snapshot(self, **kwargs): _ = kwargs return {"platform_profile": {"feature_catalog": [{"name": "智能配置", "route": "/settings/ai"}]}} async def get_user_snapshot(self, **kwargs): _ = kwargs return {"projects": []} class _FakeService( AdaptiveRAGAnswerMainlineMixin, AdaptiveRAGTargetResolutionMixin, ): def __init__(self) -> None: self.db = object() self.tenant_id = 1 self.context_cache = _FakeContextCache() self.retrieval_called = False def _plan_query_runtime(self, **kwargs): _ = kwargs return SimpleNamespace( thinking_mode="normal", retrieval_answer_mode="retrieval_normal", budget=SimpleNamespace(max_steps=2, vector_top_k=3), allow_fast_path=True, reason="deterministic_query_type", ) def _build_followup_clarification_payload(self, **kwargs): _ = kwargs return None def _build_route_clarification_payload(self, **kwargs): _ = kwargs return None async def _build_meta_followup_payload(self, **kwargs): _ = kwargs return None async def _maybe_return_clarification_response(self, **kwargs): _ = kwargs return None async def _maybe_return_meta_followup_response(self, **kwargs): _ = kwargs return None def _get_active_external_qa_context(self): return {} def _build_operation_contract(self, *, question: str, query_semantics): _ = (question, query_semantics) return { "query_type": "existence", "answer_contract": "yes_no_with_evidence", "object_mentions": ["开票系统"], } async def _resolve_internal_target(self, **kwargs): _ = kwargs return { "target_entity_type": "project", "target_ref": "project:6", "resolved_label": "自动开票系统", "resolution_mode": "deterministic", "confidence": 0.96, "candidate_summary": [], } async def _run_deterministic_query(self, **kwargs): _ = kwargs return None async def _build_retrieval_response(self, **kwargs): self.retrieval_called = True assert kwargs["query_type"] == "existence" assert kwargs["query_semantics"]["target_resolution"]["target_ref"] == "project:6" return {"processing_stage": "retrieval"} def _build_snapshot_direct_answer(self, *args, **kwargs): raise AssertionError("snapshot direct answer should be skipped for project existence target") async def _maybe_return_snapshot_direct_response(self, **kwargs): raise AssertionError("snapshot direct response should be skipped for project existence target") async def _build_internal_model_config_fast_answer(self, **kwargs): _ = kwargs return None async def _try_glm_project_semantic_answer(self, **kwargs): _ = kwargs return None service = _FakeService() result = await service._execute_base_answer_mainline( clean_q="帮我看看系统里面有没有开票系统。", asked_by=1, asked_via="pmflow", project_id=None, source_chat_id=None, session_id=11, turn_index=3, context_session_id=11, conversation=[], state_row=None, effective_q="帮我看看系统里面有没有开票系统。", rewrite_meta={}, query_type="explain", query_semantics={ "source_policy": "internal", "effective_source_policy": "internal", "subject_focus": "feature", "object_mentions": ["开票系统"], }, retrieval_domains=["db", "pmflow"], scene_semantics={"scene_key": "ai_pmo", "snapshot_focus": "feature", "deep_intent": "none"}, thinking_mode="normal", active_thinking_mode="normal", deep_thinking=False, enforce_scene_prompt_only=False, deep_retrieval_steps=2, deep_vector_top_k=3, started=0.0, message_intent="question", mixed_signal_part=None, consultant_mode_preference=None, route_decision={ "route_mode": "internal", "effective_source_policy": "internal", "reply_contract": {"head": "内部知识库查询：", "tail_hint": None}, }, ) assert result["processing_stage"] == "retrieval" assert service.retrieval_called is True @pytest.mark.asyncio async def test_query_semantics_prefers_structured_model_output_over_hint_tables( monkeypatch: pytest.MonkeyPatch, ) -> None: class _FakeLLM: async def generate(self, prompt: str, **kwargs): _ = (prompt, kwargs) return ( '{"intent":"question","question_part":"我感觉很多重复的项目在系统，你能列一下吗？",' '"statement_part":"","query_type":"list","retrieval_domains":["db","graph"],' '"subject_focus":"project","scope_hint":"global","feature_focus":"none"}' ) class _FakeService(AdaptiveRAGCoreIntentMixin, AdaptiveRAGDeterministicQueryCoreMixin): def __init__(self) -> None: self.db = object() self.tenant_id = 1 self.llm = _FakeLLM() async def _fake_aplan_message(cls, *, message_text: str, source_system: str, metadata=None): _ = (cls, message_text, source_system, metadata) return WorkflowSemanticPlanner.deserialize_bundle( { "bundle_id": "semantic-query-type", "semantic_version": "v1", "source_system": "adaptive_rag", "primary_workflow": "query_flow", "workflows": [ { "workflow_type": "query_flow", "workflow_action": "answer", "target_scope": "global", "operation_codes": ["query.answer"], "requires_confirmation": False, "confidence": 0.93, "clarification_needed": False, "metadata": {}, } ], "message_gate": "auto", "reply_contract": {"mode": "text", "template_key": "workflow_bundle", "summary": "query_flow"}, "diagnostics": {"message_intent": "question"}, } ) monkeypatch.setattr(WorkflowSemanticPlanner, "aplan_message", classmethod(_fake_aplan_message)) service = _FakeService() semantics = await service._resolve_query_semantics( message="我感觉很多重复的项目在系统，你能列一下吗？", source_system="pmflow", ) assert semantics["query_type"] == "list" assert semantics["retrieval_domains"] == ["db", "graph"] assert semantics["intent"] == "question" assert semantics["subject_focus"] == "project" assert semantics["scope_hint"] == "global" assert semantics["feature_focus"] == "none" @pytest.mark.asyncio async def test_query_semantics_accepts_existence_query_type_from_structured_output( monkeypatch: pytest.MonkeyPatch, ) -> None: class _FakeLLM: async def generate(self, prompt: str, **kwargs): _ = (prompt, kwargs) return ( '{"intent":"question","question_part":"系统里有没有A股项目？",' '"statement_part":"","query_type":"existence","retrieval_domains":["db","graph"],' '"object_mentions":["A股项目"],' '"subject_focus":"project","scope_hint":"global","feature_focus":"none",' '"query_profile":{"needs_private_context":true,"needs_freshness":false,"referenced_objects":["project_object"],"confidence":0.81},' '"confidence":0.91}' ) class _FakeService(AdaptiveRAGCoreIntentMixin): def __init__(self) -> None: self.db = object() self.tenant_id = 1 self.llm = _FakeLLM() async def _fake_aplan_message(cls, *, message_text: str, source_system: str, metadata=None): _ = (cls, message_text, source_system, metadata) return WorkflowSemanticPlanner.deserialize_bundle( { "bundle_id": "semantic-query-existence", "semantic_version": "v1", "source_system": "adaptive_rag", "primary_workflow": "query_flow", "workflows": [ { "workflow_type": "query_flow", "workflow_action": "answer", "target_scope": "global", "operation_codes": ["query.answer"], "requires_confirmation": False, "confidence": 0.89, "clarification_needed": False, "metadata": {}, } ], "message_gate": "auto", "reply_contract": {"mode": "text", "template_key": "workflow_bundle", "summary": "query_flow"}, "diagnostics": {"message_intent": "question"}, } ) monkeypatch.setattr(WorkflowSemanticPlanner, "aplan_message", classmethod(_fake_aplan_message)) service = _FakeService() semantics = await service._resolve_query_semantics( message="系统里有没有A股项目？", source_system="pmflow", ) assert semantics["query_type"] == "existence" assert semantics["object_mentions"] == ["A股项目"] assert semantics["retrieval_domains"] == ["db", "graph"] assert semantics["query_profile"]["referenced_objects"] == ["project_object"] assert semantics["query_profile"]["needs_private_context"] is True @pytest.mark.asyncio async def test_query_semantics_reuses_cached_result_for_identical_request( monkeypatch: pytest.MonkeyPatch, ) -> None: planner_calls: list[dict[str, object]] = [] llm_calls: list[str] = [] class _FakeLLM: async def generate(self, prompt: str, **kwargs): _ = kwargs llm_calls.append(prompt) return ( '{"intent":"question","question_part":"系统里有没有采购经理每日实时库存上报服务？",' '"statement_part":"","query_type":"existence","retrieval_domains":["db","pmflow"],' '"object_mentions":["采购经理每日实时库存上报服务"],' '"subject_focus":"project","scope_hint":"global","feature_focus":"none",' '"source_policy":"internal","effective_source_policy":"internal",' '"query_profile":{"needs_private_context":true,"needs_freshness":false,"referenced_objects":["project_object"],"confidence":0.93},' '"confidence":0.96}' ) class _FakeService(AdaptiveRAGCoreIntentMixin): def __init__(self) -> None: self.db = object() self.tenant_id = 1 self.llm = _FakeLLM() async def _fake_aplan_message(cls, *, message_text: str, source_system: str, metadata=None): _ = cls planner_calls.append( { "message_text": message_text, "source_system": source_system, "metadata": dict(metadata or {}), } ) return WorkflowSemanticPlanner.deserialize_bundle( { "bundle_id": "semantic-query-cache", "semantic_version": "v1", "source_system": "adaptive_rag", "primary_workflow": "query_flow", "workflows": [ { "workflow_type": "query_flow", "workflow_action": "answer", "target_scope": "global", "operation_codes": ["query.answer"], "requires_confirmation": False, "confidence": 0.94, "clarification_needed": False, "metadata": {}, } ], "message_gate": "auto", "reply_contract": {"mode": "text", "template_key": "workflow_bundle", "summary": "query_flow"}, "diagnostics": {"message_intent": "question"}, } ) monkeypatch.setattr(WorkflowSemanticPlanner, "aplan_message", classmethod(_fake_aplan_message)) service = _FakeService() first = await service._resolve_query_semantics( message="系统里有没有采购经理每日实时库存上报服务？", source_system="pmflow", metadata={"project_id": 1}, ) second = await service._resolve_query_semantics( message="系统里有没有采购经理每日实时库存上报服务？", source_system="pmflow", metadata={"project_id": 1}, ) assert first == second assert len(planner_calls) == 1 assert len(llm_calls) == 1 @pytest.mark.asyncio async def test_query_semantics_prompt_contract_guides_internal_project_source_policy( monkeypatch: pytest.MonkeyPatch, ) -> None: class _FakeLLM: async def generate(self, prompt: str, **kwargs): _ = kwargs if '"source_policy"' in prompt and '"effective_source_policy"' in prompt: return ( '{"intent":"question","question_part":"系统里有没有采购经理每日实时库存上报服务？",' '"statement_part":"","query_type":"existence","retrieval_domains":["db","pmflow"],' '"object_mentions":["采购经理每日实时库存上报服务"],' '"subject_focus":"project","scope_hint":"global","feature_focus":"none",' '"source_policy":"internal","effective_source_policy":"internal",' '"query_profile":{"needs_private_context":true,"needs_freshness":false,"referenced_objects":["project_object"],"confidence":0.93},' '"confidence":0.96}' ) return ( '{"intent":"question","question_part":"系统里有没有采购经理每日实时库存上报服务？",' '"statement_part":"","query_type":"existence","retrieval_domains":["db","pmflow"],' '"object_mentions":["采购经理每日实时库存上报服务"],' '"subject_focus":"project","scope_hint":"global","feature_focus":"none",' '"query_profile":{"needs_private_context":true,"needs_freshness":false,"referenced_objects":["project_object"],"confidence":0.93},' '"confidence":0.96}' ) class _FakeService(AdaptiveRAGCoreIntentMixin): def __init__(self) -> None: self.db = object() self.tenant_id = 1 self.llm = _FakeLLM() async def _fake_aplan_message(cls, *, message_text: str, source_system: str, metadata=None): _ = (cls, message_text, source_system, metadata) return WorkflowSemanticPlanner.deserialize_bundle( { "bundle_id": "semantic-query-internal-project", "semantic_version": "v1", "source_system": "adaptive_rag", "primary_workflow": "query_flow", "workflows": [ { "workflow_type": "query_flow", "workflow_action": "answer", "target_scope": "global", "operation_codes": ["query.answer"], "requires_confirmation": False, "confidence": 0.94, "clarification_needed": False, "metadata": {}, } ], "message_gate": "auto", "reply_contract": {"mode": "text", "template_key": "workflow_bundle", "summary": "query_flow"}, "diagnostics": {"message_intent": "question"}, } ) monkeypatch.setattr(WorkflowSemanticPlanner, "aplan_message", classmethod(_fake_aplan_message)) service = _FakeService() semantics = await service._resolve_query_semantics( message="系统里有没有采购经理每日实时库存上报服务？", source_system="pmflow", ) assert '"source_policy"' in PROMPT_RAG_QUERY_SEMANTICS assert '"effective_source_policy"' in PROMPT_RAG_QUERY_SEMANTICS assert semantics["source_policy"] == "internal" assert semantics["effective_source_policy"] == "internal" def test_feature_catalog_match_skips_lexical_query_term_fallback() -> None: class _FakeService(AdaptiveRAGManifestFeatureMixinP1): @staticmethod def _extract_query_terms(question: str, *, preferred: str = "") -> list[str]: # pragma: no cover - should not be called raise AssertionError(f"feature lexical term fallback should be skipped: {question}, {preferred}") service = _FakeService() rows = service._match_feature_catalog_entries( question="智能配置入口在哪？", system_snapshot={ "platform_profile": { "feature_catalog": [ { "name": "智能配置", "route": "/ai-config", "summary": "管理模型和提示词配置", "aliases": ["模型设置"], } ] } }, ) assert rows assert rows[0]["name"] == "智能配置" def test_feature_catalog_match_skips_generic_project_list_for_unrelated_project_mention() -> None: class _FakeService(AdaptiveRAGManifestFeatureMixinP1): pass service = _FakeService() rows = service._match_feature_catalog_entries( question="A股项目", system_snapshot={ "platform_profile": { "feature_catalog": [ { "name": "项目列表", "route": "/projects", "summary": "查看全部项目", }, { "name": "智能配置", "route": "/ai-config", "summary": "管理模型配置", }, ] } }, ) assert rows == [] def test_internal_answer_contract_verifier_blocks_total_count_substitution_for_existence() -> None: class _FakeVerifier(AdaptiveRAGAnswerPayloadMixin, AdaptiveRAGQueryRouteGatewayMixin): pass service = _FakeVerifier() verdict = service._verify_internal_answer_contract( query_type="existence", answer="当前系统里项目总数为 42 个。", sources=[ { "source": "db", "label": "Project database", "score": 0.99, "metadata": {"table": "projects"}, } ], route_decision={"route_mode": "internal", "effective_source_policy": "internal"}, internal_context_packet=_make_internal_context_packet( query_type="existence", answer_contract="yes_no_with_evidence", ), ) assert verdict["ok"] is False assert verdict["reason_code"] == "no_total_count_substitution" def test_internal_answer_contract_verifier_allows_project_snapshot_with_task_totals_for_existence() -> None: class _FakeVerifier(AdaptiveRAGAnswerPayloadMixin, AdaptiveRAGQueryRouteGatewayMixin): pass service = _FakeVerifier() verdict = service._verify_internal_answer_contract( query_type="existence", answer=( "有。项目ID 123，项目名“采购经理每日实时库存上报服务”，状态 active，负责人 系统管理员，" "最近更新 2026-04-13T14:27:59.301650，任务总数 4，已完成 0，进行中 0，待处理 4。" ), sources=[ { "source": "db", "label": "Project database", "score": 0.99, "metadata": {"table": "projects", "matched_project_ids": [123]}, } ], route_decision={"route_mode": "internal", "effective_source_policy": "internal"}, internal_context_packet=_make_internal_context_packet( query_type="existence", answer_contract="yes_no_with_evidence", target_ref="project:123", ), ) assert verdict["ok"] is True assert verdict["reason_code"] is None def test_internal_answer_contract_verifier_allows_evidence_backed_existence_answer() -> None: class _FakeVerifier(AdaptiveRAGAnswerPayloadMixin, AdaptiveRAGQueryRouteGatewayMixin): pass service = _FakeVerifier() verdict = service._verify_internal_answer_contract( query_type="existence", answer="有，当前匹配到 1 个相关项目：#101 A股趋势打分工具（状态:active）", sources=[ { "source": "db", "label": "Project database", "score": 0.99, "metadata": {"table": "projects", "match_count": 1}, } ], route_decision={"route_mode": "internal", "effective_source_policy": "internal"}, internal_context_packet=_make_internal_context_packet( query_type="existence", answer_contract="yes_no_with_evidence", target_ref="project:101", ), ) assert verdict["ok"] is True assert verdict["reason_code"] is None @pytest.mark.asyncio async def test_classify_intent_prefers_structured_semantics_without_rule_split( monkeypatch: pytest.MonkeyPatch, ) -> None: class _FakeLLM: async def generate(self, prompt: str, **kwargs): _ = (prompt, kwargs) return ( '{"intent":"mixed","question_part":"现在进展如何？","statement_part":"并新增任务确认流",' '"query_type":"status","retrieval_domains":["db","graph","pmflow"]}' ) class _FakeService(AdaptiveRAGCoreIntentMixin): def __init__(self) -> None: self.db = object() self.tenant_id = 1 self.llm = _FakeLLM() async def _fake_aplan_message(cls, *, message_text: str, source_system: str, metadata=None): _ = (cls, message_text, source_system, metadata) return WorkflowSemanticPlanner.deserialize_bundle( { "bundle_id": "semantic-intent", "semantic_version": "v1", "source_system": "adaptive_rag", "primary_workflow": "query_flow", "workflows": [ { "workflow_type": "query_flow", "workflow_action": "answer", "target_scope": "global", "operation_codes": ["query.answer"], "requires_confirmation": False, "confidence": 0.88, "clarification_needed": False, "metadata": {}, } ], "message_gate": "auto", "reply_contract": {"mode": "text", "template_key": "workflow_bundle", "summary": "query_flow"}, "diagnostics": {"message_intent": "business_review"}, } ) monkeypatch.setattr(WorkflowSemanticPlanner, "aplan_message", classmethod(_fake_aplan_message)) service = _FakeService() result = await service.classify_intent("现在进展如何？并新增任务确认流") assert result == { "intent": "mixed", "confidence": 0.88, "question_part": "现在进展如何？", "statement_part": "并新增任务确认流", } @pytest.mark.asyncio async def test_vector_retrieval_skips_legacy_fallback_for_non_postgresql_session() -> None: class _FakeLLM: async def get_embedding_async(self, question: str, **kwargs): _ = (question, kwargs) return [0.1, 0.2, 0.3] class _FakeService(AdaptiveRAGRetrievalVectorMixin): def __init__(self) -> None: self.db = object() self.tenant_id = 1 self.llm = _FakeLLM() self.legacy_called = False def _map_domains_to_source_types(self, domains: list[str]) -> list[str]: return list(domains) def _is_postgresql_session(self) -> bool: return False async def _retrieve_vector_context_legacy(self, **kwargs): _ = kwargs self.legacy_called = True return ["legacy-hit"] service = _FakeService() result = await service._retrieve_vector_context( "查询项目文档", domains=["doc"], project_id=None, source_chat_id=None, ) assert result == [] assert service.legacy_called is False @pytest.mark.asyncio async def test_vector_retrieval_skips_legacy_fallback_when_pg_query_errors() -> None: class _FakeLLM: async def get_embedding_async(self, question: str, **kwargs): _ = (question, kwargs) return [0.1, 0.2, 0.3] class _FakeService(AdaptiveRAGRetrievalVectorMixin): def __init__(self) -> None: self.db = object() self.tenant_id = 1 self.llm = _FakeLLM() self.legacy_called = False def _map_domains_to_source_types(self, domains: list[str]) -> list[str]: return list(domains) def _is_postgresql_session(self) -> bool: return True async def _retrieve_vector_context_pg(self, **kwargs): _ = kwargs return None async def _retrieve_vector_context_legacy(self, **kwargs): _ = kwargs self.legacy_called = True return ["legacy-hit"] service = _FakeService() result = await service._retrieve_vector_context( "查询项目文档", domains=["doc"], project_id=None, source_chat_id=None, ) assert result == [] assert service.legacy_called is False @pytest.mark.asyncio async def test_deep_guard_answer_raises_on_empty_llm_response() -> None: class _FakeLLM: async def generate(self, prompt: str, **kwargs): _ = (prompt, kwargs) return "" class _FakeService(AdaptiveRAGDeepGuardAnswerMixin): def __init__(self) -> None: self.db = object() self.tenant_id = 1 self.llm = _FakeLLM() def _normalize_thinking_mode(self, thinking_mode: str) -> str: return "normal" if str(thinking_mode or "").strip().lower() != "deep" else "deep" async def get_project_manifest(self, project_id): _ = project_id return {} async def _select_scene_prompt(self, **kwargs): _ = kwargs return "external_trend", "请回答问题" def _enforce_feature_evidence_in_answer(self, **kwargs): return str(kwargs.get("answer_text") or "") service = _FakeService() with pytest.raises(ValueError, match="adaptive_rag_answer_empty_response"): await service._generate_answer( question="最近AI行业有什么动态", retrieved=[], conversation=[], project_id=None, asked_via="feishu", ) @pytest.mark.asyncio async def test_deep_guard_answer_uses_low_first_routing_meta_for_deep_thinking() -> None: class _FakeLLM: def __init__(self) -> None: self.kwargs: dict[str, object] = {} async def generate(self, prompt: str, **kwargs): _ = prompt self.kwargs = dict(kwargs) return "low-tier answer" class _FakeService(AdaptiveRAGDeepGuardAnswerMixin): def __init__(self) -> None: self.db = object() self.tenant_id = 1 self.llm = _FakeLLM() def _normalize_thinking_mode(self, thinking_mode: str) -> str: return "deep" if str(thinking_mode or "").strip().lower() == "deep" else "normal" async def get_project_manifest(self, project_id): _ = project_id return {} async def _select_scene_prompt(self, **kwargs): _ = kwargs return "external_trend", "请回答问题" def _enforce_feature_evidence_in_answer(self, **kwargs): return str(kwargs.get("answer_text") or "") service = _FakeService() result = await service._generate_answer( question="最近AI行业有什么动态", retrieved=[], conversation=[], project_id=None, asked_via="feishu", thinking_mode="deep", ) assert result == "low-tier answer" assert service.llm.kwargs["function_name"] == "adaptive_rag_answer_deep" routing_meta = service.llm.kwargs["routing_meta"] assert isinstance(routing_meta, dict) assert routing_meta["tier_alias"] == "low" assert routing_meta["planned_tier"] == "low" assert routing_meta["response_contract"] == "complete" assert routing_meta["fallback_policy"] == "low_to_high" assert routing_meta["execution_mode"] == "query" assert routing_meta["routing_decision"] == "force_low_first" @pytest.mark.asyncio async def test_deep_guard_answer_external_route_uses_external_presenter_without_internal_context() -> None: class _FakePresenter: def __init__(self) -> None: self.calls: list[dict[str, object]] = [] async def present(self, *, question: str, context_packet: dict, thinking_mode: str, answer_max_tokens=None): self.calls.append( { "question": question, "context_packet": dict(context_packet), "thinking_mode": thinking_mode, "answer_max_tokens": answer_max_tokens, } ) return { "answer_text": "只基于外部证据生成的回答", "prompt_variant_id": "external_summary_with_sources", } class _FakeService(AdaptiveRAGDeepGuardAnswerMixin): def __init__(self) -> None: self.db = object() self.tenant_id = 1 self.llm = object() self.presenter = _FakePresenter() self.prompt_variant = "unknown" def _normalize_thinking_mode(self, thinking_mode: str) -> str: _ = thinking_mode return "normal" async def get_project_manifest(self, project_id): # pragma: no cover - should not be called raise AssertionError(f"manifest should be skipped for external route: {project_id}") async def _resolve_answer_scene_semantics(self, **kwargs): # pragma: no cover - should not be called raise AssertionError(f"scene semantics should be skipped for external route: {kwargs}") async def _select_scene_prompt(self, **kwargs): # pragma: no cover - should not be called raise AssertionError(f"scene prompt should be skipped for external route: {kwargs}") def _build_external_answer_presenter(self): return self.presenter def _remember_answer_prompt_variant(self, prompt_variant_id: str) -> None: self.prompt_variant = prompt_variant_id def _enforce_feature_evidence_in_answer(self, **kwargs): return str(kwargs.get("answer_text") or "") service = _FakeService() result = await service._generate_answer( question="最近 AI 编程模型有什么新动态？", retrieved=[], conversation=[], project_id=7, asked_via="feishu", query_semantics={"effective_source_policy": "external"}, external_context_packet={ "question": "最近 AI 编程模型有什么新动态？", "plan": { "answer_contract": "summary_with_sources", "time_range_hint": "最近", }, "adapter_attempts": [{"adapter": "live_search", "status": "success"}], "verified_evidence": [ { "source_type": "url", "source_label": "OpenAI Developers", "title": "Models - Codex | OpenAI Developers", "target_url": "https://developers.openai.com/codex/models", "snippet": "Latest: GPT-5.4", } ], "verifier": {"ok": True}, "uncertainties": [], }, ) assert result == "只基于外部证据生成的回答" assert service.prompt_variant == "external_summary_with_sources" assert len(service.presenter.calls) == 1 assert service.presenter.calls[0]["question"] == "最近 AI 编程模型有什么新动态？" @pytest.mark.asyncio async def test_retrieval_response_external_insufficient_evidence_keeps_external_clarify_contract() -> None: class _FakeDB: def add(self, obj) -> None: obj.id = 1 async def flush(self) -> None: return None async def commit(self) -> None: return None async def refresh(self, obj) -> None: _ = obj return None class _FakeContextCache: async def append_session_messages(self, **kwargs) -> None: _ = kwargs return None class _FakeService( AdaptiveRAGAnswerRetrievalMixin, AdaptiveRAGAnswerPayloadMixin, AdaptiveRAGQueryRouteGatewayMixin, AdaptiveRAGDeepGuardRulesMixin, ): def __init__(self) -> None: self.db = _FakeDB() self.context_cache = _FakeContextCache() self.tenant_id = 1 def _normalize_thinking_mode(self, thinking_mode: str) -> str: return "deep" if str(thinking_mode or "").strip().lower() == "deep" else "normal" async def _execute_external_query_gateway(self, **kwargs): _ = kwargs return [], { "mode": "external_query_gateway_verifier_blocked", "external_context_packet": { "question": "OpenAI 最近发布了哪些新模型？", "plan": { "answer_contract": "summary_with_sources", }, "adapter_attempts": [{"adapter": "live_search", "status": "empty"}], "verified_evidence": [], "verifier": { "ok": False, "reason_code": "insufficient_evidence", "missing_fields": ["external_evidence"], }, "uncertainties": ["insufficient_evidence"], }, "tool_trace": [], "domains_used": ["url"], } async def _generate_answer(self, *args, **kwargs): _ = (args, kwargs) return "当前关于“OpenAI 最近发布了哪些新模型？”的外部证据不足。请补充更明确的对象、范围或继续提供可核验来源后，我再继续分析。" def _peek_answer_prompt_variant(self): return "external_clarify" def _peek_last_answer_routing_snapshot(self): return {} def _dedupe_sources(self, retrieved): _ = retrieved return [] def _build_qa_record_runtime_fields(self, **kwargs): return { "policy_version": "test", "citations": [], "sources_used": list(kwargs.get("sources") or []), "evidence_pack": {}, "tool_trace": list(kwargs.get("tool_trace") or []), } def _build_qa_record_external_fields(self, **kwargs): _ = kwargs return {} async def _update_session_state_after_turn(self, **kwargs): _ = kwargs return None def _build_response_payload(self, **kwargs): return kwargs service = _FakeService() result = await service._build_retrieval_response( clean_q="OpenAI 最近发布了哪些新模型？", effective_q="OpenAI 最近发布了哪些新模型？", asked_by=1, asked_via="feishu", project_id=None, source_chat_id=None, session_id=11, turn_index=2, context_session_id=11, conversation=[], state_row=None, rewrite_meta={"mode": "direct"}, query_type="explain", query_semantics={"effective_source_policy": "external"}, retrieval_domains=["url"], scene_semantics={"scene_key": "default", "deep_intent": "none"}, thinking_mode="normal", active_thinking_mode="normal", deep_thinking=False, forced_deep_reason="", deep_retrieval_steps=2, deep_vector_top_k=3, system_snapshot={}, user_snapshot=None, started=0.0, message_intent=None, mixed_signal_part=None, answer_mode="retrieval_normal", consultant_mode_preference=None, route_decision={ "route_mode": "external", "effective_source_policy": "external", "decision_origin": "query_semantics_contract", "reply_contract": {"head": "外部实时查询：", "tail_hint": None}, "query_profile": {"needs_freshness": True, "referenced_objects": ["public_api"]}, }, ) assert result["answer_mode"] == "clarify" assert result["grounding_status"] == "insufficient_evidence" assert result["sources"] == [] assert result["sources_used"] == [] assert "系统快照" not in result["answer"] assert "外部证据不足" in result["answer"] assert result["answer"].startswith("外部实时查询：") assert result["missing_fields"] == ["external_evidence"] @pytest.mark.asyncio async def test_retrieval_response_exposes_fit_brief_and_external_recommendation_blocks() -> None: class _FakeDB: def add(self, obj) -> None: obj.id = 2 async def flush(self) -> None: return None async def commit(self) -> None: return None async def refresh(self, obj) -> None: _ = obj return None class _FakeContextCache: async def append_session_messages(self, **kwargs) -> None: _ = kwargs return None class _FakeService( AdaptiveRAGAnswerRetrievalMixin, AdaptiveRAGAnswerPayloadMixin, AdaptiveRAGQueryRouteGatewayMixin, AdaptiveRAGDeepGuardRulesMixin, ): def __init__(self) -> None: self.db = _FakeDB() self.context_cache = _FakeContextCache() self.tenant_id = 1 self.fit_brief_seen = None def _normalize_thinking_mode(self, thinking_mode: str) -> str: return "deep" if str(thinking_mode or "").strip().lower() == "deep" else "normal" def _to_float(self, value, default=0.0): try: return float(value) except Exception: return float(default) def _build_policy_version(self, *, prompt_variant_id: str | None = None) -> str: return f"retrieval-v2.1|routing:unknown|prompt:{prompt_variant_id or 'unknown'}" def _normalize_query_route_decision(self, payload): return dict(payload or {}) async def _build_project_fit_brief(self, **kwargs): _ = kwargs return { "project_summary": "当前项目：PMFlow AI 管家，聚焦项目内问答与需求流转。", "repo_summary": "当前仓库：FastAPI 后端 + React 前端。", "current_capabilities": ["AI 管家", "智能配置"], "constraints": ["只允许基于外部公开证据给出推荐。"], "recommendation_focus": ["判断 Responses API 是否适合当前项目接入"], } async def _execute_external_query_gateway(self, **kwargs): self.fit_brief_seen = kwargs.get("fit_brief") return [ RetrievedItem( source="url", content="Responses API 支持工具调用与结构化输出。", score=0.93, source_label="OpenAI Docs", metadata={ "target_url": "https://platform.openai.com/docs/guides/responses", }, ) ], { "mode": "external_query_gateway", "external_context_packet": { "question": "这个项目适不适合接 OpenAI Responses API？", "plan": { "answer_contract": "summary_with_sources", "topic": "Responses API 适配性", }, "adapter_attempts": [{"adapter": "live_search", "status": "success"}], "verified_evidence": [ { "source_type": "url", "source_label": "OpenAI Docs", "title": "Responses API guide", "target_url": "https://platform.openai.com/docs/guides/responses", "snippet": "Responses API supports tool calls and structured outputs.", } ], "verifier": {"ok": True}, "uncertainties": [], "retrieval_status": "evidence_found", }, "tool_trace": [], "domains_used": ["url"], } async def _generate_answer(self, *args, **kwargs): _ = (args, kwargs) return "外部公开资料显示 Responses API 值得关注，但目前还需要先做项目映射验证。" def _peek_answer_prompt_variant(self): return "external_summary_with_sources" def _peek_last_answer_routing_snapshot(self): return {} def _dedupe_sources(self, retrieved): _ = retrieved return [ { "source": "url", "label": "OpenAI Docs", "score": 0.93, "metadata": { "target_url": "https://platform.openai.com/docs/guides/responses", }, } ] def _build_qa_record_runtime_fields(self, **kwargs): return { "policy_version": "test", "citations": [], "sources_used": list(kwargs.get("sources") or []), "evidence_pack": {}, "tool_trace": list(kwargs.get("tool_trace") or []), } def _build_qa_record_external_fields(self, **kwargs): _ = kwargs return {} async def _update_session_state_after_turn(self, **kwargs): _ = kwargs return None service = _FakeService() result = await service._build_retrieval_response( clean_q="这个项目适不适合接 OpenAI Responses API？", effective_q="这个项目适不适合接 OpenAI Responses API？", asked_by=1, asked_via="feishu", project_id=17, source_chat_id=None, session_id=12, turn_index=1, context_session_id=12, conversation=[], state_row=None, rewrite_meta={"mode": "direct"}, query_type="explain", query_semantics={ "effective_source_policy": "external", "project_operating_context": { "current_project_id": 17, "current_repo_scope": "pmflow-main", "page_anchor": {"project_id": 17}, "thread_anchor": {}, "fit_scope": "current_project_and_repo", "decision_strategy": "answer_then_offer_plan", }, "execution_recipe": { "primary_lane": "external", "fit_brief_required": True, "external_evidence_required": True, "plan_handoff_mode": "offer_after_answer", }, }, retrieval_domains=["url"], scene_semantics={"scene_key": "default", "deep_intent": "none"}, thinking_mode="normal", active_thinking_mode="normal", deep_thinking=False, forced_deep_reason="", deep_retrieval_steps=2, deep_vector_top_k=3, system_snapshot={}, user_snapshot=None, started=time.perf_counter(), message_intent=None, mixed_signal_part=None, answer_mode="retrieval_normal", consultant_mode_preference=None, route_decision={ "route_mode": "external", "effective_source_policy": "external", "decision_origin": "query_semantics_contract", "reply_contract": {"head": "外部实时查询：", "tail_hint": None}, "query_profile": {"needs_freshness": True, "referenced_objects": ["public_api"]}, }, ) assert service.fit_brief_seen is not None assert result["fit_brief"]["project_summary"].startswith("当前项目：PMFlow AI 管家") assert result["fit_brief"]["current_capabilities"] == ["AI 管家", "智能配置"] assert result["external_recommendation"]["retrieval_status"] == "evidence_found" assert result["external_recommendation"]["impact_status"] == "indirect_only" assert result["external_recommendation"]["affected_signal_sources"] == [] assert "映射验证" in str(result["external_recommendation"]["external_action"]) @pytest.mark.asyncio async def test_retrieval_response_can_disable_fit_brief_external_recommendation( monkeypatch: pytest.MonkeyPatch, ) -> None: class _FakeDB: def add(self, obj) -> None: obj.id = 2 async def flush(self) -> None: return None async def commit(self) -> None: return None async def refresh(self, obj) -> None: _ = obj return None class _FakeContextCache: async def append_session_messages(self, **kwargs) -> None: _ = kwargs return None class _FakeService( AdaptiveRAGAnswerRetrievalMixin, AdaptiveRAGAnswerPayloadMixin, AdaptiveRAGQueryRouteGatewayMixin, AdaptiveRAGDeepGuardRulesMixin, ): def __init__(self) -> None: self.db = _FakeDB() self.context_cache = _FakeContextCache() self.tenant_id = 1 self.fit_brief_seen = "unset" def _normalize_thinking_mode(self, thinking_mode: str) -> str: return "deep" if str(thinking_mode or "").strip().lower() == "deep" else "normal" def _to_float(self, value, default=0.0): try: return float(value) except Exception: return float(default) def _build_policy_version(self, *, prompt_variant_id: str | None = None) -> str: return f"retrieval-v2.1|routing:unknown|prompt:{prompt_variant_id or 'unknown'}" def _normalize_query_route_decision(self, payload): return dict(payload or {}) async def _build_project_fit_brief(self, **kwargs): _ = kwargs raise AssertionError("fit brief builder should be bypassed when rollback flag is off") async def _execute_external_query_gateway(self, **kwargs): self.fit_brief_seen = kwargs.get("fit_brief") return [ RetrievedItem( source="url", content="Responses API 支持工具调用与结构化输出。", score=0.93, source_label="OpenAI Docs", metadata={ "target_url": "https://platform.openai.com/docs/guides/responses", }, ) ], { "mode": "external_query_gateway", "external_context_packet": { "question": "这个项目适不适合接 OpenAI Responses API？", "plan": { "answer_contract": "summary_with_sources", "topic": "Responses API 适配性", }, "adapter_attempts": [{"adapter": "live_search", "status": "success"}], "verified_evidence": [ { "source_type": "url", "source_label": "OpenAI Docs", "title": "Responses API guide", "target_url": "https://platform.openai.com/docs/guides/responses", "snippet": "Responses API supports tool calls and structured outputs.", } ], "verifier": {"ok": True}, "uncertainties": [], "retrieval_status": "evidence_found", }, "tool_trace": [], "domains_used": ["url"], } async def _generate_answer(self, *args, **kwargs): _ = (args, kwargs) return "外部公开资料显示 Responses API 值得关注，但目前还需要先做项目映射验证。" def _peek_answer_prompt_variant(self): return "external_summary_with_sources" def _peek_last_answer_routing_snapshot(self): return {} def _dedupe_sources(self, retrieved): _ = retrieved return [ { "source": "url", "label": "OpenAI Docs", "score": 0.93, "metadata": { "target_url": "https://platform.openai.com/docs/guides/responses", }, } ] def _build_qa_record_runtime_fields(self, **kwargs): return { "policy_version": "test", "citations": [], "sources_used": list(kwargs.get("sources") or []), "evidence_pack": {}, "tool_trace": list(kwargs.get("tool_trace") or []), } def _build_qa_record_external_fields(self, **kwargs): _ = kwargs return {} async def _update_session_state_after_turn(self, **kwargs): _ = kwargs return None monkeypatch.setenv("PMFLOW_ENABLE_FIT_BRIEF_EXTERNAL_RECOMMENDATION", "0") service = _FakeService() result = await service._build_retrieval_response( clean_q="这个项目适不适合接 OpenAI Responses API？", effective_q="这个项目适不适合接 OpenAI Responses API？", asked_by=1, asked_via="feishu", project_id=17, source_chat_id=None, session_id=12, turn_index=1, context_session_id=12, conversation=[], state_row=None, rewrite_meta={"mode": "direct"}, query_type="explain", query_semantics={ "effective_source_policy": "external", "project_operating_context": { "current_project_id": 17, "current_repo_scope": "pmflow-main", "page_anchor": {"project_id": 17}, "thread_anchor": {}, "fit_scope": "current_project_and_repo", "decision_strategy": "answer_then_offer_plan", }, "execution_recipe": { "primary_lane": "external", "fit_brief_required": True, "external_evidence_required": True, "plan_handoff_mode": "offer_after_answer", }, }, retrieval_domains=["url"], scene_semantics={"scene_key": "default", "deep_intent": "none"}, thinking_mode="normal", active_thinking_mode="normal", deep_thinking=False, forced_deep_reason="", deep_retrieval_steps=2, deep_vector_top_k=3, system_snapshot={}, user_snapshot=None, started=time.perf_counter(), message_intent=None, mixed_signal_part=None, answer_mode="retrieval_normal", consultant_mode_preference=None, route_decision={ "route_mode": "external", "effective_source_policy": "external", "decision_origin": "query_semantics_contract", "reply_contract": {"head": "外部实时查询：", "tail_hint": None}, "query_profile": {"needs_freshness": True, "referenced_objects": ["public_api"]}, }, ) assert service.fit_brief_seen == {} assert result["fit_brief"] == {} assert result["external_recommendation"] == {} def test_external_recommendation_does_not_treat_capability_name_as_direct_match_without_formal_anchor() -> None: result = AdaptiveRAGAnswerPayloadMixin._build_external_recommendation( external_context_packet={ "retrieval_status": "evidence_found", "verified_evidence": [ { "source_type": "url", "source_label": "OpenAI Docs", "title": "AI 管家接入 Responses API", "target_url": "https://platform.openai.com/docs/guides/responses", "snippet": "AI 管家可以通过 Responses API 编排工具调用。", } ], "verifier": {"ok": True}, }, fit_brief={ "project_summary": "当前项目：PMFlow AI 管家", "current_capabilities": ["AI 管家"], "signal_source_anchors": [], "constraints": [], "recommendation_focus": [], }, ) assert result["retrieval_status"] == "evidence_found" assert result["impact_status"] == "indirect_only" assert result["affected_signal_sources"] == [] def test_external_recommendation_uses_formal_signal_source_anchor_for_direct_match() -> None: result = AdaptiveRAGAnswerPayloadMixin._build_external_recommendation( external_context_packet={ "retrieval_status": "evidence_found", "verified_evidence": [ { "source_type": "url", "source_label": "OpenAI Docs", "title": "Responses API guide", "target_url": "https://platform.openai.com/docs/guides/responses", "snippet": "OpenAI Docs 说明 Responses API 支持结构化输出与工具调用。", } ], "verifier": {"ok": True}, }, fit_brief={ "project_summary": "当前项目：PMFlow AI 管家", "current_capabilities": ["AI 管家"], "signal_source_anchors": ["OpenAI Docs"], "constraints": [], "recommendation_focus": [], }, ) assert result["retrieval_status"] == "evidence_found" assert result["impact_status"] == "direct_match" assert result["affected_signal_sources"] == ["OpenAI Docs"] @pytest.mark.asyncio async def test_deep_guard_answer_prefers_member_workload_direct_answer() -> None: class _FakeResult: def __init__(self, rows=None, scalar=None): self._rows = rows or [] self._scalar = scalar def all(self): return self._rows def first(self): return self._rows[0] if self._rows else None def scalar_one_or_none(self): return self._scalar class _FakeDB: def __init__(self) -> None: self.calls = 0 async def execute(self, stmt, params=None): # noqa: ANN001 self.calls += 1 if self.calls == 1: return _FakeResult(rows=[SimpleNamespace(id=24, name="杨宇", username="yangyu")]) return _FakeResult(rows=[(265.56, 95.6, 60.0)]) class _FakeLLM: async def generate(self, prompt: str, **kwargs): # pragma: no cover - should not be called raise AssertionError("LLM should not be called for direct member workload answer") class _FakeService(AdaptiveRAGDeepGuardAnswerMixin): def __init__(self) -> None: self.db = _FakeDB() self.tenant_id = 1 self.llm = _FakeLLM() def _normalize_thinking_mode(self, thinking_mode: str) -> str: return "normal" async def get_project_manifest(self, project_id): _ = project_id return {} async def _resolve_answer_scene_semantics(self, **kwargs): _ = kwargs return { "scene_key": "member_workload", "snapshot_focus": "none", "deep_intent": "none", "confidence": 0.96, "reason": "structured-scene", } async def _select_scene_prompt(self, **kwargs): _ = kwargs return "member_workload", "member workload prompt" def _enforce_feature_evidence_in_answer(self, **kwargs): return str(kwargs.get("answer_text") or "") service = _FakeService() result = await service._generate_answer( question="杨宇现在负载情况如何？", retrieved=[], conversation=[], project_id=None, asked_via="feishu", ) assert "杨宇当前负载265.56%" in result assert "严重超载" in result @pytest.mark.asyncio async def test_deep_guard_answer_prefers_structured_member_workload_scene_without_keyword_hints() -> None: class _FakeResult: def __init__(self, rows=None): self._rows = rows or [] def all(self): return self._rows def first(self): return self._rows[0] if self._rows else None class _FakeDB: def __init__(self) -> None: self.calls = 0 async def execute(self, stmt, params=None): # noqa: ANN001 _ = (stmt, params) self.calls += 1 if self.calls == 1: return _FakeResult(rows=[SimpleNamespace(id=24, name="杨宇", username="yangyu")]) return _FakeResult(rows=[(82.0, 41.0, 50.0)]) class _FakeService(AdaptiveRAGDeepGuardAnswerMixin): def __init__(self) -> None: self.db = _FakeDB() self.tenant_id = 1 def _normalize_thinking_mode(self, thinking_mode: str) -> str: _ = thinking_mode return "normal" async def get_project_manifest(self, project_id): _ = project_id return {} async def _resolve_answer_scene_semantics(self, **kwargs): _ = kwargs return { "scene_key": "member_workload", "snapshot_focus": "none", "deep_intent": "none", "confidence": 0.95, "reason": "structured-scene", } async def _select_scene_prompt(self, **kwargs): # pragma: no cover - should not be called raise AssertionError("scene prompt should not be rendered for direct workload answer") def _enforce_feature_evidence_in_answer(self, **kwargs): return str(kwargs.get("answer_text") or "") service = _FakeService() result = await service._generate_answer( question="杨宇现在忙不忙？", retrieved=[], conversation=[], project_id=None, asked_via="feishu", ) assert "杨宇当前负载82.00%" in result assert "负载偏高" in result @pytest.mark.asyncio async def test_structured_db_retrieval_prefers_structured_people_focus_without_keyword_hints() -> None: class _FakeScalarResult: def __init__(self, rows): self._rows = rows def scalars(self): return self def all(self): return self._rows class _FakeDB: async def execute(self, stmt, params=None): # noqa: ANN001 _ = (stmt, params) return _FakeScalarResult( [ SimpleNamespace(id=7, name="杨宇", role="backend", updated_at=None), SimpleNamespace(id=8, name="林宇航", role="pm", updated_at=None), ] ) class _FakeService(AdaptiveRAGRetrievalRouterDBMixin): def __init__(self) -> None: self.db = _FakeDB() self.tenant_id = 1 def _query_subject_focus(self, query_semantics): # noqa: ANN001 return str((query_semantics or {}).get("subject_focus") or "unknown") def _query_scope_hint(self, query_semantics): # noqa: ANN001 return str((query_semantics or {}).get("scope_hint") or "none") def _normalize_source_registry_metadata(self, *, source_type: str, metadata: dict, explicit_updated_at=None): _ = (source_type, explicit_updated_at) return dict(metadata) service = _FakeService() rows = await service._retrieve_structured_db( "他们都有哪些人？", project_id=None, query_semantics={ "subject_focus": "people", "scope_hint": "global", "feature_focus": "none", }, ) assert len(rows) == 1 assert "成员清单" in rows[0].content assert "杨宇" in rows[0].content def test_feature_evidence_prefers_structured_scene_without_keyword_hints() -> None: class _FakeService(AdaptiveRAGManifestFeatureMixinP2): def _query_subject_focus(self, query_semantics): # noqa: ANN001 return str((query_semantics or {}).get("subject_focus") or "unknown") def _query_feature_focus(self, query_semantics): # noqa: ANN001 return str((query_semantics or {}).get("feature_focus") or "none") def _collect_feature_evidence(self, *, question: str, retrieved, system_snapshot): _ = (question, retrieved, system_snapshot) return [ { "feature_name": "智能配置", "route": "/ai-config", "page_file": "frontend/src/pages/AIConfig.tsx", "apis": ["/api/v1/ai-config"], } ] service = _FakeService() text = service._enforce_feature_evidence_in_answer( question="这个模块怎么进？", answer_text="先看说明。", retrieved=[], system_snapshot={}, scene_semantics={"snapshot_focus": "feature"}, ) assert "证据补充（Feature Catalog）" in text assert "/ai-config" in text @pytest.mark.asyncio async def test_deep_guard_answer_feishu_direct_prefers_manifest_and_compact_focus_context() -> None: class _FakeLLM: def __init__(self) -> None: self.prompt = "" async def generate(self, prompt: str, **kwargs): _ = kwargs self.prompt = prompt return "信息不足，缺少：目标对象" class _FakeService(AdaptiveRAGDeepGuardAnswerMixin): def __init__(self) -> None: self.db = object() self.tenant_id = 1 self.llm = _FakeLLM() def _normalize_thinking_mode(self, thinking_mode: str) -> str: return "normal" async def get_project_manifest(self, project_id): _ = project_id return { "manifest_text": "项目#7 Alpha（进行中）；功能 18 个；KG 实体 12，关系 19。" } async def _render_scene_prompt(self, *, prompt_key: str, fallback_template: str, **kwargs): _ = prompt_key return str(fallback_template).format(**kwargs).strip() def _enforce_feature_evidence_in_answer(self, **kwargs): return str(kwargs.get("answer_text") or "") service = _FakeService() system_snapshot = { "assistant_profile": {"name": "PMFlow", "identity": "项目管理顾问"}, "platform_profile": { "backend": {"module_counts": {"projects": 28, "tasks": 146, "signals": 41}}, "feature_catalog": [ {"name": "项目管理", "route": "/projects"}, {"name": "信号接入", "route": "/signals"}, {"name": "任务看板", "route": "/board"}, {"name": "知识图谱", "route": "/kg"}, {"name": "训练中心", "route": "/training"}, ], }, } user_snapshot = { "current_user": {"name": "林宇航"}, "projects": [{"id": idx, "title": f"项目{idx}"} for idx in range(1, 15)], "tasks": [{"id": idx, "title": f"任务{idx}"} for idx in range(1, 10)], } result = await service._generate_answer( question="信息不全，继续提供", retrieved=[], conversation=[ {"question": "上一次你缺什么", "answer": "缺目标对象和验收口径"}, {"question": "现在呢", "answer": "还缺时间边界"}, ], project_id=7, system_snapshot=system_snapshot, user_snapshot=user_snapshot, asked_via="feishu", ) assert result == "信息不足，缺少：目标对象" assert "项目画像：" in service.llm.prompt assert "项目#7 Alpha（进行中）" in service.llm.prompt assert "系统摘要：" in service.llm.prompt assert "用户焦点：" in service.llm.prompt assert "林宇航" in service.llm.prompt assert '"projects"' not in service.llm.prompt assert "项目14" not in service.llm.prompt @pytest.mark.asyncio async def test_select_scene_prompt_applies_consultant_mode_preference_wrapper() -> None: class _FakeService(AdaptiveRAGDeepGuardAnswerMixin): def __init__(self) -> None: self.db = object() self.tenant_id = 1 async def _render_scene_prompt(self, *, prompt_key: str, fallback_template: str, **kwargs): _ = (fallback_template, kwargs) return f"PROMPT::{prompt_key}" service = _FakeService() scene_key, prompt = await service._select_scene_prompt( question="这个方案怎么做更稳妥？", project_id=7, asked_via="pmflow", message_intent=None, mixed_signal_part=None, conversation_text="无", context_blocks_text="无", system_snapshot={}, user_snapshot={}, system_snapshot_text="{}", user_snapshot_text="{}", relevance_max=0.61, query_type="explain", consultant_mode_preference="advise", ) assert scene_key == "default_consultant_advise" assert "PROMPT::PROMPT_RAG_ANSWER" in prompt assert "稳妥建议" in prompt def test_ai_pmo_qa_prompt_includes_five_lenses_and_runtime_state_guard() -> None: assert "事实源在哪" in PROMPT_AI_PMO_QA assert "输出模板在哪" in PROMPT_AI_PMO_QA assert "检索范围在哪" in PROMPT_AI_PMO_QA assert "执行器在哪" in PROMPT_AI_PMO_QA assert "反馈回流在哪" in PROMPT_AI_PMO_QA assert "静态资料" in PROMPT_AI_PMO_QA assert "运行态配置" in PROMPT_AI_PMO_QA @pytest.mark.asyncio async def test_select_scene_prompt_routes_business_review_to_ai_pmo_prompt() -> None: class _FakeService(AdaptiveRAGDeepGuardAnswerMixin): def __init__(self) -> None: self.db = object() self.tenant_id = 1 async def _render_scene_prompt(self, *, prompt_key: str, fallback_template: str, **kwargs): _ = fallback_template return ( f"PROMPT::{prompt_key}|" f"business_review={kwargs.get('business_review_mode')}|" f"framework={kwargs.get('review_framework')}" ) service = _FakeService() scene_key, prompt = await service._select_scene_prompt( question="我要做一个大模型 API 聚合平台，帮我分析下要怎么做", project_id=None, asked_via="feishu", message_intent="business_review", mixed_signal_part=None, conversation_text="用户上一轮提到要做 API 聚合平台", context_blocks_text="无", system_snapshot={}, user_snapshot={}, system_snapshot_text="{}", user_snapshot_text="{}", relevance_max=0.51, query_type="explain", consultant_mode_preference="clarify", ) assert scene_key == "ai_pmo_business_review_consultant_clarify" assert "PROMPT::PROMPT_AI_PMO_QA" in prompt assert "business_review=true" in prompt assert "framework=five_lenses" in prompt def test_runtime_state_query_guard_blocks_static_catalog_evidence() -> None: class _FakeService(AdaptiveRAGDeepGuardRulesMixin): pass service = _FakeService() decision = service._evaluate_post_retrieval_guard( deep_intent="runtime_state_query", sources=[ {"source": "feature_catalog", "label": "Feature Catalog", "metadata": {}}, {"source": "graph", "label": "Knowledge Graph", "metadata": {"path": "1->uses->2"}}, ], relevance_max=0.96, ) assert decision["should_block_with_guard"] is True assert decision["guard_focus"] == "runtime_state" assert "无法仅凭静态资料确认" in service._build_evidence_guard_answer( "高级模型路由是否启用？", guard_focus=str(decision["guard_focus"]), ) def test_runtime_state_query_guard_allows_routing_config_evidence() -> None: class _FakeService(AdaptiveRAGDeepGuardRulesMixin): pass service = _FakeService() decision = service._evaluate_post_retrieval_guard( deep_intent="runtime_state_query", sources=[ { "source": "doc", "label": "Routing Config", "metadata": {"source_id": "backend/.control_plane/pmflow-routing-rules.json"}, } ], relevance_max=0.74, ) assert decision["should_block_with_guard"] is False def test_engine_process_guard_requests_auto_retry_on_snapshot_only_sources() -> None: class _FakeService(AdaptiveRAGDeepGuardRulesMixin): pass service = _FakeService() decision = service._evaluate_post_retrieval_guard( deep_intent="engine_process_query", sources=[ {"source": "system", "label": "System Snapshot", "metadata": {}}, {"source": "system", "label": "User Snapshot", "metadata": {}}, ], relevance_max=0.41, ) assert decision["auto_retry_reason"] == "snapshot_only" def test_chat_external_fact_scene_policy_preserves_anchored_external_scene_without_question_heuristics() -> None: class _FakeService(AdaptiveRAGAnswerMainlineMixin): pass service = _FakeService() normalized = service._apply_chat_external_fact_scene_policy( question="不对吧，截止当前日期都已经有 codex5.4 了", project_id=None, scene_semantics={ "scene_key": "ai_pmo_correction", "snapshot_focus": "feature", "deep_intent": "correction_turn", "confidence": 0.95, }, anchor_prompt_variant="external_trend", ) assert normalized["scene_key"] == "industry_trend" assert normalized["deep_intent"] == "none" assert normalized["external_fact_chat"] is True def test_chat_external_fact_scene_policy_keeps_existing_external_scene() -> None: class _FakeService(AdaptiveRAGAnswerMainlineMixin): pass service = _FakeService() normalized = service._apply_chat_external_fact_scene_policy( question="当前codex最新的模型用的是什么？", project_id=None, scene_semantics={ "scene_key": "industry_trend", "snapshot_focus": "none", "deep_intent": "none", "confidence": 0.92, }, anchor_prompt_variant=None, ) assert normalized["scene_key"] == "industry_trend" assert normalized["snapshot_focus"] == "none" assert normalized["external_fact_chat"] is True def test_chat_external_fact_scene_policy_keeps_non_external_scene_unchanged() -> None: class _FakeService(AdaptiveRAGAnswerMainlineMixin): pass service = _FakeService() normalized = service._apply_chat_external_fact_scene_policy( question="我们系统当前接的是哪个 codex 模型配置？", project_id=None, scene_semantics={ "scene_key": "ai_pmo", "snapshot_focus": "identity", "deep_intent": "none", "confidence": 0.92, }, anchor_prompt_variant=None, ) assert normalized["scene_key"] == "ai_pmo" assert normalized["snapshot_focus"] == "identity" assert normalized.get("external_fact_chat") is not True def test_external_fact_freshness_guard_rejects_internal_only_sources() -> None: class _FakeService(AdaptiveRAGDeepGuardRulesMixin): pass service = _FakeService() assert service._requires_external_freshness( question="codex 目前最高模型出到什么了", scene_semantics={"scene_key": "industry_trend", "requires_freshness": True}, ) is True assert service._has_external_grounding_sources( [ {"source": "graph", "label": "Knowledge Graph", "metadata": {"path": "1->belongs_to->2"}}, {"source": "feature_catalog", "label": "Feature Catalog", "metadata": {}}, ] ) is False answer = service._build_external_freshness_guard_answer("codex 目前最高模型出到什么了") assert "当前未接入实时外部数据" in answer assert "backend/app/services" not in answer @pytest.mark.asyncio async def test_second_pass_query_skips_internal_hints_for_external_freshness_only() -> None: class _FakeService(AdaptiveRAGMultiStepCoreMixin): async def entity_resolution(self, **kwargs): # pragma: no cover - should not be called raise AssertionError(f"entity_resolution should be skipped: {kwargs}") async def get_project_manifest(self, **kwargs): # pragma: no cover - should not be called raise AssertionError(f"get_project_manifest should be skipped: {kwargs}") service = _FakeService() revised, meta = await service._build_second_pass_query( question="codex 目前最高模型出到什么了", project_id=None, query_semantics={"external_freshness_only": True}, ) assert revised == "codex 目前最高模型出到什么了" assert meta["mode"] == "freshness_guard_skip_internal_hint" @pytest.mark.asyncio async def test_live_external_freshness_context_fetches_url_rows_before_guard() -> None: class _FakeService(AdaptiveRAGAnswerRetrievalMixin, AdaptiveRAGDeepGuardRulesMixin): async def _retrieve_live_external_context(self, *, question: str, max_results: int = 3, max_pages: int = 3): _ = (question, max_results, max_pages) return ( [ RetrievedItem( source="url", content="OpenAI 在官方文章中说明 GPT-5.4 正在 rollout 到 Codex。", score=0.93, source_label="URL[Introducing GPT-5.4]", metadata={ "url": "https://openai.com/index/introducing-gpt-5-4/", "target_url": "https://openai.com/index/introducing-gpt-5-4/", "title": "Introducing GPT-5.4", }, ) ], {"query": question, "result_count": 1, "fetched_pages": 1}, ) service = _FakeService() rows, meta = await service._maybe_fetch_live_external_freshness_context( question="当前codex最新的模型用的是什么？", effective_question="当前codex最新的模型用的是什么？", query_semantics={}, scene_semantics={"scene_key": "industry_trend", "requires_freshness": True}, ) assert len(rows) == 1 assert rows[0].source == "url" assert rows[0].metadata["target_url"] == "https://openai.com/index/introducing-gpt-5-4/" assert meta["mode"] == "live_external_context" @pytest.mark.asyncio async def test_live_external_freshness_context_prefers_external_query_gateway() -> None: class _FakeService(AdaptiveRAGAnswerRetrievalMixin, AdaptiveRAGDeepGuardRulesMixin): async def _execute_external_query_gateway( self, *, question: str, query_semantics: dict | None = None, result_limit: int = 3, max_pages: int = 3, ): _ = (question, query_semantics, result_limit, max_pages) return ( [ RetrievedItem( source="url", content="OpenAI 官方页面显示 Codex 最新模型是 GPT-5.4。", score=0.94, source_label="URL[Models - Codex | OpenAI Developers]", metadata={ "url": "https://developers.openai.com/codex/models", "target_url": "https://developers.openai.com/codex/models", "title": "Models - Codex | OpenAI Developers", }, ) ], { "mode": "external_query_gateway", "adapter": "live_search", "search_result_count": 1, "fetched_pages": 1, "query": "codex latest model", }, ) service = _FakeService() rows, meta = await service._maybe_fetch_live_external_freshness_context( question="当前codex最新的模型用的是什么？", effective_question="当前codex最新的模型用的是什么？", query_semantics={}, scene_semantics={"scene_key": "industry_trend", "requires_freshness": True}, ) assert len(rows) == 1 assert rows[0].metadata["target_url"] == "https://developers.openai.com/codex/models" assert meta["mode"] == "external_query_gateway" assert meta["adapter"] == "live_search" @pytest.mark.asyncio async def test_external_query_gateway_falls_back_to_live_search_when_mcp_has_no_evidence() -> None: from app.services.external_query_service.gateway import ExternalQueryGateway from app.services.external_query_service.registry import ExternalProviderRegistry from app.services.external_query_service.schemas import ( ExternalAdapterResult, ExternalEvidenceItem, ExternalQueryPlan, ) plan = ExternalQueryPlan( plan_version="v1", query_kind="model", answer_contract="summary_with_sources", freshness_required=True, topic="codex 最新模型", subject_entities=["Codex"], location_hint=None, time_range_hint="截至今天", preferred_domains=["openai.com"], search_queries=["codex latest model"], result_limit=3, requires_multi_source=False, clarify_on_ambiguity=False, ) class _Planner: async def build_plan(self, *, question: str, query_semantics: dict | None = None) -> ExternalQueryPlan: _ = (question, query_semantics) return plan class _MCPAdapter: adapter_name = "mcp" async def execute(self, plan: ExternalQueryPlan) -> ExternalAdapterResult: _ = plan return ExternalAdapterResult(adapter_name="mcp", status="unavailable", evidence=[], meta={"reason": "no_client"}) class _LiveSearchAdapter: adapter_name = "live_search" async def execute(self, plan: ExternalQueryPlan) -> ExternalAdapterResult: _ = plan return ExternalAdapterResult( adapter_name="live_search", status="success", evidence=[ ExternalEvidenceItem( source_type="url", source_label="OpenAI Developers", title="Models - Codex | OpenAI Developers", target_url="https://developers.openai.com/codex/models", snippet="Latest: GPT-5.4", retrieved_at="2026-04-15T10:00:00+08:00", freshness_score=0.98, authority_score=0.96, grounded_fields=["latest_model"], raw_metadata={"provider": "live_search"}, ) ], meta={"provider": "live_search"}, ) gateway = ExternalQueryGateway( planner=_Planner(), registry=ExternalProviderRegistry(adapters=[_MCPAdapter(), _LiveSearchAdapter()]), ) result = await gateway.execute( question="当前 codex 最新的模型用的是什么？", query_semantics={"query_profile": {"needs_freshness": True, "referenced_objects": ["public_model"]}}, ) assert result.adapter_name == "live_search" assert result.verifier["ok"] is True assert len(result.evidence) == 1 assert result.meta["fallback_used"] is True def test_external_route_source_filter_is_fail_closed() -> None: class _FakeService(AdaptiveRAGQueryRouteGatewayMixin): pass service = _FakeService() filtered = service._filter_sources_for_route( sources=[ {"source": "feishu", "label": "Feishu history", "score": 0.8}, {"source": "pmflow", "label": "PMFlow records", "score": 0.7}, ], route_decision={"effective_source_policy": "external"}, ) assert filtered == [] @pytest.mark.asyncio async def test_live_external_search_uses_proxy_aware_http_client(monkeypatch) -> None: captured: dict[str, object] = {} class _FakeResponse: def __init__(self, text: str) -> None: self.text = text def raise_for_status(self) -> None: return None class _FakeAsyncClient: def __init__(self, *args, **kwargs) -> None: _ = args captured.update(kwargs) async def __aenter__(self): return self async def __aexit__(self, exc_type, exc, tb) -> None: _ = (exc_type, exc, tb) return None async def get(self, url: str, headers: dict[str, str]): captured["url"] = url captured["headers"] = headers return _FakeResponse('OpenAI Codex latest model') monkeypatch.setattr( "app.services.adaptive_rag_service.mixin_conversation_utils_a_p1.httpx.AsyncClient", _FakeAsyncClient, ) class _FakeService(AdaptiveRAGConversationUtilsAMixinP1): pass rows = await _FakeService()._search_live_external_results( query="OpenAI Codex latest model", max_results=1, ) assert captured["trust_env"] is True assert rows == [{"url": "https://example.com/post", "title": "OpenAI Codex latest model"}] @pytest.mark.asyncio async def test_live_external_fetch_uses_proxy_aware_http_client(monkeypatch) -> None: captured: dict[str, object] = {} class _FakeResponse: def __init__(self) -> None: self.headers = {"content-type": "text/html"} self.text = "

Fresh external fact

" def raise_for_status(self) -> None: return None class _FakeAsyncClient: def __init__(self, *args, **kwargs) -> None: _ = args captured.update(kwargs) async def __aenter__(self): return self async def __aexit__(self, exc_type, exc, tb) -> None: _ = (exc_type, exc, tb) return None async def get(self, url: str, headers: dict[str, str]): captured["url"] = url captured["headers"] = headers return _FakeResponse() monkeypatch.setattr( "app.services.adaptive_rag_service.mixin_conversation_utils_a_p1.httpx.AsyncClient", _FakeAsyncClient, ) class _FakeService(AdaptiveRAGConversationUtilsAMixinP1): pass text = await _FakeService()._fetch_url_text("https://example.com/post") assert captured["trust_env"] is True assert captured["url"] == "https://example.com/post" assert "Fresh external fact" in text def test_live_external_search_result_score_prefers_official_domain_for_model_brand_query() -> None: official = AdaptiveRAGConversationUtilsAMixinP1._score_live_external_search_result( question="当前 codex 最新的模型用的是什么？", title="Codex 全面升级 - OpenAI", url="https://openai.com/zh-Hans-CN/index/introducing-upgrades-to-codex/", ) third_party = AdaptiveRAGConversationUtilsAMixinP1._score_live_external_search_result( question="当前 codex 最新的模型用的是什么？", title="Codex 模型选择 - 菜鸟教程", url="https://www.runoob.com/codex/codex-models.html", ) assert official > third_party def test_live_external_search_result_score_prefers_codex_models_reference_page_for_latest_model_question() -> None: reference_page = AdaptiveRAGConversationUtilsAMixinP1._score_live_external_search_result( question="当前 codex 最新的模型用的是什么？", title="Models - Codex | OpenAI Developers", url="https://developers.openai.com/codex/models", ) announcement_page = AdaptiveRAGConversationUtilsAMixinP1._score_live_external_search_result( question="当前 codex 最新的模型用的是什么？", title="Introducing GPT-5.3-Codex - OpenAI", url="https://openai.com/index/introducing-gpt-5-3-codex/", ) assert reference_page > announcement_page def test_live_external_search_queries_prefer_official_site_for_model_brand_question() -> None: queries = AdaptiveRAGConversationUtilsAMixinP1._build_live_external_search_queries( "当前 codex 最新的模型用的是什么？" ) assert queries assert queries[0] == "site:openai.com codex latest model" assert any(query == "当前 codex 最新的模型用的是什么" for query in queries) def test_live_external_search_queries_strip_internal_runtime_tokens_for_model_brand_question() -> None: queries = AdaptiveRAGConversationUtilsAMixinP1._build_live_external_search_queries( "围绕“_sync_pmflow_rag_async->backend/app/api/sstc.py”回答：当前codex最新的模型用的是什么？" ) assert queries assert queries[0] == "site:openai.com codex latest model" assert all("backend/app/api/sstc.py" not in query for query in queries) assert all("_sync_pmflow_rag_async" not in query for query in queries) def test_live_external_chunk_score_prefers_latest_fact_chunk_for_chinese_model_question() -> None: latest_chunk = ( "Models – Codex | OpenAI Developers Latest: GPT-5.4 " "Prompt guidance Core concepts Text generation Code generation" ) nav_chunk = ( "Codex Docs Guides, concepts, and product docs for Codex " "Use cases Example workflows and tasks teams hand to Codex" ) latest_score = AdaptiveRAGConversationUtilsAMixinP1._score_live_external_chunk( question="当前codex最新的模型用的是什么？", title="Models - Codex | OpenAI Developers", content=latest_chunk, url="https://developers.openai.com/codex/models", ) nav_score = AdaptiveRAGConversationUtilsAMixinP1._score_live_external_chunk( question="当前codex最新的模型用的是什么？", title="Models - Codex | OpenAI Developers", content=nav_chunk, url="https://developers.openai.com/codex/models", ) assert latest_score > nav_score def test_external_model_fact_direct_answer_prefers_explicit_latest_evidence() -> None: retrieved = [ RetrievedItem( source="url", content=( "Models – Codex | OpenAI Developers Latest: GPT-5.4 " "Prompt guidance Core concepts Text generation" ), score=0.94, source_label="URL[Models - Codex | OpenAI Developers]", metadata={ "url": "https://developers.openai.com/codex/models", "target_url": "https://developers.openai.com/codex/models", }, ) ] answer = AdaptiveRAGDeepGuardAnswerMixin._build_external_model_fact_direct_answer( question="当前codex最新的模型用的是什么？", retrieved=retrieved, scene_semantics={"scene_key": "industry_trend"}, ) assert answer is not None assert "GPT-5.4" in answer assert "OpenAI" in answer @pytest.mark.asyncio async def test_live_external_context_prefers_official_candidate_beyond_base_page_window() -> None: class _FakeService(AdaptiveRAGConversationUtilsAMixinP1): async def _search_live_external_results(self, *, query: str, max_results: int = 5): _ = (query, max_results) return [ {"url": "https://example.com/codex-guide", "title": "Codex 全面上手指南"}, {"url": "https://example.com/codex-models", "title": "Codex 模型选择"}, {"url": "https://example.com/codex-news", "title": "Codex 最新动态"}, { "url": "https://openai.com/zh-Hans-CN/index/introducing-upgrades-to-codex/", "title": "Codex 全面升级 - OpenAI", }, ] async def _fetch_url_text(self, url: str) -> str: if "openai.com" in url: return "OpenAI 官方说明 Codex 当前使用 GPT-5.4。" return "第三方教程，只介绍 Codex 的一般用法。" rows, meta = await _FakeService()._retrieve_live_external_context( question="当前 codex 最新的模型用的是什么？", max_results=1, max_pages=1, ) assert rows assert rows[0].metadata["url"] == "https://openai.com/zh-Hans-CN/index/introducing-upgrades-to-codex/" assert meta["fetched_pages"] >= 1 @pytest.mark.asyncio async def test_query_semantics_respects_upstream_explicit_external_contract( monkeypatch: pytest.MonkeyPatch, ) -> None: class _FakeLLM: async def generate(self, prompt: str, **kwargs): _ = (prompt, kwargs) return ( '{"intent":"question","question_part":"今天荔湾区天气如何？","statement_part":"",' '"query_type":"status","retrieval_domains":["db","graph","url"],' '"subject_focus":"unknown","scope_hint":"none","feature_focus":"none",' '"source_policy":"external",' '"query_profile":{"needs_private_context":false,"needs_freshness":true,"referenced_objects":["weather"],"confidence":0.96}}' ) class _FakeService(AdaptiveRAGCoreIntentMixin, AdaptiveRAGAnswerMainlineMixin, AdaptiveRAGDeepGuardAnswerMixin): def __init__(self) -> None: self.db = object() self.tenant_id = 1 self.llm = _FakeLLM() async def _fake_aplan_message(cls, *, message_text: str, source_system: str, metadata=None): _ = (cls, message_text, source_system, metadata) return WorkflowSemanticPlanner.deserialize_bundle( { "bundle_id": "semantic-weather-external", "semantic_version": "v1", "source_system": "adaptive_rag", "primary_workflow": "query_flow", "workflows": [ { "workflow_type": "query_flow", "workflow_action": "answer", "target_scope": "global", "operation_codes": ["query.answer"], "requires_confirmation": False, "confidence": 0.92, "clarification_needed": False, "metadata": {}, } ], "message_gate": "auto", "reply_contract": {"mode": "text", "template_key": "workflow_bundle", "summary": "query_flow"}, "diagnostics": {"message_intent": "question"}, } ) monkeypatch.setattr(WorkflowSemanticPlanner, "aplan_message", classmethod(_fake_aplan_message)) service = _FakeService() semantics = await service._resolve_query_semantics( message="今天荔湾区天气如何？", source_system="pmflow", ) assert semantics["source_policy"] == "external" assert semantics["effective_source_policy"] == "external" assert semantics["retrieval_domains"] == ["url"] assert semantics["query_profile"]["needs_freshness"] is True assert semantics["query_profile"]["referenced_objects"] == ["weather"] assert semantics["decision_origin"] == "query_semantics_contract" assert semantics["source_reason"] == "query_semantics_contract" @pytest.mark.asyncio async def test_query_semantics_keeps_uncertain_contract_uncertain_without_default_external_first( monkeypatch: pytest.MonkeyPatch, ) -> None: class _FakeLLM: async def generate(self, prompt: str, **kwargs): _ = (prompt, kwargs) return ( '{"intent":"question","question_part":"当前 codex 最新的模型用的是什么？","statement_part":"",' '"query_type":"status","retrieval_domains":["db","pmflow"],' '"subject_focus":"feature","scope_hint":"global","feature_focus":"purpose",' '"query_profile":{"needs_private_context":false,"needs_freshness":true,"referenced_objects":["public_model"],"confidence":0.95}}' ) class _FakeService(AdaptiveRAGCoreIntentMixin, AdaptiveRAGAnswerMainlineMixin, AdaptiveRAGDeepGuardAnswerMixin): def __init__(self) -> None: self.db = object() self.tenant_id = 1 self.llm = _FakeLLM() async def _fake_aplan_message(cls, *, message_text: str, source_system: str, metadata=None): _ = (cls, message_text, source_system, metadata) return WorkflowSemanticPlanner.deserialize_bundle( { "bundle_id": "semantic-public-model-fact", "semantic_version": "v1", "source_system": "adaptive_rag", "primary_workflow": "query_flow", "workflows": [ { "workflow_type": "query_flow", "workflow_action": "answer", "target_scope": "global", "operation_codes": ["query.answer"], "requires_confirmation": False, "confidence": 0.9, "clarification_needed": False, "metadata": {}, } ], "message_gate": "auto", "reply_contract": {"mode": "text", "template_key": "workflow_bundle", "summary": "query_flow"}, "diagnostics": {"message_intent": "question"}, } ) monkeypatch.setattr(WorkflowSemanticPlanner, "aplan_message", classmethod(_fake_aplan_message)) service = _FakeService() semantics = await service._resolve_query_semantics( message="当前 codex 最新的模型用的是什么？", source_system="pmflow", ) assert semantics["source_policy"] == "uncertain" assert semantics["effective_source_policy"] == "uncertain" assert semantics["retrieval_domains"] == ["db", "pmflow"] assert semantics["query_profile"]["needs_freshness"] is True assert semantics["query_profile"]["referenced_objects"] == ["public_model"] assert semantics["decision_origin"] == "query_semantics_contract" assert semantics["source_reason"] == "query_semantics_contract" @pytest.mark.asyncio async def test_query_semantics_promotes_url_only_freshness_contract_to_external_without_object_mapping( monkeypatch: pytest.MonkeyPatch, ) -> None: class _FakeLLM: async def generate(self, prompt: str, **kwargs): _ = (prompt, kwargs) return ( '{"intent":"question","question_part":"帮我看看未来5天的广州天气如何","statement_part":"",' '"query_type":"status","retrieval_domains":["url"],' '"subject_focus":"signal","scope_hint":"global","feature_focus":"none",' '"query_profile":{"needs_private_context":false,"needs_freshness":true,"referenced_objects":["weather"],"confidence":0.95}}' ) class _FakeService(AdaptiveRAGCoreIntentMixin, AdaptiveRAGAnswerMainlineMixin, AdaptiveRAGDeepGuardAnswerMixin): def __init__(self) -> None: self.db = object() self.tenant_id = 1 self.llm = _FakeLLM() async def _fake_aplan_message(cls, *, message_text: str, source_system: str, metadata=None): _ = (cls, message_text, source_system, metadata) return WorkflowSemanticPlanner.deserialize_bundle( { "bundle_id": "semantic-url-only-freshness", "semantic_version": "v1", "source_system": "adaptive_rag", "primary_workflow": "query_flow", "workflows": [ { "workflow_type": "query_flow", "workflow_action": "answer", "target_scope": "global", "operation_codes": ["query.answer"], "requires_confirmation": False, "confidence": 0.94, "clarification_needed": False, "metadata": {}, } ], "message_gate": "auto", "reply_contract": {"mode": "text", "template_key": "workflow_bundle", "summary": "query_flow"}, "diagnostics": {"message_intent": "weather_query"}, } ) monkeypatch.setattr(WorkflowSemanticPlanner, "aplan_message", classmethod(_fake_aplan_message)) service = _FakeService() semantics = await service._resolve_query_semantics( message="帮我看看未来5天的广州天气如何", source_system="feishu", ) assert semantics["source_policy"] == "external" assert semantics["effective_source_policy"] == "external" assert semantics["retrieval_domains"] == ["url"] assert semantics["source_reason"] == "query_semantics_url_only_external_contract" assert semantics["decision_origin"] == "query_semantics_contract_normalized" @pytest.mark.asyncio async def test_query_semantics_preserves_internal_runtime_query_profile_for_runtime_question( monkeypatch: pytest.MonkeyPatch, ) -> None: class _FakeLLM: async def generate(self, prompt: str, **kwargs): _ = (prompt, kwargs) return ( '{"intent":"question","question_part":"我们系统当前接的是哪个 codex 模型配置？","statement_part":"",' '"query_type":"status","retrieval_domains":["url","db","pmflow"],' '"subject_focus":"feature","scope_hint":"project","feature_focus":"catalog",' '"source_policy":"internal",' '"query_profile":{"needs_private_context":true,"needs_freshness":false,"referenced_objects":["system_config","model_routing"],"confidence":0.97}}' ) class _FakeService(AdaptiveRAGCoreIntentMixin, AdaptiveRAGAnswerMainlineMixin, AdaptiveRAGDeepGuardAnswerMixin): def __init__(self) -> None: self.db = object() self.tenant_id = 1 self.llm = _FakeLLM() async def _fake_aplan_message(cls, *, message_text: str, source_system: str, metadata=None): _ = (cls, message_text, source_system, metadata) return WorkflowSemanticPlanner.deserialize_bundle( { "bundle_id": "semantic-model-config-internal", "semantic_version": "v1", "source_system": "adaptive_rag", "primary_workflow": "query_flow", "workflows": [ { "workflow_type": "query_flow", "workflow_action": "answer", "target_scope": "global", "operation_codes": ["query.answer"], "requires_confirmation": False, "confidence": 0.9, "clarification_needed": False, "metadata": {}, } ], "message_gate": "auto", "reply_contract": {"mode": "text", "template_key": "workflow_bundle", "summary": "query_flow"}, "diagnostics": {"message_intent": "question"}, } ) monkeypatch.setattr(WorkflowSemanticPlanner, "aplan_message", classmethod(_fake_aplan_message)) service = _FakeService() semantics = await service._resolve_query_semantics( message="我们系统当前接的是哪个 codex 模型配置？", source_system="pmflow", ) assert semantics["source_policy"] == "internal" assert semantics["effective_source_policy"] == "internal" assert semantics["retrieval_domains"] == ["db", "pmflow"] assert semantics["query_profile"]["needs_private_context"] is True assert semantics["query_profile"]["referenced_objects"] == ["system_config", "model_routing"] assert semantics["decision_origin"] == "query_semantics_contract" @pytest.mark.asyncio async def test_internal_model_config_fast_answer_reads_runtime_engine_bundle() -> None: class _FakeLLM: async def _get_or_init_bundle(self, db, *, tenant_id: int): _ = (db, tenant_id) return object(), { "active_engine_id": "low-1", "engines": [ { "id": "low-1", "name": "Qwen 低阶引擎", "provider": "glm", "model": "qwen-plus", "base_url": "https://dashscope.aliyuncs.com/compatible-mode/v1", }, { "id": "high-1", "name": "OpenAI 高阶引擎", "provider": "openai", "model": "GLM-5", "base_url": "https://api.edgefn.net/v1", }, ], "settings": { "enable_local_kb_qa": False, }, } def _resolve_active_engine_from_bundle(self, bundle: dict[str, object]): engines = list(bundle.get("engines") or []) return dict(engines[0]) async def _resolve_engine_for_call(self, db, *, tenant_id: int, function_name: str, routing_meta=None): _ = (db, tenant_id, routing_meta) if function_name == "adaptive_rag_answer_deep": return { "name": "Qwen 低阶引擎", "provider": "glm", "model": "qwen-plus", "_routing_meta": {"planned_tier": "low", "executed_tier": "low"}, } return { "name": "Qwen 低阶引擎", "provider": "glm", "model": "qwen-plus", "_routing_meta": {"planned_tier": "low", "executed_tier": "low"}, } class _FakeService(AdaptiveRAGDeepGuardAnswerMixin): def __init__(self) -> None: self.db = object() self.tenant_id = 1 self.llm = _FakeLLM() service = _FakeService() fast_result = await service._build_internal_model_config_fast_answer( question="我们系统当前接的是哪个 codex 模型配置？", query_semantics={ "effective_source_policy": "internal", "query_type": "status", "operation_contract": { "query_type": "status", }, "query_profile": { "needs_private_context": True, "needs_freshness": False, "referenced_objects": ["system_config", "model_routing"], }, "target_resolution": { "target_entity_type": "config", "target_ref": "config:model_routing", }, }, ) assert isinstance(fast_result, dict) assert "qwen-plus" in str(fast_result["answer"]) assert "adaptive_rag_answer_normal" in str(fast_result["answer"]) assert "enable_local_kb_qa=false" in str(fast_result["answer"]) assert fast_result["query_type"] == "status" assert fast_result["prompt_variant_id"] == "internal_model_config_direct" labels = [str(item.get("label") or "") for item in list(fast_result.get("sources") or [])] assert "Integration[llm_engine]" in labels assert "Integration[model_routing:adaptive_rag_answer_normal]" in labels @pytest.mark.asyncio async def test_internal_model_config_fast_answer_skips_non_config_target_resolution() -> None: class _FakeLLM: async def _get_or_init_bundle(self, db, *, tenant_id: int): # pragma: no cover - should not be called raise AssertionError(f"bundle lookup should be skipped: {db}, {tenant_id}") def _resolve_active_engine_from_bundle(self, bundle: dict[str, object]): # pragma: no cover - should not be called raise AssertionError(f"active engine should be skipped: {bundle}") async def _resolve_engine_for_call(self, db, *, tenant_id: int, function_name: str, routing_meta=None): # pragma: no cover - should not be called raise AssertionError(f"engine lookup should be skipped: {function_name}, {routing_meta}") class _FakeService(AdaptiveRAGDeepGuardAnswerMixin): def __init__(self) -> None: self.db = object() self.tenant_id = 1 self.llm = _FakeLLM() service = _FakeService() fast_result = await service._build_internal_model_config_fast_answer( question="系统里有没有知识库？", query_semantics={ "effective_source_policy": "internal", "query_type": "existence", "operation_contract": { "query_type": "existence", }, "query_profile": { "needs_private_context": True, "needs_freshness": False, "referenced_objects": ["system_config", "model_routing"], }, "target_resolution": { "target_entity_type": "project", "target_ref": "project:72", }, }, ) assert fast_result is None @pytest.mark.asyncio async def test_second_pass_query_skips_internal_hints_for_effective_external_source_policy() -> None: class _FakeService(AdaptiveRAGMultiStepCoreMixin): async def entity_resolution(self, **kwargs): # pragma: no cover - should not be called raise AssertionError(f"entity_resolution should be skipped: {kwargs}") async def get_project_manifest(self, **kwargs): # pragma: no cover - should not be called raise AssertionError(f"get_project_manifest should be skipped: {kwargs}") service = _FakeService() revised, meta = await service._build_second_pass_query( question="今天荔湾区天气如何？", project_id=None, query_semantics={"effective_source_policy": "external"}, ) assert revised == "今天荔湾区天气如何？" assert meta["mode"] == "external_source_policy_skip_internal_hint" @pytest.mark.asyncio async def test_multi_step_search_skips_internal_enrichment_for_effective_external_source_policy() -> None: class _FakeService(AdaptiveRAGMultiStepFlowMixin, AdaptiveRAGMultiStepCoreMixin): def __init__(self) -> None: self.db = object() self.tenant_id = 1 self.context_cache = SimpleNamespace( get_system_snapshot=self._unexpected_system_snapshot, ) async def _unexpected_system_snapshot(self, **kwargs): # pragma: no cover - should not be called raise AssertionError(f"system snapshot should be skipped: {kwargs}") async def entity_resolution(self, **kwargs): # pragma: no cover - should not be called raise AssertionError(f"entity_resolution should be skipped: {kwargs}") async def get_project_manifest(self, **kwargs): # pragma: no cover - should not be called raise AssertionError(f"get_project_manifest should be skipped: {kwargs}") def _match_feature_catalog_entries(self, **kwargs): # pragma: no cover - should not be called raise AssertionError(f"feature catalog should be skipped: {kwargs}") def _retrieve_feature_catalog_context(self, **kwargs): # pragma: no cover - should not be called raise AssertionError(f"feature retrieval should be skipped: {kwargs}") async def _run_single_retrieval_pass(self, **kwargs): _ = kwargs return ( [ RetrievedItem( source="url", content="广州荔湾区今日天气：多云转阵雨。", score=0.93, source_label="URL[weather.example]", metadata={"url": "https://weather.example/liwan"}, ) ], { "db_query_ms": 0, "vector_search_ms": 12, "graph_query_ms": 0, "db_timeout": False, "vector_timeout": False, "graph_timeout": False, }, ) service = _FakeService() rows, meta = await service._multi_step_search( question="今天荔湾区天气如何？", domains=["url"], project_id=None, source_chat_id=None, query_semantics={"effective_source_policy": "external"}, session_state=None, ) assert len(rows) == 1 assert rows[0].source == "url" assert meta["domains_used"] == ["url"] assert all(item.get("tool") != "freshness_guard" for item in meta["tool_trace"]) @pytest.mark.asyncio async def test_answer_scene_semantics_uses_source_policy_without_llm_call() -> None: class _FakeLLM: async def generate(self, prompt: str, **kwargs): # pragma: no cover - should not be called raise AssertionError(f"scene semantics should not hit llm: {prompt} | {kwargs}") class _FakeService(AdaptiveRAGDeepGuardAnswerMixin, AdaptiveRAGAnswerMainlineMixin): def __init__(self) -> None: self.db = object() self.tenant_id = 1 self.llm = _FakeLLM() service = _FakeService() semantics = await service._resolve_answer_scene_semantics( question="今天荔湾区天气如何？", effective_question="今天荔湾区天气如何？", asked_via="pmflow", message_intent="casual_chat", query_type="status", conversation_text="无", source_policy="external", ) assert semantics["scene_key"] == "industry_trend" assert semantics["confidence"] == 1.0 assert semantics["reason"] == "source_policy:external" @pytest.mark.asyncio async def test_answer_scene_semantics_uses_query_scope_for_external_project_scene() -> None: class _FakeLLM: async def generate(self, prompt: str, **kwargs): # pragma: no cover - should not be called raise AssertionError(f"scene semantics should not hit llm: {prompt} | {kwargs}") class _FakeService(AdaptiveRAGDeepGuardAnswerMixin, AdaptiveRAGAnswerMainlineMixin): def __init__(self) -> None: self.db = object() self.tenant_id = 1 self.llm = _FakeLLM() service = _FakeService() semantics = await service._resolve_answer_scene_semantics( question="现在这个情况会有什么影响？", effective_question="现在这个情况会有什么影响？", asked_via="pmflow", message_intent="question", query_type="explain", conversation_text="无", source_policy="external", project_id=12, query_semantics={"scope_hint": "project"}, ) assert semantics["scene_key"] == "external_trend" assert semantics["reason"] == "source_policy:external" @pytest.mark.asyncio async def test_query_route_gateway_uses_upstream_internal_contract_without_runtime_probes() -> None: class _FakeService(AdaptiveRAGQueryRouteGatewayMixin): def __init__(self) -> None: self.db = object() self.tenant_id = 1 async def _run_internal_route_probe(self, **kwargs): raise AssertionError(f"runtime internal probe should not be called: {kwargs}") async def _run_external_route_probe(self, **kwargs): raise AssertionError(f"runtime external probe should not be called: {kwargs}") async def _retrieve_query_route_memory_prior(self, **kwargs): raise AssertionError(f"route memory prior should not be called: {kwargs}") service = _FakeService() decision = await service._run_query_route_gateway( question="我们系统当前接的是哪个 codex 模型配置？", asked_via="pmflow_manual", project_id=None, source_chat_id=None, query_semantics={ "source_policy": "internal", "effective_source_policy": "internal", "query_profile": { "needs_private_context": True, "needs_freshness": False, "referenced_objects": ["system_config", "model_routing"], } }, source_policy_hint=None, ) assert decision["route_mode"] == "internal" assert decision["effective_source_policy"] == "internal" assert decision["decision_origin"] == "query_semantics_contract" assert decision["reply_contract"]["head"] == "内部知识库查询：" assert decision["probe_snapshot"]["contract"]["source_policy"] == "internal" @pytest.mark.asyncio async def test_query_route_gateway_keeps_uncertain_contract_as_clarify_without_external_first_fallback() -> None: class _FakeService(AdaptiveRAGQueryRouteGatewayMixin): def __init__(self) -> None: self.db = object() self.tenant_id = 1 async def _run_internal_route_probe(self, **kwargs): raise AssertionError(f"runtime internal probe should not be called: {kwargs}") async def _run_external_route_probe(self, **kwargs): raise AssertionError(f"runtime external probe should not be called: {kwargs}") async def _retrieve_query_route_memory_prior(self, **kwargs): raise AssertionError(f"route memory prior should not be called: {kwargs}") service = _FakeService() decision = await service._run_query_route_gateway( question="当前 codex 最新的模型用的是什么？", asked_via="pmflow_manual", project_id=None, source_chat_id=None, query_semantics={ "source_policy": "uncertain", "effective_source_policy": "uncertain", "query_profile": { "needs_private_context": False, "needs_freshness": True, "referenced_objects": ["public_model"], } }, source_policy_hint=None, ) assert decision["route_mode"] == "uncertain" assert decision["effective_source_policy"] == "uncertain" assert decision["decision_origin"] == "query_semantics_contract" assert decision["reply_contract"]["mode"] == "clarify" assert "系统内部配置" in str(decision["clarification_text"]) assert decision["probe_snapshot"]["contract"]["source_policy"] == "uncertain" @pytest.mark.asyncio async def test_query_route_gateway_builds_external_execution_recipe_for_current_project() -> None: class _FakeService(AdaptiveRAGQueryRouteGatewayMixin): def __init__(self) -> None: self.db = object() self.tenant_id = 1 service = _FakeService() decision = await service._run_query_route_gateway( question="这个方案适不适合我们当前项目？", asked_via="pmflow_manual", project_id=17, source_chat_id="pmflow-project-17", query_semantics={ "message_intent": "question", "query_type": "explain", "source_policy": "external", "effective_source_policy": "external", "query_profile": { "needs_private_context": False, "needs_freshness": True, "referenced_objects": ["public_solution"], }, }, source_policy_hint=None, ) packet = decision["project_operating_context"] recipe = decision["execution_recipe"] assert packet["current_project_id"] == 17 assert packet["page_anchor"]["project_id"] == 17 assert packet["page_anchor"]["source_chat_id"] == "pmflow-project-17" assert recipe == { "primary_lane": "external", "fit_brief_required": True, "external_evidence_required": True, "plan_handoff_mode": "offer_after_answer", } @pytest.mark.asyncio async def test_query_route_gateway_keeps_explicit_requirement_plan_recipe() -> None: class _FakeService(AdaptiveRAGQueryRouteGatewayMixin): def __init__(self) -> None: self.db = object() self.tenant_id = 1 service = _FakeService() decision = await service._run_query_route_gateway( question="那按这个结论继续收需求", asked_via="pmflow_manual", project_id=17, source_chat_id="pmflow-project-17", query_semantics={ "message_intent": "requirement_plan", "query_type": "plan", "source_policy": "internal", "effective_source_policy": "internal", "query_profile": { "needs_private_context": True, "needs_freshness": False, "referenced_objects": ["project_requirement"], }, }, source_policy_hint=None, ) assert decision["execution_recipe"] == { "primary_lane": "plan", "fit_brief_required": False, "external_evidence_required": False, "plan_handoff_mode": "explicit_plan_now", } @pytest.mark.asyncio async def test_query_route_gateway_can_disable_unified_execution_recipe(monkeypatch: pytest.MonkeyPatch) -> None: class _FakeService(AdaptiveRAGQueryRouteGatewayMixin): def __init__(self) -> None: self.db = object() self.tenant_id = 1 monkeypatch.setenv("PMFLOW_ENABLE_UNIFIED_EXECUTION_RECIPE", "0") service = _FakeService() decision = await service._run_query_route_gateway( question="这个方案适不适合当前项目？", asked_via="pmflow_manual", project_id=17, source_chat_id="pmflow-project-17", query_semantics={ "message_intent": "question", "query_type": "explain", "source_policy": "external", "effective_source_policy": "external", "query_profile": { "needs_private_context": False, "needs_freshness": True, "referenced_objects": ["public_solution"], }, }, source_policy_hint=None, ) assert decision["execution_recipe"] == { "primary_lane": "external", "fit_brief_required": False, "external_evidence_required": True, "plan_handoff_mode": "none", } @pytest.mark.asyncio async def test_query_route_clarification_response_stores_pending_route_protocol() -> None: class _FakeDB: def add(self, obj) -> None: obj.id = 1 async def flush(self) -> None: return None async def commit(self) -> None: return None async def refresh(self, obj) -> None: _ = obj return None class _FakeContextCache: async def append_session_messages(self, **kwargs) -> None: _ = kwargs return None class _FakeService( AdaptiveRAGAnswerPrecheckMixin, AdaptiveRAGQueryRouteGatewayMixin, AdaptiveRAGFollowupAnchorMixin, ): def __init__(self) -> None: self.db = _FakeDB() self.tenant_id = 1 self.context_cache = _FakeContextCache() def _to_naive_utc(self, value): return value def _build_qa_record_runtime_fields(self, **kwargs): _ = kwargs return { "policy_version": "test", "citations": [], "sources_used": [], "evidence_pack": {}, "tool_trace": [], } def _build_qa_record_external_fields(self, **kwargs): _ = kwargs return {} def _build_response_payload(self, **kwargs): return kwargs async def _update_session_state_after_turn(self, **kwargs): _ = kwargs return None service = _FakeService() state = SimpleNamespace( last_subject=None, last_entity_ids=[], last_intent=None, ambiguity="unknown", rewrite_history=[], pending_clarification=None, pending_clarification_expires_at=None, ) result = await service._maybe_return_clarification_response( clarification_payload={ "answer": "你是想问外部公开事实，还是系统内部配置/项目对象？", "code": "query_route_clarify", "candidates": [], "missing_fields": ["query_route"], }, started=0.0, clean_q="当前系统内是否有为采购经理提出的需求？", effective_q="当前系统内是否有为采购经理提出的需求？", query_type="existence", asked_by=1, asked_via="feishu", project_id=None, session_id=11, turn_index=2, state_row=state, rewrite_meta={"mode": "direct"}, context_session_id=11, active_thinking_mode="normal", route_decision={ "route_mode": "uncertain", "effective_source_policy": "uncertain", "reply_contract": { "mode": "clarify", "clarification_text": "你是想问外部公开事实，还是系统内部配置/项目对象？", }, }, ) assert result["clarification_code"] == "query_route_clarify" assert state.pending_clarification["kind"] == "query_route_selection" assert state.pending_clarification["original_question"] == "当前系统内是否有为采购经理提出的需求？" assert state.pending_clarification["option_map"] == {"A": "external", "B": "internal"} assert state.pending_clarification["options"] == [ {"key": "A", "label": "外部公开事实"}, {"key": "B", "label": "系统内部配置/项目对象"}, ] def test_query_route_pending_clarification_consumes_protocol_option_label() -> None: class _FakeService(AdaptiveRAGFollowupAnchorMixin): def _to_naive_utc(self, value): return value service = _FakeService() state = SimpleNamespace( pending_clarification={ "kind": "query_route_selection", "original_question": "当前系统内是否有为采购经理提出的需求？", "attempts": 1, "option_map": {"A": "external", "B": "internal"}, "options": [ {"key": "A", "label": "外部公开事实"}, {"key": "B", "label": "系统内部配置/项目对象"}, ], }, pending_clarification_expires_at=None, ) consumed = service._consume_pending_clarification_selection( question="内部配置", session_state=state, ) assert consumed == { "effective_question": "当前系统内是否有为采购经理提出的需求？", "source_policy_hint": "internal", } assert state.pending_clarification is None @pytest.mark.asyncio async def test_prepare_answer_runtime_passes_consumed_query_route_hint_to_preview() -> None: class _FakeService(AdaptiveRAGAnswerMainlineMixin, AdaptiveRAGFollowupAnchorMixin): def __init__(self) -> None: self.preview_kwargs: dict[str, object] = {} self.state_row = SimpleNamespace( last_subject=None, last_entity_ids=[], last_intent=None, ambiguity="unknown", rewrite_history=[], pending_clarification={ "kind": "query_route_selection", "original_question": "当前系统内是否有为采购经理提出的需求？", "attempts": 1, "option_map": {"A": "external", "B": "internal"}, "options": [ {"key": "A", "label": "外部公开事实"}, {"key": "B", "label": "系统内部配置/项目对象"}, ], }, pending_clarification_expires_at=None, ) def _to_naive_utc(self, value): return value def _build_external_conversation_key(self, **kwargs): _ = kwargs return "scope:feishu:test" def _set_active_external_qa_context(self, **kwargs): _ = kwargs async def _touch_session_for_new_record(self, **kwargs): _ = kwargs return 11, 2 def _external_session_id_from_key(self, key: str): _ = key return 11 async def _load_recent_conversation(self, **kwargs): _ = kwargs return [] async def _ensure_session_state(self, **kwargs): _ = kwargs return self.state_row async def _resolve_followup_anchor(self, **kwargs): _ = kwargs return FollowupAnchorResolution() def _rewrite_question_with_state(self, **kwargs): return kwargs["question"], {"mode": "direct"} async def preview_query_route_decision(self, **kwargs): self.preview_kwargs = dict(kwargs) return { "query_semantics": { "source_policy": "internal", "effective_source_policy": "internal", "query_type": "existence", "retrieval_domains": ["db", "pmflow"], "query_profile": { "needs_private_context": True, "needs_freshness": False, "referenced_objects": ["system_config"], }, }, "route_decision": { "route_mode": "internal", "effective_source_policy": "internal", "decision_origin": "upstream_hint", "reply_contract": { "mode": "explicit_source", "head": "内部知识库查询：", "tail_hint": None, }, "query_profile": { "needs_private_context": True, "needs_freshness": False, "referenced_objects": ["system_config"], }, "probe_snapshot_summary": {}, "probe_snapshot": {}, }, } async def _resolve_answer_scene_semantics(self, **kwargs): _ = kwargs return {"scene_key": "ai_pmo", "deep_intent": "none"} def _normalize_action_mode(self, value: str) -> str: return str(value or "").strip().lower() or "auto" async def _resolve_action_mode_async(self, **kwargs): _ = kwargs return ACTION_MODE_READ service = _FakeService() runtime = await service._prepare_answer_runtime( clean_q="内部配置", asked_by=1, asked_via="feishu", project_id=None, source_chat_id="oc_test_chat", session_id=11, conversation_key=None, force_new_session=False, action_mode="auto", ) assert runtime["resolved_question"] == "当前系统内是否有为采购经理提出的需求？" assert service.preview_kwargs["question"] == "当前系统内是否有为采购经理提出的需求？" assert service.preview_kwargs["source_policy_hint"] == "internal" assert service.state_row.pending_clarification is None @pytest.mark.asyncio async def test_prepare_answer_runtime_recomputes_route_after_consuming_query_route_selection() -> None: class _FakeService( AdaptiveRAGAnswerMainlineMixin, AdaptiveRAGFollowupAnchorMixin, AdaptiveRAGQueryRouteGatewayMixin, ): def __init__(self) -> None: self.preview_kwargs: dict[str, object] = {} self.state_row = SimpleNamespace( last_subject=None, last_entity_ids=[], last_intent=None, ambiguity="unknown", rewrite_history=[], pending_clarification={ "kind": "query_route_selection", "original_question": "当前系统内是否有为采购经理提出的需求？", "attempts": 1, "option_map": {"A": "external", "B": "internal"}, "options": [ {"key": "A", "label": "外部公开事实"}, {"key": "B", "label": "系统内部配置/项目对象"}, ], }, pending_clarification_expires_at=None, ) def _to_naive_utc(self, value): return value def _build_external_conversation_key(self, **kwargs): _ = kwargs return "scope:feishu:test" def _set_active_external_qa_context(self, **kwargs): _ = kwargs async def _touch_session_for_new_record(self, **kwargs): _ = kwargs return 11, 2 def _external_session_id_from_key(self, key: str): _ = key return 11 async def _load_recent_conversation(self, **kwargs): _ = kwargs return [] async def _ensure_session_state(self, **kwargs): _ = kwargs return self.state_row async def _resolve_followup_anchor(self, **kwargs): _ = kwargs return FollowupAnchorResolution() def _rewrite_question_with_state(self, **kwargs): return kwargs["question"], {"mode": "direct"} async def preview_query_route_decision(self, **kwargs): self.preview_kwargs = dict(kwargs) return { "query_semantics": { "source_policy": "internal", "effective_source_policy": "internal", "query_type": "existence", "retrieval_domains": ["db", "pmflow"], "query_profile": { "needs_private_context": True, "needs_freshness": False, "referenced_objects": ["project_object"], }, }, "route_decision": { "route_mode": "internal", "effective_source_policy": "internal", "decision_origin": "upstream_hint", "reply_contract": { "mode": "explicit_source", "head": "内部知识库查询：", "tail_hint": None, }, "query_profile": { "needs_private_context": True, "needs_freshness": False, "referenced_objects": ["project_object"], }, "probe_snapshot_summary": {}, "probe_snapshot": {}, }, } async def _resolve_answer_scene_semantics(self, **kwargs): _ = kwargs return {"scene_key": "ai_pmo", "deep_intent": "none"} def _normalize_action_mode(self, value: str) -> str: return str(value or "").strip().lower() or "auto" async def _resolve_action_mode_async(self, **kwargs): _ = kwargs return ACTION_MODE_READ service = _FakeService() runtime = await service._prepare_answer_runtime( clean_q="内部配置", asked_by=1, asked_via="feishu", project_id=None, source_chat_id="oc_test_chat", session_id=11, conversation_key=None, force_new_session=False, action_mode="auto", precomputed_query_semantics={ "source_policy": "uncertain", "effective_source_policy": "uncertain", "query_type": "explain", "retrieval_domains": ["db", "pmflow", "doc"], "query_profile": { "needs_private_context": True, "needs_freshness": False, "referenced_objects": ["system_config"], "confidence": 0.9, }, }, route_decision={ "route_mode": "uncertain", "effective_source_policy": "uncertain", "decision_origin": "query_semantics_contract", "reply_contract": { "mode": "clarify", "clarification_text": "你是想问外部公开事实，还是系统内部配置/项目对象？", }, "query_profile": { "needs_private_context": True, "needs_freshness": False, "referenced_objects": ["system_config"], "confidence": 0.9, }, "probe_snapshot_summary": {}, "probe_snapshot": {}, }, ) assert runtime["resolved_question"] == "当前系统内是否有为采购经理提出的需求？" assert service.preview_kwargs["question"] == "当前系统内是否有为采购经理提出的需求？" assert service.preview_kwargs["source_policy_hint"] == "internal" assert service.preview_kwargs["query_semantics"] == {} assert runtime["query_type"] == "existence" assert runtime["route_decision"]["route_mode"] == "internal" assert service.state_row.pending_clarification is None @pytest.mark.asyncio async def test_render_answer_with_route_contract_adds_explicit_source_prefix_and_summary() -> None: class _FakeService(AdaptiveRAGQueryRouteGatewayMixin): pass service = _FakeService() formatted = service._render_answer_with_route_contract( answer="当前活动引擎是 Qwen 低阶引擎。", sources=[ {"source": "db", "label": "Integration[llm_engine]", "score": 0.99}, {"source": "db", "label": "Integration[model_routing:adaptive_rag_answer_normal]", "score": 0.98}, ], route_decision={ "route_mode": "internal", "reply_contract": { "head": "内部知识库查询：", "tail_hint": None, }, }, ) assert formatted.startswith("内部知识库查询：") assert "来源摘要：" in formatted assert "Integration[llm_engine]" in formatted def test_build_response_payload_exposes_execution_recipe_and_plan_handoff() -> None: class _FakeService(AdaptiveRAGAnswerPayloadMixin): def _to_float(self, value, default=0.0): try: return float(value) except Exception: return float(default) def _normalize_thinking_mode(self, thinking_mode: str) -> str: return "deep" if str(thinking_mode or "").strip().lower() == "deep" else "normal" def _normalize_query_route_decision(self, payload): return dict(payload or {}) def _build_policy_version(self, *, prompt_variant_id: str | None = None) -> str: return f"retrieval-v2.1|routing:unknown|prompt:{prompt_variant_id or 'unknown'}" service = _FakeService() payload = service._build_response_payload( answer="建议先做一轮小范围验证。", sources=[ { "source": "url", "label": "OpenAI Docs", "score": 0.93, "metadata": {"target_url": "https://platform.openai.com/docs"}, } ], domains_used=["url"], response_time_ms=32, db_query_ms=0, vector_search_ms=0, query_type="explain", confidence=0.93, route_decision={"route_mode": "external", "effective_source_policy": "external"}, project_operating_context={ "current_project_id": 17, "current_repo_scope": "pmflow-main", "page_anchor": {"project_id": 17}, "thread_anchor": {}, "fit_scope": "current_project_and_repo", "decision_strategy": "answer_then_offer_plan", }, execution_recipe={ "primary_lane": "external", "fit_brief_required": True, "external_evidence_required": True, "plan_handoff_mode": "offer_after_answer", }, ) assert payload["project_operating_context"]["current_project_id"] == 17 assert payload["execution_recipe"]["primary_lane"] == "external" assert payload["handoff_mode"] == "offer_after_answer" assert payload["can_enter_plan"] is True assert "进入 plan" in payload["recommended_next_step"] def test_response_payload_can_disable_default_offer_plan_rendering(monkeypatch: pytest.MonkeyPatch) -> None: class _FakeService(AdaptiveRAGAnswerPayloadMixin): def _to_float(self, value, default: float = 0.0) -> float: try: return float(value) except Exception: return float(default) def _normalize_thinking_mode(self, thinking_mode: str) -> str: return "deep" if str(thinking_mode or "").strip().lower() == "deep" else "normal" def _normalize_query_route_decision(self, payload): return dict(payload or {}) def _build_policy_version(self, *, prompt_variant_id: str | None = None) -> str: return f"retrieval-v2.1|routing:unknown|prompt:{prompt_variant_id or 'unknown'}" monkeypatch.setenv("PMFLOW_ENABLE_DEFAULT_PLAN_HANDOFF_RENDERING", "0") service = _FakeService() payload = service._build_response_payload( answer="建议先做一轮小范围验证。", sources=[ { "source": "url", "label": "OpenAI Docs", "score": 0.93, "metadata": {"target_url": "https://platform.openai.com/docs"}, } ], domains_used=["url"], response_time_ms=32, db_query_ms=0, vector_search_ms=0, query_type="explain", confidence=0.93, route_decision={"route_mode": "external", "effective_source_policy": "external"}, project_operating_context={ "current_project_id": 17, "current_repo_scope": "pmflow-main", "page_anchor": {"project_id": 17}, "thread_anchor": {}, "fit_scope": "current_project_and_repo", "decision_strategy": "answer_then_offer_plan", }, execution_recipe={ "primary_lane": "external", "fit_brief_required": True, "external_evidence_required": True, "plan_handoff_mode": "offer_after_answer", }, ) assert payload["handoff_mode"] is None assert payload["can_enter_plan"] is False assert payload["recommended_next_step"] is None @pytest.mark.asyncio async def test_meta_followup_without_real_anchor_does_not_return_no_route_record_answer() -> None: class _FakeService(AdaptiveRAGFollowupAnchorMixin): async def _resolve_anchor_qa_record(self, **kwargs): _ = kwargs return None service = _FakeService() payload = await service._build_meta_followup_payload( question="我们系统当前接的是哪个 codex 模型配置？", anchor_resolution=FollowupAnchorResolution( followup_mode="meta", anchor_mode="no_anchor", is_meta_followup=True, meta_followup_kind="reply_model_identity", ), conversation_scope_key="scope:test", ) assert payload is None @pytest.mark.asyncio async def test_execute_mainline_skips_followup_clarification_after_state_subject_rewrite() -> None: class _FakeContextCache: async def get_system_snapshot(self, **kwargs): _ = kwargs return {} async def get_user_snapshot(self, **kwargs): _ = kwargs return {} class _FakeService( AdaptiveRAGAnswerMainlineMixin, AdaptiveRAGFollowupAnchorMixin, ): def __init__(self) -> None: self.db = object() self.tenant_id = 1 self.context_cache = _FakeContextCache() self.clarification_payload = None self.retrieval_kwargs: dict[str, object] = {} def _plan_query_runtime(self, **kwargs): _ = kwargs return SimpleNamespace( thinking_mode="normal", retrieval_answer_mode="retrieval_normal", budget=SimpleNamespace(max_steps=2, vector_top_k=3), allow_fast_path=False, reason="consultant_mode", ) def _build_route_clarification_payload(self, **kwargs): _ = kwargs return None async def _build_meta_followup_payload(self, **kwargs): _ = kwargs return None async def _maybe_return_clarification_response(self, **kwargs): self.clarification_payload = kwargs.get("clarification_payload") if self.clarification_payload is not None: return { "processing_stage": "clarification", "answer": self.clarification_payload.get("answer"), } return None async def _maybe_return_meta_followup_response(self, **kwargs): _ = kwargs return None def _get_active_external_qa_context(self): return {} def _build_operation_contract(self, *, question: str, query_semantics): _ = (question, query_semantics) return { "query_type": "existence", "answer_contract": "yes_no_with_evidence", } async def _resolve_internal_target(self, **kwargs): _ = kwargs return {} def _mirror_internal_context_to_query_semantics(self, *, query_semantics, **kwargs): _ = kwargs return dict(query_semantics) def _build_internal_query_plan(self, **kwargs): _ = kwargs return {} def _build_internal_query_context_packet(self, **kwargs): _ = kwargs return None async def _maybe_return_internal_context_precheck_response(self, **kwargs): _ = kwargs return None async def _build_internal_model_config_fast_answer(self, **kwargs): _ = kwargs return None def _build_snapshot_direct_answer(self, *args, **kwargs): _ = (args, kwargs) return None async def _maybe_return_snapshot_direct_response(self, **kwargs): _ = kwargs return None async def _try_glm_project_semantic_answer(self, **kwargs): _ = kwargs return None async def _build_retrieval_response(self, **kwargs): self.retrieval_kwargs = dict(kwargs) return { "processing_stage": "retrieval", "answer": "内部知识库查询：当前系统内已存在采购经理提出的需求。", } service = _FakeService() rewritten_question = "围绕“采购经理每日实时库存上报服务”回答：帮我看下采购经理那个需求是否存在系统？" result = await service._execute_base_answer_mainline( clean_q="帮我看下采购经理那个需求是否存在系统？", asked_by=1, asked_via="feishu", project_id=None, source_chat_id="chat-1", session_id=11, turn_index=2, context_session_id=11, conversation=[], state_row=SimpleNamespace( last_subject="采购经理每日实时库存上报服务", last_entity_ids=[123], last_intent="question", ambiguity="clear", rewrite_history=[], pending_clarification=None, pending_clarification_expires_at=None, ), effective_q=rewritten_question, rewrite_meta={"mode": "state_subject", "subject": "采购经理每日实时库存上报服务"}, query_type="existence", query_semantics={ "source_policy": "internal", "effective_source_policy": "internal", "query_profile": { "needs_private_context": True, "needs_freshness": False, "referenced_objects": ["project_object"], }, }, retrieval_domains=["db", "pmflow"], scene_semantics={"scene_key": "ai_pmo", "snapshot_focus": "none", "deep_intent": "none"}, thinking_mode="normal", active_thinking_mode="normal", deep_thinking=False, enforce_scene_prompt_only=False, deep_retrieval_steps=2, deep_vector_top_k=3, started=0.0, message_intent="question", mixed_signal_part=None, anchor_resolution=FollowupAnchorResolution( followup_mode="referential", anchor_mode="no_anchor", clarification_code="no_anchor_found", ), consultant_mode_preference=None, route_decision={ "route_mode": "internal", "effective_source_policy": "internal", "reply_contract": {"head": "内部知识库查询：", "tail_hint": None}, }, ) assert result["processing_stage"] == "retrieval" assert service.clarification_payload is None assert service.retrieval_kwargs["effective_q"] == rewritten_question @pytest.mark.asyncio async def test_internal_model_config_fast_answer_bypasses_fast_path_gate_when_route_is_internal() -> None: class _FakeContextCache: async def get_system_snapshot(self, **kwargs): _ = kwargs return {} async def get_user_snapshot(self, **kwargs): _ = kwargs return {} class _FakeService(AdaptiveRAGAnswerMainlineMixin): def __init__(self) -> None: self.db = object() self.tenant_id = 1 self.context_cache = _FakeContextCache() self.builder_calls = 0 self.retrieval_called = False def _plan_query_runtime(self, **kwargs): _ = kwargs return SimpleNamespace( thinking_mode="normal", retrieval_answer_mode="retrieval_normal", budget=SimpleNamespace(max_steps=2, vector_top_k=3), allow_fast_path=False, reason="consultant_mode", ) def _build_followup_clarification_payload(self, **kwargs): _ = kwargs return None def _build_route_clarification_payload(self, **kwargs): _ = kwargs return None async def _build_meta_followup_payload(self, **kwargs): _ = kwargs return None async def _maybe_return_clarification_response(self, **kwargs): _ = kwargs return None async def _maybe_return_meta_followup_response(self, **kwargs): _ = kwargs return None def _get_active_external_qa_context(self): return {} async def _build_internal_model_config_fast_answer(self, **kwargs): _ = kwargs self.builder_calls += 1 return { "answer": "当前活动引擎是 qwen-plus。", "sources": [{"source": "db", "label": "Integration[llm_engine]", "score": 0.99}], } async def _persist_fast_answer(self, **kwargs): return { "processing_stage": "fast_path", "answer": kwargs["fast_result"]["answer"], } async def _build_retrieval_response(self, **kwargs): _ = kwargs self.retrieval_called = True return {"processing_stage": "retrieval"} async def _maybe_return_snapshot_direct_response(self, **kwargs): _ = kwargs return None def _build_snapshot_direct_answer(self, *args, **kwargs): _ = (args, kwargs) return None service = _FakeService() result = await service._execute_base_answer_mainline( clean_q="我们系统当前接的是哪个 codex 模型配置？", asked_by=1, asked_via="pmflow_manual", project_id=None, source_chat_id=None, session_id=11, turn_index=3, context_session_id=11, conversation=[], state_row=None, effective_q="我们系统当前接的是哪个 codex 模型配置？", rewrite_meta={}, query_type="explain", query_semantics={ "source_policy": "internal", "effective_source_policy": "internal", "query_profile": { "needs_private_context": True, "needs_freshness": False, "referenced_objects": ["system_config", "model_routing"], }, }, retrieval_domains=["db", "pmflow"], scene_semantics={"scene_key": "ai_pmo", "snapshot_focus": "feature", "deep_intent": "none"}, thinking_mode="none", active_thinking_mode="normal", deep_thinking=False, enforce_scene_prompt_only=False, deep_retrieval_steps=2, deep_vector_top_k=3, started=0.0, message_intent="system_configuration_inquiry", mixed_signal_part=None, consultant_mode_preference="informative", route_decision={ "route_mode": "internal", "effective_source_policy": "internal", "reply_contract": {"head": "内部知识库查询：", "tail_hint": None}, "query_profile": { "needs_private_context": True, "needs_freshness": False, "referenced_objects": ["system_config", "model_routing"], }, }, ) assert result["processing_stage"] == "fast_path" assert "qwen-plus" in result["answer"] assert service.builder_calls == 1 assert service.retrieval_called is False @pytest.mark.asyncio async def test_execute_mainline_blocks_internal_route_when_internal_context_packet_missing() -> None: class _FakeContextCache: async def get_system_snapshot(self, **kwargs): _ = kwargs return {} async def get_user_snapshot(self, **kwargs): _ = kwargs return {} class _FakeService( AdaptiveRAGAnswerMainlineMixin, AdaptiveRAGAnswerPayloadMixin, ): def __init__(self) -> None: self.db = object() self.tenant_id = 1 self.context_cache = _FakeContextCache() self.persist_kwargs: dict[str, object] = {} def _plan_query_runtime(self, **kwargs): _ = kwargs return SimpleNamespace( thinking_mode="normal", retrieval_answer_mode="retrieval_normal", budget=SimpleNamespace(max_steps=2, vector_top_k=3), allow_fast_path=True, reason="deterministic_query_type", ) def _build_followup_clarification_payload(self, **kwargs): _ = kwargs return None def _build_route_clarification_payload(self, **kwargs): _ = kwargs return None async def _build_meta_followup_payload(self, **kwargs): _ = kwargs return None async def _maybe_return_clarification_response(self, **kwargs): _ = kwargs return None async def _maybe_return_meta_followup_response(self, **kwargs): _ = kwargs return None def _get_active_external_qa_context(self): return {} def _build_operation_contract(self, *, question: str, query_semantics): _ = (question, query_semantics) return { "query_type": "existence", "answer_contract": "yes_no_with_evidence", "object_mentions": ["开票系统"], } async def _resolve_internal_target(self, **kwargs): _ = kwargs return { "target_entity_type": "project", "target_ref": "project:6", "resolved_label": "自动开票系统", "resolution_mode": "deterministic", "confidence": 0.96, "candidate_summary": [], } def _build_internal_query_context_packet(self, **kwargs): _ = kwargs return None async def _persist_fast_answer(self, **kwargs): self.persist_kwargs = dict(kwargs) return { "processing_stage": "fast_path", "answer": kwargs["fast_result"]["answer"], "answer_mode": kwargs["answer_mode"], "missing_fields": list(kwargs["fast_result"].get("missing_fields") or []), } async def _run_deterministic_query(self, **kwargs): # pragma: no cover - should not be called raise AssertionError(f"deterministic query should be blocked: {kwargs}") async def _build_internal_model_config_fast_answer(self, **kwargs): # pragma: no cover - should not be called raise AssertionError(f"internal model config fast answer should be blocked: {kwargs}") async def _try_glm_project_semantic_answer(self, **kwargs): # pragma: no cover - should not be called raise AssertionError(f"glm semantic fast answer should be blocked: {kwargs}") async def _build_retrieval_response(self, **kwargs): # pragma: no cover - should not be called raise AssertionError(f"retrieval should be blocked: {kwargs}") async def _maybe_return_snapshot_direct_response(self, **kwargs): _ = kwargs return None def _build_snapshot_direct_answer(self, *args, **kwargs): _ = (args, kwargs) return None service = _FakeService() result = await service._execute_base_answer_mainline( clean_q="帮我看看系统里面有没有开票系统。", asked_by=1, asked_via="pmflow_manual", project_id=None, source_chat_id=None, session_id=11, turn_index=3, context_session_id=11, conversation=[], state_row=None, effective_q="帮我看看系统里面有没有开票系统。", rewrite_meta={}, query_type="explain", query_semantics={ "source_policy": "internal", "effective_source_policy": "internal", "subject_focus": "project", }, retrieval_domains=["db", "pmflow"], scene_semantics={"scene_key": "ai_pmo", "snapshot_focus": "none", "deep_intent": "none"}, thinking_mode="normal", active_thinking_mode="normal", deep_thinking=False, enforce_scene_prompt_only=False, deep_retrieval_steps=2, deep_vector_top_k=3, started=0.0, message_intent="question", mixed_signal_part=None, consultant_mode_preference=None, route_decision={ "route_mode": "internal", "effective_source_policy": "internal", "reply_contract": {"head": "内部知识库查询：", "tail_hint": None}, }, ) assert result["processing_stage"] == "fast_path" assert result["answer_mode"] == "clarify" assert service.persist_kwargs["fast_result"]["reason_code"] == "missing_internal_context_packet" assert service.persist_kwargs["fast_result"]["missing_fields"] == ["internal_context_packet"] @pytest.mark.asyncio async def test_execute_mainline_blocks_internal_route_when_query_plan_contract_missing() -> None: class _FakeContextCache: async def get_system_snapshot(self, **kwargs): _ = kwargs return {} async def get_user_snapshot(self, **kwargs): _ = kwargs return {} class _FakeService( AdaptiveRAGAnswerMainlineMixin, AdaptiveRAGAnswerPayloadMixin, ): def __init__(self) -> None: self.db = object() self.tenant_id = 1 self.context_cache = _FakeContextCache() self.persist_kwargs: dict[str, object] = {} def _plan_query_runtime(self, **kwargs): _ = kwargs return SimpleNamespace( thinking_mode="normal", retrieval_answer_mode="retrieval_normal", budget=SimpleNamespace(max_steps=2, vector_top_k=3), allow_fast_path=True, reason="deterministic_query_type", ) def _build_followup_clarification_payload(self, **kwargs): _ = kwargs return None def _build_route_clarification_payload(self, **kwargs): _ = kwargs return None async def _build_meta_followup_payload(self, **kwargs): _ = kwargs return None async def _maybe_return_clarification_response(self, **kwargs): _ = kwargs return None async def _maybe_return_meta_followup_response(self, **kwargs): _ = kwargs return None def _get_active_external_qa_context(self): return {} def _build_operation_contract(self, *, question: str, query_semantics): _ = (question, query_semantics) return { "query_type": "existence", "answer_contract": "yes_no_with_evidence", "object_mentions": ["开票系统"], } async def _resolve_internal_target(self, **kwargs): _ = kwargs return { "target_entity_type": "project", "target_ref": "project:6", "resolved_label": "自动开票系统", "resolution_mode": "deterministic", "confidence": 0.96, "candidate_summary": [], } def _build_internal_query_context_packet(self, **kwargs): payload = dict(kwargs) return InternalContextPacket.model_validate( { "packet_version": "v1", "question": str(payload.get("question") or ""), "scope": { "tenant_id": 1, "project_id": None, "session_id": 11, "conversation_scope_key": None, "reply_to_message_id": None, "root_message_id": None, }, "route_decision": dict(payload.get("route_decision") or {}), "operation_contract": dict(payload.get("operation_contract") or {}), "target_resolution": dict(payload.get("target_resolution") or {}), "query_plan": { "plan_version": "v2", "query_type": "existence", "entity_type": "project", "answer_contract": "", "target_ref": "project:6", "filters": [{"field": "project_id", "operator": "equals", "value": 6}], }, "executor_summary": {}, "verifier_summary": {}, "uncertainties": [], } ) async def _persist_fast_answer(self, **kwargs): self.persist_kwargs = dict(kwargs) return { "processing_stage": "fast_path", "answer": kwargs["fast_result"]["answer"], "answer_mode": kwargs["answer_mode"], "missing_fields": list(kwargs["fast_result"].get("missing_fields") or []), } async def _run_deterministic_query(self, **kwargs): # pragma: no cover - should not be called raise AssertionError(f"deterministic query should be blocked: {kwargs}") async def _build_internal_model_config_fast_answer(self, **kwargs): # pragma: no cover - should not be called raise AssertionError(f"internal model config fast answer should be blocked: {kwargs}") async def _try_glm_project_semantic_answer(self, **kwargs): # pragma: no cover - should not be called raise AssertionError(f"glm semantic fast answer should be blocked: {kwargs}") async def _build_retrieval_response(self, **kwargs): # pragma: no cover - should not be called raise AssertionError(f"retrieval should be blocked: {kwargs}") async def _maybe_return_snapshot_direct_response(self, **kwargs): _ = kwargs return None def _build_snapshot_direct_answer(self, *args, **kwargs): _ = (args, kwargs) return None service = _FakeService() result = await service._execute_base_answer_mainline( clean_q="帮我看看系统里面有没有开票系统。", asked_by=1, asked_via="pmflow_manual", project_id=None, source_chat_id=None, session_id=11, turn_index=3, context_session_id=11, conversation=[], state_row=None, effective_q="帮我看看系统里面有没有开票系统。", rewrite_meta={}, query_type="explain", query_semantics={ "source_policy": "internal", "effective_source_policy": "internal", "subject_focus": "project", }, retrieval_domains=["db", "pmflow"], scene_semantics={"scene_key": "ai_pmo", "snapshot_focus": "none", "deep_intent": "none"}, thinking_mode="normal", active_thinking_mode="normal", deep_thinking=False, enforce_scene_prompt_only=False, deep_retrieval_steps=2, deep_vector_top_k=3, started=0.0, message_intent="question", mixed_signal_part=None, consultant_mode_preference=None, route_decision={ "route_mode": "internal", "effective_source_policy": "internal", "reply_contract": {"head": "内部知识库查询：", "tail_hint": None}, }, ) assert result["processing_stage"] == "fast_path" assert result["answer_mode"] == "clarify" assert service.persist_kwargs["fast_result"]["reason_code"] == "missing_internal_query_plan_contract" assert service.persist_kwargs["fast_result"]["missing_fields"] == ["answer_contract"]