Update conversation_logic.py

conversation_logic.py

@@ -69,7 +69,6 @@ MISMATCH_TERMS = {
     "number_theory": ["circle", "triangle", "median salary"],
 }
 
-
 def _normalize_classified_topic(topic: Optional[str], category: Optional[str], question_text: str) -> str:
     t = (topic or "").strip().lower()
     q = (question_text or "").lower()
@@ -80,7 +79,7 @@ def _normalize_classified_topic(topic: Optional[str], category: Optional[str], q
 
     if "%" in q or "percent" in q:
         return "percent"
-    if "ratio" in q or ":" in q:
+    if "ratio" in q or re.search(r"\b\d+\s*:\s*\d+\b", q):
         return "ratio"
     if "probability" in q or "chosen at random" in q:
         return "probability"
@@ -115,10 +114,6 @@ def _teaching_lines(chunks: List[RetrievedChunk]) -> List[str]:
 
 
 def _safe_steps(steps: List[str]) -> List[str]:
-    """
-    Defensive cleanup in case any solver step accidentally contains
-    explicit final-answer phrasing.
-    """
     cleaned: List[str] = []
     banned_patterns = [
         r"\bthe answer is\b",
@@ -174,12 +169,12 @@ def _compose_reply(
         return steps[0]
 
     if normalize_category(category) == "Verbal":
-        return "I can help analyse the wording or logic, but I do not have a full verbal solver yet."
+        return "I can help analyse the wording or logic, but I need the full question text to guide you properly."
 
     if normalize_category(category) == "DataInsight":
-        return "I can help reason through the data, but I cannot confidently solve this from the current parse alone yet."
+        return "I can help reason through the data, but I need the full question or chart details to guide you properly."
 
-    return "I can help with this, but I cannot confidently solve it from the current parse alone yet."
+    return "I can help with this, but I need the full question text to guide you properly."
 
 
 def _normalize_text(text: str) -> str:
@@ -215,7 +210,7 @@ def _infer_structure_terms(question_text: str, topic: Optional[str], question_ty
         terms.extend(["multiply", "undo operations"])
     if "%" in q or "percent" in q:
         terms.extend(["percent", "percentage"])
-    if "ratio" in q:
+    if "ratio" in q or re.search(r"\b\d+\s*:\s*\d+\b", q):
         terms.extend(["ratio", "proportion"])
     if "mean" in q or "average" in q:
         terms.extend(["mean", "average"])
@@ -404,6 +399,117 @@ def _build_retrieval_query(
     return " ".join(parts).strip()
 
 
+def _fallback_more_info_reply(
+    category: Optional[str],
+    topic: Optional[str],
+    intent: str,
+) -> str:
+    normalized_category = normalize_category(category)
+
+    if normalized_category == "Quantitative" or topic in {
+        "algebra", "percent", "ratio", "probability", "number_theory", "geometry", "statistics", "quant"
+    }:
+        if intent in {"walkthrough", "step_by_step", "method", "explain", "hint", "instruction"}:
+            return (
+                "I need the full question wording to guide this properly step by step. "
+                "Please paste the complete problem, and include the answer choices if there are any."
+            )
+        return (
+            "I need the full question wording to help properly. "
+            "Please paste the complete problem, and include the answer choices if there are any."
+        )
+
+    if normalized_category == "DataInsight":
+        return (
+            "I need the full chart, table, or question wording to help properly. "
+            "Please send the complete prompt and any answer choices."
+        )
+
+    if normalized_category == "Verbal":
+        return (
+            "I need the full passage, sentence, or question wording to help properly. "
+            "Please paste the complete text and any answer choices."
+        )
+
+    return (
+        "I need a bit more information to help properly. "
+        "Please send the full question or exact wording."
+    )
+
+
+def _is_bad_generated_reply(text: str, user_text: str = "") -> bool:
+    t = (text or "").strip()
+    tl = t.lower()
+    ul = (user_text or "").strip().lower()
+
+    if not t:
+        return True
+
+    if len(t) < 12:
+        return True
+
+    bad_exact = {
+        "0",
+        "formula",
+        "formula formula",
+        "the answer",
+        "answer only",
+        "unknown",
+        "none",
+        "n/a",
+    }
+    if tl in bad_exact:
+        return True
+
+    bad_substrings = [
+        "if the problem is not fully solvable",
+        "if the problem is not fully solvable from the parse",
+        "give the test a chance to solve it",
+        "use the formula formula",
+        "cannot parse alone yet",
+        "i cannot parse",
+        "current parse alone",
+        "from the parse alone",
+    ]
+    if any(b in tl for b in bad_substrings):
+        return True
+
+    banned_answer_patterns = [
+        r"\bthe answer is\b",
+        r"\banswer:\b",
+        r"\bx\s*=",
+        r"\by\s*=",
+        r"\btherefore\b",
+        r"\bthat gives\b",
+        r"\bresult is\b",
+    ]
+    if any(re.search(p, tl) for p in banned_answer_patterns):
+        return True
+
+    words = re.findall(r"\b\w+\b", tl)
+    if len(words) >= 4:
+        unique_ratio = len(set(words)) / max(1, len(words))
+        if unique_ratio < 0.45:
+            return True
+
+    user_keywords = _extract_keywords(ul)
+    gen_keywords = _extract_keywords(tl)
+    if user_keywords and gen_keywords:
+        overlap = user_keywords.intersection(gen_keywords)
+        if len(overlap) == 0 and len(t) < 180:
+            return True
+
+    nonsense_patterns = [
+        r"\bformula\s+formula\b",
+        r"\btest\s+a\s+chance\s+to\s+solve\b",
+        r"^[\W_]*\d+[\W_]*$",
+    ]
+    if any(re.search(p, tl) for p in nonsense_patterns):
+        return True
+
+    return False
+
+
 class ConversationEngine:
     def __init__(
         self,
@@ -445,8 +551,6 @@ class ConversationEngine:
         resolved_intent = intent or detect_intent(user_text, help_mode)
         resolved_help_mode = help_mode or intent_to_help_mode(resolved_intent)
 
-        # Critical change:
-        # never reveal answers from this layer, regardless of transparency/help mode
         result = SolverResult(
             domain="general",
             solved=False,
@@ -530,7 +634,12 @@ class ConversationEngine:
         if selected_chunks and resolved_help_mode != "answer":
             reply = f"{reply}\n\nRelevant study notes:\n" + "\n".join(_teaching_lines(selected_chunks))
 
-        if not result.solved and self.generator is not None:
+        should_try_generator = (
+            self.generator is not None
+            and not result.solved
+        )
+
+        if should_try_generator:
             try:
                 generated = self.generator.generate(
                     user_text=user_text or solver_input,
@@ -540,16 +649,35 @@ class ConversationEngine:
                     retrieval_context=selected_chunks,
                     chat_history=chat_history or [],
                 )
+
                 if generated and generated.strip():
-                    reply = generated.strip()
-                    result.used_generator = True
+                    candidate = generated.strip()
+
+                    if not _is_bad_generated_reply(candidate, user_text or solver_input):
+                        reply = candidate
+                        result.used_generator = True
+                    else:
+                        reply = _fallback_more_info_reply(
+                            category=inferred_category,
+                            topic=result.topic,
+                            intent=resolved_intent,
+                        )
+                else:
+                    reply = _fallback_more_info_reply(
+                        category=inferred_category,
+                        topic=result.topic,
+                        intent=resolved_intent,
+                    )
+
             except Exception:
-                pass
+                reply = _fallback_more_info_reply(
+                    category=inferred_category,
+                    topic=result.topic,
+                    intent=resolved_intent,
+                )
 
         reply = format_reply(reply, tone, verbosity, transparency, resolved_help_mode)
 
-        # Critical change:
-        # never expose final answer fields to Unity/client
         result.answer_letter = None
         result.answer_value = None
         result.internal_answer = None