elkay: api.py, chatbot

phase/Student_view/chatbot.py

@@ -1,40 +1,52 @@
 # phase/Student_view/chatbot.py
-import streamlit as st
+import os
 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
+import streamlit as st
 
+# --- use our backend client (utils/api.py) ---
+try:
+    from utils import api as backend
+except ModuleNotFoundError:
+    # fallback if running from a different CWD
+    import sys, pathlib
+    ROOT = pathlib.Path(__file__).resolve().parents[2]
+    if str(ROOT) not in sys.path:
+        sys.path.insert(0, str(ROOT))
+    from utils import api as backend
 
 TUTOR_WELCOME = "Hi! I'm your AI Financial Tutor. What would you like to learn today?"
 
-
 # -------------------------------
-# Session helpers
+# History helpers
 # -------------------------------
+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 or "").strip(),
+            "sender": sender,
+            "timestamp": datetime.datetime.now(),
+        }
+    )
+
 def _coerce_ts(ts):
     if isinstance(ts, datetime.datetime):
         return ts
-    try:
-        # try epoch
-        if isinstance(ts, (int, float)):
+    if isinstance(ts, (int, float)):
+        try:
             return datetime.datetime.fromtimestamp(ts)
-        if isinstance(ts, str):
+        except Exception:
+            return None
+    if isinstance(ts, str):
+        for parser in (datetime.datetime.fromisoformat, lambda s: datetime.datetime.fromtimestamp(float(s))):
             try:
-                return datetime.datetime.fromisoformat(ts)
+                return parser(ts)
             except Exception:
-                return datetime.datetime.fromtimestamp(float(ts))
-    except Exception:
-        pass
-    return datetime.datetime.now()
-
+                pass
+    return None
 
 def _normalize_messages():
     msgs = st.session_state.get("messages", [])
@@ -44,131 +56,108 @@ def _normalize_messages():
         text = (m.get("text") or "").strip()
         sender = m.get("sender") or "user"
         ts = _coerce_ts(m.get("timestamp")) or now
-        if text:
-            normed.append({**m, "text": text, "sender": sender, "timestamp": ts})
+        normed.append({**m, "text": text, "sender": sender, "timestamp": ts})
     st.session_state.messages = normed
 
-
-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.
-    """
+    """Convert our local history into [{role, content}] for the backend."""
     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", "")})
+    for m in st.session_state.get("messages", []):
+        text = (m.get("text") or "").strip()
+        if not text:
+            continue
+        role = "assistant" if (m.get("sender") == "assistant") else "user"
+        hist.append({"role": role, "content": text})
     return hist
 
+# -------------------------------
+# Reply via backend (/chat)
+# -------------------------------
+def _reply_via_backend(user_text: str) -> str:
+    # Defaults: use selected lesson/level if present
+    lesson_id = st.session_state.get("current_lesson_id") or 0
+    level_slug = (st.session_state.get("user", {}).get("level") or "beginner").strip().lower()
+
+    try:
+        answer = backend.chat_ai(
+            query=user_text,
+            lesson_id=lesson_id,
+            level_slug=level_slug,
+            history=_history_for_backend(),
+        )
+        return (answer or "").strip()
+    except Exception as e:
+        err_text = "".join(traceback.format_exception_only(type(e), e)).strip()
+        return f"⚠️ Chat failed: {err_text}"
 
 # -------------------------------
 # Streamlit page
 # -------------------------------
 def show_page():
     st.title("🤖 AI Financial Tutor")
-    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}")
+    st.caption("Get personalized help with your financial questions")
 
-    # First-time session state
     if "messages" not in st.session_state:
         st.session_state.messages = [{
-            "id": "welcome",
+            "id": "1",
             "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")
+            t = 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>"
+                    "<div style='background:#e0e0e0;color:#000;padding:10px;border-radius:12px;"
+                    "max-width:70%;margin-bottom:6px;'>"
+                    f"{msg.get('text','')}<br><sub>{t}</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>"
+                    "<div style='background:#4CAF50;color:#fff;padding:10px;border-radius:12px;"
+                    "max-width:70%;margin-left:auto;margin-bottom:6px;'>"
+                    f"{msg.get('text','')}<br><sub>{t}</sub></div>"
                 )
             st.markdown(bubble, unsafe_allow_html=True)
 
         if st.session_state.is_typing:
-            st.markdown("🤖 _Tutor is typing..._")
+            st.markdown("🤖 _FinanceBot is typing..._")
 
-    # Quick starters
+    # Quick suggestions when only the welcome is present
     if len(st.session_state.messages) == 1:
         st.markdown("Try asking about:")
         cols = st.columns(2)
-        for i, q in enumerate([
+        quick = [
             "How does compound interest work?",
             "How much should I save for emergencies?",
-            "What's a simple budgeting rule?",
-            "How do I start investing safely?",
-        ]):
-            if cols[i % 2].button(q):
+            "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"suggest_{i}"):
                 add_message(q, "user")
                 st.session_state.is_typing = True
                 st.rerun()
 
-    # Input
-    user_input = st.chat_input("Ask me anything about personal finance…")
+    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("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: {''.join(traceback.format_exception_only(type(e), e)).strip()}", "assistant")
-        finally:
-            st.session_state.is_typing = False
-            st.rerun()
+        with st.spinner("FinanceBot is thinking..."):
+            bot_reply = _reply_via_backend(st.session_state.messages[-1]["text"])
+            add_message(bot_reply, "assistant")
+        st.session_state.is_typing = False
+        st.rerun()
 
     if st.button("Back to Dashboard", key="ai_tutor_back_btn"):
         st.session_state.current_page = "Student Dashboard"

utils/api.py

@@ -1,4 +1,4 @@
-# phase/api.py
+# utils/api.py
 import os
 import json
 import logging