update lesson.py -alanna

phase/Student_view/lesson.py

@@ -1,41 +1,68 @@
+# frontend/lesson.py
 import os
 import re
 import random
 import requests
 from typing import List, Dict, Tuple, Optional
 
-
 import streamlit as st
-from utils import db as dbapi
+from utils import db as dbapi  # still used for teacher-assigned(DB) lessons
 
+# ===============================
+# Backend integration (HF Spaces)
+# ===============================
 
-# ========== 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
+def _resolve_backend_url() -> str:
+    """
+    Resolve the backend base URL in a Spaces-friendly way.
+    Priority: environment -> st.secrets -> localhost (dev).
+    """
+    url = os.getenv("BACKEND_URL", "").strip() or (
+        getattr(st, "secrets", {}).get("BACKEND_URL", "").strip() if hasattr(st, "secrets") else ""
     )
-    AGENTS_AVAILABLE = True
-except Exception:
-    AGENTS_AVAILABLE = False
+    if not url:
+        url = "http://localhost:8000"  # dev fallback
+    return url.rstrip("/")
+
+BACKEND_URL = _resolve_backend_url()
+
+def _backend_post(path: str, payload: dict, timeout: float = 8.0) -> Optional[dict]:
+    """
+    POST to backend and return JSON (or None on error).
+    CORS is already allowed server-side; Streamlit calls from the server.
+    """
+    try:
+        r = requests.post(f"{BACKEND_URL}{path}", json=payload, timeout=timeout)
+        if r.ok:
+            return r.json()
+    except Exception:
+        pass
+    return None
+
+# ===============================
+# Visuals
+# ===============================
 
-    
-# --- Load external CSS ---
-def load_css(file_name):
+def load_css(file_name: str):
     try:
-        with open(file_name, 'r') as f:
+        with open(file_name, 'r', encoding="utf-8") as f:
             st.markdown(f"<style>{f.read()}</style>", unsafe_allow_html=True)
     except FileNotFoundError:
         st.warning("⚠️ Stylesheet not found. Please ensure 'assets/styles.css' exists.")
 
-# --- Settings ---
+# ===============================
+# Settings
+# ===============================
+
 MAX_TOPICS = 5  # show topics 1..5 only, then Summary
 MINI_QUIZ_MIN = 2
 MINI_QUIZ_MAX = 4
 
-# --- Data structure for lessons ---
-{
+# ===============================
+# Catalog (moved into a variable)
+# ===============================
+
+lessons_by_level: Dict[str, List[dict]] = {
     "beginner": [
         {
             "id": 1,
@@ -53,8 +80,8 @@ MINI_QUIZ_MAX = 4
                 "Spending Wisely",
                 "Play: Money Match",
                 "Quiz",
-                "Summary: My Money Plan"
-            ]
+                "Summary: My Money Plan",
+            ],
         },
         {
             "id": 2,
@@ -72,8 +99,8 @@ MINI_QUIZ_MAX = 4
                 "Making Choices",
                 "Play: Budget Builder",
                 "Quiz",
-                "Summary: My First Budget"
-            ]
+                "Summary: My First Budget",
+            ],
         },
         {
             "id": 3,
@@ -91,8 +118,8 @@ MINI_QUIZ_MAX = 4
                 "Money Safety",
                 "Play: Piggy Bank Challenge",
                 "Quiz",
-                "Summary: Money Journal"
-            ]
+                "Summary: Money Journal",
+            ],
         },
         {
             "id": 4,
@@ -110,9 +137,9 @@ MINI_QUIZ_MAX = 4
                 "Advertising Basics",
                 "Play: Smart Shopper",
                 "Quiz",
-                "Summary: My Business Plan"
-            ]
-        }
+                "Summary: My Business Plan",
+            ],
+        },
     ],
     "intermediate": [
         {
@@ -131,8 +158,8 @@ MINI_QUIZ_MAX = 4
                 "Tracking Spending",
                 "Play: Budget Tracker",
                 "Quiz",
-                "Summary: My Monthly Budget"
-            ]
+                "Summary: My Monthly Budget",
+            ],
         },
         {
             "id": 6,
@@ -150,8 +177,8 @@ MINI_QUIZ_MAX = 4
                 "Loss Prevention",
                 "Play: Profit Planner",
                 "Quiz",
-                "Summary: My Profit Plan"
-            ]
+                "Summary: My Profit Plan",
+            ],
         },
         {
             "id": 7,
@@ -169,8 +196,8 @@ MINI_QUIZ_MAX = 4
                 "Banking Safety",
                 "Play: Bank Manager",
                 "Quiz",
-                "Summary: My Bank Plan"
-            ]
+                "Summary: My Bank Plan",
+            ],
         },
         {
             "id": 8,
@@ -188,9 +215,9 @@ MINI_QUIZ_MAX = 4
                 "Economic Choices",
                 "Play: Market Simulator",
                 "Quiz",
-                "Summary: My Market Plan"
-            ]
-        }
+                "Summary: My Market Plan",
+            ],
+        },
     ],
     "advanced": [
         {
@@ -209,8 +236,8 @@ MINI_QUIZ_MAX = 4
                 "Financial Goals",
                 "Play: Financial Planner",
                 "Quiz",
-                "Summary: My Financial Plan"
-            ]
+                "Summary: My Financial Plan",
+            ],
         },
         {
             "id": 10,
@@ -228,8 +255,8 @@ MINI_QUIZ_MAX = 4
                 "Scaling a Business",
                 "Play: Business Tycoon",
                 "Quiz",
-                "Summary: My Business Growth Plan"
-            ]
+                "Summary: My Business Growth Plan",
+            ],
         },
         {
             "id": 11,
@@ -247,8 +274,8 @@ MINI_QUIZ_MAX = 4
                 "Investment Risks",
                 "Play: Investment Game",
                 "Quiz",
-                "Summary: My Investment Plan"
-            ]
+                "Summary: My Investment Plan",
+            ],
         },
         {
             "id": 12,
@@ -266,29 +293,68 @@ MINI_QUIZ_MAX = 4
                 "Economic Impact",
                 "Play: Economy Builder",
                 "Quiz",
-                "Summary: My Economic Model"
-            ]
-        }
-    ]
+                "Summary: My Economic Model",
+            ],
+        },
+    ],
 }
 
