"""Adaptive RAG answer mainline orchestration helpers.""" from __future__ import annotations from .shared import * from .internal_query_context import InternalContextPacket, internal_context_block_reason class AdaptiveRAGAnswerMainlineMixin: @staticmethod def _mirror_internal_context_to_query_semantics( *, query_semantics: Optional[dict[str, Any]], operation_contract: Optional[dict[str, Any]] = None, target_resolution: Optional[dict[str, Any]] = None, query_plan: Optional[dict[str, Any]] = None, ) -> dict[str, Any]: mirrored = dict(query_semantics or {}) if isinstance(query_semantics, dict) else {} if isinstance(operation_contract, dict): mirrored["operation_contract"] = dict(operation_contract) if isinstance(target_resolution, dict): mirrored["target_resolution"] = dict(target_resolution) if isinstance(query_plan, dict): mirrored["query_plan"] = dict(query_plan) return mirrored @staticmethod def _normalize_runtime_consultant_mode_preference(value: Optional[str]) -> Optional[str]: text = str(value or "").strip().lower() if text in {"clarify", "advise", "challenge", "brainstorm", "execute"}: return text return None @staticmethod def _internal_answer_contract_for_query_type(query_type: str) -> str: normalized = str(query_type or QUERY_TYPE_UNKNOWN).strip().lower() if normalized == QUERY_TYPE_EXISTENCE: return "yes_no_with_evidence" if normalized == QUERY_TYPE_COUNT: return "count_scalar" if normalized == QUERY_TYPE_LIST: return "entity_list" if normalized == QUERY_TYPE_STATUS: return "entity_snapshot" if normalized == QUERY_TYPE_EXPLAIN: return "explanation_with_citations" if normalized == QUERY_TYPE_DIAGNOSE: return "diagnosis_with_evidence" if normalized == QUERY_TYPE_COMPARE: return "comparison_with_basis" return "clarify_or_fail" @staticmethod def _has_resolved_followup_rewrite(rewrite_meta: Optional[dict[str, Any]]) -> bool: if not isinstance(rewrite_meta, dict): return False mode = str(rewrite_meta.get("mode") or "").strip().lower() return mode in { "state_subject", "state_entities", "followup_anchor_recent_reply", "followup_anchor_meta", } @staticmethod def _mirror_followup_state_to_query_semantics( *, query_semantics: Optional[dict[str, Any]], session_state: Optional[QASessionState], rewrite_meta: Optional[dict[str, Any]], ) -> dict[str, Any]: semantics = dict(query_semantics or {}) if isinstance(query_semantics, dict) else {} if not isinstance(rewrite_meta, dict): return semantics rewrite_mode = str(rewrite_meta.get("mode") or "").strip().lower() if rewrite_mode not in {"state_subject", "state_entities"}: return semantics entity_ids: list[int] = [] if isinstance(getattr(session_state, "last_entity_ids", None), list): for value in list(getattr(session_state, "last_entity_ids", None) or []): try: entity_ids.append(int(value)) except Exception: continue payload = { "rewrite_mode": rewrite_mode, "last_subject": str(getattr(session_state, "last_subject", "") or "").strip() or None, "last_entity_ids": entity_ids[:6], } semantics["session_followup_context"] = payload return semantics @staticmethod def _internal_entity_type_for_subject_focus(subject_focus: str) -> str: normalized = str(subject_focus or "").strip().lower() if normalized == "people": return "user" if normalized in {"project", "task", "signal", "feature"}: return normalized return "unknown" def _build_internal_query_plan( self, *, question: str, project_id: Optional[int], query_semantics: Optional[dict[str, Any]], operation_contract: Optional[dict[str, Any]] = None, target_resolution: Optional[dict[str, Any]] = None, ) -> Optional[dict[str, Any]]: semantics = query_semantics if isinstance(query_semantics, dict) else {} operation = operation_contract if isinstance(operation_contract, dict) else ( semantics.get("operation_contract") if isinstance(semantics.get("operation_contract"), dict) else {} ) target = target_resolution if isinstance(target_resolution, dict) else ( semantics.get("target_resolution") if isinstance(semantics.get("target_resolution"), dict) else {} ) source_policy = str( semantics.get("effective_source_policy") or semantics.get("source_policy") or "" ).strip().lower() if source_policy != "internal": return None query_type = str( operation.get("query_type") or semantics.get("query_type") or QUERY_TYPE_UNKNOWN ).strip().lower() or QUERY_TYPE_UNKNOWN subject_focus = self._query_subject_focus(semantics) if hasattr(self, "_query_subject_focus") else "unknown" entity_type = str( target.get("target_entity_type") or self._internal_entity_type_for_subject_focus(subject_focus) ).strip().lower() or "unknown" scope_hint = self._query_scope_hint(semantics) if hasattr(self, "_query_scope_hint") else "none" target_ref = str(target.get("target_ref") or "").strip() or None filters: list[dict[str, Any]] = [] if entity_type == "project" and target_ref and target_ref.startswith("project:"): try: resolved_project_id = int(target_ref.split(":", 1)[1]) except Exception: resolved_project_id = None if resolved_project_id is not None: filters.append( { "field": "project_id", "operator": "equals", "value": resolved_project_id, "value_source": "target_resolution", } ) elif entity_type == "project": mention_collector = getattr(self, "_collect_lookup_terms", None) if callable(mention_collector): operation_mentions = mention_collector( question=question, query_semantics=semantics, operation_contract=operation, target_resolution=target, limit=3, ) else: operation_mentions = [ str(item or "").strip() for item in list(operation.get("object_mentions") or []) if str(item or "").strip() ] if operation_mentions: for raw in operation_mentions[:3]: filters.append( { "field": "semantic_label", "operator": "equals_or_alias", "value": raw, "value_source": "operation_contract", } ) elif entity_type == "feature" and target_ref: filters.append( { "field": "feature_ref", "operator": "equals", "value": target_ref, "value_source": "target_resolution", } ) elif entity_type == "config" and target_ref: filters.append( { "field": "config_ref", "operator": "equals", "value": target_ref, "value_source": "target_resolution", } ) return { "plan_version": "v2" if operation or target else "v1", "query_type": query_type, "entity_type": entity_type, "answer_contract": self._internal_answer_contract_for_query_type(query_type), "target_ref": target_ref, "filters": filters, "scope": { "tenant_bound": True, "project_id": int(project_id) if project_id is not None else None, "scope_hint": scope_hint, }, "retrieval_policy": { "facts_first": True, "allow_fallback_text": True, }, "verifier_checks": [ "contract_matches_query_type", "evidence_backed", ], } def _build_internal_query_context_packet( self, *, question: str, project_id: Optional[int], session_id: Optional[int], conversation_scope_key: Optional[str], reply_to_message_id: Optional[str], root_message_id: Optional[str], route_decision: Optional[dict[str, Any]], operation_contract: Optional[dict[str, Any]], target_resolution: Optional[dict[str, Any]], query_plan: Optional[dict[str, Any]], ) -> InternalContextPacket | None: normalize_route_decision = getattr(self, "_normalize_query_route_decision", None) normalized_route = ( normalize_route_decision(route_decision) if callable(normalize_route_decision) else (dict(route_decision or {}) if isinstance(route_decision, dict) else {}) ) if str(normalized_route.get("effective_source_policy") or "").strip().lower() != "internal": return None return InternalContextPacket.model_validate( { "packet_version": "v1", "question": str(question or "").strip(), "scope": { "tenant_id": int(getattr(self, "tenant_id", 0) or 0), "project_id": int(project_id) if project_id is not None else None, "session_id": int(session_id) if session_id is not None else None, "conversation_scope_key": str(conversation_scope_key or "").strip() or None, "reply_to_message_id": str(reply_to_message_id or "").strip() or None, "root_message_id": str(root_message_id or "").strip() or None, }, "route_decision": dict(normalized_route), "operation_contract": dict(operation_contract or {}) if isinstance(operation_contract, dict) else {}, "target_resolution": dict(target_resolution or {}) if isinstance(target_resolution, dict) else {}, "query_plan": dict(query_plan or {}) if isinstance(query_plan, dict) else {}, "executor_summary": {}, "verifier_summary": {}, "uncertainties": [], } ) async def _maybe_return_internal_context_precheck_response( self, *, question: str, effective_question: str, asked_by: Optional[int], asked_via: str, project_id: Optional[int], session_id: Optional[int], context_session_id: Optional[int], turn_index: int, state_row: Optional[QASessionState], rewrite_meta: Optional[dict[str, Any]], thinking_mode: str, query_type: str, route_decision: Optional[dict[str, Any]], query_semantics: Optional[dict[str, Any]], internal_context_packet: Any, ) -> Optional[dict[str, Any]]: packet_block = internal_context_block_reason( internal_context_packet, route_decision=route_decision, ) if packet_block is None: return None reason_code, missing_fields = packet_block guard_builder = getattr(self, "_build_internal_answer_contract_guard_payload", None) if not callable(guard_builder): return None guard_payload = guard_builder( query_type=query_type, reason_code=reason_code, missing_fields=list(missing_fields or []), ) persist_fast_answer = getattr(self, "_persist_fast_answer", None) if callable(persist_fast_answer): return await persist_fast_answer( question=question, asked_by=asked_by, asked_via=asked_via, project_id=project_id, fast_result={ "answer": str(guard_payload.get("answer") or "").strip(), "sources": list(guard_payload.get("sources") or []), "missing_fields": list(guard_payload.get("missing_fields") or []), "reason_code": str(guard_payload.get("reason_code") or "").strip() or reason_code, "query_type": str(query_type or QUERY_TYPE_UNKNOWN).strip() or QUERY_TYPE_UNKNOWN, "confidence": 0.0, "db_query_ms": 0, "response_time_ms": 0, "prompt_variant_id": "internal_context_guard", }, session_id=session_id, external_session_id=context_session_id, turn_index=turn_index, query_type=query_type, missing_fields=list(guard_payload.get("missing_fields") or []), state_row=state_row, effective_question=effective_question, rewrite_meta=rewrite_meta or {}, thinking_mode=thinking_mode, answer_mode=str(guard_payload.get("answer_mode") or ANSWER_MODE_CLARIFY), route_decision=route_decision, query_semantics=query_semantics, internal_context_packet=internal_context_packet, ) return dict(guard_payload or {}) @classmethod def _extract_prompt_variant_from_policy_version(cls, policy_version: Optional[str]) -> Optional[str]: raw = str(policy_version or "").strip() if not raw: return None for part in raw.split("|"): normalized = str(part or "").strip() if not normalized.startswith("prompt:"): continue value = normalized.split(":", 1)[1].strip().lower() return value or None return None async def _resolve_anchor_prompt_variant( self, *, anchor_resolution: Optional[FollowupAnchorResolution], conversation_scope_key: Optional[str], ) -> Optional[str]: resolver = getattr(self, "_resolve_anchor_qa_record", None) if not callable(resolver): return None try: anchor_row = await resolver( anchor_resolution=anchor_resolution, conversation_scope_key=conversation_scope_key, ) except Exception: return None if anchor_row is None: return None return self._extract_prompt_variant_from_policy_version(getattr(anchor_row, "policy_version", None)) def _apply_chat_external_fact_scene_policy( self, *, question: str, project_id: Optional[int], scene_semantics: Optional[dict[str, Any]], anchor_prompt_variant: Optional[str] = None, ) -> dict[str, Any]: _ = question normalized = dict(scene_semantics or {}) scene_key = str(normalized.get("scene_key") or "default").strip().lower() or "default" anchor_variant = str(anchor_prompt_variant or "").strip().lower() if scene_key in {"ai_pmo", "ai_pmo_correction"} and anchor_variant in {"external_trend", "industry_trend"}: scene_key = anchor_variant normalized["snapshot_focus"] = "none" normalized["deep_intent"] = "none" if scene_key == "external_trend" and project_id is None: scene_key = "industry_trend" if scene_key in {"external_trend", "industry_trend"}: normalized["external_fact_chat"] = True normalized["scene_key"] = scene_key return normalized def _plan_query_runtime( self, *, question: str, effective_question: str, query_type: str, scene_semantics: Optional[dict[str, Any]] = None, requested_thinking_mode: str, enforce_scene_prompt_only: bool, consultant_mode_preference: Optional[str] = None, ) -> QueryPlannerDecision: normalize_thinking_mode = getattr( self, "_normalize_thinking_mode", lambda value: THINKING_MODE_DEEP if str(value or "").strip().lower() == THINKING_MODE_DEEP else THINKING_MODE_NORMAL, ) normalized_thinking_mode = normalize_thinking_mode(requested_thinking_mode) normalized_query_type = str(query_type or QUERY_TYPE_UNKNOWN).strip().lower() normalized_consultant_mode = self._normalize_runtime_consultant_mode_preference( consultant_mode_preference ) fast_path_candidate = normalized_query_type in { QUERY_TYPE_EXISTENCE, QUERY_TYPE_COUNT, QUERY_TYPE_LIST, QUERY_TYPE_STATUS, } normalized_question = str(question or "").strip() normalized_effective = str(effective_question or "").strip() normalized_scene_semantics = scene_semantics if isinstance(scene_semantics, dict) else {} deep_intent = str(normalized_scene_semantics.get("deep_intent") or "none").strip().lower() force_deep_by_semantics = deep_intent in { "correction_turn", "correction_escalation", "engine_process_query", "runtime_state_query", } if enforce_scene_prompt_only: retrieval_mode = ANSWER_MODE_RETRIEVAL_DEEP if normalized_thinking_mode == THINKING_MODE_DEEP else ANSWER_MODE_RETRIEVAL_NORMAL return QueryPlannerDecision( answer_mode=retrieval_mode, thinking_mode=THINKING_MODE_DEEP if retrieval_mode == ANSWER_MODE_RETRIEVAL_DEEP else THINKING_MODE_NORMAL, allow_fast_path=False, retrieval_answer_mode=retrieval_mode, budget=RetrievalBudget( max_steps=DEEP_RETRIEVAL_STEPS if retrieval_mode == ANSWER_MODE_RETRIEVAL_DEEP else AGENT_MAX_RETRIEVAL_STEPS, vector_top_k=DEEP_VECTOR_TOP_K if retrieval_mode == ANSWER_MODE_RETRIEVAL_DEEP else DEFAULT_TOP_K, ), reason="scene_prompt_only", ) if fast_path_candidate and not force_deep_by_semantics: if normalized_consultant_mode: return QueryPlannerDecision( answer_mode=ANSWER_MODE_RETRIEVAL_NORMAL, thinking_mode=THINKING_MODE_NORMAL, allow_fast_path=False, retrieval_answer_mode=ANSWER_MODE_RETRIEVAL_NORMAL, budget=RetrievalBudget(max_steps=AGENT_MAX_RETRIEVAL_STEPS, vector_top_k=DEFAULT_TOP_K), reason=f"consultant_mode:{normalized_consultant_mode}", ) return QueryPlannerDecision( answer_mode=ANSWER_MODE_FAST_PATH, thinking_mode=THINKING_MODE_NORMAL, allow_fast_path=True, retrieval_answer_mode=ANSWER_MODE_RETRIEVAL_NORMAL, budget=RetrievalBudget(max_steps=AGENT_MAX_RETRIEVAL_STEPS, vector_top_k=DEFAULT_TOP_K), reason="deterministic_query_type", ) retrieval_mode = ANSWER_MODE_RETRIEVAL_DEEP if (normalized_thinking_mode == THINKING_MODE_DEEP or force_deep_by_semantics) else ANSWER_MODE_RETRIEVAL_NORMAL return QueryPlannerDecision( answer_mode=retrieval_mode, thinking_mode=THINKING_MODE_DEEP if retrieval_mode == ANSWER_MODE_RETRIEVAL_DEEP else THINKING_MODE_NORMAL, allow_fast_path=False, retrieval_answer_mode=retrieval_mode, budget=RetrievalBudget( max_steps=DEEP_RETRIEVAL_STEPS if retrieval_mode == ANSWER_MODE_RETRIEVAL_DEEP else AGENT_MAX_RETRIEVAL_STEPS, vector_top_k=DEEP_VECTOR_TOP_K if retrieval_mode == ANSWER_MODE_RETRIEVAL_DEEP else DEFAULT_TOP_K, ), reason="requested_thinking_mode" if retrieval_mode == ANSWER_MODE_RETRIEVAL_DEEP else "default_retrieval", ) async def _prepare_answer_runtime( self, *, clean_q: str, asked_by: Optional[int], asked_via: str, project_id: Optional[int], source_chat_id: Optional[str], session_id: Optional[int], conversation_key: Optional[str], force_new_session: bool, action_mode: str, source_message_id: Optional[str] = None, source_sender_open_id: Optional[str] = None, thread_context: Optional[dict[str, Any]] = None, source_policy: Optional[str] = None, precomputed_query_semantics: Optional[dict[str, Any]] = None, route_decision: Optional[dict[str, Any]] = None, ) -> dict[str, Any]: external_conversation_key = self._build_external_conversation_key( asked_via=asked_via, source_chat_id=source_chat_id, conversation_key=conversation_key, source_sender_open_id=source_sender_open_id, sender=None, thread_context=thread_context, ) self._set_active_external_qa_context( source_chat_id=source_chat_id, source_message_id=source_message_id, source_sender_open_id=source_sender_open_id, conversation_scope_key=external_conversation_key, thread_context=thread_context, ) session_id, turn_index = await self._touch_session_for_new_record( asked_by=asked_by, asked_via=asked_via, project_id=project_id, question=clean_q, preferred_session_id=session_id, force_new_session=bool(force_new_session), external_conversation_key=external_conversation_key, ) context_session_id: Optional[int] if session_id is not None: context_session_id = int(session_id) elif asked_by is None: context_session_id = self._external_session_id_from_key(external_conversation_key) else: context_session_id = None conversation = await self._load_recent_conversation( asked_by=asked_by, asked_via=asked_via, project_id=project_id, session_id=session_id, external_session_id=context_session_id, limit=10, ) state_session_id = int(session_id) if session_id is not None else ( int(context_session_id) if context_session_id is not None else None ) state_row = await self._ensure_session_state(session_id=state_session_id) pending_selection = self._consume_pending_clarification_selection( question=clean_q, session_state=state_row, ) resolved_question = str(pending_selection.get("effective_question") or clean_q).strip() if isinstance( pending_selection, dict ) else clean_q consumed_source_policy_hint = ( str(pending_selection.get("source_policy_hint") or "").strip().lower() or None if isinstance(pending_selection, dict) else None ) anchor_resolution = await self._resolve_followup_anchor( question=resolved_question, session_id=state_session_id, context_session_id=context_session_id, session_state=state_row, conversation_scope_key=external_conversation_key, source_chat_id=source_chat_id, source_sender_open_id=source_sender_open_id, source_message_id=source_message_id, thread_context=thread_context, ) effective_q, rewrite_meta = self._rewrite_question_with_state( question=resolved_question, conversation=conversation, session_state=state_row, anchor_resolution=anchor_resolution, ) query_semantics = dict(precomputed_query_semantics or {}) if isinstance(precomputed_query_semantics, dict) else {} should_refresh_route_preview = bool( isinstance(pending_selection, dict) and ( resolved_question != clean_q or consumed_source_policy_hint ) ) if should_refresh_route_preview: query_semantics = {} route_decision = None route_preview = await self.preview_query_route_decision( question=effective_q, asked_via=asked_via, project_id=project_id, source_chat_id=source_chat_id, source_message_id=source_message_id, conversation_scope_key=external_conversation_key, reply_to_message_id=str((thread_context or {}).get("reply_to_message_id") or "").strip() or None, root_message_id=str((thread_context or {}).get("root_message_id") or "").strip() or None, source_policy_hint=consumed_source_policy_hint or source_policy, query_semantics=query_semantics, ) if should_refresh_route_preview or not isinstance(route_decision, dict) or not query_semantics else { "query_semantics": self._apply_route_decision_to_query_semantics( query_semantics=query_semantics, route_decision=route_decision, ), "route_decision": self._normalize_query_route_decision(route_decision), } query_semantics = ( dict(route_preview.get("query_semantics") or {}) if isinstance(route_preview.get("query_semantics"), dict) else {} ) operation_contract = None operation_contract_builder = getattr(self, "_build_operation_contract", None) if callable(operation_contract_builder): operation_contract = operation_contract_builder( question=effective_q, query_semantics=query_semantics, ) query_semantics = self._mirror_internal_context_to_query_semantics( query_semantics=query_semantics, operation_contract=operation_contract, ) internal_query_plan = self._build_internal_query_plan( question=effective_q, project_id=project_id, query_semantics=query_semantics, operation_contract=operation_contract, ) query_semantics = self._mirror_internal_context_to_query_semantics( query_semantics=query_semantics, query_plan=internal_query_plan, ) route_decision = ( dict(route_preview.get("route_decision") or {}) if isinstance(route_preview.get("route_decision"), dict) else {} ) query_type = str( (operation_contract or {}).get("query_type") or query_semantics.get("query_type") or QUERY_TYPE_UNKNOWN ).strip().lower() or QUERY_TYPE_UNKNOWN conversation_text = "\n".join( [ f"Q: {str(row.get('question') or '').strip()}\nA: {str(row.get('answer') or '').strip()}" for row in conversation[-4:] if isinstance(row, dict) ] ) or "无" scene_semantics = await self._resolve_answer_scene_semantics( question=clean_q, effective_question=effective_q, asked_via=asked_via, message_intent=str(query_semantics.get("message_intent") or query_semantics.get("intent") or "").strip().lower() or None, query_type=query_type, conversation_text=conversation_text, source_policy=str( route_decision.get("effective_source_policy") or query_semantics.get("effective_source_policy") or query_semantics.get("source_policy") or source_policy or "" ).strip().lower() or None, project_id=project_id, query_semantics=query_semantics, ) anchor_prompt_variant = await self._resolve_anchor_prompt_variant( anchor_resolution=anchor_resolution, conversation_scope_key=external_conversation_key, ) scene_semantics = self._apply_chat_external_fact_scene_policy( question=resolved_question, project_id=project_id, scene_semantics=scene_semantics, anchor_prompt_variant=anchor_prompt_variant, ) if bool(scene_semantics.get("requires_freshness")): query_semantics["external_freshness_only"] = True query_semantics["retrieval_domains"] = ["url"] query_semantics["source_policy"] = "external" query_semantics["effective_source_policy"] = "external" route_decision = self._normalize_query_route_decision( { **route_decision, "route_mode": str(route_decision.get("route_mode") or "external"), "effective_source_policy": "external", "decision_origin": str(route_decision.get("decision_origin") or "freshness_guard"), "reply_contract": { "mode": "explicit_source", "head": "外部实时查询：", "tail_hint": None, }, "query_profile": query_semantics.get("query_profile"), "probe_snapshot_summary": route_decision.get("probe_snapshot_summary"), "probe_snapshot": route_decision.get("probe_snapshot"), } ) requested_action_mode = self._normalize_action_mode(action_mode) effective_action_mode = await self._resolve_action_mode_async( requested_mode=requested_action_mode, question=resolved_question, effective_question=effective_q, asked_via=asked_via, ) return { "session_id": session_id, "turn_index": turn_index, "context_session_id": context_session_id, "conversation": conversation, "state_row": state_row, "resolved_question": resolved_question, "effective_q": effective_q, "rewrite_meta": rewrite_meta, "query_type": query_type, "query_semantics": query_semantics, "retrieval_domains": list(query_semantics.get("retrieval_domains") or []), "message_intent": str(query_semantics.get("message_intent") or query_semantics.get("intent") or "").strip().lower() or None, "scene_semantics": scene_semantics if isinstance(scene_semantics, dict) else {}, "effective_action_mode": effective_action_mode, "anchor_resolution": anchor_resolution, "route_decision": route_decision, } async def _execute_base_answer_mainline( self, *, clean_q: str, asked_by: Optional[int], asked_via: str, project_id: Optional[int], source_chat_id: Optional[str], session_id: Optional[int], turn_index: int, context_session_id: Optional[int], conversation: list[dict[str, str]], state_row: Optional[QASessionState], effective_q: str, rewrite_meta: dict[str, Any], query_type: str, query_semantics: dict[str, Any], retrieval_domains: list[str], scene_semantics: dict[str, Any], thinking_mode: str, active_thinking_mode: str, deep_thinking: bool, enforce_scene_prompt_only: bool, deep_retrieval_steps: int, deep_vector_top_k: int, started: float, message_intent: Optional[str], mixed_signal_part: Optional[str], anchor_resolution: Optional[FollowupAnchorResolution] = None, consultant_mode_preference: Optional[str] = None, route_decision: Optional[dict[str, Any]] = None, ) -> dict[str, Any]: operation_contract = ( dict(query_semantics.get("operation_contract") or {}) if isinstance(query_semantics.get("operation_contract"), dict) else {} ) operation_contract_builder = getattr(self, "_build_operation_contract", None) if not operation_contract and callable(operation_contract_builder): operation_contract = operation_contract_builder( question=effective_q, query_semantics=query_semantics, ) if isinstance(operation_contract, dict): query_semantics["operation_contract"] = operation_contract query_type = str( operation_contract.get("query_type") or query_type or QUERY_TYPE_UNKNOWN ).strip().lower() or QUERY_TYPE_UNKNOWN planner = self._plan_query_runtime( question=clean_q, effective_question=effective_q, query_type=query_type, scene_semantics=scene_semantics, requested_thinking_mode=active_thinking_mode, enforce_scene_prompt_only=enforce_scene_prompt_only, consultant_mode_preference=consultant_mode_preference, ) active_thinking_mode = planner.thinking_mode deep_thinking = planner.retrieval_answer_mode == ANSWER_MODE_RETRIEVAL_DEEP deep_retrieval_steps = int(planner.budget.max_steps or deep_retrieval_steps) deep_vector_top_k = int(planner.budget.vector_top_k or deep_vector_top_k) forced_deep_reason = "" if not deep_thinking and not planner.allow_fast_path: deep_intent = str((scene_semantics or {}).get("deep_intent") or "none").strip().lower() if deep_intent != "none": forced_deep_reason = deep_intent deep_thinking = True active_thinking_mode = THINKING_MODE_DEEP clarification_payload = None if not self._has_resolved_followup_rewrite(rewrite_meta): clarification_payload = self._build_followup_clarification_payload( question=clean_q, anchor_resolution=anchor_resolution, session_state=state_row, ) route_clarification_payload = self._build_route_clarification_payload(route_decision=route_decision) meta_followup_payload = await self._build_meta_followup_payload( question=clean_q, anchor_resolution=anchor_resolution, conversation_scope_key=self._get_active_external_qa_context().get("conversation_scope_key"), ) clarification_result = await self._maybe_return_clarification_response( clarification_payload=clarification_payload or route_clarification_payload, started=started, clean_q=clean_q, effective_q=effective_q, query_type=query_type, asked_by=asked_by, asked_via=asked_via, project_id=project_id, session_id=session_id, turn_index=turn_index, state_row=state_row, rewrite_meta=rewrite_meta, context_session_id=context_session_id, active_thinking_mode=active_thinking_mode, route_decision=route_decision, ) if clarification_result is not None: return clarification_result meta_followup_result = await self._maybe_return_meta_followup_response( meta_followup_payload=meta_followup_payload, started=started, clean_q=clean_q, effective_q=effective_q, query_type=query_type, asked_by=asked_by, asked_via=asked_via, project_id=project_id, session_id=session_id, turn_index=turn_index, state_row=state_row, rewrite_meta=rewrite_meta, context_session_id=context_session_id, active_thinking_mode=active_thinking_mode, route_decision=route_decision, ) if meta_followup_result is not None: return meta_followup_result system_snapshot = await self.context_cache.get_system_snapshot( db=self.db, tenant_id=self.tenant_id, ) user_snapshot = await self.context_cache.get_user_snapshot( db=self.db, tenant_id=self.tenant_id, user_id=asked_by, ) prefers_external_retrieval = ( str(query_semantics.get("effective_source_policy") or query_semantics.get("source_policy") or "").strip().lower() == "external" ) query_semantics = self._mirror_followup_state_to_query_semantics( query_semantics=query_semantics, session_state=state_row, rewrite_meta=rewrite_meta, ) target_resolution = ( dict(query_semantics.get("target_resolution") or {}) if isinstance(query_semantics.get("target_resolution"), dict) else {} ) target_resolver = getattr(self, "_resolve_internal_target", None) if not prefers_external_retrieval and callable(target_resolver): target_resolution = await target_resolver( question=effective_q, project_id=project_id, query_semantics=query_semantics, system_snapshot=system_snapshot, operation_contract=operation_contract, ) query_semantics = self._mirror_internal_context_to_query_semantics( query_semantics=query_semantics, target_resolution=target_resolution, ) patch_scene_semantics = getattr(self, "_patch_scene_semantics_with_target_resolution", None) if callable(patch_scene_semantics): scene_semantics = patch_scene_semantics( scene_semantics=scene_semantics, operation_contract=operation_contract, target_resolution=target_resolution, ) internal_query_plan = self._build_internal_query_plan( question=effective_q, project_id=project_id, query_semantics=query_semantics, operation_contract=operation_contract, target_resolution=target_resolution, ) query_semantics = self._mirror_internal_context_to_query_semantics( query_semantics=query_semantics, query_plan=internal_query_plan, ) active_context = ( self._get_active_external_qa_context() if hasattr(self, "_get_active_external_qa_context") else {} ) # Keep query_semantics as a compatibility mirror only; internal execution truth moves to the packet. internal_context_packet = self._build_internal_query_context_packet( question=effective_q, project_id=project_id, session_id=session_id, conversation_scope_key=str(active_context.get("conversation_scope_key") or "").strip() or None, reply_to_message_id=str(active_context.get("reply_to_message_id") or "").strip() or None, root_message_id=str(active_context.get("root_message_id") or "").strip() or None, route_decision=route_decision, operation_contract=operation_contract, target_resolution=target_resolution, query_plan=internal_query_plan, ) precheck_response = await self._maybe_return_internal_context_precheck_response( question=clean_q, effective_question=effective_q, asked_by=asked_by, asked_via=asked_via, project_id=project_id, session_id=session_id, context_session_id=context_session_id, turn_index=turn_index, state_row=state_row, rewrite_meta=rewrite_meta, thinking_mode=active_thinking_mode, query_type=query_type, route_decision=route_decision, query_semantics=query_semantics, internal_context_packet=internal_context_packet, ) if precheck_response is not None: return precheck_response if planner.allow_fast_path and not prefers_external_retrieval: deterministic_result = await self._run_deterministic_query( question=effective_q, project_id=project_id, query_type=query_type, query_semantics=query_semantics, internal_context_packet=internal_context_packet, ) if deterministic_result is not None: return await self._persist_fast_answer( question=clean_q, asked_by=asked_by, asked_via=asked_via, project_id=project_id, fast_result=deterministic_result, session_id=session_id, external_session_id=context_session_id, turn_index=turn_index, query_type=str(deterministic_result.get("query_type") or query_type), missing_fields=list(deterministic_result.get("missing_fields") or []), state_row=state_row, effective_question=effective_q, rewrite_meta=rewrite_meta, thinking_mode=active_thinking_mode, answer_mode=ANSWER_MODE_FAST_PATH, route_decision=route_decision, query_semantics=query_semantics, internal_context_packet=internal_context_packet, ) internal_model_config_fast_answer = None internal_model_config_builder = getattr(self, "_build_internal_model_config_fast_answer", None) if not prefers_external_retrieval and callable(internal_model_config_builder): internal_model_config_fast_answer = await internal_model_config_builder( question=effective_q, query_semantics=query_semantics, internal_context_packet=internal_context_packet, ) if internal_model_config_fast_answer is not None: return await self._persist_fast_answer( question=clean_q, asked_by=asked_by, asked_via=asked_via, project_id=project_id, fast_result=internal_model_config_fast_answer, session_id=session_id, external_session_id=context_session_id, turn_index=turn_index, query_type=QUERY_TYPE_STATUS, missing_fields=[], state_row=state_row, effective_question=effective_q, rewrite_meta=rewrite_meta, thinking_mode=active_thinking_mode, answer_mode=ANSWER_MODE_FAST_PATH, route_decision=route_decision, query_semantics=query_semantics, internal_context_packet=internal_context_packet, ) direct_answer = None allow_snapshot_direct_answer = planner.allow_fast_path and not prefers_external_retrieval snapshot_direct_guard = getattr(self, "_should_allow_snapshot_direct_answer", None) if callable(snapshot_direct_guard): allow_snapshot_direct_answer = allow_snapshot_direct_answer and snapshot_direct_guard( scene_semantics=scene_semantics, operation_contract=operation_contract, target_resolution=target_resolution, ) if allow_snapshot_direct_answer: direct_answer = self._build_snapshot_direct_answer( effective_q, system_snapshot=system_snapshot, user_snapshot=user_snapshot, snapshot_focus=str((scene_semantics or {}).get("snapshot_focus") or "none"), ) direct_result = None if allow_snapshot_direct_answer: direct_result = await self._maybe_return_snapshot_direct_response( direct_answer=direct_answer, started=started, clean_q=clean_q, effective_q=effective_q, asked_by=asked_by, asked_via=asked_via, project_id=project_id, session_id=session_id, turn_index=turn_index, state_row=state_row, rewrite_meta=rewrite_meta, context_session_id=context_session_id, active_thinking_mode=active_thinking_mode, user_snapshot=user_snapshot, route_decision=route_decision, ) if direct_result is not None: return direct_result is_snapshot_direct_question = str((scene_semantics or {}).get("snapshot_focus") or "none").strip().lower() != "none" if planner.allow_fast_path and not prefers_external_retrieval and not is_snapshot_direct_question: glm_semantic_result = await self._try_glm_project_semantic_answer( clean_q=effective_q, project_id=project_id, query_semantics=query_semantics, internal_context_packet=internal_context_packet, ) if glm_semantic_result is not None: return await self._persist_fast_answer( question=clean_q, asked_by=asked_by, asked_via=asked_via, project_id=project_id, fast_result=glm_semantic_result, session_id=session_id, external_session_id=context_session_id, turn_index=turn_index, query_type=query_type if query_type != QUERY_TYPE_UNKNOWN else QUERY_TYPE_EXPLAIN, missing_fields=[], state_row=state_row, effective_question=effective_q, rewrite_meta=rewrite_meta, thinking_mode=active_thinking_mode, answer_mode=ANSWER_MODE_FAST_PATH, route_decision=route_decision, query_semantics=query_semantics, internal_context_packet=internal_context_packet, ) return await self._build_retrieval_response( clean_q=clean_q, effective_q=effective_q, asked_by=asked_by, asked_via=asked_via, project_id=project_id, source_chat_id=source_chat_id, session_id=session_id, turn_index=turn_index, context_session_id=context_session_id, conversation=conversation, state_row=state_row, rewrite_meta=rewrite_meta, query_type=query_type, query_semantics=query_semantics, retrieval_domains=retrieval_domains, scene_semantics=scene_semantics, thinking_mode=thinking_mode, active_thinking_mode=active_thinking_mode, deep_thinking=deep_thinking, forced_deep_reason=forced_deep_reason or str(planner.reason or ""), deep_retrieval_steps=deep_retrieval_steps, deep_vector_top_k=deep_vector_top_k, system_snapshot=system_snapshot, user_snapshot=user_snapshot, started=started, message_intent=message_intent, mixed_signal_part=mixed_signal_part, answer_mode=planner.retrieval_answer_mode, consultant_mode_preference=consultant_mode_preference, route_decision=route_decision, internal_context_packet=internal_context_packet, )