Update conversation_logic.py

conversation_logic.py

@@ -48,6 +48,29 @@ CONTROL_PREFIX_PATTERNS = [
     r"^\s*next step\s*$",
 ]
 
+FOLLOWUP_ONLY_INPUTS = {
+    "hint",
+    "a hint",
+    "give me a hint",
+    "can i have a hint",
+    "next hint",
+    "another hint",
+    "next step",
+    "continue",
+    "go on",
+    "walk me through it",
+    "step by step",
+    "walkthrough",
+    "i'm confused",
+    "im confused",
+    "confused",
+    "explain more",
+    "more explanation",
+    "can you explain that",
+    "help me understand",
+    "help",
+}
+
 
 def _clean_text(text: Optional[str]) -> str:
     return (text or "").strip()
@@ -81,25 +104,7 @@ def _extract_question_candidates_from_history_item(item: Dict[str, Any]) -> List
 
 def _is_followup_hint_only(text: str) -> bool:
     low = (text or "").strip().lower()
-    return low in {
-        "hint",
-        "another hint",
-        "next hint",
-        "next step",
-        "first step",
-        "continue",
-        "go on",
-        "walk me through it",
-        "step by step",
-        "walkthrough",
-        "i'm confused",
-        "im confused",
-        "confused",
-        "explain more",
-        "more explanation",
-        "can you explain that",
-        "help me understand",
-    }
+    return low in FOLLOWUP_ONLY_INPUTS
 
 
 def _strip_control_prefix(text: str) -> str:
@@ -137,11 +142,32 @@ def _looks_like_question_text(text: str) -> bool:
             "%" in t,
             bool(re.search(r"\b\d+\s*:\s*\d+\b", t)),
             bool(re.search(r"[a-zA-Z]\s*[\+\-\*/=]", t)),
-            any(k in low for k in [
-                "what is", "find", "if ", "how many", "probability", "ratio",
-                "percent", "equation", "integer", "triangle", "circle",
-                "mean", "median", "average", "remainder", "prime", "factor",
-            ]),
+            any(
+                k in low
+                for k in [
+                    "what is",
+                    "find",
+                    "if ",
+                    "how many",
+                    "probability",
+                    "ratio",
+                    "percent",
+                    "equation",
+                    "integer",
+                    "triangle",
+                    "circle",
+                    "mean",
+                    "median",
+                    "average",
+                    "remainder",
+                    "prime",
+                    "factor",
+                    "divisible",
+                    "area",
+                    "perimeter",
+                    "circumference",
+                ]
+            ),
         ]
     )
 
@@ -154,7 +180,20 @@ def _classify_input_type(raw_user_text: str) -> str:
         return "hint"
     if text in {"next hint", "another hint", "more hint", "more hints", "next step", "continue", "go on"} or text.startswith("next hint:"):
         return "next_hint"
-    if any(x in text for x in ["walkthrough", "step by step", "i'm confused", "im confused", "confused", "explain more", "help me understand"]):
+    if any(
+        x in text
+        for x in [
+            "walkthrough",
+            "step by step",
+            "i'm confused",
+            "im confused",
+            "confused",
+            "explain more",
+            "help me understand",
+            "method",
+            "explain",
+        ]
+    ):
         return "confusion"
     if text.startswith("solve:") or text.startswith("solve "):
         return "solve"
@@ -191,7 +230,12 @@ def _history_hint_stage(chat_history: Optional[List[Dict[str, Any]]]) -> int:
     return min(best, 3)
 
 
-def _recover_question_text(raw_user_text: str, question_text: Optional[str], chat_history: Optional[List[Dict[str, Any]]], input_type: str) -> str:
+def _recover_question_text(
+    raw_user_text: str,
+    question_text: Optional[str],
+    chat_history: Optional[List[Dict[str, Any]]],
+    input_type: str,
+) -> str:
     explicit = _sanitize_question_text(question_text or "")
     if explicit:
         return explicit
