Upload 11 files

app.py

@@ -1,27 +1,27 @@
 from __future__ import annotations
 
-import secrets
+import os
 from typing import Any, Dict
 
-from fastapi import FastAPI, Header, HTTPException, Request
+from fastapi import FastAPI, Request
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import HTMLResponse, JSONResponse
 
-from config import settings
-from context_parser import detect_help_mode
-from conversation_logic import generate_response
-from generator_engine import GenerativeEngine
+from context_parser import detect_intent, extract_game_context_fields, intent_to_help_mode, split_unity_message
+from conversation_logic import ConversationEngine
+from generator_engine import GeneratorEngine
 from logging_store import LoggingStore
 from models import ChatRequest, EventLogRequest, SessionFinalizeRequest, SessionStartRequest
 from retrieval_engine import RetrievalEngine
 from ui_html import HOME_HTML
-from utils import clamp01, flatten_history, get_user_text, parse_hidden_context, split_unity_message
+from utils import clamp01, get_user_text
 
-app = FastAPI(title=settings.app_name, version=settings.app_version)
 retriever = RetrievalEngine()
-generator = GenerativeEngine()
-logging_store = LoggingStore()
+generator = GeneratorEngine()
+engine = ConversationEngine(retriever=retriever, generator=generator)
+store = LoggingStore()
 
+app = FastAPI(title="Trading Game AI V2", version="2.2.0")
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],
@@ -31,14 +31,9 @@ app.add_middleware(
 )
 
 
-def _require_ingest_key(x_ingest_key: str | None) -> None:
-    if settings.ingest_api_key and not secrets.compare_digest(x_ingest_key or "", settings.ingest_api_key):
-        raise HTTPException(status_code=401, detail="Invalid ingest key")
-
-
-def _require_research_key(x_research_key: str | None) -> None:
-    if settings.research_api_key and not secrets.compare_digest(x_research_key or "", settings.research_api_key):
-        raise HTTPException(status_code=401, detail="Invalid research key")
+@app.get("/health")
+def health() -> Dict[str, Any]:
+    return {"ok": True, "app": "Trading Game AI V2", "generator_available": generator.available()}
 
 
 @app.get("/", response_class=HTMLResponse)
@@ -46,20 +41,6 @@ def home() -> str:
     return HOME_HTML
 
 
-@app.get("/health")
-def health() -> Dict[str, Any]:
-    return {
-        "ok": True,
-        "app": settings.app_name,
-        "version": settings.app_version,
-        "retrieval_rows": len(retriever.rows),
-        "generator_model": settings.generator_model,
-        "generator_task": settings.generator_task,
-        "hub_log_push_enabled": settings.push_logs_to_hub,
-        "hub_log_repo": settings.log_dataset_repo_id,
-    }
-
-
 @app.post("/chat")
 async def chat(request: Request) -> JSONResponse:
     raw_body: Any = None
@@ -76,86 +57,74 @@ async def chat(request: Request) -> JSONResponse:
 
     full_text = get_user_text(req, raw_body)
     hidden_context, actual_user_message = split_unity_message(full_text)
-    game_context = parse_hidden_context(hidden_context)
-    retrieval_query = actual_user_message or game_context.question_text or full_text
-    retrieval_chunks = retriever.search(retrieval_query)
+    game_fields = extract_game_context_fields(hidden_context)
+
+    question_text = (req.question_text or "").strip() or game_fields["question"]
+    options_text = game_fields["options"]
 
     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(actual_user_message or full_text, req_data.get("help_mode", req.help_mode))
-    chat_history = flatten_history(req_data.get("chat_history") or req_data.get("history") or req.chat_history or req.history)
 
