Update conversation_logic.py

conversation_logic.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import re
-from typing import Any, Dict, List, Optional, Set, Tuple
+from typing import Any, Dict, List, Optional, Tuple
 
 from context_parser import detect_intent, intent_to_help_mode
 from formatting import format_reply, format_explainer_response
@@ -25,6 +25,21 @@ DIRECT_SOLVE_PATTERNS = [
 ]
 
 
+CONTROL_PREFIX_PATTERNS = [
+    r"^\s*solve\s*:\s*",
+    r"^\s*solve\s+",
+    r"^\s*question\s*:\s*",
+    r"^\s*q\s*:\s*",
+    r"^\s*hint\s*:\s*",
+    r"^\s*next hint\s*:\s*",
+    r"^\s*another hint\s*:\s*",
+    r"^\s*walkthrough\s*:\s*",
+    r"^\s*step by step\s*:\s*",
+    r"^\s*explain\s*:\s*",
+    r"^\s*method\s*:\s*",
+]
+
+
 def _clean_text(text: Optional[str]) -> str:
     return (text or "").strip()
 
@@ -68,6 +83,20 @@ def _is_followup_hint_only(text: str) -> bool:
     }
 
 
+def _strip_control_prefix(text: str) -> str:
+    cleaned = (text or "").strip()
+    if not cleaned:
+        return ""
+
+    previous = None
+    while previous != cleaned:
+        previous = cleaned
+        for pattern in CONTROL_PREFIX_PATTERNS:
+            cleaned = re.sub(pattern, "", cleaned, flags=re.I).strip()
+
+    return cleaned
+
+
 def _sanitize_question_text(text: str) -> str:
     raw = (text or "").strip()
     if not raw:
@@ -77,45 +106,33 @@ def _sanitize_question_text(text: str) -> str:
 
     # Unity payload safety: take the actual question line
     if len(lines) >= 9 and re.fullmatch(r"-?\d+", lines[2]) and lines[4].lower() in {"true", "false"}:
-        return lines[1]
+        return _strip_control_prefix(lines[1])
 
     # If the first line is a command and second line looks like the question, use the second line
     if len(lines) >= 2 and lines[0].lower() in {
         "hint", "next hint", "another hint", "continue", "go on", "walkthrough", "step by step", "solve"
     }:
-        return lines[1]
+        return _strip_control_prefix(lines[1])
 
     # If clearly corrupted multiline payload leaked in, use first substantive line that looks like a question/math line
     for line in lines:
+        candidate = _strip_control_prefix(line)
         if (
-            "=" in line
-            or "%" in line
-            or ":" in line
-            or re.search(r"\b(probability|ratio|percent|integer|triangle|circle|mean|median)\b", line.lower())
-            or re.search(r"[a-zA-Z]\s*[\+\-\*/=]", line)
-            or re.search(r"[\+\-\*/=]\s*[a-zA-Z0-9]", line)
+            "=" in candidate
+            or "%" in candidate
+            or ":" in candidate
+            or re.search(r"\b(probability|ratio|percent|integer|triangle|circle|mean|median)\b", candidate.lower())
+            or re.search(r"[a-zA-Z]\s*[\+\-\*/=]", candidate)
+            or re.search(r"[\+\-\*/=]\s*[a-zA-Z0-9]", candidate)
         ):
-            return line
+            return candidate
 
-    return lines[0] if lines else raw
+    return _strip_control_prefix(lines[0] if lines else raw)
 
 
 def _extract_question_text(raw_user_text: str) -> str:
     text = _clean_text(raw_user_text)
-    lowered = text.lower()
-
-    prefixes = [
-        "solve:",
-        "solve ",
-        "question:",
-        "q:",
-    ]
-
-    for p in prefixes:
-        if lowered.startswith(p):
-            return text[len(p):].strip()
-
-    return text
+    return _strip_control_prefix(text)
 
 
 def _classify_input_type(raw_user_text: str) -> str:
@@ -140,6 +157,15 @@ def _classify_input_type(raw_user_text: str) -> str:
     if first in structured_map:
         return structured_map[first]
 
+    if t.startswith("hint:"):
+        return "hint"
+    if t.startswith("next hint:") or t.startswith("another hint:"):
+        return "next_hint"
+    if t.startswith("walkthrough:") or t.startswith("step by step:"):
+        return "confusion"
+    if t.startswith("solve:") or t.startswith("solve "):
+        return "solve"
+
     if t in {"hint", "a hint", "give me a hint", "can i have a hint"}:
         return "hint"
 
@@ -163,13 +189,12 @@ def _classify_input_type(raw_user_text: str) -> str:
     ]):
         return "confusion"
 
-    if t.startswith("solve:") or t.startswith("solve "):
-        return "solve"
+    stripped = _strip_control_prefix(text)
 
