Update app.py

app.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 
 import os
-from typing import Any, Dict
+import re
+from typing import Any, Dict, Tuple
 
 from fastapi import FastAPI, Request
 from fastapi.middleware.cors import CORSMiddleware
@@ -14,7 +15,7 @@ from ui_html import HOME_HTML
 from utils import clamp01, get_user_text
 
 
-app = FastAPI(title="GMAT Solver v3", version="3.0.0")
+app = FastAPI(title="GMAT Solver v3", version="3.1.0")
 
 app.add_middleware(
     CORSMiddleware,
@@ -25,6 +26,77 @@ app.add_middleware(
 )
 
 
+def split_unity_message(full_text: str) -> Tuple[str, str]:
+    """
+    Splits the Unity payload into:
+    - hidden_context
+    - actual_user_message
+
+    Expected Unity format:
+        <hidden context>
+
+        USER_MESSAGE:
+        <user text>
+
+    Falls back safely if marker is missing.
+    """
+    if not full_text:
+        return "", ""
+
+    marker = "USER_MESSAGE:"
+    idx = full_text.find(marker)
+
+    if idx == -1:
+        return "", full_text.strip()
+
+    hidden_context = full_text[:idx].strip()
+    actual_user_message = full_text[idx + len(marker):].strip()
+    return hidden_context, actual_user_message
+
+
+def extract_game_context_fields(hidden_context: str) -> Dict[str, str]:
+    """
+    Pull simple fields out of the hidden Unity context so downstream logic
+    can use the real question/options instead of the whole raw blob.
+    """
+    fields = {
+        "category": "",
+        "difficulty": "",
+        "question": "",
+        "options": "",
+    }
+
+    if not hidden_context:
+        return fields
+
+    category_match = re.search(r"Category:\s*(.+)", hidden_context)
+    difficulty_match = re.search(r"Difficulty:\s*(.+)", hidden_context)
+    question_match = re.search(r"Question:\s*(.+)", hidden_context, re.DOTALL)
+    options_match = re.search(
+        r"Options:\s*(.+?)(?:\nPlayer balance:|\nLast outcome:|$)",
+        hidden_context,
+        re.DOTALL,
+    )
+
+    if category_match:
+        fields["category"] = category_match.group(1).strip()
+
+    if difficulty_match:
+        fields["difficulty"] = difficulty_match.group(1).strip()
+
+    if question_match:
+        question_text = question_match.group(1).strip()
+        question_text = question_text.split("\nOptions:")[0].strip()
+        question_text = question_text.split("\nPlayer balance:")[0].strip()
+        question_text = question_text.split("\nLast outcome:")[0].strip()
+        fields["question"] = question_text
+
+    if options_match:
+        fields["options"] = options_match.group(1).strip()
+
+    return fields
+
+
 @app.get("/health")
 def health() -> Dict[str, Any]:
     return {"ok": True, "app": "GMAT Solver v3"}
@@ -54,18 +126,31 @@ async def chat(request: Request) -> JSONResponse:
     except Exception:
         req = ChatRequest()
 
-    user_text = get_user_text(req, raw_body)
+    full_text = get_user_text(req, raw_body)
+    hidden_context, actual_user_message = split_unity_message(full_text)
+    game_fields = extract_game_context_fields(hidden_context)
+
     tone = clamp01(req_data.get("tone", req.tone), 0.5)
     verbosity = clamp01(req_data.get("verbosity", req.verbosity), 0.5)
     transparency = clamp01(req_data.get("transparency", req.transparency), 0.5)
-    help_mode = detect_help_mode(user_text, req_data.get("help_mode", req.help_mode))
+
+    help_mode = detect_help_mode(
+        actual_user_message,
+        req_data.get("help_mode", req.help_mode),
+    )
 
     result = generate_response(
-        raw_user_text=user_text,
+        raw_user_text=actual_user_message,
         tone=tone,
         verbosity=verbosity,
         transparency=transparency,
         help_mode=help_mode,
+        hidden_context=hidden_context,
+        chat_history=req_data.get("chat_history", []),
+        question_text=game_fields["question"],
+        options_text=game_fields["options"],
+        question_category=game_fields["category"],
+        question_difficulty=game_fields["difficulty"],
     )
 
     return JSONResponse(