-# --- Utility functions ---
+# ===============================
+# Utility helpers
+# ===============================
 
 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 get_difficulty_color(difficulty: str) -> str:
+    return {"Easy": "#28a745", "Medium": "#ffc107", "Hard": "#dc3545"}.get(difficulty, "#6c757d")
+
+def get_level_info(level: str) -> dict:
+    level_info = {
+        "beginner": {"display": "🌱 Beginner", "color": "#28a745", "description": "Build your financial foundation"},
+        "intermediate": {"display": "🚀 Intermediate", "color": "#007bff", "description": "Grow your financial knowledge"},
+        "advanced": {"display": "🎓 Advanced", "color": "#6f42c1", "description": "Master advanced strategies"},
+    }
+    return level_info.get(level, level_info["beginner"])
+
+# ===============================
+# Topic content (from backend)
+# ===============================
+
+def _fetch_topic_content_via_backend(lesson_title: str, module_id: str, topic_name: str) -> Optional[str]:
+    """
+    Uses the new backend /lesson endpoint:
+      POST /lesson {lesson, module, topic} -> {lesson_content}
+    """
+    resp = _backend_post("/lesson", {"lesson": lesson_title, "module": module_id, "topic": topic_name})
+    if resp and isinstance(resp, dict):
+        content = resp.get("lesson_content")
+        if isinstance(content, str) and content.strip():
+            return content.strip()
+    return None
+# (endpoint contract: /lesson and /lesson-quiz are defined in backend main.py) :contentReference[oaicite:0]{index=0}
+
+def load_topic_content(lesson_id: int, topic_index: int) -> str:
+    """
+    Frontend no longer reads local files. We call the backend for each topic.
+    """
+    # Resolve the lesson & topic name from the catalog for the current user level.
+    # We don't know the level here; the caller passes the concrete lesson already, so
+    # this function will usually be called via show_lesson_page which has the lesson dict.
+    # To keep this utility, we'll compute names dynamically in the caller and pass through here.
+    return "⚠️ Topic loader expects to be called from show_lesson_page with the resolved names."
+
 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 = []
