Update context_parser.py

context_parser.py

@@ -1,31 +1,115 @@
 from __future__ import annotations
 
 import re
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Dict, List, Optional
 
 
-def split_unity_message(text: str) -> Tuple[str, str]:
-    """
-    Splits a Unity-style message into:
-    - hidden/system/game context prefix
-    - actual user-facing message
+def _to_bool(value: str) -> bool:
+    return str(value or "").strip().lower() in {"true", "1", "yes", "y"}
+
+
+def _looks_like_int(value: str) -> bool:
+    return bool(re.fullmatch(r"-?\d+", str(value or "").strip()))
 
-    If no obvious split is found, returns ("", original_text).
+
+def split_unity_message(text: str) -> Dict[str, Any]:
+    """
+    Parses several Unity-style message formats and always returns a stable dict.
+
+    Supported cases:
+    1. Plain user text
+    2. Hidden-context prefix + USER:/PROMPT:/MESSAGE:
+    3. Structured multiline payload like:
+         hint
+         x/5 = 12
+         0
+         solve
+         False
+         answer
+         answer
+         algebra
+         Quantitative
     """
     raw = (text or "").strip()
+
+    result: Dict[str, Any] = {
+        "hidden_context": "",
+        "user_text": raw,
+        "question_text": "",
+        "hint_stage": 0,
+        "user_last_input_type": "",
+        "built_on_previous_turn": False,
+        "help_mode": "",
+        "intent": "",
+        "topic": "",
+        "category": "",
+    }
+
     if not raw:
-        return "", ""
+        return result
 
-    # Pattern like:
-    # CONTEXT: ...
-    # USER: ...
-    m = re.search(r"(?is)^(.*?)(?:\buser\b|\bprompt\b|\bmessage\b)\s*:\s*(.+)$", raw)
-    if m:
-        hidden = (m.group(1) or "").strip()
-        user = (m.group(2) or "").strip()
-        return hidden, user
+    # Case 1: hidden/system context followed by USER:/PROMPT:/MESSAGE:
+    tagged_match = re.search(r"(?is)^(.*?)(?:\buser\b|\bprompt\b|\bmessage\b)\s*:\s*(.+)$", raw)
+    if tagged_match:
+        hidden = (tagged_match.group(1) or "").strip()
+        user = (tagged_match.group(2) or "").strip()
+        result["hidden_context"] = hidden
+        result["user_text"] = user
+        return result
 
-    return "", raw
+    # Case 2: exact structured Unity payload block
+    lines = [line.strip() for line in raw.splitlines() if line.strip()]
+    if len(lines) >= 9 and _looks_like_int(lines[2]) and lines[4].lower() in {"true", "false"}:
+        result["user_text"] = lines[0]
+        result["question_text"] = lines[1]
+        result["hint_stage"] = int(lines[2])
+        result["user_last_input_type"] = lines[3]
+        result["built_on_previous_turn"] = _to_bool(lines[4])
+        result["help_mode"] = lines[5]
+        result["intent"] = lines[6]
+        result["topic"] = lines[7]
+        result["category"] = lines[8]
+        return result
+
+    # Case 3: field-based payload
+    def _extract_field(name: str) -> str:
+        match = re.search(rf"(?im)^\s*{re.escape(name)}\s*[:=]\s*(.+?)\s*$", raw)
+        return (match.group(1) or "").strip() if match else ""
+
+    question_text = _extract_field("question") or _extract_field("question_text")
+    user_text = _extract_field("user") or _extract_field("message") or _extract_field("prompt")
+    hint_stage_text = _extract_field("hint_stage")
+    user_last_input_type = _extract_field("user_last_input_type")
+    built_on_previous_turn = _extract_field("built_on_previous_turn")
+    help_mode = _extract_field("help_mode")
+    intent = _extract_field("intent")
+    topic = _extract_field("topic")
+    category = _extract_field("category")
+
+    if any([
+        question_text,
+        user_text,
+        hint_stage_text,
+        user_last_input_type,
+        built_on_previous_turn,
+        help_mode,
+        intent,
+        topic,
+        category,
+    ]):
+        result["question_text"] = question_text
+        result["user_text"] = user_text or raw
+        result["hint_stage"] = int(hint_stage_text) if _looks_like_int(hint_stage_text) else 0
+        result["user_last_input_type"] = user_last_input_type
+        result["built_on_previous_turn"] = _to_bool(built_on_previous_turn)
+        result["help_mode"] = help_mode
+        result["intent"] = intent
+        result["topic"] = topic
+        result["category"] = category
+        return result
+
+    # Fallback: plain message
+    return result
 
 
 def _extract_options(text: str) -> List[str]:
@@ -42,7 +126,6 @@ def _extract_options(text: str) -> List[str]:
     if options:
         return options
 
-    # fallback: inline A) ... B) ...
     matches = re.findall(r"(?:^|\s)([A-E])[\)\.\:]\s*(.*?)(?=(?:\s+[A-E][\)\.\:])|$)", text, flags=re.I | re.S)
     if matches:
         return [m[1].strip() for m in matches if m[1].strip()]
@@ -51,10 +134,6 @@ def _extract_options(text: str) -> List[str]:
 
 
 def extract_game_context_fields(text: str) -> Dict[str, Any]:
-    """
-    Extracts lightweight structured fields from hidden Unity/game context.
-    Always returns stable keys expected by app.py.
-    """
     raw = (text or "").strip()
 
     result: Dict[str, Any] = {
@@ -70,33 +149,27 @@ def extract_game_context_fields(text: str) -> Dict[str, Any]:
     if not raw:
         return result
 
-    # question
     q_match = re.search(r"\bquestion\s*[:=]\s*(.+?)(?=\n[A-Za-z_ ]+\s*[:=]|\Z)", raw, flags=re.I | re.S)
     if q_match:
         result["question"] = q_match.group(1).strip()
 
-    # options block
     opt_match = re.search(r"\b(?:options|choices|answers)\s*[:=]\s*(.+?)(?=\n[A-Za-z_ ]+\s*[:=]|\Z)", raw, flags=re.I | re.S)
     if opt_match:
         result["options"] = _extract_options(opt_match.group(1))
 
-    # if no explicit options block, scan whole context
     if not result["options"]:
         result["options"] = _extract_options(raw)
 
     result["has_choices"] = len(result["options"]) > 0
 
-    # difficulty
     difficulty_match = re.search(r"\bdifficulty\s*[:=]\s*([A-Za-z0-9_\- ]+)", raw, flags=re.I)
     if difficulty_match:
         result["difficulty"] = difficulty_match.group(1).strip()
 
-    # category/topic
     category_match = re.search(r"\b(?:category|topic)\s*[:=]\s*([A-Za-z0-9_\- /]+)", raw, flags=re.I)
     if category_match:
         result["category"] = category_match.group(1).strip()
 
-    # money/balance
     money_match = re.search(r"\b(?:money|balance|bank)\s*[:=]\s*([\-]?\d+(?:\.\d+)?)", raw, flags=re.I)
     if money_match:
         try:
@@ -127,10 +200,6 @@ def extract_game_context_fields(text: str) -> Dict[str, Any]:
 
 
 def detect_intent(text: str, incoming_help_mode: Optional[str] = None) -> str:
-    """
-    Returns one of:
-    answer, hint, instruction, walkthrough, explain, method, definition, concept
-    """
     forced = (incoming_help_mode or "").strip().lower()
     if forced in {
         "answer",
@@ -213,8 +282,10 @@ def detect_intent(text: str, incoming_help_mode: Optional[str] = None) -> str:
 
 
 def intent_to_help_mode(intent: str) -> str:
-    if intent in {"walkthrough", "step_by_step", "explain", "method", "concept"}:
+    if intent in {"walkthrough", "step_by_step"}:
         return "walkthrough"
+    if intent in {"explain", "method", "concept"}:
+        return "explain"
     if intent == "hint":
         return "hint"
     if intent in {"definition", "instruction"}: