elkay: api.py, chatbot

phase/Student_view/chatbot.py

@@ -1,44 +1,29 @@
 # phase/Student_view/chatbot.py
 import streamlit as st
-import datetime, traceback
-from typing import List, Dict
-import utils.api as api  # <-- use backend
-
-TUTOR_PROMPT = (
-    "You are a kind Jamaican primary-school finance tutor. "
-    "Keep answers short, friendly, and age-appropriate. "
-    "Teach step-by-step with tiny examples. Avoid giving personal financial advice. "
-    "Ensure the explanations are based on the Jamaican context and currency (JMD). "
-    "If you don't know the answer, just say you don't know."
-)
-
-def _history_for_backend(messages: List[Dict]) -> List[Dict[str, str]]:
-    # Convert local history to backend chat format
-    msgs = [{"role": "system", "content": TUTOR_PROMPT}]
-    for m in messages:
-        txt = (m.get("text") or "").strip()
-        if not txt:
-            continue
-        role = "assistant" if (m.get("sender") == "assistant") else "user"
-        msgs.append({"role": role, "content": txt})
-    return msgs
+import datetime
+import traceback
+import sys
+from pathlib import Path
+
+# --- Make sure we can import phase/api.py no matter where Streamlit runs from ---
+ROOT = Path(__file__).resolve().parents[1]  # .../phase
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+import api as backend  # uses BACKEND_URL + optional BACKEND_TOKEN
 
-def add_message(text: str, sender: str):
-    if "messages" not in st.session_state:
-        st.session_state.messages = []
-    st.session_state.messages.append(
-        {
-            "id": str(datetime.datetime.now().timestamp()),
-            "text": text,
-            "sender": sender,
-            "timestamp": datetime.datetime.now()
-        }
-    )
 
+TUTOR_WELCOME = "Hi! I'm your AI Financial Tutor. What would you like to learn today?"
+
+
+# -------------------------------
+# Session helpers
+# -------------------------------
 def _coerce_ts(ts):
     if isinstance(ts, datetime.datetime):
         return ts
     try:
+        # try epoch
         if isinstance(ts, (int, float)):
             return datetime.datetime.fromtimestamp(ts)
         if isinstance(ts, str):
@@ -47,8 +32,9 @@ def _coerce_ts(ts):
             except Exception:
                 return datetime.datetime.fromtimestamp(float(ts))
     except Exception:
-        return None
-    return None
+        pass
+    return datetime.datetime.now()
+
 
 def _normalize_messages():
     msgs = st.session_state.get("messages", [])
@@ -58,80 +44,128 @@ def _normalize_messages():
         text = (m.get("text") or "").strip()
         sender = m.get("sender") or "user"
         ts = _coerce_ts(m.get("timestamp")) or now
-        normed.append({**m, "text": text, "sender": sender, "timestamp": ts})
+        if text:
+            normed.append({**m, "text": text, "sender": sender, "timestamp": ts})
     st.session_state.messages = normed
 
-def _reply_with_backend():
-    # Identify context — if your app tracks current lesson/level in session, use it here
-    lesson_id = st.session_state.get("current_lesson_id", 0)
-    level_slug = st.session_state.get("current_level_slug", "beginner")
 
-    user_query = st.session_state.messages[-1]["text"]
-    history = _history_for_backend(st.session_state.get("messages", []))
+def add_message(text: str, sender: str):
+    if "messages" not in st.session_state:
+        st.session_state.messages = []
+    st.session_state.messages.append(
+        {
+            "id": str(datetime.datetime.now().timestamp()),
+            "text": text,
+            "sender": sender,
+            "timestamp": datetime.datetime.now(),
+        }
+    )
+
+
+def _history_for_backend():
+    """
+    Convert local message format -> backend ChatRequest.history
+    Keeps only the last ~10 turns to keep prompts lean.
+    """
+    hist = []
+    for m in st.session_state.get("messages", [])[-20:]:
+        role = "assistant" if m.get("sender") == "assistant" else "user"
+        hist.append({"role": role, "content": m.get("text", "")})
+    return hist
 
-    # Let backend do retrieval + chat generation
-    return api.chat_ai(user_query, lesson_id=lesson_id, level_slug=level_slug, history=history)
 
+# -------------------------------
+# Streamlit page
+# -------------------------------
 def show_page():
     st.title("🤖 AI Financial Tutor")
-    st.caption("Get personalized help with your financial questions")
+    st.caption("Backed by your local TinyLlama on the backend")
+
+    # Health ping (optional, but helpful)
+    col_a, col_b = st.columns(2)
+    with col_a:
+        try:
+            h = backend.health()
+            ok = h.get("status") == "ok"
+            st.success(f"Backend: {'OK' if ok else 'Not ready'}")
+        except Exception as e:
+            st.error(f"Backend health failed: {e}")
 
+    # First-time session state
     if "messages" not in st.session_state:
         st.session_state.messages = [{
-            "id": "1",
-            "text": "Hi! I'm your AI Financial Tutor. What would you like to learn today?",
+            "id": "welcome",
+            "text": TUTOR_WELCOME,
             "sender": "assistant",
-            "timestamp": datetime.datetime.now()
+            "timestamp": datetime.datetime.now(),
         }]
     if "is_typing" not in st.session_state:
         st.session_state.is_typing = False
 
     _normalize_messages()
 
+    # Chat history bubbles
     chat_container = st.container()
     with chat_container:
         for msg in st.session_state.messages:
-            time_str = msg["timestamp"].strftime("%H:%M") if hasattr(msg["timestamp"], "strftime") else datetime.datetime.now().strftime("%H:%M")
-            bubble = (
-                f"<div style='background-color:#e0e0e0; color:black; padding:10px; border-radius:12px; max-width:70%; margin-bottom:5px;'>"
-                f"{msg.get('text','')}<br><sub>{time_str}</sub></div>"
-                if msg.get("sender") == "assistant" else
-                f"<div style='background-color:#4CAF50; color:white; padding:10px; border-radius:12px; max-width:70%; margin-left:auto; margin-bottom:5px;'>"
-                f"{msg.get('text','')}<br><sub>{time_str}</sub></div>"
-            )
+            time_str = msg["timestamp"].strftime("%H:%M")
+            if msg.get("sender") == "assistant":
+                bubble = (
+                    f"<div style='background:#e0e0e0;color:#000;padding:10px;border-radius:12px;"
+                    f"max-width:70%;margin-bottom:6px;'>{msg.get('text','')}<br>"
+                    f"<sub>{time_str}</sub></div>"
+                )
+            else:
+                bubble = (
+                    f"<div style='background:#4CAF50;color:#fff;padding:10px;border-radius:12px;"
+                    f"max-width:70%;margin-left:auto;margin-bottom:6px;'>{msg.get('text','')}<br>"
+                    f"<sub>{time_str}</sub></div>"
+                )
             st.markdown(bubble, unsafe_allow_html=True)
 
         if st.session_state.is_typing:
-            st.markdown("🤖 _FinanceBot is typing..._")
+            st.markdown("🤖 _Tutor is typing..._")
 
+    # Quick starters
     if len(st.session_state.messages) == 1:
         st.markdown("Try asking about:")
         cols = st.columns(2)
-        quick = [
+        for i, q in enumerate([
             "How does compound interest work?",
             "How much should I save for emergencies?",
-            "What's a good budgeting strategy?",
-            "How do I start investing?"
-        ]
-        for i, q in enumerate(quick):
-            if cols[i % 2].button(q, key=f"quick_{i}"):
+            "What's a simple budgeting rule?",
+            "How do I start investing safely?",
+        ]):
+            if cols[i % 2].button(q):
                 add_message(q, "user")
                 st.session_state.is_typing = True
                 st.rerun()
 
-    user_input = st.chat_input("Ask me anything about personal finance...")
+    # Input
+    user_input = st.chat_input("Ask me anything about personal finance…")
     if user_input:
         add_message(user_input, "user")
         st.session_state.is_typing = True
         st.rerun()
 
+    # Produce reply (via backend /chat)
     if st.session_state.is_typing:
         try:
-            with st.spinner("FinanceBot is thinking..."):
-                bot_reply = _reply_with_backend()
+            with st.spinner("Thinking…"):
+                history = _history_for_backend()
+                # If your app tracks lesson_id/level in session, pass them here; else use defaults.
+                lesson_id = st.session_state.get("current_lesson_id", 0)
+                level = st.session_state.get("current_level_slug", "beginner")
+
+                bot_reply = backend.chat_ai(
+                    query=st.session_state.messages[-1]["text"],
+                    lesson_id=lesson_id,
+                    level_slug=level,
+                    history=history,
+                ) or "I couldn't generate a response just now."
                 add_message(bot_reply, "assistant")
         except Exception as e:
-            add_message(f"⚠️ Error: {e}", "assistant")
+            add_message(f"⚠️ Error: {''.join(traceback.format_exception_only(type(e), e)).strip()}", "assistant")
         finally:
             st.session_state.is_typing = False
             st.rerun()

utils/api.py

@@ -1,4 +1,8 @@
-import os, json, requests, logging
+# phase/api.py
+import os
+import json
+import logging
+import requests
 from urllib3.util.retry import Retry
 from requests.adapters import HTTPAdapter
 
@@ -7,15 +11,10 @@ BACKEND = (os.getenv("BACKEND_URL") or "").strip().rstrip("/")
 if not BACKEND:
     raise RuntimeError("BACKEND_URL is not set in Space secrets.")
 
-BACKEND_URL = os.getenv("BACKEND_URL")
-
 TOKEN = (os.getenv("BACKEND_TOKEN") or os.getenv("HF_TOKEN") or "").strip()
-
-# Increased timeout for potential late-night latency
 DEFAULT_TIMEOUT = int(os.getenv("BACKEND_TIMEOUT", "60"))
 
 _session = requests.Session()
-
 retry = Retry(
     total=3,
     connect=3,
@@ -26,7 +25,6 @@ retry = Retry(
 )
 _session.mount("https://", HTTPAdapter(max_retries=retry))
 _session.mount("http://", HTTPAdapter(max_retries=retry))
-
 _session.headers.update({
     "Accept": "application/json, */*;q=0.1",
     "User-Agent": "FinEdu-Frontend/1.0 (+spaces)",
@@ -34,12 +32,17 @@ _session.headers.update({
 if TOKEN:
     _session.headers["Authorization"] = f"Bearer {TOKEN}"
 
-# Setup logging for debugging
-logging.basicConfig(level=logging.DEBUG)
+logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
+# --- Optional API prefix (e.g., "/api")
+API_PREFIX_ENV = (os.getenv("BACKEND_API_PREFIX") or "").strip().rstrip("/")
+def _prefixes():
+    return ["/" + API_PREFIX_ENV.strip("/"), ""] if API_PREFIX_ENV else [""]
+
+# ---- Core helpers ----
 def _json_or_raise(resp: requests.Response):
-    ctype = resp.headers.get("content-type", "")
+    ctype = (resp.headers.get("content-type") or "").lower()
     if "application/json" in ctype:
         return resp.json()
     try:
@@ -51,29 +54,34 @@ def _json_or_raise(resp: requests.Response):
 def _req(method: str, path: str, **kw):
     if not path.startswith("/"):
         path = "/" + path
-    url = f"{BACKEND}{path}"
-    kw.setdefault("timeout", DEFAULT_TIMEOUT)
-    try:
-        r = _session.request(method, url, **kw)
-        r.raise_for_status()
-    except requests.HTTPError as e:
-        body = ""
+    for pref in _prefixes():
+        url = f"{BACKEND}{pref}{path}"
         try:
-            body = r.text[:500]
-        except Exception:
-            pass
-        status = getattr(r, "status_code", "?")
-        if status in (401, 403):
-            raise RuntimeError(
-                f"{method} {path} failed [{status}] – auth rejected. "
-                f"Check BACKEND_TOKEN/HF_TOKEN permissions and that the backend Space is private/readable."
-            ) from e
-        raise RuntimeError(f"{method} {path} failed [{status}]: {body}") from e
-    except requests.RequestException as e:
-        raise RuntimeError(f"{method} {path} failed: {e.__class__.__name__}: {e}") from e
-    return r
-
-# ---- Health ----
+            r = _session.request(method, url, timeout=DEFAULT_TIMEOUT, **kw)
+            r.raise_for_status()
+            return r
+        except requests.HTTPError as e:
+            status = getattr(e.response, "status_code", "?")
+            # try next prefix on 404
+            if status == 404:
+                continue
+            body = ""
+            try:
+                body = e.response.text[:500]
+            except Exception:
+                pass
+            if status in (401, 403):
+                raise RuntimeError(
+                    f"{method} {url} failed [{status}] – auth rejected. "
+                    f"Check BACKEND_TOKEN/HF_TOKEN and backend visibility."
+                ) from e
+            raise RuntimeError(f"{method} {url} failed [{status}]: {body}") from e
+        except requests.RequestException as e:
+            # try next prefix
+            continue
+    raise RuntimeError(f"No matching endpoint for {method} {path} with prefixes {list(_prefixes())}")
+
+# ---- Public helpers ----
 def health():
     try:
         return _json_or_raise(_req("GET", "/health"))
@@ -83,187 +91,42 @@ def health():
             return {"ok": True}
         except Exception:
             return {"ok": False}
-        
-# --- Optional API prefix (e.g., "/api" or "/v1")
-API_PREFIX_ENV = (os.getenv("BACKEND_API_PREFIX") or "").strip().rstrip("/")
-
-def _prefixes():
-    if API_PREFIX_ENV:
-        return ["/" + API_PREFIX_ENV.strip("/"), ""]
-    return [""]
-
-def _try_candidates(method: str, candidates: list[tuple[str, dict]]):
-    tried = []
-    for pref in _prefixes():
-        for path, kw in candidates:
-            url = f"{BACKEND}{pref}{path}"
-            tried.append(f"{method} {url}")
-            try:
-                r = _session.request(method, url, timeout=DEFAULT_TIMEOUT, **kw)
-            except requests.RequestException as e:
-                continue
-            if r.status_code in (401, 403):
-                snippet = (r.text or "")[:200]
-                raise RuntimeError(f"{method} {path} auth failed [{r.status_code}]: {snippet}")
-            if 200 <= r.status_code < 300:
-                return _json_or_raise(r)
-    raise RuntimeError("No matching endpoint for this operation. Tried:\n- " + "\n- ".join(tried))
-
-
-
 
-class _BackendError(Exception):
-    pass
-
-def _get(url, params=None, timeout=30):
-    if not BACKEND_URL:
-        raise _BackendError("BACKEND_URL is not set")
-    r = requests.get(f"{BACKEND_URL}{url}", params=params or {}, timeout=timeout)
-    r.raise_for_status()
-    return r.json()
-
-def _post(url, json=None, timeout=60):
-    if not BACKEND_URL:
-        raise _BackendError("BACKEND_URL is not set")
-    r = requests.post(f"{BACKEND_URL}{url}", json=json or {}, timeout=timeout)
-    r.raise_for_status()
-    return r.json()
-
-def retrieve(query: str, lesson_id: int, level_slug: str = "beginner", k: int = 5) -> str:
-    try:
-        data = _get("/retrieve", params={"query": query, "lesson_id": lesson_id, "level_slug": level_slug, "k": k})
-        return data.get("context", "")
-    except Exception as e:
-        return f"(retrieval failed: {e})"
+# ---------- Auth ----------
+def login(email: str, password: str):
+    return _json_or_raise(_req("POST", "/auth/login", json={"email": email, "password": password}))
 
-def chat_ai(query: str, lesson_id: int, level_slug: str, history=None) -> str:
+def signup_student(name: str, email: str, password: str, level_label: str, country_label: str):
     payload = {
-        "query": query,
-        "lesson_id": lesson_id,
-        "level_slug": level_slug or "beginner",
-        "history": history or []
+        "name": name, "email": email, "password": password,
+        "level_label": level_label, "country_label": country_label
     }
-    try:
-        data = _post("/chat", json=payload, timeout=90)
-        return data.get("answer", "")
-    except Exception as e:
-        return f"(chat failed: {e})"
-    
+    return _json_or_raise(_req("POST", "/auth/signup/student", json=payload))
 
+def signup_teacher(title: str, name: str, email: str, password: str):
+    payload = {"title": title, "name": name, "email": email, "password": password}
+    return _json_or_raise(_req("POST", "/auth/signup/teacher", json=payload))
 
-# -- Helpers for student_db.py
-def user_stats(student_id: int):
-    return _req("GET", f"/students/{student_id}/stats").json()
-def list_assignments_for_student(student_id: int):
-    return _req("GET", f"/students/{student_id}/assignments").json()
-def student_quiz_average(student_id: int):
-    d = _req("GET", f"/students/{student_id}/quiz_avg").json()
-    if isinstance(d, dict):
-        for k in ("avg", "average", "score_pct", "score", "value"):
-            if k in d:
-                v = d[k]
-                break
-        else:
-            v = next((vv for vv in d.values() if isinstance(vv, (int, float, str))), 0)
-    else:
-        v = d
-    try:
-        return int(round(float(str(v).strip().rstrip("%"))))
-    except Exception:
-        return 0
-def recent_lessons_for_student(student_id: int, limit: int = 5):
-    return _req("GET", f"/students/{student_id}/recent", params={"limit": limit}).json()
-
-# -- Teacher endpoints (backend Space)
+# ---------- Classes ----------
 def create_class(teacher_id: int, name: str):
-    return _try_candidates("POST", [
-        (f"/teachers/{teacher_id}/classes", {"json": {"name": name}}),
-        ("/classes", {"json": {"teacher_id": teacher_id, "name": name}}),
-    ])
-
-def teacher_tiles(teacher_id: int):
-    return _json_or_raise(_req("GET", f"/teachers/{teacher_id}/tiles"))
+    return _json_or_raise(_req("POST", f"/teachers/{teacher_id}/classes", json={"name": name}))
 
 def list_classes_by_teacher(teacher_id: int):
-    return _try_candidates("GET", [
-        (f"/teachers/{teacher_id}/classes", {}),
-    ])
-
-def class_student_metrics(class_id: int):
-    return _try_candidates("GET", [
-        (f"/classes/{class_id}/students/metrics", {}),
-        (f"/classes/{class_id}/student_metrics", {}),
-        (f"/classes/{class_id}/students", {}),
-    ])
-
-def class_weekly_activity(class_id: int):
-    return _try_candidates("GET", [
-        (f"/classes/{class_id}/activity/weekly", {}),
-        (f"/classes/{class_id}/weekly_activity", {}),
-    ])
-
-def class_progress_overview(class_id: int):
-    return _try_candidates("GET", [
-        (f"/classes/{class_id}/progress", {}),
-        (f"/classes/{class_id}/progress_overview", {}),
-    ])
+    return _json_or_raise(_req("GET", f"/teachers/{teacher_id}/classes"))
 
-def class_recent_activity(class_id: int, limit=6, days=30):
-    return _try_candidates("GET", [
-        (f"/classes/{class_id}/activity/recent", {"params": {"limit": limit, "days": days}}),
-        (f"/classes/{class_id}/recent_activity", {"params": {"limit": limit, "days": days}}),
-    ])
-
-def list_students_in_class(class_id: int):
-    return _json_or_raise(_req("GET", f"/classes/{class_id}/students"))
-
-def level_from_xp(xp: int):
-    return _json_or_raise(_req("GET", "/levels/from_xp", params={"xp": xp}))["level"]
-
-# -- teacherlink.py helpers
 def join_class_by_code(student_id: int, code: str):
     d = _json_or_raise(_req("POST", f"/students/{student_id}/classes/join", json={"code": code}))
     return d.get("class_id", d)
 
-def list_classes_for_student(student_id: int):
-    return _json_or_raise(_req("GET", f"/students/{student_id}/classes"))
-
-def class_content_counts(class_id: int):
-    return _try_candidates("GET", [
-        (f"/classes/{class_id}/content_counts", {}),
-        (f"/classes/{class_id}/counts", {}),
-    ])
-
-def student_class_progress(student_id: int, class_id: int):
-    return _json_or_raise(_req("GET", f"/classes/{class_id}/students/{student_id}/progress"))
-
 def leave_class(student_id: int, class_id: int):
     _json_or_raise(_req("POST", f"/classes/{class_id}/leave", json={"student_id": student_id}))
     return True
 
-def student_assignments_for_class(student_id: int, class_id: int):
-    return _json_or_raise(_req("GET", f"/classes/{class_id}/students/{student_id}/assignments"))
-
-# ---------- TEACHERS / CLASSES / CONTENT (BACKEND ROUTES THAT EXIST) ----------
-def create_class(teacher_id: int, name: str):
-    return _try_candidates("POST", [
-        (f"/teachers/{teacher_id}/classes", {"json": {"name": name}}),
-        ("/classes", {"json": {"teacher_id": teacher_id, "name": name}}),
-    ])
-
-def list_classes_by_teacher(teacher_id: int):
-    return _try_candidates("GET", [
-        (f"/teachers/{teacher_id}/classes", {}),
-    ])
-
 def list_students_in_class(class_id: int):
     return _json_or_raise(_req("GET", f"/classes/{class_id}/students"))
 
 def class_content_counts(class_id: int):
-    return _try_candidates("GET", [
-        (f"/classes/{class_id}/content_counts", {}),
-        (f"/classes/{class_id}/counts", {}),
-    ])
+    return _json_or_raise(_req("GET", f"/classes/{class_id}/content_counts"))
 
 def list_class_assignments(class_id: int):
     return _json_or_raise(_req("GET", f"/classes/{class_id}/assignments"))
@@ -271,51 +134,36 @@ def list_class_assignments(class_id: int):
 def class_analytics(class_id: int):
     return _json_or_raise(_req("GET", f"/classes/{class_id}/analytics"))
 
-def teacher_tiles(teacher_id: int):
-    return _json_or_raise(_req("GET", f"/teachers/{teacher_id}/tiles"))
-
 def class_student_metrics(class_id: int):
-    return _try_candidates("GET", [
-        (f"/classes/{class_id}/students/metrics", {}),
-        (f"/classes/{class_id}/student_metrics", {}),
-        (f"/classes/{class_id}/students", {}),
-    ])
+    return _json_or_raise(_req("GET", f"/classes/{class_id}/students/metrics"))
 
 def class_weekly_activity(class_id: int):
-    return _try_candidates("GET", [
-        (f"/classes/{class_id}/activity/weekly", {}),
-        (f"/classes/{class_id}/weekly_activity", {}),
-    ])
+    return _json_or_raise(_req("GET", f"/classes/{class_id}/activity/weekly"))
 
 def class_progress_overview(class_id: int):
-    return _try_candidates("GET", [
-        (f"/classes/{class_id}/progress", {}),
-        (f"/classes/{class_id}/progress_overview", {}),
-    ])
+    return _json_or_raise(_req("GET", f"/classes/{class_id}/progress"))
 
 def class_recent_activity(class_id: int, limit=6, days=30):
-    return _try_candidates("GET", [
-        (f"/classes/{class_id}/activity/recent", {"params": {"limit": limit, "days": days}}),
-        (f"/classes/{class_id}/recent_activity", {"params": {"limit": limit, "days": days}}),
-    ])
+    return _json_or_raise(_req("GET", f"/classes/{class_id}/activity/recent",
+                               params={"limit": limit, "days": days}))
+
+def student_class_progress(student_id: int, class_id: int):
+    return _json_or_raise(_req("GET", f"/classes/{class_id}/students/{student_id}/progress"))
+
+def student_assignments_for_class(student_id: int, class_id: int):
+    return _json_or_raise(_req("GET", f"/classes/{class_id}/students/{student_id}/assignments"))
 
-# Lessons
+# ---------- Lessons ----------
 def list_lessons_by_teacher(teacher_id: int):
     return _json_or_raise(_req("GET", f"/teachers/{teacher_id}/lessons"))
 
 def create_lesson(teacher_id: int, title: str, description: str,
                   subject: str, level: str, sections: list[dict]):
     payload = {
-        "title": title,
-        "description": description,
-        "subject": subject,
-        "level": level,
-        "sections": sections,
+        "title": title, "description": description,
+        "subject": subject, "level": level, "sections": sections,
     }
-    d = _try_candidates("POST", [
-        (f"/teachers/{teacher_id}/lessons", {"json": payload}),
-        ("/lessons", {"json": {"teacher_id": teacher_id, **payload}}),
-    ])
+    d = _json_or_raise(_req("POST", f"/teachers/{teacher_id}/lessons", json=payload))
     return d.get("lesson_id", d.get("id", d))
 
 def get_lesson(lesson_id: int):
@@ -323,96 +171,46 @@ def get_lesson(lesson_id: int):
 
 def update_lesson(lesson_id: int, teacher_id: int, title: str, description: str,
                   subject: str, level: str, sections: list[dict]):
-    d = _req("PUT", f"/lessons/{lesson_id}", json={
-        "teacher_id": teacher_id,
-        "title": title,
-        "description": description,
-        "subject": subject,
-        "level": level,
-        "sections": sections
-    }).json()
+    d = _json_or_raise(_req("PUT", f"/lessons/{lesson_id}", json={
+        "teacher_id": teacher_id, "title": title, "description": description,
+        "subject": subject, "level": level, "sections": sections
+    }))
     return bool(d.get("ok", True))
 
 def delete_lesson(lesson_id: int, teacher_id: int):
-    d = _req("DELETE", f"/lessons/{lesson_id}", json={"teacher_id": teacher_id}).json()
+    d = _json_or_raise(_req("DELETE", f"/lessons/{lesson_id}", json={"teacher_id": teacher_id}))
     return bool(d.get("ok", True)), d.get("message", "")
 
-# Quizzes
+def list_assigned_students_for_lesson(lesson_id: int):
+    return _json_or_raise(_req("GET", f"/lessons/{lesson_id}/assignees"))
+
+# ---------- Quizzes ----------
 def list_quizzes_by_teacher(teacher_id: int):
     return _json_or_raise(_req("GET", f"/teachers/{teacher_id}/quizzes"))
 
-def create_quiz(lesson_id: int, title: str, items: list[dict], settings: dict):
-    d = _req("POST", "/quizzes", json={
-        "lesson_id": lesson_id, "title": title, "items": items, "settings": settings
-    }).json()
-    return d.get("quiz_id", d.get("id", d))
-
-def mark_assignment_started(student_id: int, assignment_id: int):
-    return _req("POST",
-                f"/assignments/{assignment_id}/start",
-                json={"student_id": student_id}).json()
-
-def set_assignment_progress(student_id: int, assignment_id: int, current_pos: int, progress: float):
-    return _req("PATCH",
-                f"/assignments/{assignment_id}/progress",
-                json={"student_id": student_id, "current_pos": current_pos, "progress": progress}).json()
-
 def get_quiz(quiz_id: int):
-    """Fetch a teacher-created quiz (GET /quizzes/{quiz_id}) and return JSON."""
     return _json_or_raise(_req("GET", f"/quizzes/{quiz_id}"))
 
-def submit_quiz(*, lesson_id: int | None, level_slug: str | None,
-                user_answers: list[dict], original_quiz: list[dict]):
-    """
-    Grade the quiz on the backend. Returns:
-      {"score":{"correct":int,"total":int}, "wrong":[...], "feedback":str}
-    """
-    payload = {
-        "lesson_id": int(lesson_id) if lesson_id is not None else None,
-        "level_slug": level_slug,
-        "user_answers": user_answers,
-        "original_quiz": original_quiz,
-    }
-    return _try_candidates("POST", [
-        ("/quiz/submit", {"json": payload}),
-    ])
+def create_quiz(lesson_id: int, title: str, items: list[dict], settings: dict):
+    d = _json_or_raise(_req("POST", "/quizzes", json={
+        "lesson_id": lesson_id, "title": title, "items": items, "settings": settings
+    }))
+    return d.get("quiz_id", d.get("id", d))
 
-def update_quiz(quiz_id: int,
-                teacher_id: int, title: str, items: list[dict], settings: dict):
-    d = _req("PUT", f"/quizzes/{quiz_id}", json={
+def update_quiz(quiz_id: int, teacher_id: int, title: str, items: list[dict], settings: dict):
+    d = _json_or_raise(_req("PUT", f"/quizzes/{quiz_id}", json={
         "teacher_id": teacher_id, "title": title, "items": items, "settings": settings
-    }).json()
+    }))
     return bool(d.get("ok", True))
 
 def delete_quiz(quiz_id: int, teacher_id: int):
-    d = _req("DELETE", f"/quizzes/{quiz_id}", json={"teacher_id": teacher_id}).json()
+    d = _json_or_raise(_req("DELETE", f"/quizzes/{quiz_id}", json={"teacher_id": teacher_id}))
     return bool(d.get("ok", True)), d.get("message", "")
 
-def list_assigned_students_for_lesson(lesson_id: int):
-    return _json_or_raise(_req("GET", f"/lessons/{lesson_id}/assignees"))
-
-def list_assigned_students_for_quiz(quiz_id: int):
-    return _json_or_raise(_req("GET", f"/quizzes/{quiz_id}/assignees"))
-
-# Assignments
-def assign_to_class(lesson_id: int | None, quiz_id: int | None, class_id: int, teacher_id: int, due_at: str | None = None):
-    d = _try_candidates("POST", [
-        ("/assign", {"json": {
-            "lesson_id": lesson_id, "quiz_id": quiz_id,
-            "class_id": class_id, "teacher_id": teacher_id, "due_at": due_at
-        }}),
-        ("/assignments", {"json": {
-            "lesson_id": lesson_id, "quiz_id": quiz_id,
-            "class_id": class_id, "teacher_id": teacher_id, "due_at": due_at
-        }}),
-    ])
-    return bool(d.get("ok", True))
-
-# ---------- LLM-based quiz generation (backend uses GEN_MODEL) ----------
 def generate_quiz_from_text(content: str, n_questions: int = 5, subject: str = "finance", level: str = "beginner"):
-    return _req("POST", "/quiz/generate", json={
+    return _json_or_raise(_req("POST", "/quiz/generate", json={
         "content": content, "n_questions": n_questions, "subject": subject, "level": level
-    }).json()
+    }))
 
 def generate_quiz(*, lesson_id: int | None, level_slug: str | None, lesson_title: str | None):
     payload = {
@@ -420,138 +218,138 @@ def generate_quiz(*, lesson_id: int | None, level_slug: str | None, lesson_title
         "level_slug": level_slug,
         "lesson_title": lesson_title,
     }
-    logger.debug(f"Generating quiz with POST method and payload: {payload}")
-    try:
-        resp = _req("POST", "/quiz/auto", json=payload)
-        logger.debug(f"Raw response from /quiz/auto: {resp.text}")
-        logger.debug(f"Response status code: {resp.status_code}")
-        result = _json_or_raise(resp)
-        # Ensure result is a list of quiz items, handling Qwen's potential JSON structure
-        if isinstance(result, dict) and "items" in result:
-            return result["items"]
-        return result if isinstance(result, list) else []
-    except requests.HTTPError as e:
-        logger.error(f"HTTP Error in quiz generation: {e.response.status_code} - {e.response.text}")
-        return []
-    except RuntimeError as e:
-        logger.error(f"Quiz generation failed: {str(e)}")
-        return []  # Return empty list to prevent app crash
-
-# ---- Legacy agent endpoints (keep) ----
-def start_agent(student_id: int, lesson_id: int, level_slug: str):
-    return _json_or_raise(_req("POST", "/agent/start",
-                               json={"student_id": student_id, "lesson_id": lesson_id, "level_slug": level_slug}))
-
-def get_agent_quiz(student_id: int, lesson_id: int, level_slug: str):
-    d = _json_or_raise(_req("POST", "/agent/quiz",
-                            json={"student_id": student_id, "lesson_id": lesson_id, "level_slug": level_slug}))
-    return d["items"]
-
-def grade_quiz(student_id: int, lesson_id: int, level_slug: str,
-               answers: list[str], assignment_id: int | None = None):
-    d = _json_or_raise(_req("POST", "/agent/grade",
-                            json={"student_id": student_id, "lesson_id": lesson_id, "level_slug": level_slug,
-                                  "answers": answers, "assignment_id": assignment_id}))
-    return d["score"], d["total"]
-
-def next_step(student_id: int, lesson_id: int, level_slug: str,
-              answers: list[str], assignment_id: int | None = None):
-    return _json_or_raise(_req("POST", "/agent/coach_or_celebrate",
-                               json={"student_id": student_id, "lesson_id": lesson_id, "level_slug": level_slug,
-                                     "answers": answers, "assignment_id": assignment_id}))
-
-# ---- Auth ----
-def login(email: str, password: str):
-    return _json_or_raise(_req("POST", "/auth/login", json={"email": email, "password": password}))
-
-def signup_student(name: str, email: str, password: str, level_label: str, country_label: str):
-    payload_student = {
-        "name": name, "email": email, "password": password,
-        "level_label": level_label, "country_label": country_label
+    resp = _req("POST", "/quiz/auto", json=payload)
+    result = _json_or_raise(resp)
+    if isinstance(result, dict) and "items" in result:
+        return result["items"]
+    return result if isinstance(result, list) else []
+
+def submit_quiz(*, student_id: int, lesson_id: int, level_slug: str,
+                user_answers: list[dict], original_quiz: list[dict], assignment_id: int | None = None):
+    payload = {
+        "student_id": student_id,
+        "lesson_id": lesson_id,
+        "level_slug": level_slug,
+        "user_answers": user_answers,
+        "original_quiz": original_quiz,
+        "assignment_id": assignment_id,
     }
-    return _try_candidates("POST", [
-        ("/auth/signup/student", {"json": payload_student}),
-        ("/auth/register", {"json": {
-            "role": "student", "name": name, "email": email, "password": password,
-            "level": level_label, "country": country_label
-        }}),
-    ])
+    return _json_or_raise(_req("POST", "/quiz/grade", json=payload))
 
-def signup_teacher(title: str, name: str, email: str, password: str):
-    payload_teacher = {"title": title, "name": name, "email": email, "password": password}
-    return _try_candidates("POST", [
-        ("/auth/signup/teacher", {"json": payload_teacher}),
-        ("/auth/register", {"json": {
-            "role": "teacher", "title": title, "name": name, "email": email, "password": password
-        }}),
-    ])
-
-# ---- New LangGraph-backed endpoints ----
-def fetch_lesson_content(lesson: str, module: str, topic: str):
-    r = _json_or_raise(_req("POST", "/lesson",
-                            json={"lesson": lesson, "module": module, "topic": topic}))
-    return r["lesson_content"]
+# ---------- Tutor explain ----------
+def tutor_explain(lesson_id: int, level_slug: str, wrong: list[dict]):
+    payload = {"lesson_id": lesson_id, "level_slug": level_slug, "wrong": wrong}
+    return _json_or_raise(_req("POST", "/tutor/explain", json=payload, timeout=60))
 
-def submit_lesson_quiz(lesson: str, module: str, topic: str, responses: dict):
-    return _json_or_raise(_req("POST", "/lesson-quiz",
-                               json={"lesson": lesson, "module": module, "topic": topic, "responses": responses}))
+# ---------- Student dashboard ----------
+def user_stats(student_id: int):
+    return _json_or_raise(_req("GET", f"/students/{student_id}/stats"))
 
-def submit_practice_quiz(lesson: str, responses: dict):
-    return _json_or_raise(_req("POST", "/practice-quiz",
-                               json={"lesson": lesson, "responses": responses}))
+def list_assignments_for_student(student_id: int):
+    return _json_or_raise(_req("GET", f"/students/{student_id}/assignments"))
+
+def student_quiz_average(student_id: int):
+    d = _json_or_raise(_req("GET", f"/students/{student_id}/quiz_avg"))
+    # backend returns {"avg_pct": ...}
+    for k in ("avg_pct", "avg", "average", "score_pct", "score", "value"):
+        if k in d:
+            try:
+                return int(round(float(str(d[k]).strip().rstrip("%"))))
+            except Exception:
+                break
+    return 0
+
+def recent_lessons_for_student(student_id: int, limit: int = 5):
+    return _json_or_raise(_req("GET", f"/students/{student_id}/recent", params={"limit": limit}))
+
+def list_classes_for_student(student_id: int):
+    return _json_or_raise(_req("GET", f"/students/{student_id}/classes"))
 
-def send_to_chatbot(messages: list[dict]):
-    return _json_or_raise(_req("POST", "/chatbot", json={"messages": messages}))
+def level_from_xp(xp: int):
+    return _json_or_raise(_req("GET", "/level-from-xp", params={"xp": xp}))["level"]
 
-# --- Game API helpers ---
+# ---------- Games ----------
 def record_money_match_play(user_id: int, target: int, total: int,
-                            elapsed_ms: int, matched: bool, gained_xp: int):
+                            elapsed_ms: int, matched: bool, gained_xp: int | None = None):
     payload = {
-        "user_id": user_id, "target": target, "total": total,
-        "elapsed_ms": elapsed_ms, "matched": matched, "gained_xp": gained_xp,
+        "user_id": user_id,
+        "target": target,
+        "total": total,
+        "elapsed_ms": elapsed_ms,
+        "matched": bool(matched),
+        "gained_xp": gained_xp,
     }
-    return _try_candidates("POST", [
-        ("/games/money_match/record", {"json": payload}),
-    ])
+    return _json_or_raise(_req("POST", "/games/money_match/record", json=payload))
 
-def record_budget_builder_play(user_id: int, weekly_allowance: int, budget_score: int,
-                               elapsed_ms: int, allocations: list[dict], gained_xp: int | None):
+def record_budget_builder_play(user_id: int, weekly_allowance: int,
+                               allocations: list[dict], gained_xp: int | None = None):
     payload = {
         "user_id": user_id,
         "weekly_allowance": weekly_allowance,
-        "budget_score": budget_score,
-        "elapsed_ms": elapsed_ms,
         "allocations": allocations,
         "gained_xp": gained_xp,
     }
-    return _try_candidates("POST", [
-        ("/games/budget_builder/record", {"json": payload}),
-    ])
+    return _json_or_raise(_req("POST", "/games/budget_builder/record", json=payload))
 
-def record_debt_dilemma_play(user_id: int, loans_cleared: int,
-                             mistakes: int, elapsed_ms: int, gained_xp: int):
+def record_debt_dilemma_play(user_id: int, *, level: int, round_no: int,
+                             wallet: int, health: int, happiness: int, credit_score: int,
+                             event_json: dict, outcome: str, gained_xp: int | None = None):
     payload = {
         "user_id": user_id,
-        "loans_cleared": loans_cleared,
-        "mistakes": mistakes,
-        "elapsed_ms": elapsed_ms,
+        "level": level,
+        "round_no": round_no,
+        "wallet": wallet,
+        "health": health,
+        "happiness": happiness,
+        "credit_score": credit_score,
+        "event_json": event_json,
+        "outcome": outcome,
         "gained_xp": gained_xp,
     }
-    return _try_candidates("POST", [
-        ("/games/debt_dilemma/record", {"json": payload}),
-    ])
+    return _json_or_raise(_req("POST", "/games/debt_dilemma/record", json=payload))
 
-def record_profit_puzzler_play(user_id: int, puzzles_solved: int, mistakes: int, elapsed_ms: int, gained_xp: int | None = None):
-    payload = {"user_id": user_id, "puzzles_solved": puzzles_solved, "mistakes": mistakes, "elapsed_ms": elapsed_ms}
-    if gained_xp is not None:
-        payload["gained_xp"] = gained_xp
-    return _try_candidates("POST", [("/games/profit_puzzler/record", {"json": payload})])
+def record_profit_puzzler_play(user_id: int, scenario_id: str, title: str,
+                               units: int, price: int, cost: int,
+                               user_answer: float, actual_profit: float, is_correct: bool,
+                               gained_xp: int | None = None):
+    payload = {
+        "user_id": user_id, "scenario_id": scenario_id, "title": title,
+        "units": units, "price": price, "cost": cost,
+        "user_answer": user_answer, "actual_profit": actual_profit,
+        "is_correct": bool(is_correct), "gained_xp": gained_xp,
+    }
+    return _json_or_raise(_req("POST", "/games/profit_puzzler/record", json=payload))
 
-# --- Tutor Explanation ---
-def tutor_explain(lesson_id: int, level_slug: str, wrong: list[dict]):
+# ---------- RAG passthrough ----------
+def retrieve(query: str, lesson_id: int, level_slug: str = "beginner", k: int = 5) -> str:
+    try:
+        d = _json_or_raise(_req("GET", "/retrieve",
+                                params={"query": query, "lesson_id": lesson_id, "level_slug": level_slug, "k": k}))
+        return d.get("context", "")
+    except Exception as e:
+        return f"(retrieval failed: {e})"
+
+def chat_ai(query: str, lesson_id: int, level_slug: str, history=None) -> str:
     payload = {
-        "lesson_id": lesson_id,
-        "level_slug": level_slug,
-        "wrong": wrong
+        "query": query,
+        "lesson_id": int(lesson_id) if lesson_id is not None else 0,
+        "level_slug": level_slug or "beginner",
+        "history": history or [],
     }
-    return _json_or_raise(_req("POST", "/tutor/explain", json=payload, timeout=60))
+    try:
+        d = _json_or_raise(_req("POST", "/chat", json=payload, timeout=90))
+        return d.get("answer", "")
+    except Exception as e:
+        return f"(chat failed: {e})"
+
+# ---------- LangGraph-backed ----------
+def fetch_lesson_content(lesson: str, module: str, topic: str):
+    d = _json_or_raise(_req("POST", "/lesson", json={"lesson": lesson, "module": module, "topic": topic}))
+    return d.get("lesson_content", "")
+
+def submit_lesson_quiz(lesson: str, module: str, topic: str, responses: dict):
+    return _json_or_raise(_req("POST", "/lesson-quiz",
+                               json={"lesson": lesson, "module": module, "topic": topic, "responses": responses}))
+
+def submit_practice_quiz(lesson: str, responses: dict):
+    return _json_or_raise(_req("POST", "/practice-quiz", json={"lesson": lesson, "responses": responses}))