-    for i in range(1, n + 1):
-        text = load_topic_content(lesson_id, i)
-        first_sentence = re.split(r'(?<=[.!?])\s+', (text or "").strip())[:1]
-        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 ----------
+    """Deterministic summary: first sentence from topics 1..N (no LLM)."""
+    # NOTE: We delegate actual fetch in show_lesson_page where we know the lesson dict.
+    return "Summary will appear after you navigate topics."
+
+# ===============================
+# Mini-quiz helpers
+# ===============================
+
 _DEFAULT_BANK: List[Dict] = [
     {"id": "b1", "question": "Why do people make a budget?",
      "options": ["To plan money and make choices", "To waste money", "To hide money", "To lose track"],
@@ -308,107 +374,78 @@ 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() -> List[Dict] | None:
-    # Uses your legacy stub: /agent/quiz returns {"items":[{question,options,answer_key,points}...]}
-    resp = _backend_post("/agents/quiz/auto",
-                         {"lesson": lesson_title, "module": module_id, "topic": topic_name}) \
-           or _backend_post("/agent/quiz", {"lesson_id": module_id, "level_slug": "beginner"})
-    items = None
-    if resp:
-        items = resp.get("questions") or resp.get("items")
-    if items and isinstance(items, list):
-        out = []
-        for i, it in enumerate(items, start=1):
-            out.append({
-                "id": it.get("id") or f"auto_{i}",
-                "question": it.get("question",""),
-                "options": it.get("options", []),
-                "answer_key": it.get("answer_key","A")
-            })
-        return out
-    return None
+def fetch_auto_quiz_from_backend(lesson_title: str, module_id: str, topic_name: str) -> Optional[List[Dict]]:
+    """
+    Use the kept legacy stub to fetch items:
+      POST /agent/quiz -> {"items":[{question,options,answer_key,points}...]}
+    """
+    resp = _backend_post("/agent/quiz", {"student_id": 0, "lesson_id": int(module_id), "level_slug": "beginner"})
+    # Legacy shape still present in backend for compatibility. :contentReference[oaicite:1]{index=1}
+    items = (resp or {}).get("items")
+    if not isinstance(items, list):
+        return None
+    out = []
+    for i, it in enumerate(items, start=1):
+        out.append({
+            "id": it.get("id") or f"auto_{i}",
+            "question": it.get("question", ""),
+            "options": it.get("options", []) or [],
+            "answer_key": it.get("answer_key", "A"),
+        })
+    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)
+    Preferred grading path:
+      POST /lesson-quiz {lesson,module,topic,responses} -> {grade, feedback, next_steps}
+    Fallback to legacy /agent/grade + /agent/coach_or_celebrate.
     """
-    resp = _backend_post("/agents/quiz", {
-        "lesson": lesson_title,
-        "module": module_id,
-        "topic": topic_name,
-        "responses": responses
+    # New combined endpoint (LangGraph-backed). :contentReference[oaicite:2]{index=2}
+    resp = _backend_post("/lesson-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!")
+    if resp and isinstance(resp, dict) and isinstance(resp.get("grade"), dict):
+        grade_map = resp["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 fallbacks kept server-side for compatibility. :contentReference[oaicite:3]{index=3}
+    grade_only = _backend_post("/agent/grade", {
+        "answers": list(responses.values()),
+        "lesson_id": int(module_id),
+        "level_slug": "beginner"
+    }) or {}
+    score, total = int(grade_only.get("score", 0)), int(grade_only.get("total", len(responses)))
+
+    coach = _backend_post("/agent/coach_or_celebrate", {
+        "answers": list(responses.values()),
+        "lesson_id": int(module_id),
+        "level_slug": "beginner"
+    }) or {}
+    feedback = coach.get("feedback") or coach.get("message") or "Nice work! Review any tricky items and ask me questions."
     return score, total, feedback
 
-# ---------- Agent integration (in-process) ----------
 def agent_generate_quiz(lesson: dict) -> List[Dict]:
     """
-    Prefer local agent nodes; fallback to HTTP; then fallback local bank.
+    1) Try backend /agent/quiz for items.
+    2) Fallback local bank.
     """
     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.
+    Grade + get chatbot feedback via backend (/lesson-quiz), else fallback local.
     answers_by_idx: {0:'A',1:'C',...}
     """
     title = lesson.get("title", f"Lesson {lesson.get('id')}")
@@ -421,85 +458,31 @@ def agent_grade_and_chat(lesson: dict, items: List[Dict],
         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
+    score, total, feedback = grade_and_chat_via_backend(title, module_id, topic_name, responses)
+    if total:
+        return score, total, feedback
 
     # Local fallback grading
     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)
