Update conversation_logic.py

conversation_logic.py

@@ -1,16 +1,49 @@
 from __future__ import annotations
 
-from context_parser import (
-    mentions_choice_letter,
-    parse_hidden_context,
-    user_is_referring_to_existing_question,
-)
+from typing import Any, Dict, List, Optional
+
+from context_parser import mentions_choice_letter, user_is_referring_to_existing_question
 from formatting import format_reply
 from models import SolverResult
 from quant_solver import extract_choices, is_quant_question, solve_quant
 
 
-def build_choice_explanation(chosen_letter: str, result: SolverResult, choices: dict[str, str], help_mode: str) -> str:
+class ResponseContext:
+    def __init__(
+        self,
+        visible_user_text: str,
+        question_text: str,
+        options_text: str,
+        question_category: str,
+        question_difficulty: str,
+        chat_history: Optional[List[Dict[str, Any]]] = None,
+    ):
+        self.visible_user_text = (visible_user_text or "").strip()
+        self.question_text = (question_text or "").strip()
+        self.options_text = (options_text or "").strip()
+        self.question_category = (question_category or "").strip()
+        self.question_difficulty = (question_difficulty or "").strip()
+        self.chat_history = chat_history or []
+
+    @property
+    def combined_question_block(self) -> str:
+        parts: List[str] = []
+
+        if self.question_text:
+            parts.append(self.question_text)
+
+        if self.options_text:
+            parts.append(self.options_text)
+
+        return "\n".join(parts).strip()
+
+
+def build_choice_explanation(
+    chosen_letter: str,
+    result: SolverResult,
+    choices: dict[str, str],
+    help_mode: str,
+) -> str:
     choice_text = choices.get(chosen_letter, "").strip()
     value_text = result.answer_value.strip() if result.answer_value else ""
 
