Update app.py

app.py

@@ -1,151 +1,76 @@
 from __future__ import annotations
 
-import os
-from typing import Any, Dict
-
-from fastapi import FastAPI, Request
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import HTMLResponse, JSONResponse
-
-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, get_user_text
-
-retriever = RetrievalEngine()
-generator = GeneratorEngine()
-engine = ConversationEngine(retriever=retriever, generator=generator)
-store = LoggingStore()
-
-app = FastAPI(title="Trading Game AI V2", version="2.3.0")
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-
-@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)
-def home() -> str:
-    return HOME_HTML
-
-
-@app.post("/chat")
-async def chat(request: Request) -> JSONResponse:
-    try:
-        raw_body: Any = None
-        try:
-            raw_body = await request.json()
-        except Exception:
-            try:
-                raw_body = (await request.body()).decode("utf-8", errors="ignore")
-            except Exception:
-                raw_body = None
-
-        req_data: Dict[str, Any] = raw_body if isinstance(raw_body, dict) else {}
-        req = ChatRequest(**req_data) if isinstance(req_data, dict) else ChatRequest()
-
-        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)
-
-        question_text = (getattr(req, "question_text", None) or "").strip() or game_fields["question"]
-        options_text = getattr(req, "options_text", None) or game_fields["options"]
-        category = (
-            req_data.get("category")
-            or getattr(req, "category", None)
-            or game_fields.get("category")
-        )
-
-        tone = clamp01(req_data.get("tone", getattr(req, "tone", 0.5)), 0.5)
-        verbosity = clamp01(req_data.get("verbosity", getattr(req, "verbosity", 0.5)), 0.5)
-        transparency = clamp01(req_data.get("transparency", getattr(req, "transparency", 0.5)), 0.5)
-
-        incoming_help_mode = req_data.get("help_mode", getattr(req, "help_mode", None))
-        explicit_intent = req_data.get("intent", getattr(req, "intent", None))
-        intent = explicit_intent or detect_intent(actual_user_message or full_text, incoming_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,
-            chat_history=getattr(req, "chat_history", None) or getattr(req, "history", None) or [],
-            question_text=question_text,
-            options_text=options_text,
-            category=category,
-        )
-
-        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,
-                },
-            }
-        )
-    except Exception as e:
-        return JSONResponse(
-            {
-                "error": type(e).__name__,
-                "detail": str(e),
-            },
-            status_code=500,
-        )
-
-
-@app.post("/log/session/start")
-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(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 log_session_finalize(payload: SessionFinalizeRequest) -> Dict[str, Any]:
-    return store.finalize_session(payload.session_id, payload.summary)
-
-
-@app.get("/research/sessions")
-def research_sessions() -> Dict[str, Any]:
-    return {"sessions": store.list_sessions()}
-
-
-@app.get("/research/session/{session_id}")
-def research_session(session_id: str) -> Dict[str, Any]:
-    return store.get_session(session_id)
-
-
-if __name__ == "__main__":
-    import uvicorn
-
-    port = int(os.getenv("PORT", "7860"))
-    uvicorn.run(app, host="0.0.0.0", port=port)
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional
+
+from pydantic import BaseModel
+
+
+class ChatRequest(BaseModel):
+    message: Optional[str] = None
+    prompt: Optional[str] = None
+    query: Optional[str] = None
+    text: Optional[str] = None
+    user_message: Optional[str] = None
+    input: Optional[str] = None
+    content: Optional[str] = None
+
+    tone: Optional[float] = 0.5
+    verbosity: Optional[float] = 0.5
+    transparency: Optional[float] = 0.5
+
+    help_mode: Optional[str] = None
+    intent: Optional[str] = None
+    category: Optional[str] = None
+    chat_history: Optional[List[Dict[str, Any]]] = None
+    history: Optional[List[Dict[str, Any]]] = None
+
+    question_text: Optional[str] = None
+    options_text: Optional[List[str]] = None
+    question_id: Optional[str] = None
+    session_id: Optional[str] = None
+    user_id: Optional[str] = None
+
+
+class SessionStartRequest(BaseModel):
+    session_id: str
+    user_id: Optional[str] = None
+    condition: Optional[str] = None
+    metadata: Optional[Dict[str, Any]] = None
+
+
+class EventLogRequest(BaseModel):
+    session_id: str
+    event_type: str
+    timestamp: Optional[str] = None
+    payload: Optional[Dict[str, Any]] = None
+
+
+class SessionFinalizeRequest(BaseModel):
+    session_id: str
+    summary: Optional[Dict[str, Any]] = None
+
+
+@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)