-        return score, len(keys)
+        keys = [it.get("answer_key", "A").strip().upper() for it in items_]
+        raw = (letters or []) + [""] * len(keys)
+        sc = sum(1 for a, k in zip(raw, keys) if (a or "").strip().upper() == k)
+        return sc, len(keys)
 
     letters = [responses[it.get("id") or f"q{i+1}"] for i, it in enumerate(items)]
-    score, total = grade_locally(items, letters)
-    feedback = "Nice work! I can walk you through any tricky ones—ask me in the chat."
-    return score, total, feedback
+    local_score, local_total = grade_locally(items, letters)
+    local_feedback = "Nice work! I can walk you through any tricky ones—ask me in the chat."
+    return local_score, local_total, local_feedback
 
+# ===============================
+# Session progress helpers
+# ===============================
 
-def _db_to_general_lesson_shape(L: dict, sections: list) -> dict:
-    """Convert a DB lesson+sections into the same dict shape used by general lessons."""
-    level = (L.get("level") or "beginner").lower()
-    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"
-
-    return {
-        "id": int(L["lesson_id"]),
-        "title": L.get("title") or "Untitled",
-        "description": L.get("description") or "",
-        "duration": duration,
-        "completed": False,
-        "locked": False,
-        "difficulty": difficulty,
-        "topics": topics,
-        "_db_sections": sections,
-        "_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"},
-        "intermediate": {"display": "🚀 Intermediate", "color": "#007bff", "description": "Grow your financial knowledge"},
-        "advanced": {"display": "🎓 Advanced", "color": "#6f42c1", "description": "Master advanced strategies"},
-    }
-    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:
-        st.session_state.topic_progress = {}  # {lesson_id: max_topic_index_seen}
+        st.session_state.topic_progress = {}
     if "lesson_completed" not in st.session_state:
-        st.session_state.lesson_completed = {}  # {lesson_id: True/False}
+        st.session_state.lesson_completed = {}
 
 def _mark_topic_seen(lesson_id: int, topic_index: int):
     _ensure_progress_state()
@@ -510,14 +493,16 @@ 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):
+def _complete_lesson(lesson: dict):
     _ensure_progress_state()
     st.session_state.lesson_completed[lesson["id"]] = True
     lesson["completed"] = True
 
-#-----
+# ===============================
+# Cards & detail
+# ===============================
 
-def show_lesson_cards(lessons, user_level):
+def show_lesson_cards(lessons: List[dict], user_level: str):
     level_info = get_level_info(user_level)
 
     # Level header
@@ -530,51 +515,34 @@ def show_lesson_cards(lessons, user_level):
 
     # Stats
     total_lessons = len(lessons)
-    completed_lessons = sum(1 for lesson in lessons if lesson["completed"])
+    completed_lessons = sum(1 for lesson in lessons if lesson.get("completed"))
     progress_pct = int((completed_lessons / total_lessons) * 100) if total_lessons else 0
 
     col1, col2, col3, col4 = st.columns(4)
-    with col1:
-        st.metric("📚 Total Lessons", total_lessons)
-    with col2:
-        st.metric("✅ Completed", completed_lessons)
-    with col3:
-        st.metric("📈 Progress", f"{progress_pct}%")
+    with col1: st.metric("📚 Total Lessons", total_lessons)
+    with col2: st.metric("✅ Completed", completed_lessons)
+    with col3: st.metric("📈 Progress", f"{progress_pct}%")
     with col4:
-        available_lessons = sum(1 for lesson in lessons if not lesson["locked"])
+        available_lessons = sum(1 for lesson in lessons if not lesson.get("locked"))
         st.metric("🔓 Available", available_lessons)
 
     st.markdown("---")
 
-    # Display lessons in a 3-column grid like Microsoft Learn
     cols = st.columns(3)
     for i, lesson in enumerate(lessons):
         lesson["completed"] = lesson.get("completed") or _is_lesson_completed(lesson["id"])
-
         with cols[i % 3]:
-            if lesson["locked"]:
-                icon_html = '🔒'
-                card_opacity = "0.6"
-            elif lesson["completed"]:
-                icon_html = '✓'
-                card_opacity = "1"
+            if lesson.get("locked"):
+                icon_html, card_opacity = '🔒', "0.6"
+            elif lesson.get("completed"):
+                icon_html, card_opacity = '✓', "1"
             else:
-                icon_html = '📖'
-                card_opacity = "1"
+                icon_html, card_opacity = '📖', "1"
 
             card_html = f"""
             <div class="lesson-card" style="
-                background: white; 
-                border: 1px solid #e1e5e9; 
-                border-radius: 8px; 
-                padding: 24px; 
-                margin-bottom: 15px; 
-                opacity: {card_opacity}; 
-                box-shadow: 0 2px 4px rgba(0,0,0,0.1); 
-                height: 250px;
-                transition: all 0.3s ease;
-                cursor: pointer;
-            ">
+                background: white; border: 1px solid #e1e5e9; border-radius: 8px; padding: 24px; margin-bottom: 15px;
+                opacity: {card_opacity}; box-shadow: 0 2px 4px rgba(0,0,0,0.1); height: 250px; transition: all 0.3s ease; cursor: pointer;">
                 <div style="display: flex; justify-content: space-between; align-items: flex-start;">
                     <h3 style="margin: 0; font-size: 18px; font-weight: 600; color: #323130; line-height: 1.3;">{lesson['title']}</h3>
                     <div style="color: #28a745; font-size: 24px;">{icon_html}</div>
@@ -588,9 +556,9 @@ def show_lesson_cards(lessons, user_level):
             """
             st.markdown(card_html, unsafe_allow_html=True)
 
-            if lesson["locked"]:
+            if lesson.get("locked"):
                 st.button("🔒 Locked", key=f"lesson_locked_{lesson['id']}", disabled=True, use_container_width=True)
-            elif lesson["completed"]:
+            elif lesson.get("completed"):
                 if st.button("✅ Review", key=f"lesson_review_{lesson['id']}", use_container_width=True, type="secondary"):
                     st.session_state.selected_lesson = lesson["id"]
                     st.rerun()
@@ -599,7 +567,7 @@ def show_lesson_cards(lessons, user_level):
                     st.session_state.selected_lesson = lesson["id"]
                     st.rerun()
 
-def show_lesson_detail(lesson):
+def show_lesson_detail(lesson: dict):
     units = len(get_display_topics(lesson))
     st.markdown(f"""
         <h1 style="font-size:2.5rem; margin-bottom:0;">{lesson['title']}</h1>
@@ -607,7 +575,6 @@ def show_lesson_detail(lesson):
         <hr style="margin:1rem 0;"/>
     """, unsafe_allow_html=True)
 
-    # Learning objectives section
     st.subheader("Learning objectives")
     st.markdown("<p style='color:#888; margin-bottom:0.5rem;'>In this module, you'll</p>", unsafe_allow_html=True)
     st.markdown(
@@ -617,7 +584,6 @@ def show_lesson_detail(lesson):
         "- Understanding simple financial transactions"
     )
 
-    # Start button
     if st.button("▶ Start", key=f"start_{lesson['id']}", type="primary"):
         st.session_state.start_lesson = True
         st.session_state.current_topic = 1
@@ -628,32 +594,39 @@ def show_lesson_detail(lesson):
 
     st.markdown("---")
 
-    # Topics list (with clickable links)
     st.subheader("Topics")
-    display_topics = get_display_topics(lesson)
-    for i, t in enumerate(display_topics, start=1):
+    for i, t in enumerate(get_display_topics(lesson), start=1):
         st.markdown(f"- [{t}](#topic-{i})")
 
     st.markdown("---")
 
-    # Back button
     if st.button("⬅ Back to Lessons", key=f"back_{lesson['id']}"):
         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")
-    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
+# ===============================
+# Lesson page (now calls backend)
+# ===============================
+
+def _topic_text_from_backend(current_lesson: dict, topic_index: int) -> str:
+    topics = get_display_topics(current_lesson)
+    topic_index = max(1, min(topic_index, len(topics)))
+    topic_name = topics[topic_index - 1]
+    title = current_lesson.get("title", f"Lesson {current_lesson.get('id')}")
+    module_id = str(current_lesson.get("id"))
+    if topic_name.lower() == "summary":
+        # Build summary from first N topics (pull each from backend)
+        bullets = []
+        for i in range(1, min(MAX_TOPICS, len(topics)) + 1):
+            tn = topics[i - 1]
+            txt = _fetch_topic_content_via_backend(title, module_id, tn) or ""
+            first_sentence = re.split(r'(?<=[.!?])\s+', txt.strip())[:1]
+            bullets.append(f"• {first_sentence[0] if first_sentence else ('Key idea from topic ' + str(i))}")
+        return "<br>".join(bullets) or "No summary available."
+    # Normal topic
+    return _fetch_topic_content_via_backend(title, module_id, topic_name) or "⚠️ Topic content not available."
+
+def show_lesson_page(lesson: dict, lessons: List[dict]):
     if st.button("⬅ Back to Lessons", key=f"back_top_{lesson['id']}"):
         st.session_state.selected_lesson = None
         st.session_state.current_topic = 1