@@ -208,7 +252,13 @@ def _recover_question_text(raw_user_text: str, question_text: Optional[str], cha
     return ""
 
 
-def _choose_effective_question_text(raw_user_text: str, question_text: Optional[str], input_type: str, state: Dict[str, Any], chat_history: Optional[List[Dict[str, Any]]]) -> Tuple[str, bool]:
+def _choose_effective_question_text(
+    raw_user_text: str,
+    question_text: Optional[str],
+    input_type: str,
+    state: Dict[str, Any],
+    chat_history: Optional[List[Dict[str, Any]]],
+) -> Tuple[str, bool]:
     explicit_question = _sanitize_question_text(question_text or "")
     stored_question = _sanitize_question_text(state.get("question_text", ""))
     if _is_followup_input(input_type):
@@ -273,12 +323,10 @@ def _normalize_classified_topic(topic: Optional[str], category: Optional[str], q
     has_ratio_form = bool(re.search(r"\b\d+\s*:\s*\d+\b", q))
     has_algebra_form = (
         "=" in q
-        or bool(re.search(r"\b[xyz]\b", q))
+        or bool(re.search(r"\b[xyzabn]\b", q))
         or bool(re.search(r"\d+[a-z]\b", q))
         or bool(re.search(r"\b[a-z]\s*[\+\-\*/=]", q))
     )
-    if has_algebra_form:
-        return "algebra"
     if t not in {"general_quant", "general", "unknown", ""}:
         return t
     if "%" in q or "percent" in q:
@@ -289,10 +337,12 @@ def _normalize_classified_topic(topic: Optional[str], category: Optional[str], q
         return "probability"
     if any(k in q for k in ["divisible", "remainder", "prime", "factor"]):
         return "number_theory"
-    if any(k in q for k in ["circle", "triangle", "perimeter", "area", "circumference"]):
+    if any(k in q for k in ["circle", "triangle", "perimeter", "area", "circumference", "rectangle"]):
         return "geometry"
-    if any(k in q for k in ["mean", "median", "average"]):
+    if any(k in q for k in ["mean", "median", "average", "variability", "standard deviation"]):
         return "statistics" if c == "Quantitative" else "data"
+    if has_algebra_form:
+        return "algebra"
     if c == "DataInsight":
         return "data"
     if c == "Verbal":
@@ -303,7 +353,7 @@ def _normalize_classified_topic(topic: Optional[str], category: Optional[str], q
 
 
 def _strip_bullet_prefix(text: str) -> str:
-    return re.sub(r"^\s*-\s*", "", (text or "").strip())
+    return re.sub(r"^\s*[-•]\s*", "", (text or "").strip())
 
 
 def _safe_steps(steps: List[str]) -> List[str]:
@@ -314,10 +364,6 @@ def _safe_steps(steps: List[str]) -> List[str]:
         r"\bthis gives\b",
         r"\btherefore\b",
         r"\bthus\b",
-        r"\bso x\s*=",
-        r"\bso y\s*=",
-        r"\bx\s*=",
-        r"\by\s*=",
         r"\bresult is\b",
         r"\bfinal answer\b",
     ]
@@ -382,7 +428,9 @@ def _extract_explainer_scaffold(explainer_result: Any) -> Dict[str, Any]:
     }
 
 
-def _get_result_steps(result: SolverResult) -> List[str]:
+def _get_result_steps(result: Optional[SolverResult]) -> List[str]:
+    if result is None:
+        return []
     display_steps = getattr(result, "display_steps", None)
     if isinstance(display_steps, list) and display_steps:
         return _safe_steps(display_steps)
@@ -399,7 +447,9 @@ def _get_result_steps(result: SolverResult) -> List[str]:
     return []
 
 
-def _apply_safe_step_sanitization(result: SolverResult) -> None:
+def _apply_safe_step_sanitization(result: Optional[SolverResult]) -> None:
+    if result is None:
+        return
     safe_steps = _get_result_steps(result)
     result.steps = list(safe_steps)
     setattr(result, "display_steps", list(safe_steps))
@@ -456,8 +506,42 @@ def _is_direct_solve_request(text: str, intent: str) -> bool:
     return False
 
 
+def _is_help_first_mode(help_mode: str) -> bool:
+    return help_mode in {"hint", "walkthrough", "explain", "instruction", "step_by_step"}
+
+
+def _should_try_solver(is_quant: bool, help_mode: str, solver_input: str) -> bool:
+    if not is_quant or not solver_input:
+        return False
+    return help_mode in {"answer", "walkthrough", "instruction", "hint", "step_by_step"}
+
+
+def _should_prefer_question_support(help_mode: str, fallback_pack: Dict[str, Any]) -> bool:
+    if not fallback_pack:
+        return False
+    support_source = str(fallback_pack.get("support_source", "")).strip().lower()
+    has_specific_content = support_source in {"question_bank", "question_id", "question_text"}
+    if help_mode in {"hint", "walkthrough", "instruction", "step_by_step", "explain"}:
+        return has_specific_content or bool(fallback_pack)
+    return False
+
+
+def _minimal_generic_reply(category: Optional[str]) -> str:
+    c = normalize_category(category)
+    if c == "Verbal":
+        return "I can help analyse the wording or logic, but I need the full question text to guide you properly."
+    if c == "DataInsight":
+        return "I can help reason through the data, but I need the full question or chart details to guide you properly."
+    return "Start by identifying the main relationship in the problem."
+
+
 class ConversationEngine:
-    def __init__(self, retriever: Optional[RetrievalEngine] = None, generator: Optional[GeneratorEngine] = None, **kwargs) -> None:
+    def __init__(
+        self,
+        retriever: Optional[RetrievalEngine] = None,
+        generator: Optional[GeneratorEngine] = None,
+        **kwargs,
+    ) -> None:
         self.retriever = retriever
         self.generator = generator
 
@@ -512,12 +596,16 @@ class ConversationEngine:
             resolved_help_mode = "hint"
         elif input_type == "confusion":
             resolved_help_mode = "walkthrough"
+        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))
+        is_quant = bool(solver_input) and (
+            inferred_category == "Quantitative" or is_quant_question(solver_input)
+        )
 
         result = SolverResult(
             domain="quant" if is_quant else "general",
@@ -532,20 +620,12 @@ class ConversationEngine:
         )
 
         solver_result: Optional[SolverResult] = None
