Update conversation_logic.py

conversation_logic.py

@@ -55,6 +55,16 @@ FOLLOWUP_ONLY_INPUTS = {
     "can i have a hint",
     "next hint",
     "another hint",
+    "more hint",
+    "more hints",
+    "second hint",
+    "third hint",
+    "second next hint",
+    "what do i do first",
+    "what should i do first",
+    "what do i do next",
+    "what should i do next",
+    "first step",
     "next step",
     "continue",
     "go on",
@@ -293,8 +303,6 @@ def _classify_input_type(raw_user_text: str) -> str:
             "first step",
             "where do i start",
             "how should i start",
-            "give me a hint",
-            "can i have a hint",
         ]
     ):
         return "hint"
@@ -302,19 +310,18 @@ def _classify_input_type(raw_user_text: str) -> str:
     if text in {"hint", "a hint", "give me a hint", "can i have a hint"} or text.startswith("hint:"):
         return "hint"
     if any(
-        p in text
-        for p in [
+        phrase in text
+        for phrase in [
             "next hint",
             "another hint",
             "more hint",
             "more hints",
             "second hint",
             "third hint",
-            "fourth hint",
             "second next hint",
-            "next step",
             "what do i do next",
             "what should i do next",
+            "next step",
             "continue",
             "go on",
         ]
@@ -624,87 +631,6 @@ def _looks_like_simple_linear_equation(question_text: str) -> bool:
     )
 
 
-def _extract_simple_linear_equation_hint_data(question_text: str) -> Optional[Dict[str, Any]]:
-    q = _clean_text(question_text)
-    if not q:
-        return None
-
-    low = q.lower().replace("−", "-").replace("–", "-")
-    low = re.sub(r"\s+", " ", low)
-    var_match = re.search(r"\bwhat is\s+([a-z])\b", low)
-    if not var_match:
-        return None
-    var = var_match.group(1)
-
-    eq_match = re.search(
-        rf"([+-]?\d*)\s*{var}\s*([+-])\s*(\d+(?:\.\d+)?)\s*=\s*([+-]?\d+(?:\.\d+)?)",
-        low,
-    )
-    if not eq_match:
-        eq_match = re.search(
-            rf"([+-]?\d+(?:\.\d+)?)\s*([+-])\s*([+-]?\d*)\s*{var}\s*=\s*([+-]?\d+(?:\.\d+)?)",
-            low,
-        )
-        if not eq_match:
-            return None
-        constant = eq_match.group(1)
-        op = eq_match.group(2)
-        coeff_raw = eq_match.group(3)
-        rhs = eq_match.group(4)
-    else:
-        coeff_raw = eq_match.group(1)
-        op = eq_match.group(2)
-        constant = eq_match.group(3)
-        rhs = eq_match.group(4)
-
-    if coeff_raw in {"", "+", None}:
-        coeff = 1.0
-    elif coeff_raw == "-":
-        coeff = -1.0
-    else:
-        try:
-            coeff = float(coeff_raw)
-        except Exception:
-            return None
-
-    try:
-        const_val = float(constant)
-        rhs_val = float(rhs)
-    except Exception:
-        return None
-
-    first_inverse = "add" if op == "-" else "subtract"
-    after_inverse = rhs_val + const_val if op == "-" else rhs_val - const_val
-    second_inverse = "divide" if abs(coeff) != 1 else "keep"
-    final_value = after_inverse / coeff if coeff != 0 else None
-
-    def _fmt_num(value: float) -> str:
-        try:
-            if float(value).is_integer():
-                return str(int(value))
-        except Exception:
-            pass
-        return str(value)
-
-    return {
-        "variable": var,
-        "coefficient": coeff,
-        "constant": const_val,
-        "rhs": rhs_val,
-        "operator": op,
-        "first_inverse": first_inverse,
-        "after_inverse": after_inverse,
-        "second_inverse": second_inverse,
-        "final_value": final_value,
-        "equation_text": f"{_fmt_num(coeff)}{var} {op} {_fmt_num(const_val)} = {_fmt_num(rhs_val)}",
-        "coefficient_text": _fmt_num(coeff),
-        "constant_text": _fmt_num(const_val),
-        "rhs_text": _fmt_num(rhs_val),
-        "after_inverse_text": _fmt_num(after_inverse),
-        "final_value_text": _fmt_num(final_value) if final_value is not None else None,
-    }
-
-
 def _question_specific_ratio_reply(question_text: str) -> str:
     q = _clean_text(question_text)
     low = q.lower()
@@ -968,18 +894,6 @@ def _question_specific_hint_ladder(
     topic = (classified_topic or "general").lower()
 
     if _looks_like_simple_linear_equation(q) or topic == "algebra":
-        eq_data = _extract_simple_linear_equation_hint_data(q)
-        if eq_data:
-            var = eq_data["variable"]
-            constant_text = eq_data["constant_text"]
-            rhs_text = eq_data["rhs_text"]
-            after_inverse_text = eq_data["after_inverse_text"]
-            coefficient_text = eq_data["coefficient_text"]
-            return [
-                f"Focus on the constant term attached to the variable side: {eq_data['operator']} {constant_text}.",
-                f"Undo that first by {eq_data['first_inverse']}ing {constant_text} on both sides, which changes the right side from {rhs_text} to {after_inverse_text}.",
-                f"Then divide both sides by {coefficient_text} so {var} stands alone.",
-            ]
         return [
             "Look at the variable side and ask which operation is furthest away from the variable.",
             "Undo the addition or subtraction first by doing the opposite on both sides.",
@@ -1140,8 +1054,14 @@ def _should_prefer_question_support(help_mode: str, fallback_pack: Dict[str, Any
     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"}:
+    has_specific_content = support_source in {
+        "question_bank",
+        "question_bank_refined",
+        "question_id",
+        "question_text",
+        "generated_question_specific",
+    }
+    if help_mode in {"hint", "walkthrough", "instruction", "step_by_step", "explain", "method"}:
         return has_specific_content or bool(fallback_pack)
     return False
 
@@ -1323,7 +1243,7 @@ class ConversationEngine:
         result.help_mode = resolved_help_mode
         result.meta = result.meta or {}
         result.meta["hint_stage"] = hint_stage
-        result.meta["max_stage"] = 3
+        result.meta["max_stage"] = 4
         result.meta["recovered_question_text"] = solver_input
         result.meta["question_id"] = question_id
         result.meta["classified_topic"] = question_topic if question_topic else "general"
@@ -1401,14 +1321,21 @@ class ConversationEngine:
         if input_type in {"hint", "next_hint"}:
             hint_lines: List[str] = []
 
-            custom_ladder = _question_specific_hint_ladder(
-                question_text=solver_input,
-                options_text=options_text,
-                classified_topic=question_topic,
-            )
-            if custom_ladder:
-                idx = min(max(hint_stage - 1, 0), len(custom_ladder) - 1)
-                hint_lines = [custom_ladder[idx]]
+            if fallback_pack:
+                fallback_hints = _safe_meta_list(fallback_pack.get("hint_ladder", []))
+                if fallback_hints:
+                    idx = min(max(hint_stage - 1, 0), len(fallback_hints) - 1)
+                    hint_lines = [fallback_hints[idx]]
+
+            if not hint_lines:
+                custom_ladder = _question_specific_hint_ladder(
+                    question_text=solver_input,
+                    options_text=options_text,
+                    classified_topic=question_topic,
+                )
+                if custom_ladder:
+                    idx = min(max(hint_stage - 1, 0), len(custom_ladder) - 1)
+                    hint_lines = [custom_ladder[idx]]
 
             if not hint_lines and explainer_scaffold:
                 ladder = _safe_meta_list(explainer_scaffold.get("hint_ladder", []))
@@ -1423,12 +1350,6 @@ class ConversationEngine:
                 elif next_hint_text:
                     hint_lines = [next_hint_text]
 
-            if not hint_lines and fallback_pack:
-                fallback_hints = _safe_meta_list(fallback_pack.get("hint_ladder", []))
-                if fallback_hints:
-                    idx = min(max(hint_stage - 1, 0), len(fallback_hints) - 1)
-                    hint_lines = [fallback_hints[idx]]
-
             if not hint_lines and fallback_reply_core:
                 split_lines = [line.strip("- ").strip() for line in fallback_reply_core.splitlines() if line.strip()]
                 if split_lines:
@@ -1456,18 +1377,7 @@ class ConversationEngine:
 
         elif question_specific_reply_core and (
             input_type not in {"hint", "next_hint"}
-            and not any(
-                phrase in _clean_text(user_text).lower()
-                for phrase in [
-                    "next hint",
-                    "another hint",
-                    "what do i do next",
-                    "what should i do next",
-                    "next step",
-                    "continue",
-                    "go on",
-                ]
-            )
+            and not (prefer_question_support and fallback_reply_core)
             and (
                 _is_help_first_mode(resolved_help_mode)
                 or input_type in {"other", "confusion"}
@@ -1477,6 +1387,8 @@ class ConversationEngine:
                         "how do i solve",
                         "what do i do first",
                         "what should i do first",
+                        "what do i do next",
+                        "what should i do next",
                         "how should i start",
                     ]
                 )