Update conversation_logic.py

conversation_logic.py

@@ -24,19 +24,28 @@ DIRECT_SOLVE_PATTERNS = [
     r"\bcalculate\b",
 ]
 
-
 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*hint\s*$",
     r"^\s*next hint\s*:\s*",
+    r"^\s*next hint\s*$",
     r"^\s*another hint\s*:\s*",
+    r"^\s*another hint\s*$",
     r"^\s*walkthrough\s*:\s*",
+    r"^\s*walkthrough\s*$",
     r"^\s*step by step\s*:\s*",
+    r"^\s*step by step\s*$",
     r"^\s*explain\s*:\s*",
+    r"^\s*explain\s*$",
     r"^\s*method\s*:\s*",
+    r"^\s*method\s*$",
+    r"^\s*continue\s*$",
+    r"^\s*go on\s*$",
+    r"^\s*next step\s*$",
 ]
 
 
@@ -80,6 +89,7 @@ def _is_followup_hint_only(text: str) -> bool:
         "go on",
         "walk me through it",
         "step by step",
+        "walkthrough",
     }
 
 
@@ -104,23 +114,22 @@ def _sanitize_question_text(text: str) -> str:
 
     lines = [line.strip() for line in raw.splitlines() if line.strip()]
 
-    # 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 _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"
+        "hint", "next hint", "another hint", "continue", "go on",
+        "walkthrough", "step by step", "solve", "explain", "method"
     }:
         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 not candidate:
+            continue
         if (
             "=" 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)
@@ -195,15 +204,8 @@ def _classify_input_type(raw_user_text: str) -> str:
         return "question"
 
     if any(k in stripped.lower() for k in [
-        "what is",
-        "find",
-        "if ",
-        "how many",
-        "probability",
-        "ratio",
-        "percent",
-        "equation",
-        "integer",
+        "what is", "find", "if ", "how many", "probability", "ratio",
+        "percent", "equation", "integer"
     ]):
         return "question"
 
@@ -252,7 +254,7 @@ def _recover_question_text_from_history(
         return _sanitize_question_text(_extract_question_text(raw_user_text))
 
     if not chat_history:
-        return _sanitize_question_text(_extract_question_text(raw_user_text))
+        return ""
 
     for item in reversed(chat_history):
         role = str(item.get("role", "")).lower()
@@ -265,9 +267,11 @@ def _recover_question_text_from_history(
         if _is_followup_hint_only(low):
             continue
 
-        return _sanitize_question_text(_extract_question_text(text))
+        recovered = _sanitize_question_text(_extract_question_text(text))
+        if recovered:
+            return recovered
 
-    return _sanitize_question_text(_extract_question_text(raw_user_text))
+    return ""
 
 
 def _choose_effective_question_text(
@@ -289,8 +293,10 @@ def _choose_effective_question_text(
             question_text=question_text,
             chat_history=chat_history,
         )
-        cleaned = _sanitize_question_text(recovered)
-        return cleaned, bool(cleaned)
+        if recovered:
+            return recovered, True
+
+        return "", True
 
     if explicit_question:
         return explicit_question, False
@@ -334,7 +340,8 @@ def _update_session_state(
     topic: Optional[str],
     category: Optional[str],
 ) -> Dict[str, Any]:
-    state["question_text"] = question_text
+    if question_text:
+        state["question_text"] = question_text
     state["hint_stage"] = int(hint_stage or 0)
     state["user_last_input_type"] = user_last_input_type
     state["built_on_previous_turn"] = bool(built_on_previous_turn)
@@ -501,18 +508,16 @@ def _build_hint_from_steps(
     fallback: Optional[List[str]] = None,
 ) -> str:
     safe_steps = _safe_steps(steps)
+    stage = max(1, min(int(hint_stage or 1), 3))
+
     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])
+        index = min(stage - 1, len(safe_steps) - 1)
+        return f"- {safe_steps[index]}"
 
     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])
+        index = min(stage - 1, len(fallback) - 1)
+        return f"- {fallback[index]}"
 
     return "- Start by identifying the main relationship in the problem."
 
@@ -531,6 +536,19 @@ def _walkthrough_from_steps(steps: List[str], verbosity: float) -> str:
     return "\n".join(f"- {s}" for s in shown_steps)
 
 
+def _answer_path_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.35 else
+        safe_steps[:3] if verbosity < 0.8 else
+        safe_steps
+    )
+    return "\n".join(f"- {s}" for s in shown_steps)
+
+
 def _compose_reply(
     result: SolverResult,
     intent: str,
@@ -602,14 +620,9 @@ def _compose_reply(
         ])
 
     if intent in {"explain", "method", "concept", "answer"}:
