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
+from typing import Any, Dict, List, Optional, Set, Tuple
 
 from context_parser import detect_intent, intent_to_help_mode
 from formatting import format_reply, format_explainer_response
@@ -85,6 +85,16 @@ def detect_help_mode(text: str) -> str:
     return "explain"
 
 
+def _clean_text(text: Optional[str]) -> str:
+    return (text or "").strip()
+
+
+def _safe_get_state(session_state: Optional[Dict[str, Any]]) -> Dict[str, Any]:
+    if isinstance(session_state, dict):
+        return dict(session_state)
+    return {}
+
+
 def _extract_text_from_history_item(item: Dict[str, Any]) -> str:
     if not isinstance(item, dict):
         return ""
@@ -119,6 +129,102 @@ def _is_followup_hint_only(text: str) -> bool:
     }
 
 
+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
+
+
+def _classify_input_type(raw_user_text: str) -> str:
+    text = _clean_text(raw_user_text)
+    t = text.lower()
+
+    if not t:
+        return "empty"
+
+    if t in {"hint", "a hint", "give me a hint", "can i have a hint"}:
+        return "hint"
+
+    if t in {"next hint", "another hint", "more hint", "more hints", "next step", "continue", "go on"}:
+        return "next_hint"
+
+    if any(x in t for x in [
+        "i don't get it",
+        "i dont get it",
+        "i do not get it",
+        "i'm confused",
+        "im confused",
+        "confused",
+        "explain more",
+        "more explanation",
+        "can you explain that",
+        "help me understand",
+    ]):
+        return "confusion"
+
+    if t.startswith("solve:") or t.startswith("solve "):
+        return "solve"
+
+    if "=" in text and re.search(r"[A-Za-z]", text):
+        return "question"
+
+    if any(k in t for k in [
+        "what is",
+        "find",
+        "if ",
+        "how many",
+        "probability",
+        "ratio",
+        "percent",
+        "equation",
+        "integer",
+    ]):
+        return "question"
+
+    return "other"
+
+
+def _is_followup_input(input_type: str) -> bool:
+    return input_type in {"hint", "next_hint", "confusion"}
+
+
+def _history_hint_stage(chat_history: Optional[List[Dict[str, Any]]]) -> int:
+    if not chat_history:
+        return 0
+
+    best = 0
+    for item in chat_history:
+        if not isinstance(item, dict):
+            continue
+
+        if "hint_stage" in item:
+            try:
+                best = max(best, int(item["hint_stage"]))
+            except Exception:
+                pass
+
+        meta = item.get("meta")
+        if isinstance(meta, dict) and "hint_stage" in meta:
+            try:
+                best = max(best, int(meta["hint_stage"]))
+            except Exception:
+                pass
+
+    return min(best, 3)
+
+
 def _recover_question_text_from_history(
     raw_user_text: str,
     question_text: Optional[str],
@@ -129,10 +235,10 @@ def _recover_question_text_from_history(
         return explicit
 
     if not _is_followup_hint_only(raw_user_text):
-        return (raw_user_text or "").strip()
+        return _extract_question_text(raw_user_text)
 
     if not chat_history:
-        return (raw_user_text or "").strip()
+        return _extract_question_text(raw_user_text)
 
     for item in reversed(chat_history):
         role = str(item.get("role", "")).lower()
@@ -148,9 +254,83 @@ def _recover_question_text_from_history(
         if _is_followup_hint_only(low):
             continue
 
-        return text
+        return _extract_question_text(text)
+
+    return _extract_question_text(raw_user_text)
+
+
+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 = _clean_text(question_text)
+    stored_question = _clean_text(state.get("question_text"))
+
+    if _is_followup_input(input_type):
+        if stored_question:
+            return stored_question, True
+
+        recovered = _recover_question_text_from_history(
+            raw_user_text=raw_user_text,
+            question_text=question_text,
+            chat_history=chat_history,
+        )
+        return _clean_text(recovered), bool(_clean_text(recovered))
+
+    if explicit_question:
+        return explicit_question, False
+
+    return _extract_question_text(raw_user_text), False
+
+
+def _compute_hint_stage(
+    input_type: str,
+    prior_hint_stage: int,
+    fallback_history_stage: int = 0,
+) -> int:
+    prior = int(prior_hint_stage or 0)
+    history = int(fallback_history_stage or 0)
+    base = max(prior, history)
+
+    if input_type in {"solve", "question"}:
+        return 0
+
+    if input_type == "hint":
+        return max(1, base)
+
+    if input_type == "next_hint":
+        return base + 1 if base > 0 else 2
+
+    if input_type == "confusion":
+        return min((base if base > 0 else 1) + 1, 3)
 
-    return (raw_user_text or "").strip()
+    return base
+
+
+def _update_session_state(
+    state: Dict[str, Any],
+    *,
+    question_text: str,
+    hint_stage: int,
+    user_last_input_type: str,
+    built_on_previous_turn: bool,
+    help_mode: str,
+    intent: str,
+    topic: Optional[str],
+    category: Optional[str],
+) -> Dict[str, Any]:
+    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)
+    state["help_mode"] = help_mode
+    state["intent"] = intent
+    state["topic"] = topic
+    state["category"] = category
+    return state
 
 
 def _normalize_classified_topic(topic: Optional[str], category: Optional[str], question_text: str) -> str:
@@ -166,6 +346,9 @@ def _normalize_classified_topic(topic: Optional[str], category: Optional[str], q
         or bool(re.search(r"\b[a-z]\s*[\+\-\*/=]", q))
     )
 
+    if has_algebra_form:
+        return "algebra"
+
     if t == "ratio" and not has_ratio_form and has_algebra_form:
         t = "algebra"
 
@@ -297,10 +480,13 @@ def _build_scaffold_reply(
     next_hint = _safe_meta_text(scaffold.get("next_hint")) if scaffold else None
     setup_actions = _safe_meta_list(scaffold.get("setup_actions", [])) if scaffold else []
     intermediate_steps = _safe_meta_list(scaffold.get("intermediate_steps", [])) if scaffold else []
+    hint_ladder = _safe_meta_list(scaffold.get("hint_ladder", [])) if scaffold else []
 
     target_mode = help_mode or intent
 
     if target_mode == "hint" or intent == "hint":
+        if hint_ladder:
+            return hint_ladder[0]
         return first_move or next_hint or (setup_actions[0] if setup_actions else None) or ask or (teaching_points[0] if teaching_points else None)
 
     if target_mode == "instruction" or intent == "instruction":
@@ -446,71 +632,15 @@ def _is_progression_request(text: str) -> bool:
             "show the steps",
             "go on",
             "continue",
+            "i don't get it",
+            "i dont get it",
+            "i do not get it",
+            "confused",
+            "explain more",
         ]
     )
 
 
-def _history_hint_stage(chat_history: Optional[List[Dict[str, Any]]]) -> int:
-    if not chat_history:
-        return 0
-
-    best = 0
-    for item in chat_history:
-        if not isinstance(item, dict):
-            continue
-
-        if "hint_stage" in item:
-            try:
-                best = max(best, int(item["hint_stage"]))
-            except Exception:
-                pass
-
-        meta = item.get("meta")
-        if isinstance(meta, dict) and "hint_stage" in meta:
-            try:
-                best = max(best, int(meta["hint_stage"]))
-            except Exception:
-                pass
-
-    return min(best, 3)
-
-
-def _resolve_hint_stage(
-    user_text: str,
-    intent: str,
-    help_mode: str,
-    chat_history: Optional[List[Dict[str, Any]]],
-) -> int:
-    history_stage = _history_hint_stage(chat_history)
-    low = (user_text or "").strip().lower()
-
-    if help_mode == "definition":
-        return 0
-
-    if help_mode in {"walkthrough", "step_by_step"}:
-        return 3
-
-    if _is_direct_solve_request(user_text, intent):
-        return 3
-
-    if any(p in low for p in ["next hint", "another hint", "next step", "continue", "go on"]):
-        return min(history_stage + 1, 3)
-
-    if "first step" in low:
-        return max(history_stage, 1)
-
-    if "hint" in low:
-        return max(history_stage, 1)
-
-    if intent in {"method", "instruction", "explain", "concept"}:
-        return max(history_stage, 1)
-
-    if _is_progression_request(low):
-        return min(max(history_stage, 1), 3)
-
-    return history_stage
-
-
 class ConversationEngine:
     def __init__(
         self,
@@ -533,15 +663,23 @@ class ConversationEngine:
         chat_history: Optional[List[Dict[str, Any]]] = None,
         question_text: Optional[str] = None,
         options_text: Optional[List[str]] = None,
+        session_state: Optional[Dict[str, Any]] = None,
         **kwargs,
     ) -> SolverResult:
-        user_text = (raw_user_text or "").strip()
-        recovered_question_text = _recover_question_text_from_history(
+        user_text = _clean_text(raw_user_text)
+        state = _safe_get_state(session_state)
+
+        input_type = _classify_input_type(user_text)
+
+        effective_question_text, built_on_previous_turn = _choose_effective_question_text(
             raw_user_text=user_text,
             question_text=question_text,
+            input_type=input_type,
+            state=state,
             chat_history=chat_history,
         )
-        solver_input = recovered_question_text
+
+        solver_input = effective_question_text
 
         category = normalize_category(kwargs.get("category"))
         classification = classify_question(question_text=solver_input, category=category)
@@ -554,8 +692,21 @@ class ConversationEngine:
         )
 
         resolved_intent = intent or detect_intent(user_text, help_mode)
+
+        if input_type in {"hint", "next_hint"}:
+            resolved_intent = "hint"
+        elif input_type == "confusion":
+            resolved_intent = "walkthrough"
+        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 = "walkthrough"
+
         is_quant = inferred_category == "Quantitative" or is_quant_question(solver_input)
 
         result = SolverResult(
@@ -590,6 +741,18 @@ class ConversationEngine:
             if not result.topic or result.topic in {"general_quant", "general", "unknown"}:
                 result.topic = getattr(explainer_result, "topic", None) if explainer_understood else question_topic
 
+            if result.topic == "ratio":
+                qlow = solver_input.lower()
+                has_ratio_form = bool(re.search(r"\b\d+\s*:\s*\d+\b", qlow))
+                has_algebra_form = (
+                    "=" in qlow
+                    or bool(re.search(r"\b[xyz]\b", qlow))
+                    or bool(re.search(r"\d+[a-z]\b", qlow))
+                    or bool(re.search(r"\b[a-z]\s*[\+\-\*/=]", qlow))
+                )
+                if has_algebra_form and not has_ratio_form:
+                    result.topic = "algebra"
+
         result.meta = result.meta or {}
 
         if explainer_understood:
@@ -600,11 +763,12 @@ class ConversationEngine:
             result.meta["explainer_teaching_points"] = explainer_teaching_points
             result.meta["scaffold"] = explainer_scaffold
 
-        hint_stage = _resolve_hint_stage(
-            user_text=user_text or solver_input,
-            intent=resolved_intent,
-            help_mode=resolved_help_mode,
-            chat_history=chat_history,
+        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=input_type,
+            prior_hint_stage=prior_hint_stage,
+            fallback_history_stage=history_hint_stage,
         )
 
         result.meta["hint_stage"] = hint_stage
@@ -612,7 +776,7 @@ class ConversationEngine:
         result.meta["can_reveal_answer"] = bool(
             result.solved and _is_direct_solve_request(user_text or solver_input, resolved_intent) and hint_stage >= 3
         )
-        result.meta["recovered_question_text"] = recovered_question_text
+        result.meta["recovered_question_text"] = effective_question_text
 
         if explainer_understood:
             reply = format_explainer_response(
@@ -644,12 +808,28 @@ class ConversationEngine:
             result.answer_value = None
             result.internal_answer = None
 
+        state = _update_session_state(
+            state,
+            question_text=effective_question_text,
+            hint_stage=hint_stage,
+            user_last_input_type=input_type,
+            built_on_previous_turn=built_on_previous_turn,
+            help_mode=resolved_help_mode,
+            intent=resolved_intent,
+            topic=result.topic,
+            category=inferred_category,
+        )
+
         result.reply = reply
         result.help_mode = resolved_help_mode
         result.meta["intent"] = resolved_intent
-        result.meta["question_text"] = recovered_question_text or ""
+        result.meta["question_text"] = effective_question_text or ""
         result.meta["options_count"] = len(options_text or [])
         result.meta["category"] = inferred_category
         result.meta["classified_topic"] = question_topic
 
+        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