@@ -661,7 +634,6 @@ def show_lesson_page(lesson, lessons):
         st.session_state.start_lesson = False
         st.rerun()
 
-    # Header
     st.markdown(f"""
     <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>
@@ -674,10 +646,9 @@ def show_lesson_page(lesson, lessons):
     </div>
     """, unsafe_allow_html=True)
 
-    # Two-column layout
     col1, col2 = st.columns([2, 1])
 
-    # --- LEFT COLUMN: Lesson content ---
+    # LEFT: content / quiz
     with col1:
         # If the mini-quiz is active, render it and return early
         if st.session_state.get("show_mini_quiz"):
@@ -688,17 +659,14 @@ def show_lesson_page(lesson, lessons):
         if "current_topic" not in st.session_state:
             st.session_state.current_topic = 1
 
-        # Clamp to valid range in case topics changed
         st.session_state.current_topic = max(1, min(st.session_state.current_topic, len(topics)))
         topic_idx = st.session_state.current_topic - 1
         topic_name = topics[topic_idx]
 
-        # Track progress (max topic reached)
         _mark_topic_seen(lesson["id"], st.session_state.current_topic)
 
         st.subheader(f"Topic {st.session_state.current_topic}: {topic_name}")
 
-        # --- Special handling for Play / Quiz / Summary / Normal ---
         if topic_name.lower().startswith("play"):
             st.info("���� This is a game-based activity to reinforce learning.")
             st.write("👉 Instructions on how to play go here.")
@@ -706,21 +674,14 @@ def show_lesson_page(lesson, lessons):
                 st.markdown('<a href="http://your-game-url.com" target="_blank">Open Game in New Tab</a>', unsafe_allow_html=True)
 
         elif "quiz" in topic_name.lower():
-            # kept only for compatibility; normally hidden by get_display_topics
             st.info("📝 Quick quiz (legacy). This is superseded by the auto mini-quiz at completion.")
 
-        elif topic_name.lower() == "summary":
-            st.info("🧾 Module Summary")
-            summary_html = summarize_first_n_topics(lesson["id"], MAX_TOPICS)
-            st.markdown(f"<div class='topic-content'>{summary_html}</div>", unsafe_allow_html=True)
-
         else:
-            content = load_topic_content(lesson["id"], st.session_state.current_topic)
-            st.markdown(f"<div class='topic-content'>{content}</div>", unsafe_allow_html=True)
+            content_html = _topic_text_from_backend(lesson, st.session_state.current_topic)
+            st.markdown(f"<div class='topic-content'>{content_html}</div>", unsafe_allow_html=True)
 
-        # Topic navigation buttons
+        # Topic nav
         prev_col, next_col = st.columns([1, 1])
-
         with prev_col:
             st.markdown("<div class='topic-nav-btn prev-btn'>", unsafe_allow_html=True)
             if st.session_state.current_topic > 1:
@@ -732,16 +693,15 @@ def show_lesson_page(lesson, lessons):
         with next_col:
             st.markdown("<div class='topic-nav-btn next-btn'>", unsafe_allow_html=True)
             is_last_topic = (st.session_state.current_topic >= len(topics))
-
             if not is_last_topic:
                 if st.button("Next Topic ➡", key=f"next_topic_{lesson['id']}", type="primary"):
                     st.session_state.current_topic += 1
                     st.rerun()
             else:
-                # Last page = Summary → trigger the mini-quiz (2–4 questions)
+                # 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)  # FIX: use agent_generate_quiz
                         st.session_state.mini_quiz_answers = {}
                         st.session_state.mini_q_idx = 0
                         st.session_state.show_mini_quiz = True
@@ -750,7 +710,7 @@ def show_lesson_page(lesson, lessons):
                     st.button("✅ Completed", key=f"completed_{lesson['id']}", disabled=True)
             st.markdown("</div>", unsafe_allow_html=True)
 
-    # --- RIGHT COLUMN: Progress + Lesson navigation ---
+    # RIGHT: progress + lesson navigation
     with col2:
         st.subheader("📊 Progress")
         _ensure_progress_state()