-        if is_quant and resolved_help_mode in {"answer", "walkthrough", "instruction", "hint"}:
+        if _should_try_solver(is_quant, resolved_help_mode, solver_input):
             try:
                 solver_result = route_solver(solver_input)
             except Exception:
                 solver_result = None
-            if solver_result is not None:
-                result = solver_result
-                result.domain = "quant"
-                result.meta = result.meta or {}
-                if not result.topic or result.topic in {"general_quant", "general", "unknown"}:
-                    result.topic = question_topic
-
-        _apply_safe_step_sanitization(result)
-        solver_steps = _get_result_steps(result)
+            _apply_safe_step_sanitization(solver_result)
 
         explainer_result = None
         explainer_understood = False
@@ -559,14 +639,6 @@ class ConversationEngine:
             explainer_understood = True
             explainer_scaffold = _extract_explainer_scaffold(explainer_result)
 
-        result.help_mode = resolved_help_mode
-        result.meta = result.meta or {}
-        result.meta["hint_stage"] = hint_stage
-        result.meta["max_stage"] = 3
-        result.meta["recovered_question_text"] = solver_input
-        result.meta["question_id"] = question_id
-
-        use_solver_steps_for_reply = bool(solver_steps)
         fallback_reply_core = ""
         fallback_pack: Dict[str, Any] = {}
         if solver_input:
@@ -574,24 +646,61 @@ class ConversationEngine:
                 question_id=question_id,
                 question_text=solver_input,
                 options_text=options_text,
