Update app.py

app.py

@@ -5,11 +5,10 @@ import ast
 import json
 import math
 import os
-import random
 import re
 from dataclasses import dataclass
 from statistics import mean, median
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Dict, List, Optional
 
 from fastapi import FastAPI, Request
 from fastapi.middleware.cors import CORSMiddleware
@@ -26,7 +25,7 @@ except Exception:
 # App setup
 # =========================================================
 
-app = FastAPI(title="GMAT Solver v2", version="2.0.0")
+app = FastAPI(title="GMAT Solver v3", version="3.0.0")
 
 app.add_middleware(
     CORSMiddleware,
@@ -52,23 +51,40 @@ class ChatRequest(BaseModel):
     verbosity: Optional[float] = 0.5
     transparency: Optional[float] = 0.5
 
-    help_mode: Optional[str] = "answer"   # hint | walkthrough | answer
+    help_mode: Optional[str] = "answer"
     history: Optional[List[Dict[str, Any]]] = None
 
 
 # =========================================================
-# Utilities
+# Data classes
 # =========================================================
 
-CHOICE_LETTERS = ["A", "B", "C", "D", "E"]
-
-
 @dataclass
 class SolverResult:
     reply: str
     domain: str
     solved: bool
     help_mode: str
+    answer_letter: Optional[str] = None
+    answer_value: Optional[str] = None
+
+
+@dataclass
+class ParsedContext:
+    raw_message: str
+    visible_user_text: str
+    full_context_text: str
+    question_text: str
+    options_text: str
+    combined_question_block: str
+    recent_conversation: str
+
+
+# =========================================================
+# Utilities
+# =========================================================
+
+CHOICE_LETTERS = ["A", "B", "C", "D", "E"]
 
 
 def clamp01(x: Any, default: float = 0.5) -> float:
@@ -79,13 +95,6 @@ def clamp01(x: Any, default: float = 0.5) -> float:
         return default
 
 
-def safe_float(x: str) -> Optional[float]:
-    try:
-        return float(x)
-    except Exception:
-        return None
-
-
 def normalize_spaces(text: str) -> str:
     return re.sub(r"\s+", " ", text).strip()
 
@@ -94,26 +103,16 @@ def clean_math_text(text: str) -> str:
     t = text
     t = t.replace("×", "*").replace("÷", "/").replace("–", "-").replace("—", "-")
     t = t.replace("−", "-").replace("^", "**")
-    t = re.sub(r"(\d)\s*%", r"(\1/100)", t)
     return t
 
 
 def extract_text_from_any_payload(payload: Any) -> str:
-    """
-    Robust extractor so the backend still works even if Unity/browser sends:
-    - plain string
-    - {"message":"..."}
-    - {"prompt":"..."}
-    - {"input":{"message":"..."}}
-    - "{\"message\":\"...\"}"  (JSON string)
-    """
     if payload is None:
         return ""
 
     if isinstance(payload, str):
         s = payload.strip()
 
-        # Try JSON string
         if (s.startswith("{") and s.endswith("}")) or (s.startswith("[") and s.endswith("]")):
             try:
                 decoded = json.loads(s)
@@ -121,7 +120,6 @@ def extract_text_from_any_payload(payload: Any) -> str:
             except Exception:
                 pass
 
-        # Try Python dict string
         try:
             decoded = ast.literal_eval(s)
             if isinstance(decoded, (dict, list)):
@@ -140,7 +138,7 @@ def extract_text_from_any_payload(payload: Any) -> str:
                 extracted = extract_text_from_any_payload(payload[key])
                 if extracted:
                     return extracted
-        # Fallback: flatten all string values
+
         strings: List[str] = []
         for v in payload.values():
             if isinstance(v, (str, dict, list)):
@@ -157,25 +155,42 @@ def extract_text_from_any_payload(payload: Any) -> str:
 
 
 def get_user_text(req: ChatRequest, raw_body: Any = None) -> str:
-    # First use typed fields
     for field in ["message", "prompt", "query", "text", "user_message"]:
         value = getattr(req, field, None)
         if isinstance(value, str) and value.strip():
             return value.strip()
 
-    # Then raw request body
     return extract_text_from_any_payload(raw_body).strip()
 
 
-def detect_help_mode(text: str, supplied: Optional[str]) -> str:
-    if supplied in {"hint", "walkthrough", "answer"}:
-        return supplied
-    lower = text.lower()
-    if "hint" in lower:
-        return "hint"
-    if "walkthrough" in lower or "step by step" in lower or "work through" in lower:
-        return "walkthrough"
-    return "answer"
+def style_prefix(tone: float) -> str:
+    if tone < 0.33:
+        return "Let’s solve it efficiently."
+    if tone < 0.66:
+        return "Let’s work through it."
+    return "You’ve got this — let’s solve it cleanly."
+
+
+def format_reply(core: str, tone: float, verbosity: float, transparency: float, help_mode: str) -> str:
+    prefix = style_prefix(tone)
+
+    if help_mode == "hint":
+        if transparency < 0.4:
+            return f"{prefix}\n\nHint: {core}"
+        return f"{prefix}\n\nHint:\n{core}"
+
+    if help_mode == "walkthrough":
+        if verbosity < 0.35:
+            return f"{prefix}\n\n{core}"
+        return f"{prefix}\n\nWalkthrough:\n{core}"
+
+    if verbosity < 0.33:
+        return f"{prefix}\n\n{core}"
+
+    if transparency >= 0.5:
+        return f"{prefix}\n\n{core}"
+
+    return f"{prefix}\n\n{core}"
 
 
 def has_answer_choices(text: str) -> bool:
@@ -190,12 +205,6 @@ def has_answer_choices(text: str) -> bool:
 
 
 def extract_choices(text: str) -> Dict[str, str]:
-    """
-    Supports:
-    A) 5
-    B. 7
-    C: 9
-    """
     matches = list(
         re.finditer(
             r"(?im)(?:^|\n|\s)([A-E])[\)\.\:]\s*(.*?)(?=(?:\n?\s*[A-E][\)\.\:]\s)|$)",
@@ -221,6 +230,160 @@ def extract_numbers(text: str) -> List[float]:
     return out
 
 
+def extract_section(text: str, start_label: str, end_labels: List[str]) -> str:
+    start_idx = text.find(start_label)
+    if start_idx == -1:
+        return ""
+
+    start_idx += len(start_label)
+    remaining = text[start_idx:]
+
+    end_positions = []
+    for label in end_labels:
+        idx = remaining.find(label)
+        if idx != -1:
+            end_positions.append(idx)
+
+    if end_positions:
+        end_idx = min(end_positions)
+        return remaining[:end_idx].strip()
+
+    return remaining.strip()
+
+
+def parse_hidden_context(message: str) -> ParsedContext:
+    raw = message or ""
+
+    visible_user_text = ""
+    question_text = ""
+    options_text = ""
+    recent_conversation = ""
+
+    if "Latest player message:" in raw:
+        visible_user_text = extract_section(raw, "Latest player message:", [])
+    elif "Player message:" in raw:
+        visible_user_text = extract_section(raw, "Player message:", [])
+    else:
+        visible_user_text = raw.strip()
+
+    if "Question:" in raw:
+        question_text = extract_section(
+            raw,
+            "Question:",
+            ["\nOptions:", "\nPlayer balance:", "\nLast outcome:", "\nRecent conversation:", "\nLatest player message:", "\nPlayer message:"]
+        )
+
+    if "Options:" in raw:
+        options_text = extract_section(
+            raw,
+            "Options:",
+            ["\nPlayer balance:", "\nLast outcome:", "\nRecent conversation:", "\nLatest player message:", "\nPlayer message:"]
+        )
+
+    if "Recent conversation:" in raw:
+        recent_conversation = extract_section(
+            raw,
+            "Recent conversation:",
+            ["\nLatest player message:", "\nPlayer message:"]
+        )
+
+    combined_parts = []
+    if question_text:
+        combined_parts.append(question_text.strip())
+    if options_text:
+        combined_parts.append(options_text.strip())
+
+    combined_question_block = "\n".join([p for p in combined_parts if p]).strip()
+    if not combined_question_block:
+        combined_question_block = raw.strip()
+
+    return ParsedContext(
+        raw_message=raw,
+        visible_user_text=visible_user_text.strip(),
+        full_context_text=raw.strip(),
+        question_text=question_text.strip(),
+        options_text=options_text.strip(),
+        combined_question_block=combined_question_block.strip(),
+        recent_conversation=recent_conversation.strip(),
+    )
+
+
+def detect_help_mode(user_text: str, supplied: Optional[str]) -> str:
+    lower = (user_text or "").lower().strip()
+
+    if supplied in {"hint", "walkthrough", "answer"}:
+        if lower not in {"hint", "walkthrough", "answer"}:
+            if "hint" in lower:
+                return "hint"
+            if "walkthrough" in lower or "step by step" in lower or "work through" in lower:
+                return "walkthrough"
+            if "explain" in lower and "why" in lower:
+                return "walkthrough"
+            return supplied
+        return supplied
+
+    if lower in {"hint", "just a hint", "hint please", "small hint"}:
+        return "hint"
+
+    if "hint" in lower:
+        return "hint"
+
+    if (
+        "walkthrough" in lower
+        or "step by step" in lower
+        or "work through" in lower
+        or "explain step by step" in lower
+    ):
+        return "walkthrough"
+
+    if "why" in lower or "explain" in lower:
+        return "walkthrough"
+
+    return "answer"
+
+
+def user_is_referring_to_existing_question(user_text: str, question_text: str) -> bool:
+    lower = (user_text or "").lower().strip()
+
+    if not question_text:
+        return False
+
+    short_refs = {
+        "help", "hint", "why", "why?", "explain", "explain it", "explain this",
+        "answer", "what's the answer", "what is the answer", "is it a", "is it b",
+        "is it c", "is it d", "is it e", "which one", "which option",
+        "what do i do first", "what do i do", "how do i start", "are you sure",
+        "can you help", "help me", "i don't get it", "i dont get it",
+        "why is it c", "why is it b", "why is it a", "why is it d", "why is it e"
+    }
+
+    if lower in short_refs:
+        return True
+
+    if len(lower) <= 25 and any(phrase in lower for phrase in [
+        "is it ", "why", "hint", "explain", "answer", "help", "first step"
+    ]):
+        return True
+
+    return False
+
+
+def mentions_choice_letter(user_text: str) -> Optional[str]:
+    lower = (user_text or "").lower().strip()
+    m = re.search(r"\b(?:is it|answer is|it's|its|option|choice)\s*([a-e])\b", lower)
+    if m:
+        return m.group(1).upper()
+
+    m = re.search(r"\bwhy is it\s*([a-e])\b", lower)
+    if m:
+        return m.group(1).upper()
+
+    if lower in {"a", "b", "c", "d", "e"}:
+        return lower.upper()
+
+    return None
+
+
 def is_quant_question(text: str) -> bool:
     lower = text.lower()
     quant_keywords = [
@@ -238,51 +401,16 @@ def is_quant_question(text: str) -> bool:
     return False
 
 
-def style_prefix(tone: float) -> str:
-    if tone < 0.33:
-        return "Let's solve it efficiently."
-    if tone < 0.66:
-        return "Let's work through it."
-    return "You’ve got this — let’s solve it cleanly."
-
-
-def format_reply(
-    core: str,
-    tone: float,
-    verbosity: float,
-    transparency: float,
-    help_mode: str,
-) -> str:
-    prefix = style_prefix(tone)
-
-    if help_mode == "hint":
-        if transparency < 0.4:
-            return f"{prefix}\n\nHint: {core}"
-        return f"{prefix}\n\nHint:\n{core}"
-
-    if help_mode == "walkthrough":
-        if verbosity < 0.35:
-            return f"{prefix}\n\n{core}"
-        return f"{prefix}\n\nWalkthrough:\n{core}"
-
-    # answer
-    if verbosity < 0.33:
-        return f"{prefix}\n\n{core}"
-    if transparency >= 0.5:
-        return f"{prefix}\n\nAnswer:\n{core}"
-    return f"{prefix}\n\n{core}"
-
-
 # =========================================================
-# Simple quant engine
+# Quant engine
 # =========================================================
 
 def try_eval_expression(expr: str) -> Optional[float]:
     expr = clean_math_text(expr)
     expr = expr.strip()
-
-    # very light cleanup
+    expr = expr.replace("%", "/100")
     expr = re.sub(r"[^0-9\.\+\-\*\/\(\)\s]", "", expr)
+
     if not expr:
         return None
 
@@ -293,11 +421,6 @@ def try_eval_expression(expr: str) -> Optional[float]:
 
 
 def parse_direct_expression_question(text: str) -> Optional[str]:
-    """
-    Examples:
-    - What is 12*8 - 5?
-    - Calculate (15 + 3)/2
-    """
     lower = text.lower()
     m = re.search(
         r"(?:what is|calculate|compute|evaluate|find)\s+([0-9\.\+\-\*\/\(\)\s]+)\??",
@@ -311,51 +434,61 @@ def parse_direct_expression_question(text: str) -> Optional[str]:
     return expr
 
 
-def solve_basic_expression(text: str, help_mode: str) -> Optional[str]:
+def solve_basic_expression(text: str, help_mode: str) -> Optional[SolverResult]:
     expr = parse_direct_expression_question(text)
     if not expr:
         return None
+
     value = try_eval_expression(expr)
     if value is None:
         return None
 
     if help_mode == "hint":
-        return "Focus on order of operations: parentheses, multiplication/division, then addition/subtraction."
-    if help_mode == "walkthrough":
-        return f"Evaluate the expression {expr} using order of operations.\nThat gives {value:g}."
-    return f"The value is {value:g}."
+        reply = "Focus on order of operations: parentheses, multiplication/division, then addition/subtraction."
+    elif help_mode == "walkthrough":
+        reply = f"Evaluate the expression {expr} using order of operations.\nThat gives {value:g}."
+    else:
+        reply = f"The value is {value:g}."
+
+    return SolverResult(reply=reply, domain="quant", solved=True, help_mode=help_mode, answer_value=f"{value:g}")
 
 
-def solve_percent_question(text: str, help_mode: str) -> Optional[str]:
+def solve_percent_question(text: str, help_mode: str) -> Optional[SolverResult]:
     lower = text.lower()
 
-    # "what is 20% of 150"
     m = re.search(r"what is\s+(\d+(?:\.\d+)?)\s*%\s+of\s+(\d+(?:\.\d+)?)", lower)
     if m:
         p = float(m.group(1))
         n = float(m.group(2))
         ans = p / 100 * n
+
         if help_mode == "hint":
-            return "Convert the percent to a decimal, then multiply."
-        if help_mode == "walkthrough":
-            return f"{p}% of {n} = {p/100:g} × {n} = {ans:g}."
-        return f"The answer is {ans:g}."
+            reply = "Convert the percent to a decimal, then multiply."
+        elif help_mode == "walkthrough":
+            reply = f"{p}% of {n} = {p/100:g} × {n} = {ans:g}."
+        else:
+            reply = f"The answer is {ans:g}."
+
+        return SolverResult(reply=reply, domain="quant", solved=True, help_mode=help_mode, answer_value=f"{ans:g}")
 
-    # "x is what percent of y"
     m = re.search(r"(\d+(?:\.\d+)?)\s+is\s+what percent of\s+(\d+(?:\.\d+)?)", lower)
     if m:
         x = float(m.group(1))
         y = float(m.group(2))
         if y == 0:
             return None
+
         ans = x / y * 100
+
         if help_mode == "hint":
-            return "Use part ÷ whole × 100."
-        if help_mode == "walkthrough":
-            return f"Percent = ({x} / {y}) × 100 = {ans:g}%."
-        return f"The answer is {ans:g}%."
+            reply = "Use part ÷ whole × 100."
+        elif help_mode == "walkthrough":
+            reply = f"Percent = ({x} / {y}) × 100 = {ans:g}%."
+        else:
+            reply = f"The answer is {ans:g}%."
+
+        return SolverResult(reply=reply, domain="quant", solved=True, help_mode=help_mode, answer_value=f"{ans:g}%")
 
-    # "increased by 20%" / "decreased by 20%"
     m = re.search(
         r"(\d+(?:\.\d+)?)\s+(?:is\s+)?(increased|decreased)\s+by\s+(\d+(?:\.\d+)?)\s*%",
         lower,
@@ -365,24 +498,33 @@ def solve_percent_question(text: str, help_mode: str) -> Optional[str]:
         direction = m.group(2)
         p = float(m.group(3)) / 100
         ans = base * (1 + p) if direction == "increased" else base * (1 - p)
+
         if help_mode == "hint":
-            return "Use multiplier form: increase → 1 + p, decrease → 1 - p."
-        if help_mode == "walkthrough":
+            reply = "Use multiplier form: increase → 1 + p, decrease → 1 - p."
+        elif help_mode == "walkthrough":
             mult = 1 + p if direction == "increased" else 1 - p
-            return f"Multiplier = {mult:g}, so {base:g} × {mult:g} = {ans:g}."
-        return f"The result is {ans:g}."
+            reply = f"Multiplier = {mult:g}, so {base:g} × {mult:g} = {ans:g}."
+        else:
+            reply = f"The result is {ans:g}."
+
+        return SolverResult(reply=reply, domain="quant", solved=True, help_mode=help_mode, answer_value=f"{ans:g}")
 
     return None
 
 
-def solve_ratio_question(text: str, help_mode: str) -> Optional[str]:
+def solve_ratio_question(text: str, help_mode: str) -> Optional[SolverResult]:
     lower = text.lower()
 
-    # "ratio of a to b is 3:5 and total is 32"
     m = re.search(
         r"ratio of .*? is\s+(\d+)\s*:\s*(\d+).*?total (?:is|of)\s+(\d+(?:\.\d+)?)",
         lower
     )
+    if not m:
+        m = re.search(
+            r"(\d+)\s*:\s*(\d+).*?total (?:is|of)\s+(\d+(?:\.\d+)?)",
+            lower
+        )
+
     if m:
         a = float(m.group(1))
         b = float(m.group(2))
@@ -390,123 +532,144 @@ def solve_ratio_question(text: str, help_mode: str) -> Optional[str]:
         parts = a + b
         if parts == 0:
             return None
+
         first = total * a / parts
         second = total * b / parts
+
         if help_mode == "hint":
-            return "Add the ratio parts, then convert each part into a fraction of the total."
-        if help_mode == "walkthrough":
-            return (
+            reply = "Add the ratio parts, then convert each part into a fraction of the total."
+        elif help_mode == "walkthrough":
+            reply = (
                 f"Total parts = {a:g} + {b:g} = {parts:g}.\n"
                 f"First quantity = {a:g}/{parts:g} × {total:g} = {first:g}.\n"
                 f"Second quantity = {b:g}/{parts:g} × {total:g} = {second:g}."
             )
-        return f"The two quantities are {first:g} and {second:g}."
+        else:
+            reply = f"The two quantities are {first:g} and {second:g}."
+
+        return SolverResult(reply=reply, domain="quant", solved=True, help_mode=help_mode, answer_value=f"{first:g}, {second:g}")
 
     return None
 
 
-def solve_average_question(text: str, help_mode: str) -> Optional[str]:
+def solve_average_question(text: str, help_mode: str) -> Optional[SolverResult]:
     lower = text.lower()
 
     if "mean" in lower or "average" in lower:
         nums = extract_numbers(text)
         if len(nums) >= 2:
             ans = mean(nums)
+
             if help_mode == "hint":
-                return "Add the numbers, then divide by how many there are."
-            if help_mode == "walkthrough":
-                return f"The numbers are {', '.join(f'{x:g}' for x in nums)}.\nTheir average is {ans:g}."
-            return f"The average is {ans:g}."
+                reply = "Add the numbers, then divide by how many there are."
+            elif help_mode == "walkthrough":
+                reply = f"The numbers are {', '.join(f'{x:g}' for x in nums)}.\nTheir average is {ans:g}."
+            else:
+                reply = f"The average is {ans:g}."
+
+            return SolverResult(reply=reply, domain="quant", solved=True, help_mode=help_mode, answer_value=f"{ans:g}")
 
     if "median" in lower:
         nums = extract_numbers(text)
         if len(nums) >= 2:
             ans = median(nums)
+
             if help_mode == "hint":
-                return "Sort the numbers first, then take the middle value."
-            if help_mode == "walkthrough":
+                reply = "Sort the numbers first, then take the middle value."
+            elif help_mode == "walkthrough":
                 s = sorted(nums)
-                return f"Sorted numbers: {', '.join(f'{x:g}' for x in s)}.\nThe median is {ans:g}."
-            return f"The median is {ans:g}."
+                reply = f"Sorted numbers: {', '.join(f'{x:g}' for x in s)}.\nThe median is {ans:g}."
+            else:
+                reply = f"The median is {ans:g}."
+
+            return SolverResult(reply=reply, domain="quant", solved=True, help_mode=help_mode, answer_value=f"{ans:g}")
 
     return None
 
 
-def solve_probability_question(text: str, help_mode: str) -> Optional[str]:
+def solve_probability_question(text: str, help_mode: str) -> Optional[SolverResult]:
     lower = text.lower()
 
-    # Simple "probability of selecting one red from 3 red and 5 blue"
-    m = re.search(
-        r"(\d+)\s+red.*?(\d+)\s+blue.*?probability",
-        lower
-    )
+    m = re.search(r"(\d+)\s+red.*?(\d+)\s+blue.*?probability", lower)
     if m:
         r = float(m.group(1))
         b = float(m.group(2))
         total = r + b
         if total == 0:
             return None
+
         ans = r / total
+
         if help_mode == "hint":
-            return "Probability = favorable outcomes ÷ total outcomes."
-        if help_mode == "walkthrough":
-            return f"Favorable outcomes = {r:g}, total outcomes = {total:g}, so probability = {r:g}/{total:g} = {ans:g}."
-        return f"The probability is {ans:g}."
+            reply = "Probability = favorable outcomes ÷ total outcomes."
+        elif help_mode == "walkthrough":
+            reply = f"Favorable outcomes = {r:g}, total outcomes = {total:g}, so probability = {r:g}/{total:g} = {ans:g}."
+        else:
+            reply = f"The probability is {ans:g}."
+
+        return SolverResult(reply=reply, domain="quant", solved=True, help_mode=help_mode, answer_value=f"{ans:g}")
 
     return None
 
 
-def solve_geometry_question(text: str, help_mode: str) -> Optional[str]:
+def solve_geometry_question(text: str, help_mode: str) -> Optional[SolverResult]:
     lower = text.lower()
 
-    # Rectangle area
     m = re.search(r"rectangle.*?length\s*(?:is|=)?\s*(\d+(?:\.\d+)?)\D+width\s*(?:is|=)?\s*(\d+(?:\.\d+)?)", lower)
     if m and "area" in lower:
         l = float(m.group(1))
         w = float(m.group(2))
         ans = l * w
+
         if help_mode == "hint":
-            return "For a rectangle, area = length × width."
-        if help_mode == "walkthrough":
-            return f"Area = {l:g} × {w:g} = {ans:g}."
-        return f"The area is {ans:g}."
+            reply = "For a rectangle, area = length × width."
+        elif help_mode == "walkthrough":
+            reply = f"Area = {l:g} × {w:g} = {ans:g}."
+        else:
+            reply = f"The area is {ans:g}."
+
+        return SolverResult(reply=reply, domain="quant", solved=True, help_mode=help_mode, answer_value=f"{ans:g}")
 
-    # Circle area
     m = re.search(r"circle.*?radius\s*(?:is|=)?\s*(\d+(?:\.\d+)?)", lower)
     if m and "area" in lower:
         r = float(m.group(1))
         ans = math.pi * r * r
+
         if help_mode == "hint":
-            return "For a circle, area = πr²."
-        if help_mode == "walkthrough":
-            return f"Area = π({r:g})² = {ans:.4f}."
-        return f"The area is {ans:.4f}."
+            reply = "For a circle, area = πr²."
+        elif help_mode == "walkthrough":
+            reply = f"Area = π({r:g})² = {ans:.4f}."
+        else:
+            reply = f"The area is {ans:.4f}."
+
+        return SolverResult(reply=reply, domain="quant", solved=True, help_mode=help_mode, answer_value=f"{ans:.4f}")
 
-    # Triangle area
     m = re.search(r"triangle.*?base\s*(?:is|=)?\s*(\d+(?:\.\d+)?)\D+height\s*(?:is|=)?\s*(\d+(?:\.\d+)?)", lower)
     if m and "area" in lower:
         b = float(m.group(1))
         h = float(m.group(2))
         ans = 0.5 * b * h
+
         if help_mode == "hint":
-            return "Triangle area = 1/2 × base × height."
-        if help_mode == "walkthrough":
-            return f"Area = 1/2 × {b:g} × {h:g} = {ans:g}."
-        return f"The area is {ans:g}."
+            reply = "Triangle area = 1/2 × base × height."
+        elif help_mode == "walkthrough":
+            reply = f"Area = 1/2 × {b:g} × {h:g} = {ans:g}."
+        else:
+            reply = f"The area is {ans:g}."
+
+        return SolverResult(reply=reply, domain="quant", solved=True, help_mode=help_mode, answer_value=f"{ans:g}")
 
     return None
 
 
-def solve_linear_equation(text: str, help_mode: str) -> Optional[str]:
+def solve_linear_equation(text: str, help_mode: str) -> Optional[SolverResult]:
     if sp is None:
         return None
 
     lower = text.lower().replace("^", "**")
 
-    # Find "solve for x: 2x + 3 = 11"
     m = re.search(r"(?:solve for x|find x|value of x).*?([\-0-9a-z\+\*/\s\(\)]+=[\-0-9a-z\+\*/\s\(\)]+)", lower)
     if not m:
-        # Or just something like "2x + 3 = 11"
         m = re.search(r"([\-0-9a-z\+\*/\s\(\)]+=[\-0-9a-z\+\*/\s\(\)]+)", lower)
         if not m:
             return None
@@ -530,10 +693,13 @@ def solve_linear_equation(text: str, help_mode: str) -> Optional[str]:
         sol = sols[0]
 
         if help_mode == "hint":
-            return "Collect the x-terms on one side and constants on the other."
-        if help_mode == "walkthrough":
-            return f"Solve {eq_text} for x.\nThis gives x = {sp.simplify(sol)}."
-        return f"x = {sp.simplify(sol)}."
+            reply = "Collect the x-terms on one side and constants on the other."
+        elif help_mode == "walkthrough":
+            reply = f"Solve {eq_text} for x.\nThis gives x = {sp.simplify(sol)}."
+        else:
+            reply = f"x = {sp.simplify(sol)}."
+
+        return SolverResult(reply=reply, domain="quant", solved=True, help_mode=help_mode, answer_value=str(sp.simplify(sol)))
     except Exception:
         return None
 
@@ -543,13 +709,14 @@ def compare_to_choices_numeric(answer_value: float, choices: Dict[str, str]) ->
     best_diff = float("inf")
 
     for letter, raw in choices.items():
-        # pick first numeric expression in the choice
         expr = raw.strip()
         expr_val = try_eval_expression(expr)
+
         if expr_val is None:
             nums = extract_numbers(expr)
             if len(nums) == 1:
                 expr_val = nums[0]
+
         if expr_val is None:
             continue
 
@@ -558,17 +725,14 @@ def compare_to_choices_numeric(answer_value: float, choices: Dict[str, str]) ->
             best_diff = diff
             best_letter = letter
 
-    if best_letter is None:
-        return None
     return best_letter
 
 
-def solve_by_option_checking(text: str, help_mode: str) -> Optional[str]:
+def solve_by_option_checking(text: str, help_mode: str) -> Optional[SolverResult]:
     choices = extract_choices(text)
     if len(choices) < 3:
         return None
 
-    # Try direct expression in stem
     expr = parse_direct_expression_question(text)
     if expr:
         val = try_eval_expression(expr)
@@ -576,12 +740,14 @@ def solve_by_option_checking(text: str, help_mode: str) -> Optional[str]:
             letter = compare_to_choices_numeric(val, choices)
             if letter:
                 if help_mode == "hint":
-                    return "Evaluate the expression first, then match it to the answer choices."
-                if help_mode == "walkthrough":
-                    return f"The expression evaluates to {val:g}, which matches choice {letter}."
-                return f"The correct choice is {letter}."
+                    reply = "Evaluate the expression first, then match it to the answer choices."
+                elif help_mode == "walkthrough":
+                    reply = f"The expression evaluates to {val:g}, which matches choice {letter}."
+                else:
+                    reply = f"The correct choice is {letter}."
+
+                return SolverResult(reply=reply, domain="quant", solved=True, help_mode=help_mode, answer_letter=letter, answer_value=f"{val:g}")
 
-    # Try percent
     lower = text.lower()
     m = re.search(r"what is\s+(\d+(?:\.\d+)?)\s*%\s+of\s+(\d+(?:\.\d+)?)", lower)
     if m:
@@ -589,29 +755,15 @@ def solve_by_option_checking(text: str, help_mode: str) -> Optional[str]:
         letter = compare_to_choices_numeric(val, choices)
         if letter:
             if help_mode == "hint":
-                return "Compute the percentage, then match it to the options."
-            if help_mode == "walkthrough":
-                return f"{m.group(1)}% of {m.group(2)} = {val:g}, so the correct choice is {letter}."
-            return f"The correct choice is {letter}."
-
-    return None
+                reply = "Compute the percentage, then match it to the options."
+            elif help_mode == "walkthrough":
+                reply = f"{m.group(1)}% of {m.group(2)} = {val:g}, so the correct choice is {letter}."
+            else:
+                reply = f"The correct choice is {letter}."
 
+            return SolverResult(reply=reply, domain="quant", solved=True, help_mode=help_mode, answer_letter=letter, answer_value=f"{val:g}")
 
-def fallback_quant_response(help_mode: str) -> str:
-    if help_mode == "hint":
-        return (
-            "Identify the question type first: arithmetic, percent, ratio, algebra, probability, "
-            "statistics, or geometry. Then extract the given numbers and set up the core relation."
-        )
-    if help_mode == "walkthrough":
-        return (
-            "I can help, but this question needs the full stem to solve properly.\n"
-            "Please paste the complete GMAT-style question including any answer choices A-E."
-        )
-    return (
-        "Please paste the full GMAT-style question, ideally with answer choices A-E, "
-        "so I can solve it directly."
-    )
+    return None
 
 
 def solve_quant(text: str, help_mode: str) -> SolverResult:
@@ -630,110 +782,225 @@ def solve_quant(text: str, help_mode: str) -> SolverResult:
         try:
             out = solver(text, help_mode)
             if out:
-                return SolverResult(
-                    reply=out,
-                    domain="quant",
-                    solved=True,
-                    help_mode=help_mode,
-                )
+                return out
         except Exception:
             pass
 
-    return SolverResult(
-        reply=fallback_quant_response(help_mode),
-        domain="quant",
-        solved=False,
-        help_mode=help_mode,
-    )
+    if help_mode == "hint":
+        reply = (
+            "Identify the question type first: arithmetic, percent, ratio, algebra, probability, "
+            "statistics, or geometry. Then extract the given numbers and set up the core relation."
+        )
+    elif help_mode == "walkthrough":
+        reply = (
+            "I can help with this, but I cannot confidently solve it from the current parse alone. "
+            "I can still talk through the first step or eliminate options if needed."
+        )
+    else:
+        reply = (
+            "I can help with this, but I can’t confidently solve it from the current parse alone yet."
+        )
+
+    return SolverResult(reply=reply, domain="quant", solved=False, help_mode=help_mode)
 
 
 # =========================================================
-# Light verbal / general GMAT support
+# Conversational layer
 # =========================================================
 
-def solve_verbal_or_general(text: str, help_mode: str) -> SolverResult:
-    lower = text.lower()
+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 ""
+
+    if help_mode == "hint":
+        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."
+
+    if help_mode == "walkthrough":
+        if value_text and choice_text:
+            return (
+                f"The calculation gives {value_text}.\n"
+                f"Choice {chosen_letter} is {choice_text}, so it matches.\n"
+                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"The solved result matches choice {chosen_letter}, so that is why it is correct."
+
+    if value_text and choice_text:
+        return f"Yes — it’s {chosen_letter}, because the calculation gives {value_text}, and choice {chosen_letter} is {choice_text}."
+    if choice_text:
+        return f"Yes — it’s {chosen_letter}, because that option matches the result."
+    return f"Yes — it’s {chosen_letter}."
+
+
+def handle_conversational_followup(ctx: ParsedContext, help_mode: str) -> Optional[SolverResult]:
+    user_text = ctx.visible_user_text
+    lower = user_text.lower().strip()
+    question_block = ctx.combined_question_block
+
+    if not question_block:
+        return None
+
+    if not user_is_referring_to_existing_question(user_text, ctx.question_text):
+        return None
+
+    solved = solve_quant(question_block, "answer")
+
+    asked_letter = mentions_choice_letter(user_text)
+    choices = extract_choices(question_block)
+
+    if asked_letter and solved.answer_letter and asked_letter == solved.answer_letter:
+        reply = build_choice_explanation(asked_letter, solved, choices, help_mode)
+        return SolverResult(
+            reply=reply,
+            domain="quant",
+            solved=solved.solved,
+            help_mode=help_mode,
+            answer_letter=solved.answer_letter,
+            answer_value=solved.answer_value,
+        )
+
+    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":
+            reply = (
+                f"It is not {asked_letter}.\n"
+                f"The calculation leads to choice {solved.answer_letter}"
+                + (f", which is {correct_choice_text}." if correct_choice_text else ".")
+            )
+        else:
+            reply = f"It is not {asked_letter} — the correct choice is {solved.answer_letter}."
+        return SolverResult(
+            reply=reply,
+            domain="quant",
+            solved=solved.solved,
+            help_mode=help_mode,
+            answer_letter=solved.answer_letter,
+            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
+        else:
+            reply = solve_quant(question_block, "answer").reply
+        return SolverResult(reply=reply, domain="quant", solved=solved.solved, help_mode=help_mode, answer_letter=solved.answer_letter, answer_value=solved.answer_value)
+
+    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,
+        )
+
+    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})."
+            else:
+                extra = f"\n\nSo the correct choice is {solved.answer_letter}."
+            walkthrough_result.reply += extra
+        return walkthrough_result
+
+    if "hint" in lower:
+        hint_result = solve_quant(question_block, "hint")
+        return hint_result
+
+    if "answer" in lower or "which one" in lower or "are you sure" in lower:
+        answer_result = solve_quant(question_block, "answer")
+        return answer_result
+
+    return None
+
+
+# =========================================================
+# Main response logic
+# =========================================================
+
+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 help_mode == "hint":
             reply = (
-                "For GMAT verbal, first identify the task:\n"
+                "First identify the task:\n"
                 "- Sentence Correction: grammar + meaning\n"
                 "- Critical Reasoning: conclusion, evidence, assumption\n"
                 "- Reading Comprehension: passage role, inference, detail"
             )
         elif help_mode == "walkthrough":
             reply = (
-                "Paste the full verbal question and all answer choices A-E.\n"
-                "I can then eliminate choices based on grammar, logic, scope, or passage support."
+                "I can help verbally too, but for now this backend is strongest on quant-style items. "
+                "For verbal, I’d use elimination based on grammar, logic, scope, or passage support."
             )
         else:
-            reply = (
-                "Paste the full verbal question with answer choices A-E and I’ll help eliminate the options."
-            )
+            reply = "I can help with verbal strategy, but this version is strongest on quant-style questions right now."
+
         return SolverResult(reply=reply, domain="verbal", solved=False, help_mode=help_mode)
 
-    return SolverResult(
-        reply=(
-            "Paste the full GMAT-style question, ideally with answer choices A-E.\n"
-            "I can handle:\n"
-            "- arithmetic, percentages, ratios, algebra, basic statistics, probability, geometry\n"
-            "- option checking for multiple-choice quant questions\n"
-            "- strategy help for verbal questions\n"
-            "Also tell me whether you want a hint, a walkthrough, or just the final answer."
-        ),
-        domain="fallback",
-        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."
+    elif help_mode == "walkthrough":
+        reply = "I can talk it through step by step using the current in-game question context."
+    else:
+        reply = "Send a message naturally and I’ll respond using the current question context."
 
+    return SolverResult(reply=reply, domain="fallback", solved=False, help_mode=help_mode)
 
-# =========================================================
-# Main chat logic
-# =========================================================
 
 def generate_response(
-    user_text: str,
+    raw_user_text: str,
     tone: float,
     verbosity: float,
     transparency: float,
     help_mode: str,
 ) -> SolverResult:
-    text = user_text.strip()
+    ctx = parse_hidden_context(raw_user_text)
+    visible_user_text = ctx.visible_user_text.strip()
+    question_block = ctx.combined_question_block.strip()
 
-    if not text:
-        return SolverResult(
-            reply=(
-                "Paste the GMAT-style question and I’ll solve it.\n"
-                "Include answer choices A-E if it’s multiple choice."
-            ),
+    if not raw_user_text.strip():
+        result = SolverResult(
+            reply="Ask a question and I’ll help using the current in-game context.",
             domain="fallback",
             solved=False,
             help_mode=help_mode,
         )
-
-    # If the user asks for modes explicitly
-    if text.lower() in {"hint", "walkthrough", "answer"}:
-        return SolverResult(
-            reply="Got it. Now paste the full question.",
-            domain="control",
-            solved=False,
-            help_mode=text.lower(),
-        )
-
-    # Quant vs verbal/fallback
-    if is_quant_question(text):
-        result = solve_quant(text, help_mode)
-    else:
-        result = solve_verbal_or_general(text, help_mode)
-
-    result.reply = format_reply(
-        core=result.reply,
-        tone=tone,
-        verbosity=verbosity,
-        transparency=transparency,
-        help_mode=help_mode,
-    )
+        result.reply = format_reply(result.reply, tone, verbosity, transparency, help_mode)
+        return result
+
+    followup = handle_conversational_followup(ctx, help_mode)
+    if followup is not None:
+        followup.reply = format_reply(followup.reply, tone, verbosity, transparency, followup.help_mode)
+        return followup
+
+    if question_block and is_quant_question(question_block):
+        result = solve_quant(question_block, help_mode)
+        result.reply = format_reply(result.reply, tone, verbosity, transparency, help_mode)
+        return result
+
+    if is_quant_question(visible_user_text):
+        result = solve_quant(visible_user_text, help_mode)
+        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.reply = format_reply(result.reply, tone, verbosity, transparency, help_mode)
     return result
 
 
@@ -743,7 +1010,7 @@ def generate_response(
 
 @app.get("/health")
 def health() -> Dict[str, Any]:
-    return {"ok": True, "app": "GMAT Solver v2"}
+    return {"ok": True, "app": "GMAT Solver v3"}
 
 
 @app.get("/", response_class=HTMLResponse)
@@ -753,7 +1020,7 @@ def home() -> str:
 <html>
 <head>
   <meta charset="utf-8">
-  <title>GMAT Solver v2</title>
+  <title>GMAT Solver v3</title>
   <style>
     body { font-family: Arial, sans-serif; max-width: 900px; margin: 40px auto; padding: 0 16px; }
     textarea { width: 100%; min-height: 220px; padding: 12px; font-size: 16px; }
@@ -766,16 +1033,14 @@ def home() -> str:
   </style>
 </head>
 <body>
-  <h1>GMAT Solver v2</h1>
-  <p>Paste a full GMAT-style question. Quant works best. Include answer choices A-E when possible.</p>
+  <h1>GMAT Solver v3</h1>
+  <p>This version supports natural chat and hidden Unity context.</p>
 
-  <label for="message">Question</label>
-  <textarea id="message" placeholder="Example: What is 20% of 150?
-A) 20
-B) 25
-C) 30
-D) 35
-E) 40"></textarea>
+  <label for="message">Message</label>
+  <textarea id="message" placeholder="Try:
+why is it c
+
+Or paste a whole question."></textarea>
 
   <div class="row">
     <div class="card">
@@ -835,12 +1100,6 @@ E) 40"></textarea>
 
 @app.post("/chat")
 async def chat(request: Request) -> JSONResponse:
-    """
-    Robust endpoint:
-    - accepts normal JSON body
-    - survives if body is a raw string
-    - survives nested payload structures
-    """
     raw_body: Any = None
 
     try:
@@ -851,8 +1110,8 @@ async def chat(request: Request) -> JSONResponse:
         except Exception:
             raw_body = None
 
-    # Build typed request if possible
     req_data: Dict[str, Any] = raw_body if isinstance(raw_body, dict) else {}
+
     try:
         req = ChatRequest(**req_data)
     except Exception:
@@ -865,7 +1124,7 @@ async def chat(request: Request) -> JSONResponse:
     help_mode = detect_help_mode(user_text, req_data.get("help_mode", req.help_mode))
 
     result = generate_response(
-        user_text=user_text,
+        raw_user_text=user_text,
         tone=tone,
         verbosity=verbosity,
         transparency=transparency,
@@ -879,6 +1138,8 @@ async def chat(request: Request) -> JSONResponse:
                 "domain": result.domain,
                 "solved": result.solved,
                 "help_mode": result.help_mode,
+                "answer_letter": result.answer_letter,
+                "answer_value": result.answer_value,
             },
         }
     )