Update conversation_logic.py

conversation_logic.py

@@ -1131,6 +1131,144 @@ class ConversationEngine:
         question_topic = _normalize_classified_topic(classification.get("topic"), inferred_category, solver_input)
 
         resolved_intent = intent or detect_intent(user_text, help_mode)
+                if input_type == "next_hint":
+            resolved_intent = "hint"
+        elif input_type == "confusion":
+            resolved_intent = "method"
+        elif input_type in {"solve", "question"} and resolved_intent in {"hint", "walkthrough", "step_by_step"}:
+            resolved_intent = "answer"
+
+        resolved_help_mode = help_mode or intent_to_help_mode(resolved_intent)
+        if input_type in {"hint", "next_hint"}:
+            resolved_help_mode = "hint"
+        elif input_type == "confusion":
+            resolved_help_mode = "explain"
+        elif resolved_help_mode == "step_by_step":
+            resolved_help_mode = "walkthrough"
+
+        prior_hint_stage = int(state.get("hint_stage", 0) or 0)
+        history_hint_stage = _history_hint_stage(chat_history)
+        hint_stage = _compute_hint_stage(input_type, prior_hint_stage, history_hint_stage)
+
+        is_quant = bool(solver_input) and (
+            inferred_category == "Quantitative" or is_quant_question(solver_input)
+        )
+
+        result = SolverResult(
+            domain="quant" if is_quant else "general",
+            solved=False,
+            help_mode=resolved_help_mode,
+            topic=question_topic if is_quant else "general",
+            used_retrieval=False,
+            used_generator=False,
+            steps=[],
+            teaching_chunks=[],
+            meta={},
+        )
+
+        solver_result: Optional[SolverResult] = None
+        if _should_try_solver(is_quant, resolved_help_mode, solver_input):
+            try:
+                solver_result = route_solver(solver_input)
+            except Exception:
+                solver_result = None
+            _apply_safe_step_sanitization(solver_result)
+
+        explainer_result = None
+        explainer_understood = False
+        explainer_scaffold: Dict[str, Any] = {}
+        if solver_input:
+            try:
+                explainer_result = route_explainer(solver_input)
+            except Exception:
+                explainer_result = None
+        if explainer_result is not None and getattr(explainer_result, "understood", False):
+            explainer_understood = True
+            explainer_scaffold = _extract_explainer_scaffold(explainer_result)
+
+        fallback_reply_core = ""
+        fallback_pack: Dict[str, Any] = {}
+        if solver_input:
+            fallback_reply_core, fallback_pack = _build_fallback_reply(
+                question_id=question_id,
+                question_text=solver_input,
+                options_text=options_text,
+                topic=question_topic,
+                category=inferred_category,
+                help_mode=resolved_help_mode,
+                hint_stage=hint_stage,
+                verbosity=verbosity,
+            )
+
+        question_specific_reply_core = _build_question_specific_reply(
+            question_text=solver_input,
+            options_text=options_text,
+            classified_topic=question_topic,
+            help_mode=resolved_help_mode,
+            input_type=input_type,
+            user_text=user_text,
+        )
+
+        if solver_result is not None:
+            result.meta = result.meta or {}
+            solver_topic = getattr(solver_result, "topic", None) or "unknown"
+
+            compatible_topics = {
+                question_topic,
+                "general_quant",
+                "general",
+                "unknown",
+            }
+
+            if question_topic == "algebra":
+                compatible_topics.update({"ratio"})
+            elif question_topic == "ratio":
+                compatible_topics.update({"algebra"})
+            elif question_topic == "percent":
+                compatible_topics.update({"ratio", "algebra"})
+
+            if solver_topic in compatible_topics:
+                result = solver_result
+                result.domain = "quant"
+                result.meta = result.meta or {}
+                result.topic = question_topic if question_topic else solver_topic
+                result.meta["solver_topic_accepted"] = solver_topic
+            else:
+                result.meta["solver_topic_rejected"] = solver_topic
+                result.meta["solver_topic_expected"] = question_topic
+                result.topic = question_topic if is_quant else result.topic
+        else:
+            result.meta = result.meta or {}
+            result.topic = question_topic if is_quant else result.topic
+
+        _apply_safe_step_sanitization(result)
+        solver_steps = _get_result_steps(result)
+        solver_has_steps = bool(solver_steps)
+        prefer_question_support = _should_prefer_question_support(resolved_help_mode, fallback_pack)
+        direct_solve_request = _is_direct_solve_request(user_text or solver_input, resolved_intent)
+        solver_topic_ok = result.meta.get("solver_topic_rejected") is None
+
+        result.help_mode = resolved_help_mode
+        result.meta = result.meta or {}
+        result.meta["hint_stage"] = hint_stage
+        result.meta["resolved_intent"] = resolved_intent
+        result.meta["input_type"] = input_type
+        result.meta["built_on_previous_turn"] = built_on_previous_turn
+        result.meta["question_topic"] = question_topic
+        result.meta["inferred_category"] = inferred_category
+        result.meta["question_id"] = question_id
+        result.meta["solver_used"] = solver_result is not None
+        result.meta["solver_topic_ok"] = solver_topic_ok
+        result.meta["explainer_used"] = False
+        result.meta["explainer_understood"] = explainer_understood
+        result.meta["question_support_used"] = False
+        result.meta["question_support_topic"] = fallback_pack.get("topic") if fallback_pack else None
+        result.meta["question_support_source"] = fallback_pack.get("support_source") if fallback_pack else None
+        result.meta["question_support_match"] = fallback_pack.get("support_match") if fallback_pack else None
+        result.meta["question_support_strong"] = _support_pack_is_strong(fallback_pack)
+        result.meta["prefer_question_support"] = prefer_question_support
+        result.meta["explainer_scaffold"] = explainer_scaffold
+        
         if input_type in {"hint", "next_hint"}:
             hint_lines: List[str] = []
             support_is_strong = _support_pack_is_strong(fallback_pack)