-                topic=result.topic or question_topic,
+                topic=question_topic,
                 category=inferred_category,
                 help_mode=resolved_help_mode,
                 hint_stage=hint_stage,
                 verbosity=verbosity,
             )
 
-        if resolved_help_mode == "explain" and explainer_understood:
-            reply = format_explainer_response(
-                result=explainer_result,
+        # Merge solver result into base result, but do not let it automatically decide the reply.
+        if solver_result is not None:
+            result = solver_result
+            result.domain = "quant"
+            result.meta = result.meta or {}
+            if not result.topic or result.topic in {"general_quant", "general", "unknown"}:
+                result.topic = question_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)
+
+        result.help_mode = resolved_help_mode
+        result.meta = result.meta or {}
+        result.meta["hint_stage"] = hint_stage
+        result.meta["max_stage"] = 3
+        result.meta["recovered_question_text"] = solver_input
+        result.meta["question_id"] = question_id
+        result.meta["classified_topic"] = question_topic if question_topic else "general"
+        result.meta["explainer_understood"] = explainer_understood
+        result.meta["explainer_scaffold"] = explainer_scaffold
+
+        # Source selection priority:
+        # 1) question-specific fallback for help modes
+        # 2) explainer for explain when specific support is unavailable
+        # 3) solver steps for direct answer / walkthrough fallback
+        # 4) generic fallback
+        if resolved_help_mode == "explain" and prefer_question_support and fallback_reply_core:
+            reply_core = fallback_reply_core
+            result.meta["response_source"] = "question_support"
+            result.meta["question_support_used"] = True
+            result.meta["question_support_source"] = fallback_pack.get("support_source")
+            result.meta["question_support_topic"] = fallback_pack.get("topic")
+            reply = format_reply(
+                reply_core,
                 tone=tone,
                 verbosity=verbosity,
                 transparency=transparency,
                 help_mode=resolved_help_mode,
                 hint_stage=hint_stage,
+                topic=result.topic,
             )
-            result.meta["explainer_used"] = True
-        elif resolved_help_mode == "hint" and explainer_understood and not use_solver_steps_for_reply and not fallback_pack.get("support_source") == "question_bank":
+        elif resolved_help_mode == "explain" and explainer_understood:
             reply = format_explainer_response(
                 result=explainer_result,
                 tone=tone,
@@ -600,26 +709,71 @@ class ConversationEngine:
                 help_mode=resolved_help_mode,
                 hint_stage=hint_stage,
             )
+            result.meta["response_source"] = "explainer"
             result.meta["explainer_used"] = True
+            result.meta["question_support_used"] = False
+        elif _is_help_first_mode(resolved_help_mode) and prefer_question_support and fallback_reply_core:
+            reply_core = fallback_reply_core
+            result.meta["response_source"] = "question_support"
+            result.meta["question_support_used"] = True
+            result.meta["question_support_source"] = fallback_pack.get("support_source")
+            result.meta["question_support_topic"] = fallback_pack.get("topic")
+            reply = format_reply(
+                reply_core,
+                tone=tone,
+                verbosity=verbosity,
+                transparency=transparency,
+                help_mode=resolved_help_mode,
+                hint_stage=hint_stage,
+                topic=result.topic,
+            )
+        elif resolved_help_mode == "answer" and solver_has_steps:
+            reply_core = _answer_path_from_steps(solver_steps, verbosity=verbosity)
+            result.meta["response_source"] = "solver_steps"
+            result.meta["question_support_used"] = False
+            reply = format_reply(
+                reply_core,
+                tone=tone,
+                verbosity=verbosity,
+                transparency=transparency,
+                help_mode=resolved_help_mode,
+                hint_stage=hint_stage,
+                topic=result.topic,
+            )
+        elif resolved_help_mode == "walkthrough" and solver_has_steps and not prefer_question_support:
+            reply_core = _answer_path_from_steps(solver_steps, verbosity=verbosity)
+            result.meta["response_source"] = "solver_steps"
+            result.meta["question_support_used"] = False
+            reply = format_reply(
+                reply_core,
+                tone=tone,
+                verbosity=verbosity,
+                transparency=transparency,
+                help_mode=resolved_help_mode,
+                hint_stage=hint_stage,
+                topic=result.topic,
+            )
+        elif fallback_reply_core:
+            reply_core = fallback_reply_core
+            result.meta["response_source"] = "fallback"
+            result.meta["question_support_used"] = bool(fallback_pack)
+            result.meta["question_support_source"] = fallback_pack.get("support_source")
+            result.meta["question_support_topic"] = fallback_pack.get("topic")
+            reply = format_reply(
+                reply_core,
+                tone=tone,
+                verbosity=verbosity,
+                transparency=transparency,
+                help_mode=resolved_help_mode,
+                hint_stage=hint_stage,
+                topic=result.topic,
+            )
         else:
