Update conversation_logic.py

conversation_logic.py

@@ -63,20 +63,76 @@ def _extract_text_from_history_item(item: Dict[str, Any]) -> str:
     if not isinstance(item, dict):
         return ""
 
-    for key in ("content", "text", "message", "question_text", "raw_user_text"):
+    direct_keys = ("content", "text", "message", "question_text", "raw_user_text")
+    for key in direct_keys:
         value = item.get(key)
         if isinstance(value, str) and value.strip():
             return value.strip()
 
     meta = item.get("meta")
     if isinstance(meta, dict):
-        value = meta.get("question_text")
+        for key in ("question_text", "recovered_question_text"):
+            value = meta.get(key)
+            if isinstance(value, str) and value.strip():
+                return value.strip()
+
+        nested_state = meta.get("session_state")
+        if isinstance(nested_state, dict):
+            value = nested_state.get("question_text")
+            if isinstance(value, str) and value.strip():
+                return value.strip()
+
+    nested_state = item.get("session_state")
+    if isinstance(nested_state, dict):
+        value = nested_state.get("question_text")
         if isinstance(value, str) and value.strip():
             return value.strip()
 
     return ""
 
 
+def _extract_question_candidates_from_history_item(item: Dict[str, Any]) -> List[str]:
+    if not isinstance(item, dict):
+        return []
+
+    candidates: List[str] = []
+
+    direct_keys = ("question_text", "raw_user_text", "content", "text", "message")
+    for key in direct_keys:
+        value = item.get(key)
+        if isinstance(value, str) and value.strip():
+            candidates.append(value.strip())
+
+    meta = item.get("meta")
+    if isinstance(meta, dict):
+        for key in ("question_text", "recovered_question_text"):
+            value = meta.get(key)
+            if isinstance(value, str) and value.strip():
+                candidates.append(value.strip())
+
+        nested_state = meta.get("session_state")
+        if isinstance(nested_state, dict):
+            value = nested_state.get("question_text")
+            if isinstance(value, str) and value.strip():
+                candidates.append(value.strip())
+
+    nested_state = item.get("session_state")
+    if isinstance(nested_state, dict):
+        value = nested_state.get("question_text")
+        if isinstance(value, str) and value.strip():
+            candidates.append(value.strip())
+
+    deduped: List[str] = []
+    seen = set()
+    for candidate in candidates:
+        key = candidate.strip().lower()
+        if key and key not in seen:
+            seen.add(key)
+            deduped.append(candidate.strip())
+
+    return deduped
+
+
 def _is_followup_hint_only(text: str) -> bool:
     low = (text or "").strip().lower()
     return low in {
@@ -90,6 +146,13 @@ def _is_followup_hint_only(text: str) -> bool:
         "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",
     }
 
 
@@ -144,6 +207,33 @@ def _extract_question_text(raw_user_text: str) -> str:
     return _strip_control_prefix(text)
 
 
+def _looks_like_question_text(text: str) -> bool:
+    t = (text or "").strip()
+    if not t:
+        return False
+
+    low = t.lower()
+
+    if "=" in t:
+        return True
+    if "%" in t:
+        return True
+    if re.search(r"\b\d+\s*:\s*\d+\b", t):
+        return True
+    if re.search(r"[a-zA-Z]\s*[\+\-\*/=]", t):
+        return True
+    if re.search(r"[\+\-\*/=]\s*[a-zA-Z0-9]", t):
+        return True
+    if 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",
+    ]):
+        return True
+
+    return False
+
+
 def _classify_input_type(raw_user_text: str) -> str:
     text = _clean_text(raw_user_text)
     if not text:
@@ -238,38 +328,51 @@ def _history_hint_stage(chat_history: Optional[List[Dict[str, Any]]]) -> int:
             except Exception:
                 pass
 
+        if isinstance(meta, dict):
+            nested_state = meta.get("session_state")
+            if isinstance(nested_state, dict) and "hint_stage" in nested_state:
+                try:
+                    best = max(best, int(nested_state["hint_stage"]))
+                except Exception:
+                    pass
+
     return min(best, 3)
 
 
