updating

phase/Student_view/lesson.py

@@ -1,7 +1,6 @@
 import os
 import re
 import random
-import requests
 from typing import List, Dict, Tuple, Optional
 
 import streamlit as st
@@ -10,8 +9,9 @@ import utils.api as api
 
 USE_LOCAL_DB = os.getenv("DISABLE_DB", "1") != "1"
 
+
 def _api_post(path: str, payload: dict):
-    # try to reuse your utils.api client; gracefully no-op if unavailable
+    """Route all HTTP to the backend through utils.api; no direct URL handling here."""
     try:
         if hasattr(api, "_req"):
             return api._req("POST", path, json=payload)
@@ -19,37 +19,53 @@ def _api_post(path: str, payload: dict):
         pass
     return None
 
+
 def _get_lesson(lesson_id: int):
     """Fetch a lesson from local DB if enabled, otherwise from the backend API."""
     if USE_LOCAL_DB and hasattr(dbapi, "get_lesson"):
         return dbapi.get_lesson(lesson_id)
     return api.get_lesson(lesson_id)
 
+
 def _save_progress(user_id: int, lesson_id: int, current_pos: int, status: str):
     """Best-effort save; don’t crash the UI if the backend route is missing."""
     try:
         if USE_LOCAL_DB and hasattr(dbapi, "save_progress"):
             return dbapi.save_progress(user_id, lesson_id, current_pos, status)
-        # If you exposed an HTTP route in the backend (see note below), you can call it here.
-        # Otherwise we silently skip saving when the DB is disabled.
         return True
     except Exception:
-        # Keep the lesson page usable even if the save call fails.
         return False
-    
-    
-# ========== Optional direct agent imports (same process) ==========
-AGENTS_AVAILABLE = False
-try:
-    from app.agents.schemas import AgentState  # pydantic model
-    from app.agents.nodes import (
-        node_rag, node_auto_quiz, node_grade, node_chatbot
-    )
-    AGENTS_AVAILABLE = True
-except Exception:
-    AGENTS_AVAILABLE = False
 
-    
+
+def _resolve_lesson_title_by_id(lesson_id: int) -> str:
+    """Find the lesson title from the in-app catalog; fallback to 'Lesson {id}'."""
+    for lvl in lessons_by_level.values():
+        for l in lvl:
+            try:
+                if int(l.get("id")) == int(lesson_id):
+                    return l.get("title") or f"Lesson {lesson_id}"
+            except Exception:
+                pass
+    return f"Lesson {lesson_id}"
+
+
+def _fetch_lesson_content_via_backend(lesson_id: int, topic_index: int, *,
+                                      title: Optional[str] = None,
+                                      topic_name: Optional[str] = None) -> Optional[str]:
+    """
+    Ask the backend lesson agent for the content of a topic.
+    Expected shape: { lesson_content | content }
+    """
+    title = title or _resolve_lesson_title_by_id(lesson_id)
+    module_id = str(lesson_id)
+    topic = topic_name or f"Topic {int(topic_index)}"
+
+    resp = _api_post("/agents/lesson", {"lesson": title, "module": module_id, "topic": topic})
+    if isinstance(resp, dict):
+        return resp.get("lesson_content") or resp.get("content")
+    return None
+
+
 # --- Load external CSS ---
 def load_css(file_name):
     try:
@@ -58,11 +74,13 @@ def load_css(file_name):
     except FileNotFoundError:
         st.warning("⚠️ Stylesheet not found. Please ensure 'assets/styles.css' exists.")
 
+
 # --- Settings ---
 MAX_TOPICS = 5  # show topics 1..5 only, then Summary
 MINI_QUIZ_MIN = 2
 MINI_QUIZ_MAX = 4
 