-            if use_solver_steps_for_reply:
-                reply_core = _answer_path_from_steps(solver_steps, verbosity=verbosity)
-                result.meta["question_support_used"] = False
-            elif fallback_reply_core:
-                reply_core = fallback_reply_core
-                result.meta["question_support_used"] = True
-                result.meta["question_support_source"] = fallback_pack.get("support_source")
-                result.meta["question_support_topic"] = fallback_pack.get("topic")
-            elif inferred_category == "Verbal":
-                reply_core = "I can help analyse the wording or logic, but I need the full question text to guide you properly."
-                result.meta["question_support_used"] = False
-            elif inferred_category == "DataInsight":
-                reply_core = "I can help reason through the data, but I need the full question or chart details to guide you properly."
-                result.meta["question_support_used"] = False
-            else:
-                reply_core = "- Start by identifying the main relationship in the problem."
-                result.meta["question_support_used"] = False
-
+            reply_core = _minimal_generic_reply(inferred_category)
+            if not reply_core.startswith("- "):
+                reply_core = f"- {reply_core}"
+            result.meta["response_source"] = "generic"
+            result.meta["question_support_used"] = False
             reply = format_reply(
                 reply_core,
                 tone=tone,
@@ -630,17 +784,18 @@ class ConversationEngine:
                 topic=result.topic,
             )
 
-        if resolved_help_mode in {"hint", "walkthrough", "explain", "instruction"}:
+        # Never reveal final answers during tutoring/help modes.
+        if resolved_help_mode in {"hint", "walkthrough", "explain", "instruction", "step_by_step"}:
             result.solved = False
             result.answer_letter = None
             result.answer_value = None
             result.internal_answer = None
             result.meta["internal_answer"] = None
 
-        result.meta["can_reveal_answer"] = bool(
-            result.solved and _is_direct_solve_request(user_text or solver_input, resolved_intent) and hint_stage >= 3
-        )
-        if not result.meta.get("can_reveal_answer", False):
+        # Only allow answer metadata to survive for true direct solve requests.
+        can_reveal_answer = bool(result.solved and direct_solve_request and not _is_help_first_mode(resolved_help_mode))
+        result.meta["can_reveal_answer"] = can_reveal_answer
+        if not can_reveal_answer:
             result.answer_letter = None
             result.answer_value = None
             result.internal_answer = None
@@ -666,8 +821,9 @@ class ConversationEngine:
         result.meta["question_text"] = solver_input or ""
         result.meta["options_count"] = len(options_text or [])
         result.meta["category"] = inferred_category if inferred_category else "General"
-        result.meta["classified_topic"] = question_topic if question_topic else "general"
         result.meta["user_last_input_type"] = input_type
         result.meta["built_on_previous_turn"] = built_on_previous_turn
         result.meta["session_state"] = state
-        return result
+        result.meta["used_retrieval"] = False
+        result.meta["used_generator"] = False
+        return result