-    if "=" in text and re.search(r"[A-Za-z]", text):
+    if "=" in stripped and re.search(r"[A-Za-z]", stripped):
         return "question"
 
-    if any(k in t for k in [
+    if any(k in stripped.lower() for k in [
         "what is",
         "find",
         "if ",
@@ -264,7 +289,8 @@ def _choose_effective_question_text(
             question_text=question_text,
             chat_history=chat_history,
         )
-        return _sanitize_question_text(recovered), bool(_sanitize_question_text(recovered))
+        cleaned = _sanitize_question_text(recovered)
+        return cleaned, bool(cleaned)
 
     if explicit_question:
         return explicit_question, False
@@ -366,12 +392,17 @@ def _normalize_classified_topic(topic: Optional[str], category: Optional[str], q
     return "general"
 
 
+def _strip_bullet_prefix(text: str) -> str:
+    return re.sub(r"^\s*-\s*", "", (text or "").strip())
+
+
 def _safe_steps(steps: List[str]) -> List[str]:
     cleaned: List[str] = []
     banned_patterns = [
         r"\bthe answer is\b",
         r"\banswer:\b",
         r"\bthat gives\b",
+        r"\bthis gives\b",
         r"\btherefore\b",
         r"\bso x\s*=",
         r"\bso y\s*=",
@@ -382,11 +413,12 @@ def _safe_steps(steps: List[str]) -> List[str]:
     ]
 
     for step in steps:
-        s = (step or "").strip()
+        s = _strip_bullet_prefix(step)
         lowered = s.lower()
         if any(re.search(p, lowered) for p in banned_patterns):
             continue
-        cleaned.append(s)
+        if s:
+            cleaned.append(s)
 
     return cleaned
 
@@ -436,41 +468,99 @@ def _extract_explainer_scaffold(explainer_result: Any) -> Dict[str, Any]:
     }
 
 
+def _get_result_steps(result: SolverResult) -> List[str]:
+    display_steps = getattr(result, "display_steps", None)
+    if isinstance(display_steps, list) and display_steps:
+        return _safe_steps(display_steps)
+
+    result_steps = getattr(result, "steps", None)
+    if isinstance(result_steps, list) and result_steps:
+        return _safe_steps(result_steps)
+
+    meta = getattr(result, "meta", {}) or {}
+    meta_display_steps = meta.get("display_steps")
+    if isinstance(meta_display_steps, list) and meta_display_steps:
+        return _safe_steps(meta_display_steps)
+
+    meta_steps = meta.get("steps")
+    if isinstance(meta_steps, list) and meta_steps:
+        return _safe_steps(meta_steps)
+
+    return []
+
+
+def _solver_has_useful_steps(result: Optional[SolverResult]) -> bool:
+    if result is None:
+        return False
+    return len(_get_result_steps(result)) > 0
+
+
+def _build_hint_from_steps(
+    steps: List[str],
+    hint_stage: int,
+    fallback: Optional[List[str]] = None,
+) -> str:
+    safe_steps = _safe_steps(steps)
+    if safe_steps:
+        stage = max(1, min(int(hint_stage or 1), 3))
+        if stage == 1:
+            return f"- {safe_steps[0]}"
+        if stage == 2:
+            return "\n".join(f"- {s}" for s in safe_steps[:2])
+        return "\n".join(f"- {s}" for s in safe_steps[:3])
+
+    fallback = _safe_steps(fallback or [])
+    if fallback:
+        stage = max(1, min(int(hint_stage or 1), 3))
+        return "\n".join(f"- {s}" for s in fallback[:stage])
+
+    return "- Start by identifying the main relationship in the problem."
+
+
+def _walkthrough_from_steps(steps: List[str], verbosity: float) -> str:
+    safe_steps = _safe_steps(steps)
+    if not safe_steps:
+        return ""
+
+    shown_steps = (
+        safe_steps[:2] if verbosity < 0.25 else
+        safe_steps[:3] if verbosity < 0.6 else
+        safe_steps[:4] if verbosity < 0.85 else
+        safe_steps
+    )
+    return "\n".join(f"- {s}" for s in shown_steps)
+
+
 def _compose_reply(
     result: SolverResult,
     intent: str,
     verbosity: float,
     category: Optional[str] = None,
+    hint_stage: int = 0,
+    explainer_scaffold: Optional[Dict[str, Any]] = None,
 ) -> str:
-    steps = _safe_steps(result.steps or [])
+    steps = _get_result_steps(result)
     topic = (result.topic or "").lower()
+    scaffold = explainer_scaffold or {}
+    scaffold_hint_ladder = _safe_meta_list(scaffold.get("hint_ladder", []))
 
     if intent == "hint":
-        return steps[0] if steps else "Start by identifying the main relationship in the problem."
+        return _build_hint_from_steps(steps, hint_stage=hint_stage, fallback=scaffold_hint_ladder)
 
     if intent == "instruction":
-        return (
-            f"First step: {steps[0]}"
-            if steps else
-            "First, identify the key relationship or comparison in the question."
-        )
+        if steps:
+            return f"First step: {steps[0]}"
+        return "First, identify the key relationship or comparison in the question."
 
     if intent == "definition":
-        return (
-            f"Here is the idea in context:\n- {steps[0]}"
-            if steps else
-            "This is asking for the meaning of the term or idea in the question."
-        )
+        if steps:
+            return f"Here is the idea in context:\n- {steps[0]}"
+        return "This is asking for the meaning of the term or idea in the question."
 
     if intent in {"walkthrough", "step_by_step"}:
-        if steps:
-            shown_steps = (
-                steps[:2] if verbosity < 0.25 else
-                steps[:3] if verbosity < 0.6 else
-                steps[:4] if verbosity < 0.85 else
-                steps
-            )
-            return "\n".join(f"- {s}" for s in shown_steps)
+        step_reply = _walkthrough_from_steps(steps, verbosity=verbosity)
+        if step_reply:
+            return step_reply
 
         if topic == "algebra":
             return "\n".join([
@@ -659,6 +749,19 @@ class ConversationEngine:
             meta={},
         )
 
+        solver_result: Optional[SolverResult] = None
+        if is_quant and resolved_help_mode in {"answer", "walkthrough", "instruction", "hint"}:
+            solver_result = route_solver(solver_input)
+            if solver_result is not None:
+                original_meta = result.meta or {}
+                result = solver_result
+                result.domain = "quant"
+                result.meta = result.meta or {}
+                result.meta.update(original_meta)
+
+                if not result.topic or result.topic in {"general_quant", "general", "unknown"}:
+                    result.topic = question_topic
+
         explainer_result = route_explainer(solver_input)
         explainer_understood = bool(
             explainer_result is not None and getattr(explainer_result, "understood", False)
@@ -671,18 +774,6 @@ class ConversationEngine:
             if explainer_understood else []
         )
 
-        if is_quant and resolved_help_mode in {"answer", "walkthrough", "instruction"}:
-            solver_result = route_solver(solver_input)
-            if solver_result is not None:
-                original_meta = result.meta or {}
-                result = solver_result
-                result.domain = "quant"
-                result.meta = result.meta or {}
-                result.meta.update(original_meta)
-
-                if not result.topic or result.topic in {"general_quant", "general", "unknown"}:
-                    result.topic = question_topic
-
         # force the externally resolved mode after solver routing
         result.help_mode = resolved_help_mode
 
@@ -692,14 +783,16 @@ class ConversationEngine:
         result.meta["recovered_question_text"] = solver_input
 
         if explainer_understood:
-            result.meta["explainer_used"] = resolved_help_mode in {"explain", "hint"}
+            result.meta["explainer_used"] = False
             result.meta["bridge_ready"] = bool(explainer_meta.get("bridge_ready", False))
             result.meta["hint_style"] = explainer_meta.get("hint_style")
             result.meta["explainer_summary"] = explainer_summary
             result.meta["explainer_teaching_points"] = explainer_teaching_points
             result.meta["scaffold"] = explainer_scaffold
 
-        if resolved_help_mode in {"explain", "hint"} and explainer_understood:
+        use_solver_steps_for_hint = resolved_help_mode == "hint" and _solver_has_useful_steps(result)
+
+        if resolved_help_mode == "explain" and explainer_understood:
             reply = format_explainer_response(
                 result=explainer_result,
                 tone=tone,
@@ -709,12 +802,26 @@ class ConversationEngine:
                 hint_stage=hint_stage,
             )
             result.solved = False
+            result.meta["explainer_used"] = True
+        elif resolved_help_mode == "hint" and explainer_understood and not use_solver_steps_for_hint:
+            reply = format_explainer_response(
+                result=explainer_result,
+                tone=tone,
+                verbosity=verbosity,
+                transparency=transparency,
+                help_mode=resolved_help_mode,
+                hint_stage=hint_stage,
+            )
+            result.solved = False
+            result.meta["explainer_used"] = True
         else:
             reply_core = _compose_reply(
                 result=result,
                 intent=resolved_intent,
                 verbosity=verbosity,
                 category=inferred_category,
+                hint_stage=hint_stage,
+                explainer_scaffold=explainer_scaffold,
             )
             reply = format_reply(
                 reply_core,
@@ -739,6 +846,7 @@ class ConversationEngine:
             result.answer_letter = None
             result.answer_value = None
             result.internal_answer = None
+            result.meta["internal_answer"] = None
 
         state = _update_session_state(
             state,