+
 # --- Data structure for lessons ---
 lessons_by_level = {
     "beginner": [
@@ -301,13 +319,14 @@ lessons_by_level = {
     ]
 }
 
-# --- Utility functions ---
 
+# --- Utility functions ---
 def get_display_topics(lesson: dict) -> List[str]:
     """Limit to topics 1..5 + Summary placeholder, hiding Play/old Quiz."""
     base = (lesson.get("topics") or [])[:MAX_TOPICS]
     return base + ["Summary"]
 
+
 def summarize_first_n_topics(lesson_id: int, n: int = MAX_TOPICS) -> str:
     """Very simple, deterministic summary of the first N topics (no LLM)."""
     bullets = []
@@ -317,6 +336,7 @@ def summarize_first_n_topics(lesson_id: int, n: int = MAX_TOPICS) -> str:
         bullets.append(f"• {first_sentence[0] if first_sentence else ('Key idea from topic ' + str(i))}")
     return "<br>".join(bullets) or "No summary available."
 
+
 # ---------- Mini-quiz generation ----------
 _DEFAULT_BANK: List[Dict] = [
     {"id": "b1", "question": "Why do people make a budget?",
@@ -333,21 +353,14 @@ _DEFAULT_BANK: List[Dict] = [
      "answer_key": "A"},
 ]
 
+
 def _fallback_auto_quiz() -> List[Dict]:
     k = random.randint(MINI_QUIZ_MIN, MINI_QUIZ_MAX)
     return random.sample(_DEFAULT_BANK, k)
 
-def _backend_post(path: str, payload: dict, timeout=6) -> dict | None:
-    try:
-        r = requests.post(f"{BACKEND_URL}{path}", json=payload, timeout=timeout)
-        if r.ok:
-            return r.json()
-    except Exception:
-        pass
-    return None
 
 def fetch_auto_quiz_from_backend(lesson_title: str, module_id: str, topic_name: str):
-    # Try new agents path first; fall back to legacy if present; else None
+    """Prefer new agents route; fallback to legacy if present."""
     resp = _api_post("/agents/quiz/auto",
                      {"lesson": lesson_title, "module": module_id, "topic": topic_name}) \
            or _api_post("/agent/quiz", {"lesson_id": module_id, "level_slug": "beginner"})
@@ -368,121 +381,77 @@ def fetch_auto_quiz_from_backend(lesson_title: str, module_id: str, topic_name:
         })
     return out
 
+
 def grade_and_chat_via_backend(lesson_title: str, module_id: str, topic_name: str,
                                responses: Dict[str, str]) -> Tuple[int, int, str]:
     """
-    Calls your agent quiz endpoint that matches schemas.QuizRequest/QuizResponse.
-    Returns (score, total, feedback)
+    Calls /agents/quiz (schemas.QuizRequest -> QuizResponse).
+    Returns (score, total, feedback).
     """
-    resp = _backend_post("/agents/quiz", {
+    resp = _api_post("/agents/quiz", {
         "lesson": lesson_title,
         "module": module_id,
         "topic": topic_name,
         "responses": responses
     })
-    if not resp:
-        # legacy split endpoints (score only)
-        grade_only = _backend_post("/agent/grade", {"answers": list(responses.values()),
-                                                    "lesson_id": module_id, "level_slug": "beginner"}) or {}
-        score, total = int(grade_only.get("score", 0)), int(grade_only.get("total", len(responses)))
-        # simple feedback
-        fb = (_backend_post("/agent/coach_or_celebrate", {"answers": list(responses.values()),
-                                                          "lesson_id": module_id, "level_slug": "beginner"}) or {}).get("feedback") \
-             or "Nice work! Review any tricky items and ask me questions."
-        return score, total, fb
-
-    grade_map = resp.get("grade", {})
-    score = sum(1 for ok in grade_map.values() if ok)
-    total = len(grade_map) or max(1, len(responses))
-    feedback = resp.get("feedback", "Great job!")
-    return score, total, feedback
 
-# ---------- Agent integration (in-process) ----------
+    if isinstance(resp, dict) and (resp.get("grade") or resp.get("feedback")):
+        grade_map = resp.get("grade", {})
+        score = sum(1 for ok in grade_map.values() if ok)
+        total = len(grade_map) or max(1, len(responses))
+        feedback = resp.get("feedback", "Great job!")
+        return score, total, feedback
+
+    # Legacy split fallback
+    grade_only = _api_post("/agent/grade", {"answers": list(responses.values()),
+                                            "lesson_id": module_id, "level_slug": "beginner"}) or {}
+    score = int(grade_only.get("score", 0))
+    total = int(grade_only.get("total", len(responses)))
+    fb = (_api_post("/agent/coach_or_celebrate", {"answers": list(responses.values()),
+                                                  "lesson_id": module_id, "level_slug": "beginner"}) or {}).get("feedback") \
+         or "Nice work! Review any tricky items and ask me questions."
+    return score, total, fb
+
+
+# ---------- Agent integration (HTTP) ----------
 def agent_generate_quiz(lesson: dict) -> List[Dict]:
     """
-    Prefer local agent nodes; fallback to HTTP; then fallback local bank.
+    Use backend agents to generate the mini-quiz; fallback to local bank if backend returns nothing.
     """
     title = lesson.get("title", f"Lesson {lesson.get('id')}")
     module_id = str(lesson.get("id"))
     topic_name = "Summary"
 
-    if AGENTS_AVAILABLE:
-        try:
-            s = AgentState(lesson=title, module=module_id, topic=topic_name)
-            # Retrieve content & auto-quiz
-            s = node_rag(s)
-            s = node_auto_quiz(s)
-            qs = s.quiz_questions or []
-            # normalize
-            out = []
-            for i, it in enumerate(qs, start=1):
-                out.append({
-                    "id": it.get("id") or f"q{i}",
-                    "question": it.get("question",""),
-                    "options": it.get("options", []),
-                    "answer_key": it.get("answer_key","A")
-                })
-            if out:
-                return random.sample(out, min(len(out), random.randint(MINI_QUIZ_MIN, MINI_QUIZ_MAX)))
-        except Exception:
-            pass
-
-    # HTTP backend (optional)
     items = fetch_auto_quiz_from_backend(title, module_id, topic_name)
     if items:
         return random.sample(items, min(len(items), random.randint(MINI_QUIZ_MIN, MINI_QUIZ_MAX)))
 
-    # local fallback
     return _fallback_auto_quiz()
 
+
 def agent_grade_and_chat(lesson: dict, items: List[Dict],
                          answers_by_idx: Dict[int, str]) -> Tuple[int, int, str]:
     """
-    Grade + get chatbot feedback using agents if available,
-    else HTTP backend, else local grading with friendly feedback.
-    answers_by_idx: {0:'A',1:'C',...}
+    Build {qid: 'A'|'B'...} and ask the backend agent to grade + coach.
     """
     title = lesson.get("title", f"Lesson {lesson.get('id')}")
     module_id = str(lesson.get("id"))
     topic_name = "Summary"
 
-    # Build responses keyed by question IDs
     responses: Dict[str, str] = {}
     for i, it in enumerate(items):
         qid = it.get("id") or f"q{i+1}"
         responses[qid] = (answers_by_idx.get(i) or "").strip().upper()
 
-    if AGENTS_AVAILABLE:
-        try:
-            s = AgentState(
-                lesson=title, module=module_id, topic=topic_name,
-                quiz_questions=items,  # contains answer_key for extraction if needed
-                responses=responses
-            )
-            # Grade first (uses quiz_questions -> correct_answers if missing)
-            s = node_grade(s)
-            # Fetch content so chatbot can reference it
-            s = node_rag(s)
-            s = node_chatbot(s)
-
-            grade_map = s.grade or {}
-            score = sum(1 for ok in grade_map.values() if ok)
-            total = len(grade_map) or len(items)
-            feedback = s.feedback or "Great job!"
-            return score, total, feedback
-        except Exception:
-            pass
-
-    # HTTP backend path (optional)
     backend_score, backend_total, backend_feedback = grade_and_chat_via_backend(title, module_id, topic_name, responses)
     if backend_total:
         return backend_score, backend_total, backend_feedback
 
-    # Local fallback grading
+    # Local safety net
     def grade_locally(items_: List[Dict], letters: List[str]) -> Tuple[int, int]:
-        keys = [it.get("answer_key","A").strip().upper() for it in items_]
-        raw = (letters or []) + [""]*len(keys)
-        score = sum(1 for a,k in zip(raw, keys) if (a or "").strip().upper() == k)
+        keys = [it.get("answer_key", "A").strip().upper() for it in items_]
+        raw = (letters or []) + [""] * len(keys)
+        score = sum(1 for a, k in zip(raw, keys) if (a or "").strip().upper() == k)
         return score, len(keys)
 
     letters = [responses[it.get("id") or f"q{i+1}"] for i, it in enumerate(items)]
@@ -497,7 +466,7 @@ def _db_to_general_lesson_shape(L: dict, sections: list) -> dict:
     difficulty = {"beginner": "Easy", "intermediate": "Medium", "advanced": "Hard"}.get(level, "Easy")
     topics = [(s.get("title") or f"Topic {i+1}") for i, s in enumerate(sections)]
 
-    duration = L.get("duration") or f"{max(6, len(topics)*6)} min"
+    duration = L.get("duration") or f"{max(6, len(topics) * 6)} min"
 
     return {
         "id": int(L["lesson_id"]),
@@ -512,11 +481,13 @@ def _db_to_general_lesson_shape(L: dict, sections: list) -> dict:
         "_db_level": level,
     }
 
+
 def get_difficulty_color(difficulty):
     """Return color based on difficulty level"""
     colors = {"Easy": "#28a745", "Medium": "#ffc107", "Hard": "#dc3545"}
     return colors.get(difficulty, "#6c757d")
 
+
 def get_level_info(level):
     level_info = {
         "beginner": {"display": "🌱 Beginner", "color": "#28a745", "description": "Build your financial foundation"},
@@ -525,6 +496,7 @@ def get_level_info(level):
     }
     return level_info.get(level, level_info["beginner"])
 
+
 # --- Per-user lesson progress (in memory via session_state) ---
 def _ensure_progress_state():
     if "topic_progress" not in st.session_state:
@@ -532,22 +504,25 @@ def _ensure_progress_state():
     if "lesson_completed" not in st.session_state:
         st.session_state.lesson_completed = {}  # {lesson_id: True/False}
 
+
 def _mark_topic_seen(lesson_id: int, topic_index: int):
     _ensure_progress_state()
     current = st.session_state.topic_progress.get(lesson_id, 0)
     st.session_state.topic_progress[lesson_id] = max(current, topic_index)
 
+
 def _is_lesson_completed(lesson_id: int) -> bool:
     _ensure_progress_state()
     return st.session_state.lesson_completed.get(lesson_id, False)
 
+
 def _complete_lesson(lesson):
     _ensure_progress_state()
     st.session_state.lesson_completed[lesson["id"]] = True
     lesson["completed"] = True
 
-#-----
 
+# -----
 def show_lesson_cards(lessons, user_level):
     level_info = get_level_info(user_level)
 
@@ -630,6 +605,7 @@ def show_lesson_cards(lessons, user_level):
                     st.session_state.selected_lesson = lesson["id"]
                     st.rerun()
 
+
 def show_lesson_detail(lesson):
     units = len(get_display_topics(lesson))
     st.markdown(f"""
@@ -672,17 +648,26 @@ def show_lesson_detail(lesson):
         st.session_state.selected_lesson = None
         st.rerun()
 
+
 def load_topic_content(lesson_id, topic_index):
-    """Load topic content for a specific lesson and topic index"""
-    file_path = os.path.join("phase", "Student_view", "lessons", f"lesson_{lesson_id}", f"topic_{topic_index}.txt")
+    """Fetch topic content from backend agents; fallback to new backend path under app/lessons if present."""
+    # primary: backend agents
+    text = _fetch_lesson_content_via_backend(lesson_id, topic_index)
+    if text:
+        return text
+
+    # fallback: backend’s repo path (moved under app/)
+    file_path = os.path.join("app", "lessons", f"lesson_{lesson_id}", f"topic_{topic_index}.txt")
     if os.path.exists(file_path):
         try:
             with open(file_path, "r", encoding="utf-8") as f:
                 return f.read()
         except Exception as e:
             return f"⚠️ Error loading topic content: {e}"
+
     return "⚠️ Topic content not available."
 
+
 def show_lesson_page(lesson, lessons):
     # Back link
     if st.button("⬅ Back to Lessons", key=f"back_top_{lesson['id']}"):
@@ -772,7 +757,7 @@ def show_lesson_page(lesson, lessons):
                 # Last page = Summary → trigger the mini-quiz (2–4 questions)
                 if not _is_lesson_completed(lesson["id"]):
                     if st.button("✅ Complete Module", key=f"complete_{lesson['id']}", type="primary"):
-                        st.session_state.mini_quiz_items = generate_mini_quiz()
+                        st.session_state.mini_quiz_items = agent_generate_quiz(lesson)
                         st.session_state.mini_quiz_answers = {}
                         st.session_state.mini_q_idx = 0
                         st.session_state.show_mini_quiz = True
@@ -807,15 +792,16 @@ def show_lesson_page(lesson, lessons):
 
     st.markdown("---")
 
-#----- Mini-quiz UI (auto handoff to chatbot on submit) -----
 
+# ----- Mini-quiz UI (auto handoff to chatbot on submit) -----
 def render_mini_quiz_ui(lesson: dict):
     st.markdown("### 📝 Mini Quiz")
     items = st.session_state.get("mini_quiz_items") or []
     if not items:
         st.warning("No questions available.")
         if st.button("Back"):
-            st.session_state.show_mini_quiz = False; st.rerun()
+            st.session_state.show_mini_quiz = False
+            st.rerun()
         return
 
     idx = int(st.session_state.get("mini_q_idx", 0))
@@ -835,10 +821,11 @@ def render_mini_quiz_ui(lesson: dict):
         c1, c2 = st.columns(2)
         with c1:
             if idx > 0 and st.button("⬅ Previous"):
-                st.session_state.mini_q_idx -= 1; st.rerun()
+                st.session_state.mini_q_idx -= 1
+                st.rerun()
         with c2:
-            if st.button("Next ➡" if idx < len(items)-1 else "Submit Quiz"):
-                if idx < len(items)-1:
+            if st.button("Next ➡" if idx < len(items) - 1 else "Submit Quiz"):
+                if idx < len(items) - 1:
                     st.session_state.mini_q_idx += 1
                     st.rerun()
                 else:
@@ -855,7 +842,7 @@ def render_mini_quiz_ui(lesson: dict):
 
                     # Mark completed & reset lesson state as we’re moving to chat
                     _complete_lesson(lesson)
-                    for k in ["show_mini_quiz","mini_quiz_items","mini_quiz_answers","mini_q_idx","mini_quiz_result"]:
+                    for k in ["show_mini_quiz", "mini_quiz_items", "mini_quiz_answers", "mini_q_idx", "mini_quiz_result"]:
                         st.session_state.pop(k, None)
 
                     # === Auto-redirect to Chatbot page with agent feedback ===
@@ -875,10 +862,11 @@ def render_mini_quiz_ui(lesson: dict):
                     st.experimental_rerun()
         return
 
-def render_assigned_lesson(lesson_id: int, assignment_id: int | None = None):
+
+def render_assigned_lesson(lesson_id: int, assignment_id: Optional[int] = None):
     """Render a teacher-assigned lesson from the DB using the SAME structure/CSS as general lessons."""
     user = st.session_state.user
-    user_id = user["user_id"]
+    user_id = user["user_id"]  # retained for future use
 
     data = _get_lesson(lesson_id)       # {"lesson": {...}, "sections":[...] }
     if not data or not data.get("lesson"):
@@ -902,6 +890,7 @@ def render_assigned_lesson(lesson_id: int, assignment_id: int | None = None):
     else:
         show_db_lesson_detail(lesson)
 
+
 def show_db_lesson_detail(lesson):
     st.markdown(f"""
         <h1 style="font-size:2.5rem; margin-bottom:0;">{lesson['title']}</h1>
@@ -937,6 +926,7 @@ def show_db_lesson_detail(lesson):
         st.session_state.selected_lesson = None
         st.rerun()
 
+
 def show_db_lesson_page(lesson):
     # Back link – same as general
     if st.button("⬅ Back to Lessons", key=f"db_back_top_{lesson['id']}"):
@@ -951,7 +941,7 @@ def show_db_lesson_page(lesson):
     <div style="background: linear-gradient(135deg,#20c997,#17a2b8); padding: 1.5rem; border-radius: 12px; color: white; margin-bottom: 2rem;">
         <h2 style="margin:0;">{lesson['title']}</h2>
         <p style="margin:.3rem 0;">{lesson['description']}</p>
-        <div style="margin-top:.5rem;">
+        <div style="margin-top:.5rem%;">
             <span style="background:#ffffff22;padding:6px 12px;border-radius:6px;margin-right:6px;">⏱ {lesson['duration']}</span>
             <span style="background:#ffffff22;padding:6px 12px;border-radius:6px;margin-right:6px;">📘 Module {lesson['id']}</span>
             <span style="background:#ffffff22;padding:6px 12px;border-radius:6px;">⭐ {lesson['difficulty']}</span>
@@ -976,7 +966,7 @@ def show_db_lesson_page(lesson):
 
         st.subheader(f"Topic {st.session_state.current_topic}: {topic_name}")
 
-        body = (sections[idx].get("content") or "⚠️ Topic content not available.")
+        body = (sections[idx].get("content") or "⚠️ Topic content not available.") if idx < len(sections) else "⚠️ Topic content not available."
         st.markdown(f"<div class='topic-content'>{body}</div>", unsafe_allow_html=True)
 
         prev_col, next_col = st.columns([1, 1])
@@ -1025,6 +1015,7 @@ def show_db_lesson_page(lesson):
 
     st.markdown("---")
 
+
 def show_page():
     # Load CSS
     css_path = os.path.join("assets", "styles.css")