-    result = generate_response(
-        user_text=actual_user_message or full_text,
+    intent = detect_intent(actual_user_message or full_text, req_data.get("help_mode", req.help_mode))
+    help_mode = intent_to_help_mode(intent)
+
+    result = engine.generate_response(
+        raw_user_text=actual_user_message or full_text,
         tone=tone,
         verbosity=verbosity,
         transparency=transparency,
+        intent=intent,
         help_mode=help_mode,
-        game_context=game_context,
-        chat_history=chat_history,
-        retrieval_chunks=retrieval_chunks,
-        generator=generator,
+        chat_history=req.chat_history or req.history or [],
+        question_text=question_text,
+        options_text=options_text,
     )
 
-    return JSONResponse({"reply": result.reply, "meta": result.meta})
+    return JSONResponse(
+        {
+            "reply": result.reply,
+            "meta": {
+                "domain": result.domain,
+                "solved": result.solved,
+                "help_mode": result.help_mode,
+                "answer_letter": result.answer_letter,
+                "answer_value": result.answer_value,
+                "topic": result.topic,
+                "used_retrieval": result.used_retrieval,
+                "used_generator": result.used_generator,
+            },
+        }
+    )
 
 
 @app.post("/log/session/start")
-def start_session(
-    req: SessionStartRequest,
-    x_ingest_key: str | None = Header(default=None),
-) -> Dict[str, Any]:
-    _require_ingest_key(x_ingest_key)
-    record = logging_store.start_session(req)
-    return {"ok": True, "session_id": record.session_id, "record": record.model_dump()}
+def log_session_start(payload: SessionStartRequest) -> Dict[str, Any]:
+    return store.start_session(payload.session_id, payload.user_id, payload.condition, payload.metadata)
 
 
 @app.post("/log/event")
-def log_event(
-    req: EventLogRequest,
-    x_ingest_key: str | None = Header(default=None),
-) -> Dict[str, Any]:
-    _require_ingest_key(x_ingest_key)
-    try:
-        return logging_store.append_event(req)
-    except FileNotFoundError as e:
-        raise HTTPException(status_code=404, detail=str(e)) from e
+def log_event(payload: EventLogRequest) -> Dict[str, Any]:
+    return store.log_event(payload.session_id, payload.event_type, payload.payload, payload.timestamp)
 
 
 @app.post("/log/session/finalize")
-def finalize_session(
-    req: SessionFinalizeRequest,
-    x_ingest_key: str | None = Header(default=None),
-) -> Dict[str, Any]:
-    _require_ingest_key(x_ingest_key)
-    try:
-        return logging_store.finalize_session(req)
-    except FileNotFoundError as e:
-        raise HTTPException(status_code=404, detail=str(e)) from e
+def log_session_finalize(payload: SessionFinalizeRequest) -> Dict[str, Any]:
+    return store.finalize_session(payload.session_id, payload.summary)
 
 
 @app.get("/research/sessions")
-def research_sessions(
-    x_research_key: str | None = Header(default=None),
-) -> Dict[str, Any]:
-    _require_research_key(x_research_key)
-    return {"ok": True, "sessions": logging_store.list_sessions()}
+def research_sessions() -> Dict[str, Any]:
+    return {"sessions": store.list_sessions()}
 
 
 @app.get("/research/session/{session_id}")
-def research_session(
-    session_id: str,
-    x_research_key: str | None = Header(default=None),
-) -> Dict[str, Any]:
-    _require_research_key(x_research_key)
-    try:
-        return {"ok": True, **logging_store.read_session_bundle(session_id)}
-    except FileNotFoundError as e:
-        raise HTTPException(status_code=404, detail=str(e)) from e
+def research_session(session_id: str) -> Dict[str, Any]:
+    return store.get_session(session_id)
 
 
 if __name__ == "__main__":
     import uvicorn
 
-    uvicorn.run(app, host="0.0.0.0", port=settings.port)
+    port = int(os.getenv("PORT", "7860"))
+    uvicorn.run(app, host="0.0.0.0", port=port)

context_parser.py

@@ -1,36 +1,65 @@
 from __future__ import annotations
 
 import re
+from typing import Dict, Optional
 
 
-HELP_MODES = {"hint", "guide", "walkthrough", "answer", "explain"}
+def split_unity_message(full_text: str) -> tuple[str, str]:
+    if not full_text:
+        return "", ""
+    marker = "USER_MESSAGE:"
+    idx = full_text.find(marker)
+    if idx == -1:
+        return "", full_text.strip()
+    hidden = full_text[:idx].strip()
+    user = full_text[idx + len(marker):].strip()
+    return hidden, user
 
 
+def extract_game_context_fields(hidden_context: str) -> Dict[str, str]:
+    fields = {"category": "", "difficulty": "", "question": "", "options": ""}
+    if not hidden_context:
+        return fields
 
-def detect_help_mode(user_text: str, explicit_help_mode: str | None = None) -> str:
-    if explicit_help_mode and explicit_help_mode.lower() in HELP_MODES:
-        mode = explicit_help_mode.lower()
-        return "walkthrough" if mode == "guide" else mode
+    patterns = {
+        "category": r"Category:\s*(.+)",
+        "difficulty": r"Difficulty:\s*(.+)",
+        "question": r"Question:\s*(.+?)(?:\nOptions:|\nPlayer balance:|\nLast outcome:|$)",
+        "options": r"Options:\s*(.+?)(?:\nPlayer balance:|\nLast outcome:|$)",
+    }
+    for key, pattern in patterns.items():
+        m = re.search(pattern, hidden_context, re.DOTALL)
+        if m:
+            fields[key] = m.group(1).strip()
+    return fields
 
-    text = (user_text or "").lower()
-    if any(phrase in text for phrase in ["just a hint", "small hint", "nudge", "dont tell me"]):
+
+def detect_intent(user_text: str, supplied: Optional[str] = None) -> str:
+    lower = (user_text or "").strip().lower()
+
+    if supplied:
+        supplied = supplied.strip().lower()
+        if supplied in {"hint", "method", "walkthrough", "step_by_step", "full_working", "answer"}:
+            return supplied
+
+    if any(p in lower for p in ["full working", "full working out", "show all the working", "complete working"]):
+        return "full_working"
+    if any(p in lower for p in ["step by step", "walkthrough", "work through", "explain step by step"]):
+        return "step_by_step"
+    if any(p in lower for p in ["how do i solve", "how to solve", "method", "what method", "approach"]):
+        return "method"
+    if any(p in lower for p in ["hint", "nudge", "first step", "how do i start", "what do i do first"]):
         return "hint"
-    if any(phrase in text for phrase in ["walk me through", "step by step", "show the steps", "explain how"]):
-        return "walkthrough"
-    if any(phrase in text for phrase in ["what is the answer", "which option", "is it a or b", "final answer"]):
+    if any(p in lower for p in ["why", "explain", "breakdown"]):
+        return "step_by_step"
+    if any(p in lower for p in ["solve", "what is", "answer", "give me the answer"]):
         return "answer"
-    return "explain"
+    return "answer"
 
 
-
-def is_social_or_meta_message(text: str) -> bool:
-    lower = (text or "").strip().lower()
-    if not lower:
-        return True
-    social_patterns = [
-        r"^(hi|hello|hey|thanks|thank you|ok|okay|cool|great|nice)\b",
-        r"how are you",
-        r"what can you do",
-        r"who are you",
-    ]
-    return any(re.search(p, lower) for p in social_patterns)
+def intent_to_help_mode(intent: str) -> str:
+    if intent == "hint":
+        return "hint"
+    if intent in {"method", "step_by_step", "full_working"}:
+        return "walkthrough"
+    return "answer"

conversation_logic.py

@@ -1,80 +1,106 @@
 from __future__ import annotations
 
-from typing import Any, Dict, List
+from typing import Any, Dict, List, Optional
 
-from context_parser import is_social_or_meta_message
-from formatting import build_guidance_text
-from generator_engine import GenerativeEngine
-from models import GameContext, ResponsePackage, RetrievalChunk, SolverResult
+from context_parser import intent_to_help_mode
+from formatting import format_reply
+from generator_engine import GeneratorEngine
+from models import RetrievedChunk, SolverResult
 from quant_solver import is_quant_question, solve_quant
-from safety import enforce_study_guardrails
-from utils import soft_truncate
-
-
-def _summarize_retrieval(chunks: List[RetrievalChunk]) -> str:
-    if not chunks:
-        return ""
-    lines = ["Relevant study notes:"]
-    for chunk in chunks[:3]:
-        snippet = soft_truncate(chunk.text, 180)
-        label = chunk.topic_guess or chunk.source_name or chunk.chunk_id
-        lines.append(f"- {label}: {snippet}")
-    return "\n".join(lines)
-
-
-def generate_response(
-    *,
-    user_text: str,
-    tone: float,
-    verbosity: float,
-    transparency: float,
-    help_mode: str,
-    game_context: GameContext,
-    chat_history: List[Dict[str, Any]],
-    retrieval_chunks: List[RetrievalChunk],
-    generator: GenerativeEngine,
-) -> ResponsePackage:
-    combined = "\n".join(part for part in [game_context.combined_question_block, user_text] if part.strip()).strip()
-    retrieval_text = _summarize_retrieval(retrieval_chunks)
-
-    if is_quant_question(combined):
-        result: SolverResult = solve_quant(combined)
-        reply = build_guidance_text(result, verbosity=verbosity, transparency=transparency, tone=tone)
-        if retrieval_text and verbosity >= 0.5:
-            reply = reply + "\n\n" + retrieval_text
-        reply = enforce_study_guardrails(reply, result)
-        return ResponsePackage(
-            reply=reply,
-            meta={
-                "domain": result.domain,
-                "solved": result.solved,
-                "help_mode": help_mode,
-                "answer_letter": None,
-                "answer_value": None,
-                "topic": result.detected_topic,
-                "used_retrieval": bool(retrieval_chunks),
-                "used_generator": False,
-            },
+from retrieval_engine import RetrievalEngine
+from utils import short_lines
+
+
+def _teaching_lines(chunks: List[RetrievedChunk]) -> List[str]:
+    lines = []
+    for chunk in chunks:
+        text = chunk.text.strip().replace("\n", " ")
+        if len(text) > 220:
+            text = text[:217].rstrip() + "…"
+        lines.append(f"- {chunk.topic}: {text}")
+    return lines
+
+
+def _compose_quant_reply(result: SolverResult, intent: str, reveal_answer: bool, verbosity: float) -> str:
+    steps = result.steps or []
+    internal = result.internal_answer or result.answer_value or ""
+
+    if intent == "hint":
+        return steps[0] if steps else "Start by translating the wording into an equation."
+
+    if intent == "method":
+        body = "Use this method:\n" + "\n".join(f"- {s}" for s in steps[:3])
+        if reveal_answer and internal:
+            body += f"\n\nInternal result: {internal}."
+        return body
+
+    if intent in {"step_by_step", "full_working"}:
+        body = "\n".join(f"{i+1}. {s}" for i, s in enumerate(steps[:4])) if steps else "Work through the algebra one step at a time."
+        if reveal_answer and internal:
+            body += f"\n\nSo the result is {internal}."
+        return body
+
+    if reveal_answer and internal:
+        return f"The result is {internal}."
+
+    if steps:
+        return "\n".join(f"- {s}" for s in steps[:2])
+    return result.reply or "I can help solve this, but I need a little more structure from the question."
+
+
+class ConversationEngine:
+    def __init__(self, retriever: RetrievalEngine, generator: Optional[GeneratorEngine] = None):
+        self.retriever = retriever
+        self.generator = generator or GeneratorEngine()
+
+    def generate_response(
+        self,
+        raw_user_text: str,
+        tone: float,
+        verbosity: float,
+        transparency: float,
+        intent: str,
+        help_mode: str,
+        chat_history: Optional[List[Dict[str, Any]]] = None,
+        question_text: str = "",
+        options_text: str = "",
+        retrieval_context: str = "",
+    ) -> SolverResult:
+        user_text = (raw_user_text or "").strip()
+        question_block = "\n".join([x for x in [question_text.strip(), options_text.strip()] if x]).strip()
+        solver_input = user_text or question_text or question_block
+
+        if is_quant_question(solver_input) or (question_text and is_quant_question(question_text)):
+            result = solve_quant(solver_input if is_quant_question(solver_input) else question_text)
+            result.help_mode = help_mode
+            reveal_answer = intent in {"answer", "full_working"} or transparency >= 0.85
+
+            if result.topic:
+                chunks = self.retriever.search(question_text or user_text, topic=result.topic, intent=intent, k=3)
+            else:
+                chunks = self.retriever.search(question_text or user_text, topic="general", intent=intent, k=3)
+            result.teaching_chunks = chunks
+            result.used_retrieval = bool(chunks)
+
+            core = _compose_quant_reply(result, intent, reveal_answer=reveal_answer, verbosity=verbosity)
+            if chunks and intent in {"hint", "method", "step_by_step", "full_working"}:
+                core += "\n\nRelevant study notes:\n" + "\n".join(_teaching_lines(chunks))
+            result.reply = format_reply(core, tone, verbosity, transparency, help_mode)
+            return result
+
+        # Non-quant conversational support
+        result = SolverResult(domain="general", solved=False, help_mode=help_mode)
+        prompt = (
+            "You are a helpful study assistant. Reply naturally and briefly. "
+            "Do not invent facts. If the user is asking for emotional support or general help, be supportive and practical.\n\n"
+            f"User message: {user_text}"
         )
+        generated = self.generator.generate(prompt) if self.generator and self.generator.available() else None
+        if generated:
+            result.reply = format_reply(generated, tone, verbosity, transparency, help_mode)
+            result.used_generator = True
+            return result
 
-    reply = generator.generate(
-        user_text=user_text,
-        chat_history=chat_history,
-        game_context=game_context,
-        retrieval_summary=retrieval_text,
-        tone=tone,
-        verbosity=verbosity,
-        transparency=transparency,
-    )
-    reply = enforce_study_guardrails(reply)
-    return ResponsePackage(
-        reply=reply,
-        meta={
-            "domain": "general",
-            "solved": False,
-            "help_mode": help_mode,
-            "topic": "social" if is_social_or_meta_message(user_text) else "general",
-            "used_retrieval": bool(retrieval_chunks),
-            "used_generator": True,
-        },
-    )
+        fallback = "I can help with the current question, explain a method, or talk through the next step."
+        result.reply = format_reply(fallback, tone, verbosity, transparency, help_mode)
+        return result

formatting.py

@@ -1,43 +1,27 @@
 from __future__ import annotations
 
-from typing import List
 
-from models import SolverResult
-from utils import soft_truncate
+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)
+    core = (core or "").strip()
+    if not core:
+        return prefix
 
-def tone_prefix(tone: float) -> str:
-    if tone < 0.34:
-        return ""
-    if tone < 0.67:
-        return "You’ve got this. "
-    return "You’re doing the right thing by breaking it down. "
+    if help_mode == "hint":
+        return f"{prefix}\n\nHint:\n{core}"
 
+    if help_mode == "walkthrough" and verbosity >= 0.4:
+        return f"{prefix}\n\nWalkthrough:\n{core}"
 
+    if transparency >= 0.75 and help_mode == "answer":
+        return f"{prefix}\n\n{core}"
 
-def build_guidance_text(result: SolverResult, verbosity: float, transparency: float, tone: float) -> str:
-    lines: List[str] = []
-    prefix = tone_prefix(tone)
-    if prefix:
-        lines.append(prefix.strip())
-
-    lines.append(result.explanation)
-
-    if verbosity >= 0.34 and result.steps:
-        max_steps = 2 if verbosity < 0.67 else 4
-        chosen_steps = result.steps[:max_steps]
-        if transparency < 0.34:
-            lines.append("Focus on the setup rather than the final value:")
-        elif transparency < 0.67:
-            lines.append("Use this structure:")
-        else:
-            lines.append("Here is the reasoning structure to follow:")
-        lines.extend(f"- {step}" for step in chosen_steps)
-
-    if transparency >= 0.67 and result.internal_answer_value:
-        lines.append("When you finish the calculation, compare your value with the available choices rather than jumping straight to a choice now.")
-    else:
-        lines.append("Then compare your result against the options yourself.")
-
-    return soft_truncate("\n".join(lines).strip(), 1600)
+    return f"{prefix}\n\n{core}"

generator_engine.py

@@ -1,181 +1,33 @@
 from __future__ import annotations
 
-from typing import Any, Dict, List
+from typing import Optional
 
 try:
     from transformers import pipeline
 except Exception:
     pipeline = None
 
-from config import settings
-from models import GameContext
-from utils import normalize_spaces, soft_truncate
 
-
-class GenerativeEngine:
-    def __init__(self) -> None:
-        self.task = settings.generator_task
-        self.model_name = settings.generator_model
+class GeneratorEngine:
+    def __init__(self, model_name: str = "google/flan-t5-small"):
+        self.model_name = model_name
         self.pipe = None
-        if pipeline is None:
-            return
-        try:
-            self.pipe = pipeline(
-                task=self.task,
-                model=self.model_name,
-                tokenizer=self.model_name,
-                device=-1,
-            )
-        except Exception:
-            self.pipe = None
-
-    def _style_instruction(self, tone: float, verbosity: float, transparency: float) -> str:
-        if tone < 0.34:
-            tone_label = "neutral and direct"
-        elif tone < 0.67:
-            tone_label = "friendly and professional"
-        else:
-            tone_label = "warm, encouraging, and supportive"
-
-        if verbosity < 0.34:
-            verbosity_label = "brief"
-        elif verbosity < 0.67:
-            verbosity_label = "moderate length"
-        else:
-            verbosity_label = "detailed"
-
-        if transparency < 0.34:
-            transparency_label = "do not expose chain-of-thought; keep reasoning concise"
-        elif transparency < 0.67:
-            transparency_label = "give a short explanation of reasoning"
-        else:
-            transparency_label = "explain the logic clearly but do not reveal hidden chain-of-thought"
-
-        return (
-            f"Style: {tone_label}. "
-            f"Length: {verbosity_label}. "
-            f"Reasoning visibility: {transparency_label}."
-        )
-
-    def _build_prompt(
-        self,
-        *,
-        user_text: str,
-        chat_history: List[Dict[str, Any]],
-        game_context: GameContext,
-        retrieval_summary: str,
-        tone: float,
-        verbosity: float,
-        transparency: float,
-    ) -> str:
-        history_lines: List[str] = []
-        for item in chat_history[-8:]:
-            role = str(item.get("role", "user")).strip().lower()
-            text = normalize_spaces(str(item.get("text", "")))
-            if text:
-                history_lines.append(f"{role.title()}: {text}")
-
-        context_lines: List[str] = []
-        if game_context.question_text:
-            context_lines.append(f"Current question: {game_context.question_text}")
-        if game_context.options_text:
-            context_lines.append(f"Answer options: {game_context.options_text}")
-        if game_context.question_category:
-            context_lines.append(f"Question category: {game_context.question_category}")
-        if game_context.question_difficulty:
-            context_lines.append(f"Question difficulty: {game_context.question_difficulty}")
-        if retrieval_summary:
-            context_lines.append(f"Reference material:\n{retrieval_summary}")
+        if pipeline is not None:
+            try:
+                self.pipe = pipeline("text2text-generation", model=model_name)
+            except Exception:
+                self.pipe = None
 
-        system = (
-            "You are an AI assistant inside a Unity trading-game study. "
-            "For non-quant messages, respond naturally and helpfully. "
-            "If the message is about gameplay, AI usage, sliders, or study procedure, answer clearly and accurately. "
-            "Do not invent access to hidden systems or researcher-only information. "
-            "Never claim certainty about unknown participant details. "
-            + self._style_instruction(tone, verbosity, transparency)
-        )
+    def available(self) -> bool:
+        return self.pipe is not None
 
-        user_block = f"User: {normalize_spaces(user_text)}"
-        prompt = "\n\n".join(
-            part for part in [
-                system,
-                "Recent conversation:\n" + "\n".join(history_lines) if history_lines else "",
-                "Game context:\n" + "\n".join(context_lines) if context_lines else "",
-                user_block,
-                "Assistant:"
-            ] if part
-        )
-        return prompt
-
-    def _fallback_reply(self, user_text: str, retrieval_summary: str) -> str:
-        lower = (user_text or "").lower()
-        if "what can you do" in lower:
-            return (
-                "I can help with GMAT-style quant questions, explain how the sliders affect the AI, "
-                "talk through strategy in the trading-game study, and answer general non-quant questions."
-            )
-        if "token" in lower or "cost" in lower:
-            return (
-                "AI use can be treated as a limited resource in the study. "
-                "A prompt can have a visible token cost before sending, and that cost can be logged for later analysis."
-            )
-        if retrieval_summary:
-            return "I can help with that. Here are the most relevant notes I found:\n\n" + retrieval_summary
-        return "I can help with game questions, AI-use questions, and general non-quant conversation."
-
-    def generate(
-        self,
-        *,
-        user_text: str,
-        chat_history: List[Dict[str, Any]],
-        game_context: GameContext,
-        retrieval_summary: str,
-        tone: float,
-        verbosity: float,
-        transparency: float,
-    ) -> str:
+    def generate(self, prompt: str, max_new_tokens: int = 96) -> Optional[str]:
         if self.pipe is None:
-            return self._fallback_reply(user_text, retrieval_summary)
-
-        prompt = self._build_prompt(
-            user_text=user_text,
-            chat_history=chat_history,
-            game_context=game_context,
-            retrieval_summary=retrieval_summary,
-            tone=tone,
-            verbosity=verbosity,
-            transparency=transparency,
-        )
-
-        kwargs: Dict[str, Any] = {
-            "max_new_tokens": settings.generator_max_new_tokens,
-        }
-        if self.task == "text-generation":
-            kwargs.update(
-                {
-                    "do_sample": settings.generator_do_sample,
-                    "temperature": settings.generator_temperature,
-                    "top_p": settings.generator_top_p,
-                    "return_full_text": False,
-                }
-            )
-        else:
-            kwargs.update(
-                {
-                    "do_sample": settings.generator_do_sample,
-                    "temperature": settings.generator_temperature,
-                    "top_p": settings.generator_top_p,
-                }
-            )
-
-        result = self.pipe(prompt, **kwargs)
-        if not result:
-            return self._fallback_reply(user_text, retrieval_summary)
-
-        first = result[0]
-        text = first.get("generated_text") or first.get("summary_text") or ""
-        text = normalize_spaces(text)
-        if not text:
-            return self._fallback_reply(user_text, retrieval_summary)
-        return soft_truncate(text, 1200)
+            return None
+        try:
+            out = self.pipe(prompt, max_new_tokens=max_new_tokens, do_sample=False)
+            if out and isinstance(out, list):
+                return str(out[0].get("generated_text", "")).strip()
+        except Exception:
+            return None
+        return None

logging_store.py

@@ -1,142 +1,76 @@
 from __future__ import annotations
 
 import json
-import uuid
+import os
 from datetime import datetime, timezone
-from pathlib import Path
 from typing import Any, Dict, List, Optional
 
-from huggingface_hub import CommitOperationAdd, HfApi
-
-from config import settings
-from models import EventLogRequest, SessionFinalizeRequest, SessionRecord, SessionStartRequest
-
-
-def _utc_stamp() -> str:
-    return datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%S%fZ")
-
 
 class LoggingStore:
-    def __init__(self) -> None:
-        self.root = Path(settings.local_log_dir)
-        self.root.mkdir(parents=True, exist_ok=True)
-        self.sessions_dir = self.root / "sessions"
-        self.events_dir = self.root / "events"
-        self.sessions_dir.mkdir(parents=True, exist_ok=True)
-        self.events_dir.mkdir(parents=True, exist_ok=True)
-        self.hf_api: Optional[HfApi] = HfApi(token=settings.hf_token) if settings.hf_token else None
-
-    def _session_path(self, session_id: str) -> Path:
-        return self.sessions_dir / f"{session_id}.json"
-
-    def _event_path(self, session_id: str, event_type: str) -> Path:
-        safe_event = "".join(c if c.isalnum() or c in "-._" else "_" for c in event_type)[:80]
-        session_dir = self.events_dir / session_id
-        session_dir.mkdir(parents=True, exist_ok=True)
-        return session_dir / f"{_utc_stamp()}__{safe_event}.json"
-
-    def _load_session(self, session_id: str) -> Optional[Dict[str, Any]]:
-        path = self._session_path(session_id)
-        if not path.exists():
-            return None
-        return json.loads(path.read_text(encoding="utf-8"))
-
-    def _write_json(self, path: Path, payload: Dict[str, Any]) -> None:
-        path.write_text(json.dumps(payload, indent=2, ensure_ascii=False), encoding="utf-8")
-
-    def _push_file_to_hub(self, local_path: Path, repo_path: str) -> None:
-        if not (settings.push_logs_to_hub and settings.log_dataset_repo_id and self.hf_api):
-            return
-        self.hf_api.create_repo(
-            repo_id=settings.log_dataset_repo_id,
-            repo_type="dataset",
-            private=settings.log_dataset_private,
-            exist_ok=True,
-        )
-        self.hf_api.create_commit(
-            repo_id=settings.log_dataset_repo_id,
-            repo_type="dataset",
-            commit_message=f"Add log file {repo_path}",
-            operations=[
-                CommitOperationAdd(
-                    path_in_repo=repo_path,
-                    path_or_fileobj=str(local_path),
-                )
-            ],
-        )
-
-    def start_session(self, req: SessionStartRequest) -> SessionRecord:
-        session_id = req.session_id or str(uuid.uuid4())
-        record = SessionRecord(
-            participant_id=req.participant_id,
-            session_id=session_id,
-            started_at=req.started_at,
-            condition=req.condition,
-            study_id=req.study_id,
-            game_version=req.game_version,
-            metadata=req.metadata,
-            summary={},
-            event_count=0,
-        )
-        path = self._session_path(session_id)
-        payload = record.model_dump()
-        self._write_json(path, payload)
-        self._push_file_to_hub(path, f"sessions/{session_id}.json")
+    def __init__(self, root: str = "logs"):
+        self.root = root
+        os.makedirs(self.root, exist_ok=True)
+        self.sessions_path = os.path.join(self.root, "sessions.jsonl")
+        self.events_path = os.path.join(self.root, "events.jsonl")
+
+    def _append(self, path: str, payload: Dict[str, Any]) -> None:
+        with open(path, "a", encoding="utf-8") as f:
+            f.write(json.dumps(payload, ensure_ascii=False) + "\n")
+
+    def _now(self) -> str:
+        return datetime.now(timezone.utc).isoformat()
+
+    def start_session(self, session_id: str, user_id: Optional[str], condition: Optional[str], metadata: Optional[Dict[str, Any]]) -> Dict[str, Any]:
+        record = {
+            "session_id": session_id,
+            "user_id": user_id,
+            "condition": condition,
+            "metadata": metadata or {},
+            "started_at": self._now(),
+            "type": "session_start",
+        }
+        self._append(self.sessions_path, record)
         return record
 
-    def append_event(self, req: EventLogRequest) -> Dict[str, Any]:
-        session = self._load_session(req.session_id)
-        if session is None:
-            raise FileNotFoundError(f"Unknown session_id: {req.session_id}")
-
-        payload = req.model_dump()
-        event_path = self._event_path(req.session_id, req.event_type)
-        self._write_json(event_path, payload)
-
-        session["event_count"] = int(session.get("event_count", 0)) + 1
-        self._write_json(self._session_path(req.session_id), session)
-
-        self._push_file_to_hub(event_path, f"events/{req.session_id}/{event_path.name}")
-        self._push_file_to_hub(self._session_path(req.session_id), f"sessions/{req.session_id}.json")
-
-        return {
-            "ok": True,
-            "session_id": req.session_id,
-            "event_file": event_path.name,
-            "event_count": session["event_count"],
+    def log_event(self, session_id: str, event_type: str, payload: Optional[Dict[str, Any]], timestamp: Optional[str]) -> Dict[str, Any]:
+        record = {
+            "session_id": session_id,
+            "event_type": event_type,
+            "timestamp": timestamp or self._now(),
+            "payload": payload or {},
         }
+        self._append(self.events_path, record)
+        return record
 
-    def finalize_session(self, req: SessionFinalizeRequest) -> Dict[str, Any]:
-        session = self._load_session(req.session_id)
-        if session is None:
-            raise FileNotFoundError(f"Unknown session_id: {req.session_id}")
+    def finalize_session(self, session_id: str, summary: Optional[Dict[str, Any]]) -> Dict[str, Any]:
+        record = {
+            "session_id": session_id,
+            "summary": summary or {},
+            "finalized_at": self._now(),
+            "type": "session_finalize",
+        }
+        self._append(self.sessions_path, record)
+        return record
 
-        session["finished_at"] = req.finished_at
-        session["summary"] = req.summary
-        self._write_json(self._session_path(req.session_id), session)
-        self._push_file_to_hub(self._session_path(req.session_id), f"sessions/{req.session_id}.json")
-        return {"ok": True, "session_id": req.session_id, "finished_at": req.finished_at}
+    def _read_jsonl(self, path: str) -> List[Dict[str, Any]]:
+        if not os.path.exists(path):
+            return []
+        rows = []
+        with open(path, "r", encoding="utf-8") as f:
+            for line in f:
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    rows.append(json.loads(line))
+                except Exception:
+                    continue
+        return rows
 
     def list_sessions(self) -> List[Dict[str, Any]]:
-        items: List[Dict[str, Any]] = []
-        for path in sorted(self.sessions_dir.glob("*.json"), reverse=True):
-            try:
-                items.append(json.loads(path.read_text(encoding="utf-8")))
-            except Exception:
-                continue
-        return items
-
-    def read_session_bundle(self, session_id: str) -> Dict[str, Any]:
-        session = self._load_session(session_id)
-        if session is None:
-            raise FileNotFoundError(f"Unknown session_id: {session_id}")
-
-        events: List[Dict[str, Any]] = []
-        session_dir = self.events_dir / session_id
-        for path in sorted(session_dir.glob("*.json")):
-            try:
-                events.append(json.loads(path.read_text(encoding="utf-8")))
-            except Exception:
-                continue
+        return self._read_jsonl(self.sessions_path)
 
-        return {"session": session, "events": events}
+    def get_session(self, session_id: str) -> Dict[str, Any]:
+        sessions = [r for r in self._read_jsonl(self.sessions_path) if r.get("session_id") == session_id]
+        events = [r for r in self._read_jsonl(self.events_path) if r.get("session_id") == session_id]
+        return {"session_id": session_id, "records": sessions, "events": events}

models.py

@@ -1,19 +1,9 @@
 from __future__ import annotations
 
 from dataclasses import dataclass, field
-from datetime import datetime, timezone
 from typing import Any, Dict, List, Optional
 
-from pydantic import BaseModel, Field
-
-
-def utc_now_iso() -> str:
-    return datetime.now(timezone.utc).isoformat()
-
-
-class ChatMessage(BaseModel):
-    role: str = "user"
-    text: str = ""
+from pydantic import BaseModel
 
 
 class ChatRequest(BaseModel):
@@ -23,93 +13,59 @@ class ChatRequest(BaseModel):
     text: Optional[str] = None
     user_message: Optional[str] = None
 
-    chat_history: List[ChatMessage] = Field(default_factory=list)
-    history: List[ChatMessage] = Field(default_factory=list)
-
-    tone: float = 0.5
-    verbosity: float = 0.5
-    transparency: float = 0.5
+    tone: Optional[float] = 0.5
+    verbosity: Optional[float] = 0.5
+    transparency: Optional[float] = 0.5
 
     help_mode: Optional[str] = None
+    chat_history: Optional[List[Dict[str, Any]]] = None
+    history: Optional[List[Dict[str, Any]]] = None
 
-
-@dataclass
-class GameContext:
-    raw_hidden_context: str = ""
-    question_text: str = ""
-    options_text: str = ""
-    question_category: str = ""
-    question_difficulty: str = ""
-    player_balance: Optional[float] = None
-    last_outcome: str = ""
-
-    @property
-    def combined_question_block(self) -> str:
-        parts = [p for p in [self.question_text, self.options_text] if p.strip()]
-        return "\n".join(parts).strip()
-
-
-@dataclass
-class RetrievalChunk:
-    chunk_id: str
-    text: str
-    source_name: str = ""
-    topic_guess: str = ""
-    score: float = 0.0
-
-
-@dataclass
-class SolverResult:
-    solved: bool
-    explanation: str
-    domain: str = "general"
-    internal_answer_value: Optional[str] = None
-    internal_answer_letter: Optional[str] = None
-    detected_topic: str = ""
-    steps: List[str] = field(default_factory=list)
-
-
-@dataclass
-class ResponsePackage:
-    reply: str
-    meta: Dict[str, Any]
+    question_text: Optional[str] = None
+    question_id: Optional[str] = None
+    session_id: Optional[str] = None
+    user_id: Optional[str] = None
 
 
 class SessionStartRequest(BaseModel):
-    participant_id: str
-    session_id: Optional[str] = None
+    session_id: str
+    user_id: Optional[str] = None
     condition: Optional[str] = None
-    study_id: Optional[str] = None
-    game_version: Optional[str] = None
-    metadata: Dict[str, Any] = Field(default_factory=dict)
-    started_at: str = Field(default_factory=utc_now_iso)
+    metadata: Optional[Dict[str, Any]] = None
 
 
 class EventLogRequest(BaseModel):
-    participant_id: str
     session_id: str
     event_type: str
-    timestamp: str = Field(default_factory=utc_now_iso)
-    question_index: Optional[int] = None
-    turn_index: Optional[int] = None
-    payload: Dict[str, Any] = Field(default_factory=dict)
+    timestamp: Optional[str] = None
+    payload: Optional[Dict[str, Any]] = None
 
 
 class SessionFinalizeRequest(BaseModel):
-    participant_id: str
     session_id: str
-    finished_at: str = Field(default_factory=utc_now_iso)
-    summary: Dict[str, Any] = Field(default_factory=dict)
+    summary: Optional[Dict[str, Any]] = None
 
 
-class SessionRecord(BaseModel):
-    participant_id: str
-    session_id: str
-    started_at: str
-    finished_at: Optional[str] = None
-    condition: Optional[str] = None
-    study_id: Optional[str] = None
-    game_version: Optional[str] = None
-    metadata: Dict[str, Any] = Field(default_factory=dict)
-    summary: Dict[str, Any] = Field(default_factory=dict)
-    event_count: int = 0
+@dataclass
+class RetrievedChunk:
+    text: str
+    topic: str = "general"
+    source: str = "local"
+    score: float = 0.0
+
+
+@dataclass
+class SolverResult:
+    reply: str = ""
+    domain: str = "fallback"
+    solved: bool = False
+    help_mode: str = "answer"
+    answer_letter: Optional[str] = None
+    answer_value: Optional[str] = None
+    topic: Optional[str] = None
+    used_retrieval: bool = False
+    used_generator: bool = False
+    internal_answer: Optional[str] = None
+    steps: List[str] = field(default_factory=list)
+    teaching_chunks: List[RetrievedChunk] = field(default_factory=list)
+    meta: Dict[str, Any] = field(default_factory=dict)

quant_solver.py

@@ -2,9 +2,8 @@ from __future__ import annotations
 
 import math
 import re
-from fractions import Fraction
 from statistics import mean, median
-from typing import Dict, List, Optional
+from typing import Dict, Optional
 
 try:
     import sympy as sp
@@ -12,268 +11,214 @@ except Exception:
     sp = None
 
 from models import SolverResult
-from utils import clean_math_text, normalize_spaces, safe_div
-
-CHOICE_LETTERS = ["A", "B", "C", "D", "E"]
-
+from utils import clean_math_text, normalize_spaces
 
 
 def extract_choices(text: str) -> Dict[str, str]:
+    text = text or ""
     matches = list(
         re.finditer(
-            r"(?im)(?:^|\n)\s*([A-E])[\)\.:]\s*(.*?)(?=(?:\n\s*[A-E][\)\.:]\s)|$)",
-            text or "",
+            r"(?i)\b([A-E])[\)\.:]\s*(.*?)(?=\s+\b[A-E][\)\.:]\s*|$)",
+            text,
         )
     )
     return {m.group(1).upper(): normalize_spaces(m.group(2)) for m in matches}
 
 
-
 def has_answer_choices(text: str) -> bool:
     return len(extract_choices(text)) >= 3
 
 
-
 def is_quant_question(text: str) -> bool:
     lower = clean_math_text(text).lower()
-    quant_keywords = [
-        "integer", "divisible", "remainder", "percent", "ratio", "probability",
-        "mean", "median", "average", "sum", "difference", "product", "triangle",
-        "circle", "rectangle", "area", "perimeter", "volume", "x", "y", "equation",
-        "inequality", "consecutive", "mixture", "speed", "distance", "work", "algebra",
+    keywords = [
+        "solve", "equation", "percent", "ratio", "probability", "mean", "median",
+        "average", "sum", "difference", "product", "quotient", "triangle", "circle",
+        "rectangle", "area", "perimeter", "volume", "algebra", "integer", "divisible",
+        "number", "fraction", "decimal", "geometry", "distance", "speed", "work",
     ]
-    return any(k in lower for k in quant_keywords) or (bool(re.search(r"\d", lower)) and ("?" in lower or has_answer_choices(lower)))
-
+    if any(k in lower for k in keywords):
+        return True
+    if "=" in lower and re.search(r"[a-z]", lower):
+        return True
+    if re.search(r"\d", lower) and ("?" in lower or has_answer_choices(lower)):
+        return True
+    return False
 
 
 def _prepare_expression(expr: str) -> str:
     expr = clean_math_text(expr).strip()
     expr = expr.replace("^", "**")
-    expr = expr.replace("%", "/100")
     expr = re.sub(r"(\d)\s*\(", r"\1*(", expr)
     expr = re.sub(r"\)\s*(\d)", r")*\1", expr)
     expr = re.sub(r"(\d)([a-zA-Z])", r"\1*\2", expr)
     return expr
 
 
+def _extract_equation(text: str) -> Optional[str]:
+    cleaned = clean_math_text(text)
+    if "=" not in cleaned:
+        return None
+    patterns = [
+        r"([A-Za-z0-9\.\+\-\*/\^\(\)\s]*[a-zA-Z][A-Za-z0-9\.\+\-\*/\^\(\)\s]*=[A-Za-z0-9\.\+\-\*/\^\(\)\s]+)",
+        r"([0-9A-Za-z\.\+\-\*/\^\(\)\s]+=[0-9A-Za-z\.\+\-\*/\^\(\)\s]+)",
+    ]
+    for pattern in patterns:
+        for m in re.finditer(pattern, cleaned):
+            candidate = m.group(1).strip()
+            tokens = re.findall(r"[a-z]", candidate.lower())
+            if tokens and not candidate.lower().startswith(("how do", "can you", "please", "what is", "solve ")):
+                return candidate
+    eq_index = cleaned.find("=")
+    left = re.findall(r"[A-Za-z0-9\.\+\-\*/\^\(\)\s]+$", cleaned[:eq_index])
+    right = re.findall(r"^[A-Za-z0-9\.\+\-\*/\^\(\)\s]+", cleaned[eq_index + 1:])
+    if left and right:
+        candidate = left[0].strip().split()[-1] + " = " + right[0].strip().split()[0]
+        if re.search(r"[a-z]", candidate.lower()):
+            return candidate
+    return None
 
-def _parse_numeric_text(text: str) -> Optional[float]:
-    raw = clean_math_text(text).strip().lower()
-    raw_no_space = raw.replace(" ", "")
-
-    pct_match = re.fullmatch(r"(-?\d+(?:\.\d+)?)%", raw_no_space)
-    if pct_match:
-        return float(pct_match.group(1)) / 100.0
-
-    frac_match = re.fullmatch(r"(-?\d+)\s*/\s*(-?\d+)", raw)
-    if frac_match:
-        num, den = float(frac_match.group(1)), float(frac_match.group(2))
-        return None if den == 0 else num / den
 
+def _parse_number(text: str) -> Optional[float]:
+    raw = clean_math_text(text).strip().lower()
+    pct = re.fullmatch(r"(-?\d+(?:\.\d+)?)%", raw.replace(" ", ""))
+    if pct:
+        return float(pct.group(1)) / 100.0
+    frac = re.fullmatch(r"(-?\d+)\s*/\s*(-?\d+)", raw)
+    if frac:
+        den = float(frac.group(2))
+        if den == 0:
+            return None
+        return float(frac.group(1)) / den
     try:
         return float(eval(_prepare_expression(raw), {"__builtins__": {}}, {"sqrt": math.sqrt, "pi": math.pi}))
     except Exception:
         return None
 
 
-
-def compare_to_choices_numeric(answer_value: float, choices: Dict[str, str], tolerance: float = 1e-6) -> Optional[str]:
+def _best_choice(answer_value: float, choices: Dict[str, str]) -> Optional[str]:
     best_letter = None
     best_diff = float("inf")
     for letter, raw in choices.items():
-        parsed = _parse_numeric_text(raw)
+        parsed = _parse_number(raw)
         if parsed is None:
             continue
         diff = abs(parsed - answer_value)
         if diff < best_diff:
             best_diff = diff
             best_letter = letter
-    if best_letter is not None and best_diff <= tolerance:
+    if best_letter is not None and best_diff <= 1e-6:
         return best_letter
     return None
 
 
-
-def _solve_percent_patterns(text: str) -> Optional[SolverResult]:
+def _solve_percent(text: str) -> Optional[SolverResult]:
     lower = clean_math_text(text).lower()
     choices = extract_choices(text)
 
-    m = re.search(r"what is\s+(\d+(?:\.\d+)?)\s*(?:%|percent)\s+of\s+(\d+(?:\.\d+)?)", lower)
+    m = re.search(r"(\d+(?:\.\d+)?)\s*(?:%|percent)\s+of\s+(?:a\s+)?number\s+is\s+(\d+(?:\.\d+)?)", lower)
     if m:
-        p, n = float(m.group(1)), float(m.group(2))
-        ans = p / 100.0 * n
+        p = float(m.group(1))
+        value = float(m.group(2))
+        ans = value / (p / 100.0)
         return SolverResult(
-            solved=True,
             domain="quant",
-            explanation="Convert the percent to a decimal and multiply by the base quantity.",
-            internal_answer_value=f"{ans:g}",
-            internal_answer_letter=compare_to_choices_numeric(ans, choices) if choices else None,
-            detected_topic="percent",
+            solved=True,
+            topic="percent",
+            answer_value=f"{ans:g}",
+            answer_letter=_best_choice(ans, choices) if choices else None,
+            internal_answer=f"{ans:g}",
             steps=[
-                f"Rewrite {p}% as {p/100:g}.",
-                f"Multiply {p/100:g} by {n}.",
-                "Then compare your result with the answer choices.",
+                f"Let the number be n.",
+                f"Write {p}% of n as {p/100:g}n.",
+                f"Set {p/100:g}n = {value} and solve for n.",
             ],
         )
 
-    m = re.search(r"(\d+(?:\.\d+)?)\s+is\s+what percent of\s+(\d+(?:\.\d+)?)", lower)
+    m = re.search(r"what is\s+(\d+(?:\.\d+)?)\s*(?:%|percent)\s+of\s+(\d+(?:\.\d+)?)", lower)
     if m:
-        x, y = float(m.group(1)), float(m.group(2))
-        if y == 0:
-            return None
-        ans = x / y * 100.0
+        p = float(m.group(1))
+        n = float(m.group(2))
+        ans = p / 100.0 * n
         return SolverResult(
-            solved=True,
             domain="quant",
-            explanation="Set up part ÷ whole, then convert to a percent.",
-            internal_answer_value=f"{ans:g}%",
-            internal_answer_letter=None,
-            detected_topic="percent",
-            steps=[
-                f"Treat {x} as the part and {y} as the whole.",
-                f"Compute {x}/{y}.",
-                "Multiply by 100 to convert to a percent, then match to the choices.",
-            ],
+            solved=True,
+            topic="percent",
+            answer_value=f"{ans:g}",
+            answer_letter=_best_choice(ans, choices) if choices else None,
+            internal_answer=f"{ans:g}",
+            steps=[f"Convert {p}% to {p/100:g}.", f"Multiply by {n}."]
         )
     return None
 
 
-
-def _solve_average_patterns(text: str) -> Optional[SolverResult]:
+def _solve_mean_median(text: str) -> Optional[SolverResult]:
     lower = clean_math_text(text).lower()
     nums = [float(n) for n in re.findall(r"-?\d+(?:\.\d+)?", lower)]
     if not nums:
         return None
-
     if "mean" in lower or "average" in lower:
-        avg = mean(nums)
-        return SolverResult(
-            solved=True,
-            domain="quant",
-            explanation="Add the values and divide by how many values there are.",
-            internal_answer_value=f"{avg:g}",
-            detected_topic="statistics",
-            steps=[f"Add the listed values: total them carefully.", f"Count how many values there are: {len(nums)}.", "Divide total by count, then check the choices."],
-        )
-
+        ans = mean(nums)
+        return SolverResult(domain="quant", solved=True, topic="statistics", answer_value=f"{ans:g}", internal_answer=f"{ans:g}", steps=["Add the values.", f"Divide by {len(nums)}."])
     if "median" in lower:
-        med = median(nums)
-        return SolverResult(
-            solved=True,
-            domain="quant",
-            explanation="Order the values first, then identify the middle position.",
-            internal_answer_value=f"{med:g}",
-            detected_topic="statistics",
-            steps=["Write the numbers in increasing order.", "Find the middle value, or average the two middle values if there are an even number of terms.", "Compare that result with the choices."],
-        )
-    return None
-
-
-
-def _solve_ratio_patterns(text: str) -> Optional[SolverResult]:
-    lower = clean_math_text(text).lower()
-    m = re.search(r"ratio of\s+(\w+)\s+to\s+(\w+)\s+is\s+(\d+)\s*:\s*(\d+)", lower)
-    if m:
-        return SolverResult(
-            solved=True,
-            domain="quant",
-            explanation="Use the common multiplier that turns the ratio into the actual quantities.",
-            detected_topic="ratio",
-            steps=["Call the common multiplier k.", f"Write the two quantities as {m.group(3)}k and {m.group(4)}k.", "Use the extra condition in the question to solve for k, then compute the quantity you need."],
-        )
-    return None
-
-
-
-def _solve_divisibility_patterns(text: str) -> Optional[SolverResult]:
-    lower = clean_math_text(text).lower()
-    if "divisible by" in lower and "integer" in lower:
-        expr_match = re.search(r"if\s+([a-z])\s+is an integer and\s+(.+?)\s+is divisible by\s+(\d+)", lower)
-        if expr_match:
-            var = expr_match.group(1)
-            expr = expr_match.group(2)
-            divisor = int(expr_match.group(3))
-            choices = extract_choices(text)
-            valid_letters: List[str] = []
-            valid_values: List[str] = []
-            if sp:
-                symbol = sp.symbols(var)
-                parsed_expr = sp.sympify(_prepare_expression(expr))
-                for letter, raw_choice in choices.items():
-                    try:
-                        value = int(float(_parse_numeric_text(raw_choice)))
-                    except Exception:
-                        continue
-                    if parsed_expr.subs(symbol, value) % divisor == 0:
-                        valid_letters.append(letter)
-                        valid_values.append(str(value))
-            return SolverResult(
-                solved=bool(valid_letters),
-                domain="quant",
-                explanation="Test each answer choice in the divisibility condition instead of solving abstractly first.",
-                internal_answer_value=", ".join(valid_values) if valid_values else None,
-                internal_answer_letter=valid_letters[0] if len(valid_letters) == 1 else None,
-                detected_topic="number_theory",
-                steps=[
-                    f"Use the condition that the expression must be divisible by {divisor}.",
-                    "Substitute each answer choice into the expression.",
-                    "Keep the value that makes the result a multiple of the divisor.",
-                ],
-            )
+        ans = median(nums)
+        return SolverResult(domain="quant", solved=True, topic="statistics", answer_value=f"{ans:g}", internal_answer=f"{ans:g}", steps=["Order the values.", "Take the middle value."])
     return None
 
 
-
 def _solve_linear_equation(text: str) -> Optional[SolverResult]:
-    if not sp:
+    if sp is None:
         return None
-    cleaned = clean_math_text(text)
-    lower = cleaned.lower()
-    if "value of x" not in lower and not re.search(r"\bsolve\b", lower):
+    expr = _extract_equation(text)
+    if not expr:
         return None
-
-    eq_match = re.search(r"([\d\sa-zA-Z\+\-\*/\^\(\)=]+)", cleaned)
-    if not eq_match or "=" not in eq_match.group(1):
-        return None
-    expr = eq_match.group(1)
     try:
         lhs, rhs = expr.split("=", 1)
-        x = sp.symbols("x")
-        sol = sp.solve(sp.Eq(sp.sympify(_prepare_expression(lhs)), sp.sympify(_prepare_expression(rhs))), x)
+        symbols = sorted(set(re.findall(r"\b[a-z]\b", expr)))
+        if not symbols:
+            return None
+        var_name = symbols[0]
+        var = sp.symbols(var_name)
+        sol = sp.solve(sp.Eq(sp.sympify(_prepare_expression(lhs)), sp.sympify(_prepare_expression(rhs))), var)
         if not sol:
             return None
         value = sol[0]
+        try:
+            as_float = float(value)
+        except Exception:
+            as_float = None
+        choices = extract_choices(text)
         return SolverResult(
-            solved=True,
             domain="quant",
-            explanation="Isolate the variable by performing inverse operations on both sides.",
-            internal_answer_value=str(value),
-            detected_topic="algebra",
-            steps=["Simplify each side first if needed.", "Move variable terms to one side and constants to the other.", "Divide by the remaining coefficient, then compare with the choices."],
+            solved=True,
+            topic="algebra",
+            answer_value=str(value),
+            answer_letter=_best_choice(as_float, choices) if (as_float is not None and choices) else None,
+            internal_answer=f"{var_name} = {value}",
+            steps=[
+                "Treat the statement as an equation.",
+                "Undo operations on both sides to isolate the variable.",
+                f"That gives {var_name} = {value}.",
+            ],
         )
     except Exception:
         return None
 
 
-
 def solve_quant(text: str) -> SolverResult:
     text = text or ""
-    for solver in [_solve_percent_patterns, _solve_average_patterns, _solve_ratio_patterns, _solve_divisibility_patterns, _solve_linear_equation]:
-        result = solver(text)
-        if result:
+    for fn in (_solve_percent, _solve_mean_median, _solve_linear_equation):
+        result = fn(text)
+        if result is not None:
             return result
-
-    topic = "general_quant"
-    steps = [
-        "Identify exactly what quantity the question wants.",
-        "Translate the words into an equation, ratio, table, or diagram.",
-        "Do the calculation carefully.",
-        "Use the answer choices to check reasonableness and units.",
-    ]
     return SolverResult(
-        solved=False,
         domain="quant",
-        explanation="This looks quantitative, but it does not match a strong rule-based pattern yet.",
-        detected_topic=topic,
-        steps=steps,
+        solved=False,
+        topic="general_quant",
+        reply="This looks quantitative, but it does not match a strong rule-based pattern yet.",
+        steps=[
+            "Identify the quantity the question wants.",
+            "Translate the wording into an equation, ratio, or diagram.",
+            "Carry out the calculation carefully.",
+        ],
     )

retrieval_engine.py

@@ -1,133 +1,98 @@
 from __future__ import annotations
 
 import json
-from pathlib import Path
-from typing import List
+import os
+from typing import List, Optional
 
-import numpy as np
+from models import RetrievedChunk
+from utils import clean_math_text, score_token_overlap
 
 try:
-    from datasets import load_dataset
+    import numpy as np
 except Exception:
-    load_dataset = None
+    np = None
 
 try:
-    from sentence_transformers import CrossEncoder, SentenceTransformer
+    from sentence_transformers import SentenceTransformer
 except Exception:
-    CrossEncoder = None
     SentenceTransformer = None
 
-from config import settings
-from models import RetrievalChunk
-from utils import normalize_spaces
-
 
 class RetrievalEngine:
-    def __init__(self) -> None:
-        self.rows = self._load_rows()
-        self.texts = [normalize_spaces(row.get("text", "")) for row in self.rows]
-        self.embedder = None
-        self.reranker = None
+    def __init__(self, data_path: str = "data/gmat_hf_chunks.jsonl"):
+        self.data_path = data_path
+        self.rows = self._load_rows(data_path)
+        self.encoder = None
         self.embeddings = None
-
-        if SentenceTransformer is None or CrossEncoder is None:
-            return
-
-        try:
-            self.embedder = SentenceTransformer(settings.embedding_model)
-            self.reranker = CrossEncoder(settings.cross_encoder_model)
-            self.embeddings = self.embedder.encode(
-                self.texts,
-                batch_size=64,
-                convert_to_numpy=True,
-                normalize_embeddings=True,
-                show_progress_bar=False,
-            )
-        except Exception:
-            self.embedder = None
-            self.reranker = None
-            self.embeddings = None
-
-    def _load_rows(self) -> List[dict]:
-        local_path = Path(settings.local_chunks_path)
-        if local_path.exists():
-            rows = []
-            with local_path.open("r", encoding="utf-8") as f:
-                for line in f:
-                    line = line.strip()
-                    if line:
-                        rows.append(json.loads(line))
-            if rows:
-                return rows
-
-        if settings.enable_remote_dataset_fallback and load_dataset is not None:
-            ds = load_dataset(settings.dataset_repo_id, split=settings.dataset_split)
-            return [dict(row) for row in ds]
-
-        raise FileNotFoundError(
-            f"Could not load retrieval corpus from {local_path} or {settings.dataset_repo_id}."
-        )
-
-    def _lexical_search(self, query: str, k: int) -> List[RetrievalChunk]:
-        tokens = [t for t in normalize_spaces(query).lower().split() if t]
-        scored = []
-        for idx, text in enumerate(self.texts):
-            lower = text.lower()
-            score = sum(lower.count(tok) for tok in tokens)
-            if score > 0:
-                scored.append((idx, float(score)))
-        scored.sort(key=lambda x: x[1], reverse=True)
-        results: List[RetrievalChunk] = []
-        for idx, score in scored[:k]:
-            row = self.rows[int(idx)]
-            results.append(
-                RetrievalChunk(
-                    chunk_id=str(row.get("id", idx)),
-                    text=self.texts[int(idx)],
-                    source_name=str(row.get("source_name", "")),
-                    topic_guess=str(row.get("topic_guess", "")),
-                    score=float(score),
-                )
-            )
-        return results
-
-    def search(self, query: str, k: int | None = None) -> List[RetrievalChunk]:
-        query = normalize_spaces(query)
-        if not query:
+        if SentenceTransformer is not None and self.rows:
+            try:
+                self.encoder = SentenceTransformer("sentence-transformers/all-MiniLM-L6-v2")
+                self.embeddings = self.encoder.encode([r["text"] for r in self.rows], convert_to_numpy=True, normalize_embeddings=True)
+            except Exception:
+                self.encoder = None
+                self.embeddings = None
+
+    def _load_rows(self, data_path: str):
+        rows = []
+        if not os.path.exists(data_path):
+            return rows
+        with open(data_path, "r", encoding="utf-8") as f:
+            for line in f:
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    item = json.loads(line)
+                except Exception:
+                    continue
+                rows.append({
+                    "text": item.get("text", ""),
+                    "topic": item.get("topic", item.get("section", "general")) or "general",
+                    "source": item.get("source", "local_corpus"),
+                })
+        return rows
+
+    def _topic_bonus(self, desired_topic: str, row_topic: str, intent: str) -> float:
+        desired_topic = (desired_topic or "").lower()
+        row_topic = (row_topic or "").lower()
+        intent = (intent or "").lower()
+        bonus = 0.0
+        if desired_topic and desired_topic in row_topic:
+            bonus += 1.25
+        if desired_topic == "algebra" and row_topic in {"algebra", "linear equations", "equations"}:
+            bonus += 1.0
+        if desired_topic == "percent" and "percent" in row_topic:
+            bonus += 1.0
+        if intent in {"method", "step_by_step", "full_working", "hint"}:
+            if any(k in row_topic for k in ["algebra", "percent", "fractions", "word_problems", "general"]):
+                bonus += 0.25
+        return bonus
+
+    def search(self, query: str, topic: str = "", intent: str = "answer", k: int = 3) -> List[RetrievedChunk]:
+        if not self.rows:
             return []
-
-        top_k = k or settings.retrieval_k
-
-        if self.embedder is None or self.reranker is None or self.embeddings is None:
-            return self._lexical_search(query, settings.rerank_k)
-
-        query_emb = self.embedder.encode(
-            [query],
-            convert_to_numpy=True,
-            normalize_embeddings=True,
-            show_progress_bar=False,
-        )[0]
-
-        scores = np.dot(self.embeddings, query_emb)
-        candidate_idx = np.argsort(scores)[::-1][:top_k]
-        pairs = [[query, self.texts[i]] for i in candidate_idx]
-        rerank_scores = self.reranker.predict(pairs)
-        reranked = sorted(
-            zip(candidate_idx, rerank_scores),
-            key=lambda x: float(x[1]),
-            reverse=True,
-        )[: settings.rerank_k]
-
-        results: List[RetrievalChunk] = []
-        for idx, score in reranked:
-            row = self.rows[int(idx)]
-            results.append(
-                RetrievalChunk(
-                    chunk_id=str(row.get("id", idx)),
-                    text=self.texts[int(idx)],
-                    source_name=str(row.get("source_name", "")),
-                    topic_guess=str(row.get("topic_guess", "")),
-                    score=float(score),
-                )
-            )
+        combined_query = clean_math_text(query)
+
+        scores = []
+        if self.encoder is not None and self.embeddings is not None and np is not None:
+            try:
+                q = self.encoder.encode([combined_query], convert_to_numpy=True, normalize_embeddings=True)[0]
+                semantic_scores = self.embeddings @ q
+                for row, sem in zip(self.rows, semantic_scores.tolist()):
+                    lexical = score_token_overlap(combined_query, row["text"])
+                    bonus = self._topic_bonus(topic, row["topic"], intent)
+                    scores.append((0.7 * sem + 0.3 * lexical + bonus, row))
+            except Exception:
+                scores = []
+
+        if not scores:
+            for row in self.rows:
+                lexical = score_token_overlap(combined_query, row["text"])
+                bonus = self._topic_bonus(topic, row["topic"], intent)
+                scores.append((lexical + bonus, row))
+
+        scores.sort(key=lambda x: x[0], reverse=True)
+        results = []
+        for score, row in scores[:k]:
+            results.append(RetrievedChunk(text=row["text"], topic=row["topic"], source=row["source"], score=float(score)))
         return results

ui_html.py

@@ -2,68 +2,37 @@ HOME_HTML = """
 <!doctype html>
 <html>
 <head>
-  <meta charset="utf-8" />
-  <title>Trading Game Study AI</title>
+  <meta charset=\"utf-8\">
+  <meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">
+  <title>Trading Game AI V2</title>
   <style>
-    body { font-family: Arial, sans-serif; max-width: 980px; margin: 32px auto; line-height: 1.45; }
-    textarea, input { width: 100%; margin-top: 8px; padding: 10px; }
-    button { padding: 10px 14px; margin-top: 12px; cursor: pointer; }
-    pre { background: #f6f6f6; padding: 12px; overflow-x: auto; white-space: pre-wrap; }
-    .row { margin-bottom: 24px; }
+    body { font-family: Arial, sans-serif; max-width: 900px; margin: 40px auto; padding: 0 16px; }
+    textarea { width: 100%; min-height: 180px; }
+    button { margin-top: 12px; padding: 10px 16px; }
+    pre { background: #f5f5f5; padding: 16px; white-space: pre-wrap; }
   </style>
 </head>
 <body>
-  <h1>Trading Game Study AI</h1>
-  <p>This Space supports three things: quant-help chat, non-quant generative conversation, and researcher-facing study logging endpoints.</p>
-
-  <div class="row">
-    <h2>Chat test</h2>
-    <textarea id="msg" rows="8">What can you do in this game?</textarea>
-    <button onclick="sendChat()">Send /chat</button>
-    <pre id="chatOut"></pre>
-  </div>
-
-  <div class="row">
-    <h2>Session start test</h2>
-    <input id="participant" value="demo_participant_001" />
-    <button onclick="startSession()">Send /log/session/start</button>
-    <pre id="sessionOut"></pre>
-  </div>
-
+  <h1>Trading Game AI V2</h1>
+  <p>Test the <code>/chat</code> endpoint here.</p>
+  <textarea id=\"payload\">{
+  \"message\": \"Solve: x/5 = 12\",
+  \"chat_history\": [],
+  \"tone\": 0.5,
+  \"verbosity\": 0.6,
+  \"transparency\": 0.6,
+  \"session_id\": \"test-session-1\",
+  \"user_id\": \"test-user-1\"
+}</textarea>
+  <br>
+  <button onclick=\"send()\">Send</button>
+  <pre id=\"out\"></pre>
   <script>
-    let currentSessionId = null;
-
-    async function sendChat() {
-      const body = {
-        message: document.getElementById("msg").value,
-        tone: 0.7,
-        verbosity: 0.6,
-        transparency: 0.5,
-        chat_history: []
-      };
-      const res = await fetch("/chat", {
-        method: "POST",
-        headers: {"Content-Type": "application/json"},
-        body: JSON.stringify(body)
-      });
-      document.getElementById("chatOut").textContent = JSON.stringify(await res.json(), null, 2);
-    }
-
-    async function startSession() {
-      const body = {
-        participant_id: document.getElementById("participant").value,
-        condition: "demo",
-        study_id: "pilot",
-        metadata: {"source": "browser_test_page"}
-      };
-      const res = await fetch("/log/session/start", {
-        method: "POST",
-        headers: {"Content-Type": "application/json"},
-        body: JSON.stringify(body)
-      });
+    async function send() {
+      const payload = JSON.parse(document.getElementById('payload').value);
+      const res = await fetch('/chat', {method:'POST', headers:{'Content-Type':'application/json'}, body: JSON.stringify(payload)});
       const data = await res.json();
-      currentSessionId = data.session_id || null;
-      document.getElementById("sessionOut").textContent = JSON.stringify(data, null, 2);
+      document.getElementById('out').textContent = JSON.stringify(data, null, 2);
     }
   </script>
 </body>

utils.py

@@ -1,104 +1,102 @@
 from __future__ import annotations
 
+import ast
+import json
 import math
 import re
-from typing import Any, Iterable, List, Tuple
+from typing import Any, Iterable, List
 
-from models import ChatRequest, GameContext
+from models import ChatRequest
 
 
-USER_MESSAGE_MARKER = "USER_MESSAGE:"
-
-
-def clamp01(value: Any, default: float = 0.5) -> float:
+def clamp01(x: Any, default: float = 0.5) -> float:
     try:
-        v = float(value)
+        v = float(x)
         return max(0.0, min(1.0, v))
     except Exception:
         return default
 
 
 def normalize_spaces(text: str) -> str:
-    return re.sub(r"\s+", " ", (text or "")).strip()
+    return re.sub(r"\s+", " ", str(text or "")).strip()
 
 
 def clean_math_text(text: str) -> str:
-    text = (text or "")
-    text = text.replace("−", "-").replace("×", "*").replace("÷", "/")
-    text = text.replace("\u2212", "-").replace("\u00d7", "*").replace("\u00f7", "/")
-    text = text.replace("\u2264", "<=").replace("\u2265", ">=")
-    return text
+    t = str(text or "")
+    t = t.replace("×", "*").replace("÷", "/")
+    t = t.replace("–", "-").replace("—", "-").replace("−", "-")
+    t = t.replace("\u00a0", " ")
+    return t
+
+
+def tokenize(text: str) -> List[str]:
+    return re.findall(r"[a-z0-9]+", clean_math_text(text).lower())
+
+
+def score_token_overlap(query: str, text: str) -> float:
+    q = set(tokenize(query))
+    t = set(tokenize(text))
+    if not q or not t:
+        return 0.0
+    overlap = len(q & t)
+    return overlap / max(1, len(q))
+
+
+def extract_text_from_any_payload(payload: Any) -> str:
+    if payload is None:
+        return ""
+
+    if isinstance(payload, str):
+        s = payload.strip()
+        if not s:
+            return ""
+        if (s.startswith("{") and s.endswith("}")) or (s.startswith("[") and s.endswith("]")):
+            try:
+                decoded = json.loads(s)
+                return extract_text_from_any_payload(decoded)
+            except Exception:
+                pass
+        try:
+            decoded = ast.literal_eval(s)
+            if isinstance(decoded, (dict, list)):
+                return extract_text_from_any_payload(decoded)
+        except Exception:
+            pass
+        return s
+
+    if isinstance(payload, dict):
+        for key in [
+            "message", "prompt", "query", "text", "user_message",
+            "input", "data", "payload", "body", "content",
+        ]:
+            if key in payload:
+                maybe = extract_text_from_any_payload(payload[key])
+                if maybe:
+                    return maybe
+        parts = [extract_text_from_any_payload(v) for v in payload.values()]
+        return "\n".join([p for p in parts if p]).strip()
+
+    if isinstance(payload, list):
+        parts = [extract_text_from_any_payload(x) for x in payload]
+        return "\n".join([p for p in parts if p]).strip()
+
+    return str(payload).strip()
 
 
 def get_user_text(req: ChatRequest, raw_body: Any = None) -> str:
-    for field in [req.message, req.prompt, req.query, req.text, req.user_message]:
-        if isinstance(field, str) and field.strip():
-            return field.strip()
-    if isinstance(raw_body, str):
-        return raw_body.strip()
-    return ""
-
-
-def split_unity_message(full_text: str) -> Tuple[str, str]:
-    if not full_text:
-        return "", ""
-    idx = full_text.find(USER_MESSAGE_MARKER)
-    if idx == -1:
-        return "", full_text.strip()
-    return full_text[:idx].strip(), full_text[idx + len(USER_MESSAGE_MARKER):].strip()
-
-
-
-def _search_field(pattern: str, text: str) -> str:
-    m = re.search(pattern, text, flags=re.IGNORECASE | re.DOTALL)
-    return m.group(1).strip() if m else ""
-
-
-
-def parse_hidden_context(hidden_context: str) -> GameContext:
-    ctx = GameContext(raw_hidden_context=hidden_context or "")
-    if not hidden_context:
-        return ctx
-
-    ctx.question_category = _search_field(r"Category:\s*(.+)", hidden_context).splitlines()[0] if "Category:" in hidden_context else ""
-    ctx.question_difficulty = _search_field(r"Difficulty:\s*(.+)", hidden_context).splitlines()[0] if "Difficulty:" in hidden_context else ""
-    ctx.last_outcome = _search_field(r"Last outcome:\s*(.+)", hidden_context).splitlines()[0] if "Last outcome:" in hidden_context else ""
-
-    question = _search_field(r"Question:\s*(.+?)(?:\nOptions:|\nPlayer balance:|\nLast outcome:|$)", hidden_context)
-    options = _search_field(r"Options:\s*(.+?)(?:\nPlayer balance:|\nLast outcome:|$)", hidden_context)
-    balance_text = _search_field(r"Player balance:\s*([0-9]+(?:\.[0-9]+)?)", hidden_context)
-
-    ctx.question_text = question.strip()
-    ctx.options_text = options.strip()
-    try:
-        ctx.player_balance = float(balance_text) if balance_text else None
-    except Exception:
-        ctx.player_balance = None
-    return ctx
-
-
-
-def soft_truncate(text: str, limit: int) -> str:
-    text = (text or "").strip()
-    if len(text) <= limit:
-        return text
-    trimmed = text[: limit - 1].rsplit(" ", 1)[0].strip()
-    return (trimmed or text[: limit - 1]).rstrip() + "…"
-
-
-
-def safe_div(a: float, b: float) -> float:
-    return a / b if b else math.inf
-
-
-
-def flatten_history(items: Iterable[Any]) -> List[dict]:
-    out: List[dict] = []
-    for item in items or []:
-        if isinstance(item, dict):
-            out.append({"role": str(item.get("role", "user")), "text": str(item.get("text", ""))})
-        else:
-            role = getattr(item, "role", "user")
-            text = getattr(item, "text", "")
-            out.append({"role": str(role), "text": str(text)})
+    for field in ["message", "prompt", "query", "text", "user_message"]:
+        value = getattr(req, field, None)
+        if isinstance(value, str) and value.strip():
+            return value.strip()
+    return extract_text_from_any_payload(raw_body).strip()
+
+
+def short_lines(items: Iterable[str], limit: int) -> List[str]:
+    out: List[str] = []
+    for item in items:
+        item = normalize_spaces(item)
+        if item:
+            out.append(item)
+        if len(out) >= limit:
+            break
     return out