@@ -761,13 +721,11 @@ def show_lesson_page(lesson, lessons):
 
         st.subheader("➡ Lesson Navigation")
         idx = next((i for i, l in enumerate(lessons) if l["id"] == lesson["id"]), 0)
-
         if idx > 0:
             if st.button("⬅ Previous Lesson", key=f"prev_lesson_{lesson['id']}"):
                 st.session_state.selected_lesson = lessons[idx - 1]["id"]
                 st.session_state.current_topic = 1
                 st.rerun()
-
         if idx < len(lessons) - 1:
             if st.button("Next Lesson ➡", key=f"next_lesson_{lesson['id']}"):
                 st.session_state.selected_lesson = lessons[idx + 1]["id"]
@@ -776,7 +734,9 @@ def show_lesson_page(lesson, lessons):
 
     st.markdown("---")
 
-#----- Mini-quiz UI (auto handoff to chatbot on submit) -----
+# ===============================
+# Mini-quiz UI
+# ===============================
 
 def render_mini_quiz_ui(lesson: dict):
     st.markdown("### 📝 Mini Quiz")
@@ -784,7 +744,8 @@ def render_mini_quiz_ui(lesson: dict):
     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))
@@ -804,14 +765,15 @@ 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:
                     st.session_state.mini_q_idx += 1
                     st.rerun()
                 else:
-                    # Build letters (A/B/C/...) from chosen options
+                    # Map selected option text -> letter (A/B/C/…)
                     answers_by_idx: Dict[int, str] = {}
                     for i, it in enumerate(items):
                         sel_text = st.session_state.mini_quiz_answers.get(i, "")
@@ -819,20 +781,17 @@ def render_mini_quiz_ui(lesson: dict):
                         letter = chr(65 + ops.index(sel_text)) if sel_text in ops else ""
                         answers_by_idx[i] = letter
 
-                    # === Agent grade + chatbot feedback ===
                     score, total, feedback = agent_grade_and_chat(lesson, items, answers_by_idx)
 
-                    # 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 ===
+                    # Redirect to Chatbot page with feedback message
                     st.session_state.current_page = "Chatbot"
                     if "messages" not in st.session_state:
                         st.session_state.messages = []
 
-                    # Provide a concise results summary + agent feedback as assistant
                     percent = int(round(100 * score / max(1, total)))
                     summary = f"Mini-Quiz complete — Score: {percent}% ({score}/{total})."
                     st.session_state.messages.append({
@@ -841,13 +800,34 @@ def render_mini_quiz_ui(lesson: dict):
                         "sender": "assistant"
                     })
                     st.session_state.is_typing = False
-                    st.experimental_rerun()
+                    st.rerun()
         return
 
-def render_assigned_lesson(lesson_id: int, assignment_id: int | None = None):
-    """Render a teacher-assigned lesson from the DB using the SAME structure/CSS as general lessons."""
+# ===============================
+# Teacher-assigned (DB) lessons
+# ===============================
+
+def _db_to_general_lesson_shape(L: dict, sections: list) -> dict:
+    level = (L.get("level") or "beginner").lower()
+    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"
+    return {
+        "id": int(L["lesson_id"]),
+        "title": L.get("title") or "Untitled",
+        "description": L.get("description") or "",
+        "duration": duration,
+        "completed": False,
+        "locked": False,
+        "difficulty": difficulty,
+        "topics": topics,
+        "_db_sections": sections,
+        "_db_level": level,
+    }
+
+def render_assigned_lesson(lesson_id: int, assignment_id: Optional[int] = None):
     user = st.session_state.user
-    user_id = user["user_id"]
+    _ = user["user_id"]  # not used here yet
 
     data = dbapi.get_lesson(lesson_id)   # {"lesson": {...}, "sections":[...] }
     if not data or not data.get("lesson"):