-def _recover_question_text_from_history(
+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
 
-    if not _is_followup_hint_only(raw_user_text):
-        return _sanitize_question_text(_extract_question_text(raw_user_text))
+    direct_candidate = _sanitize_question_text(_extract_question_text(raw_user_text))
+    if direct_candidate and _looks_like_question_text(direct_candidate):
+        return direct_candidate
+
+    if not _is_followup_input(input_type):
+        return direct_candidate
 
     if not chat_history:
         return ""
 
     for item in reversed(chat_history):
-        role = str(item.get("role", "")).lower()
-        text = _extract_text_from_history_item(item)
-
-        if not text or role == "assistant":
-            continue
-
-        low = text.lower().strip()
-        if _is_followup_hint_only(low):
-            continue
-
-        recovered = _sanitize_question_text(_extract_question_text(text))
-        if recovered:
-            return recovered
+        candidates = _extract_question_candidates_from_history_item(item)
+        for candidate in candidates:
+            recovered = _sanitize_question_text(candidate)
+            if not recovered:
+                continue
+            if _is_followup_hint_only(recovered):
+                continue
+            if _looks_like_question_text(recovered):
+                return recovered
+
+            extracted = _sanitize_question_text(_extract_question_text(recovered))
+            if extracted and not _is_followup_hint_only(extracted) and _looks_like_question_text(extracted):
+                return extracted
 
     return ""
 
@@ -285,13 +388,21 @@ def _choose_effective_question_text(
     stored_question = _sanitize_question_text(state.get("question_text", ""))
 
     if _is_followup_input(input_type):
-        if stored_question:
+        if explicit_question and _looks_like_question_text(explicit_question):
+            return explicit_question, False
+
+        direct_candidate = _sanitize_question_text(_extract_question_text(raw_user_text))
+        if direct_candidate and _looks_like_question_text(direct_candidate):
+            return direct_candidate, False
+
+        if stored_question and _looks_like_question_text(stored_question):
             return stored_question, True
 
-        recovered = _recover_question_text_from_history(
+        recovered = _recover_question_text(
             raw_user_text=raw_user_text,
             question_text=question_text,
             chat_history=chat_history,
+            input_type=input_type,
         )
         if recovered:
             return recovered, True
@@ -411,6 +522,7 @@ def _safe_steps(steps: List[str]) -> List[str]:
         r"\bthat gives\b",
         r"\bthis gives\b",
         r"\btherefore\b",
+        r"\bthus\b",
         r"\bso x\s*=",
         r"\bso y\s*=",
         r"\bx\s*=",
@@ -422,12 +534,20 @@ def _safe_steps(steps: List[str]) -> List[str]:
     for step in steps:
         s = _strip_bullet_prefix(step)
         lowered = s.lower()
-        if any(re.search(p, lowered) for p in banned_patterns):
+        if any(re.search(pattern, lowered) for pattern in banned_patterns):
             continue
         if s:
             cleaned.append(s)
 
-    return cleaned
+    deduped: List[str] = []
+    seen = set()
+    for step in cleaned:
+        key = step.strip().lower()
+        if key and key not in seen:
+            seen.add(key)
+            deduped.append(step.strip())
+
+    return deduped
 
 
 def _safe_meta_list(items: Any) -> List[str]:
@@ -496,6 +616,17 @@ def _get_result_steps(result: SolverResult) -> List[str]:
     return []
 
 
+def _apply_safe_step_sanitization(result: SolverResult) -> None:
+    safe_steps = _get_result_steps(result)
+
+    result.steps = list(safe_steps)
+    setattr(result, "display_steps", list(safe_steps))
+
+    result.meta = result.meta or {}
+    result.meta["steps"] = list(safe_steps)
+    result.meta["display_steps"] = list(safe_steps)
+
+
 def _solver_has_useful_steps(result: Optional[SolverResult]) -> bool:
     if result is None:
         return False
@@ -533,7 +664,7 @@ def _walkthrough_from_steps(steps: List[str], verbosity: float) -> str:
         safe_steps[:4] if verbosity < 0.85 else
         safe_steps
     )
-    return "\n".join(f"- {s}" for s in shown_steps)
+    return "\n".join(f"- {step}" for step in shown_steps)
 
 
 def _answer_path_from_steps(steps: List[str], verbosity: float) -> str:
@@ -546,7 +677,7 @@ def _answer_path_from_steps(steps: List[str], verbosity: float) -> str:
         safe_steps[:3] if verbosity < 0.8 else
         safe_steps
     )
-    return "\n".join(f"- {s}" for s in shown_steps)
+    return "\n".join(f"- {step}" for step in shown_steps)
 
 
 def _compose_reply(
@@ -567,13 +698,13 @@ def _compose_reply(
 
     if intent == "instruction":
         if steps:
-            return f"First step: {steps[0]}"
-        return "First, identify the key relationship or comparison in the question."
+            return f"- {steps[0]}"
+        return "- First, identify the key relationship or comparison in the question."
 
     if intent == "definition":
         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."
+            return f"- {steps[0]}"
+        return "- This is asking for the meaning of the term or idea in the question."
 
     if intent in {"walkthrough", "step_by_step"}:
         step_reply = _walkthrough_from_steps(steps, verbosity=verbosity)
@@ -668,29 +799,6 @@ 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,
@@ -800,6 +908,8 @@ class ConversationEngine:
                 if not result.topic or result.topic in {"general_quant", "general", "unknown"}:
                     result.topic = question_topic
 
+        _apply_safe_step_sanitization(result)
+
         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)
@@ -829,7 +939,6 @@ class ConversationEngine:
 
         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(
@@ -863,18 +972,15 @@ class ConversationEngine:
                 explainer_scaffold=explainer_scaffold,
             )
 
-            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,
-                )
+            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