@@ -18,8 +51,8 @@ def build_choice_explanation(chosen_letter: str, result: SolverResult, choices:
         if value_text and choice_text:
             return f"Work out the value first, then compare it with choice {chosen_letter} ({choice_text})."
         if choice_text:
-            return f"Focus on why choice {chosen_letter} fits the calculation better than the others."
-        return f"Focus on why choice {chosen_letter} matches the calculation."
+            return f"Focus on why choice {chosen_letter} fits better than the others."
+        return f"Focus on whether choice {chosen_letter} matches the result."
 
     if help_mode == "walkthrough":
         if value_text and choice_text:
@@ -29,7 +62,7 @@ def build_choice_explanation(chosen_letter: str, result: SolverResult, choices:
                 f"That is why {chosen_letter} is the correct answer."
             )
         if choice_text:
-            return f"Choice {chosen_letter} matches the result of the calculation, so that is why it is correct."
+            return f"Choice {chosen_letter} matches the result, so that is why it is correct."
         return f"The solved result matches choice {chosen_letter}, so that is why it is correct."
 
     if value_text and choice_text:
@@ -39,7 +72,14 @@ def build_choice_explanation(chosen_letter: str, result: SolverResult, choices:
     return f"Yes — it’s {chosen_letter}."
 
 
-def handle_conversational_followup(ctx, help_mode: str):
+def get_last_assistant_message(chat_history: List[Dict[str, Any]]) -> str:
+    for item in reversed(chat_history or []):
+        if str(item.get("role", "")).strip().lower() == "assistant":
+            return str(item.get("text", "")).strip()
+    return ""
+
+
+def handle_conversational_followup(ctx: ResponseContext, help_mode: str) -> Optional[SolverResult]:
     user_text = ctx.visible_user_text
     lower = user_text.lower().strip()
     question_block = ctx.combined_question_block
@@ -51,7 +91,6 @@ def handle_conversational_followup(ctx, help_mode: str):
         return None
 
     solved = solve_quant(question_block, "answer")
-
     asked_letter = mentions_choice_letter(user_text)
     choices = extract_choices(question_block)
 
@@ -68,6 +107,7 @@ def handle_conversational_followup(ctx, help_mode: str):
 
     if asked_letter and solved.answer_letter and asked_letter != solved.answer_letter:
         correct_choice_text = choices.get(solved.answer_letter, "").strip()
+
         if help_mode == "hint":
             reply = f"Check the calculation again and compare your result with choice {solved.answer_letter}, not {asked_letter}."
         elif help_mode == "walkthrough":
@@ -78,6 +118,7 @@ def handle_conversational_followup(ctx, help_mode: str):
             )
         else:
             reply = f"It is not {asked_letter} — the correct choice is {solved.answer_letter}."
+
         return SolverResult(
             reply=reply,
             domain="quant",
@@ -87,58 +128,72 @@ def handle_conversational_followup(ctx, help_mode: str):
             answer_value=solved.answer_value,
         )
 
-    if lower in {"help", "can you help", "help me", "i dont get it", "i don't get it"}:
-        if help_mode == "hint":
-            reply = solve_quant(question_block, "hint").reply
-        elif help_mode == "walkthrough":
-            reply = solve_quant(question_block, "walkthrough").reply
+    if "what is the question asking" in lower or "what is this asking" in lower:
+        category = ctx.question_category.lower()
+        question_text = ctx.question_text
+
+        if "variability" in question_text.lower() or "data" in category:
+            reply = (
+                "It is asking you to compare how spread out each dataset is and decide which one varies the most."
+            )
         else:
-            reply = solve_quant(question_block, "answer").reply
+            reply = (
+                "It is asking you to identify the main task, extract the relevant numbers or relationships, and then choose the matching option."
+            )
+
         return SolverResult(
             reply=reply,
             domain="quant",
-            solved=solved.solved,
-            help_mode=help_mode,
-            answer_letter=solved.answer_letter,
-            answer_value=solved.answer_value,
+            solved=False,
+            help_mode="hint",
         )
 
+    if lower in {"help", "can you help", "help me", "i dont get it", "i don't get it"}:
+        if help_mode == "hint":
+            return solve_quant(question_block, "hint")
+        if help_mode == "walkthrough":
+            return solve_quant(question_block, "walkthrough")
+        return solve_quant(question_block, "answer")
+
     if "first step" in lower or "how do i start" in lower or "what do i do first" in lower:
-        hint_result = solve_quant(question_block, "hint")
-        return SolverResult(
-            reply=hint_result.reply,
-            domain="quant",
-            solved=hint_result.solved,
-            help_mode="hint",
-            answer_letter=hint_result.answer_letter,
-            answer_value=hint_result.answer_value,
-        )
+        return solve_quant(question_block, "hint")
+
+    if "hint" in lower:
+        return solve_quant(question_block, "hint")
 
     if "why" in lower or "explain" in lower:
         walkthrough_result = solve_quant(question_block, "walkthrough")
         if solved.answer_letter and "why is it" not in lower:
-            choices = extract_choices(question_block)
             choice_text = choices.get(solved.answer_letter, "").strip()
             if choice_text:
-                extra = f"\n\nSo the correct choice is {solved.answer_letter} ({choice_text})."
+                walkthrough_result.reply += f"\n\nSo the correct choice is {solved.answer_letter} ({choice_text})."
             else:
-                extra = f"\n\nSo the correct choice is {solved.answer_letter}."
-            walkthrough_result.reply += extra
+                walkthrough_result.reply += f"\n\nSo the correct choice is {solved.answer_letter}."
         return walkthrough_result
 
-    if "hint" in lower:
-        return solve_quant(question_block, "hint")
-
-    if "answer" in lower or "which one" in lower or "are you sure" in lower:
+    if "answer" in lower or "which one" in lower or "what answer" in lower or "are you sure" in lower:
         return solve_quant(question_block, "answer")
 
+    last_ai = get_last_assistant_message(ctx.chat_history)
+    if last_ai and ("that" in lower or "it" in lower or "why" in lower):
+        return solve_quant(question_block, "walkthrough")
+
     return None
 
 
 def solve_verbal_or_general(user_text: str, help_mode: str) -> SolverResult:
     lower = user_text.lower()
 
-    if any(k in lower for k in ["sentence correction", "grammar", "verbal", "critical reasoning", "reading comprehension"]):
+    if any(
+        k in lower
+        for k in [
+            "sentence correction",
+            "grammar",
+            "verbal",
+            "critical reasoning",
+            "reading comprehension",
+        ]
+    ):
         if help_mode == "hint":
             reply = (
                 "First identify the task:\n"
@@ -148,7 +203,7 @@ def solve_verbal_or_general(user_text: str, help_mode: str) -> SolverResult:
             )
         elif help_mode == "walkthrough":
             reply = (
-                "I can help verbally too, but for now this backend is strongest on quant-style items. "
+                "I can help verbally too, but this backend is strongest on quant-style items. "
                 "For verbal, I’d use elimination based on grammar, logic, scope, or passage support."
             )
         else:
@@ -157,11 +212,11 @@ def solve_verbal_or_general(user_text: str, help_mode: str) -> SolverResult:
         return SolverResult(reply=reply, domain="verbal", solved=False, help_mode=help_mode)
 
     if help_mode == "hint":
-        reply = "I can help. Ask for a hint, an explanation, or the answer, and I’ll use the current in-game question context when available."
+        reply = "I can help. Ask for a hint, an explanation, or the answer."
     elif help_mode == "walkthrough":
-        reply = "I can talk it through step by step using the current in-game question context."
+        reply = "I can talk it through step by step."
     else:
-        reply = "Send a message naturally and I’ll respond using the current question context."
+        reply = "Ask naturally and I’ll help from the current question context when available."
 
     return SolverResult(reply=reply, domain="fallback", solved=False, help_mode=help_mode)
 
@@ -172,12 +227,26 @@ def generate_response(
     verbosity: float,
     transparency: float,
     help_mode: str,
+    hidden_context: str = "",
+    chat_history: Optional[List[Dict[str, Any]]] = None,
+    question_text: str = "",
+    options_text: str = "",
+    question_category: str = "",
+    question_difficulty: str = "",
 ) -> SolverResult:
-    ctx = parse_hidden_context(raw_user_text)
-    visible_user_text = ctx.visible_user_text.strip()
-    question_block = ctx.combined_question_block.strip()
+    ctx = ResponseContext(
+        visible_user_text=raw_user_text,
+        question_text=question_text,
+        options_text=options_text,
+        question_category=question_category,
+        question_difficulty=question_difficulty,
+        chat_history=chat_history,
+    )
+
+    visible_user_text = ctx.visible_user_text
+    question_block = ctx.combined_question_block
 
-    if not raw_user_text.strip():
+    if not visible_user_text:
         result = SolverResult(
             reply="Ask a question and I’ll help using the current in-game context.",
             domain="fallback",
@@ -202,6 +271,6 @@ def generate_response(
         result.reply = format_reply(result.reply, tone, verbosity, transparency, help_mode)
         return result
 
-    result = solve_verbal_or_general(visible_user_text or raw_user_text, help_mode)
+    result = solve_verbal_or_general(visible_user_text, help_mode)
     result.reply = format_reply(result.reply, tone, verbosity, transparency, help_mode)
     return result