-        if steps:
-            shown_steps = (
-                steps[:1] if verbosity < 0.25 else
-                steps[:2] if verbosity < 0.6 else
-                steps[:3] if verbosity < 0.85 else
-                steps
-            )
-            return "\n".join(f"- {s}" for s in shown_steps)
+        step_reply = _answer_path_from_steps(steps, verbosity=verbosity)
+        if step_reply:
+            return step_reply
 
         if topic == "algebra":
             return "\n".join([
@@ -655,6 +668,29 @@ def _is_direct_solve_request(text: str, intent: str) -> bool:
     return False
 
 
+def _render_local_response(help_mode: str, body: str) -> str:
+    body = (body or "").strip()
+    if not body:
+        return "Let’s work through it."
+
+    if help_mode == "hint":
+        return f"Let’s work through it.\n\nHint:\n{body}"
+
+    if help_mode == "walkthrough":
+        return f"Let’s work through it.\n\nWalkthrough:\n{body}"
+
+    if help_mode == "answer":
+        return f"Let’s work through it.\n\nAnswer path:\n{body}"
+
+    if help_mode == "method":
+        return f"Let’s work through it.\n\nMethod:\n{body}"
+
+    if help_mode == "explain":
+        return f"Let’s work through it.\n\nExplanation:\n{body}"
+
+    return f"Let’s work through it.\n\n{body}"
+
+
 class ConversationEngine:
     def __init__(
         self,
@@ -732,7 +768,9 @@ class ConversationEngine:
             fallback_history_stage=history_hint_stage,
         )
 
-        is_quant = 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",
@@ -740,7 +778,7 @@ class ConversationEngine:
             help_mode=resolved_help_mode,
             answer_letter=None,
             answer_value=None,
-            topic=question_topic,
+            topic=question_topic if is_quant else "general",
             used_retrieval=False,
             used_generator=False,
             internal_answer=None,
@@ -762,7 +800,7 @@ class ConversationEngine:
                 if not result.topic or result.topic in {"general_quant", "general", "unknown"}:
                     result.topic = question_topic
 
-        explainer_result = route_explainer(solver_input)
+        explainer_result = route_explainer(solver_input) if solver_input else None
         explainer_understood = bool(
             explainer_result is not None and getattr(explainer_result, "understood", False)
         )
@@ -774,7 +812,6 @@ class ConversationEngine:
             if explainer_understood else []
         )
 
-        # force the externally resolved mode after solver routing
         result.help_mode = resolved_help_mode
 
         result.meta = result.meta or {}
@@ -790,7 +827,9 @@ class ConversationEngine:
             result.meta["explainer_teaching_points"] = explainer_teaching_points
             result.meta["scaffold"] = explainer_scaffold
 
-        use_solver_steps_for_hint = resolved_help_mode == "hint" and _solver_has_useful_steps(result)
+        use_solver_steps = _solver_has_useful_steps(result)
+        use_solver_steps_for_hint = resolved_help_mode == "hint" and use_solver_steps
+        use_local_render = use_solver_steps and resolved_help_mode in {"answer", "walkthrough", "hint", "method"}
 
         if resolved_help_mode == "explain" and explainer_understood:
             reply = format_explainer_response(
@@ -823,15 +862,19 @@ class ConversationEngine:
                 hint_stage=hint_stage,
                 explainer_scaffold=explainer_scaffold,
             )
-            reply = format_reply(
-                reply_core,
-                tone=tone,
-                verbosity=verbosity,
-                transparency=transparency,
-                help_mode=resolved_help_mode,
-                hint_stage=hint_stage,
-                topic=result.topic,
-            )
+
+            if use_local_render:
+                reply = _render_local_response(resolved_help_mode, reply_core)
+            else:
+                reply = format_reply(
+                    reply_core,
+                    tone=tone,
+                    verbosity=verbosity,
+                    transparency=transparency,
+                    help_mode=resolved_help_mode,
+                    hint_stage=hint_stage,
+                    topic=result.topic,
+                )
 
             if resolved_help_mode != "answer":
                 result.solved = False
@@ -866,8 +909,8 @@ class ConversationEngine:
         result.meta["intent"] = resolved_intent
         result.meta["question_text"] = solver_input or ""
         result.meta["options_count"] = len(options_text or [])
-        result.meta["category"] = inferred_category
-        result.meta["classified_topic"] = question_topic
+        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