@@ -871,7 +851,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):
+def show_db_lesson_detail(lesson: dict):
     st.markdown(f"""
         <h1 style="font-size:2.5rem; margin-bottom:0;">{lesson['title']}</h1>
         <p style="color: #666; margin-top:0;">{lesson['duration']} &nbsp;•&nbsp; Module &nbsp;•&nbsp; {len(lesson.get("topics", []))} units</p>
@@ -895,19 +875,16 @@ def show_db_lesson_detail(lesson):
         st.rerun()
 
     st.markdown("---")
-
     st.subheader("Topics")
     for i, t in enumerate(lesson.get("topics", []), start=1):
         st.markdown(f"- [{t}](#topic-{i})")
-
     st.markdown("---")
 
     if st.button("⬅ Back to Lessons", key=f"db_back_detail_{lesson['id']}"):
         st.session_state.selected_lesson = None
         st.rerun()
 
-def show_db_lesson_page(lesson):
-    # Back link – same as general
+def show_db_lesson_page(lesson: dict):
     if st.button("⬅ Back to Lessons", key=f"db_back_top_{lesson['id']}"):
         st.session_state.selected_lesson = None
         st.session_state.current_topic = 1
@@ -915,7 +892,6 @@ def show_db_lesson_page(lesson):
         st.session_state.start_lesson = False
         st.rerun()
 
-    # Header – same gradient & chips
     st.markdown(f"""
     <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>
@@ -928,10 +904,8 @@ def show_db_lesson_page(lesson):
     </div>
     """, unsafe_allow_html=True)
 
-    # Layout
     col1, col2 = st.columns([2, 1])
 
-    # LEFT: topic content (pulled from DB sections)
     with col1:
         topics = lesson.get("topics", [])
         sections = lesson.get("_db_sections", [])
@@ -944,7 +918,6 @@ def show_db_lesson_page(lesson):
         _mark_topic_seen(lesson["id"], st.session_state.current_topic)
 
         st.subheader(f"Topic {st.session_state.current_topic}: {topic_name}")
-
         body = (sections[idx].get("content") or "⚠️ Topic content not available.")
         st.markdown(f"<div class='topic-content'>{body}</div>", unsafe_allow_html=True)
 
@@ -977,7 +950,6 @@ def show_db_lesson_page(lesson):
                     st.button("✅ Completed", key=f"db_completed_{lesson['id']}", disabled=True)
             st.markdown("</div>", unsafe_allow_html=True)
 
-    # RIGHT: progress + lesson navigation – same UI
     with col2:
         st.subheader("📊 Progress")
         _ensure_progress_state()
@@ -994,14 +966,17 @@ def show_db_lesson_page(lesson):
 
     st.markdown("---")
 
+# ===============================
+# Page entry
+# ===============================
+
 def show_page():
-    # Load CSS
+    # CSS
     css_path = os.path.join("assets", "styles.css")
     load_css(css_path)
-
     st.markdown("""<style> .markdown { font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif; line-height: 1.6;} </style>""", unsafe_allow_html=True)
 
-    # Check login
+    # Login gate
     if not st.session_state.get("user"):
         st.error("❌ Please login first to access lessons.")
         st.info("💡 Create an account to track your progress and unlock advanced content!")
@@ -1010,35 +985,32 @@ def show_page():
     user = st.session_state.user
     user_level = user.get("level", "beginner").lower()
 
-    # Deep link from Teacher Link: if a selected_lesson isn't in the catalog, render it from the DB instead.
     deep_lesson_id = st.session_state.get("selected_lesson")
     deep_assignment_id = st.session_state.get("selected_assignment")
 
-    # Try to resolve in catalog first
     lessons = lessons_by_level.get(user_level, [])
     catalog_ids = {l["id"] for l in lessons}
 
+    # If it's a teacher-assigned(DB) lesson that isn't in the catalog:
     if deep_lesson_id and deep_lesson_id not in catalog_ids:
-        # 👉 This is a teacher-assigned(DB) lesson. Open it directly.
         render_assigned_lesson(int(deep_lesson_id), deep_assignment_id)
         return
 
-    # Initialize session state
+    # Init state
     if "selected_lesson" not in st.session_state:
         st.session_state.selected_lesson = None
     if "start_lesson" not in st.session_state:
         st.session_state.start_lesson = False
 
-    # If a lesson is selected
+    # Routing
     if st.session_state.selected_lesson:
         lesson = next((l for l in lessons if l["id"] == st.session_state.selected_lesson), None)
         if lesson:
-            if st.session_state.start_lesson:  # 🚀 Jump straight into topics
+            if st.session_state.start_lesson:
                 show_lesson_page(lesson, lessons)
             else:
                 show_lesson_detail(lesson)
         else:
             st.warning("⚠️ Lesson not found")
     else:
-        # Otherwise → show lesson cards
         show_lesson_cards(lessons, user_level)