claude code

app.py

@@ -271,7 +271,25 @@ def chat(request: ChatRequest, req: Request):
             print(f"[PINECONE ERROR] Failed to retrieve context: {exc}")
             context = "No relevant context found due to a temporary search error."
 
-        # Step 3: Build message (text or multimodal with image / document)
+        # Step 3: Parse search mode sentinel injected by frontend, clean message
+        _WEB_SENTINEL = "[System Instruction: Web Search is enabled."
+        _YT_SENTINEL  = "[System Instruction: YouTube Video Search is enabled."
+
+        raw_message   = request.message
+        force_tool    = ""
+        clean_message = raw_message
+
+        if raw_message.startswith(_WEB_SENTINEL):
+            force_tool = "web_search"
+            parts = raw_message.split("User Query: ", 1)
+            clean_message = parts[1].strip() if len(parts) > 1 else raw_message
+
+        elif raw_message.startswith(_YT_SENTINEL):
+            force_tool = "yt_transcript"
+            parts = raw_message.split("User Query: ", 1)
+            clean_message = parts[1].strip() if len(parts) > 1 else raw_message
+
+        # Build message content (multimodal or text)
         extra_context = ""
         if request.doc_text:
             extra_context = (
@@ -282,14 +300,14 @@ def chat(request: ChatRequest, req: Request):
 
         if request.image:
             msg_content = [
-                {"type": "text", "text": request.message + extra_context},
+                {"type": "text", "text": clean_message + extra_context},
                 {
                     "type": "image_url",
                     "image_url": {"url": f"data:image/jpeg;base64,{request.image}"},
                 },
             ]
         else:
-            msg_content = request.message + extra_context
+            msg_content = clean_message + extra_context
 
         # Step 4: Stream LLM response via LangGraph
         has_image = bool(request.image)
@@ -303,33 +321,62 @@ def chat(request: ChatRequest, req: Request):
                 "student_profile": student_profile,
                 "user_api_key":    user_api_key,
                 "has_image":       has_image,
+                "force_tool":      force_tool,
             }
         }
 
         try:
             active_tools: set[str] = set()
-            for chunk, _metadata in chatbot.stream(
-                {"messages": [HumanMessage(content=msg_content)]},
+            initial_state = {
+                "messages":       [HumanMessage(content=msg_content)],
+                "model_attempt":  0,
+                "skipped_models": [],
+                "selected_model": "",
+                "retry_status":   "ok",
+                "force_tool":     force_tool,
+            }
+            last_retry_status = "ok"
+
+            for event in chatbot.stream(
+                initial_state,
                 config=config,
-                stream_mode="messages",
+                stream_mode="updates",
             ):
-                # Tool call started — emit tool_start so UI shows progress bar
-                if isinstance(chunk, AIMessage) and getattr(chunk, "tool_calls", None):
-                    for tc in chunk.tool_calls:
-                        tn = tc.get("name", "tool")
-                        if tn not in active_tools:
-                            active_tools.add(tn)
-                            yield sse_tool_event("tool_start", tn)
-
-                # Tool result received — emit tool_end
-                elif isinstance(chunk, ToolMessage):
-                    tn = chunk.name or "tool"
-                    active_tools.discard(tn)
-                    yield sse_tool_event("tool_end", tn)
-
-                # Regular AI text token
-                elif isinstance(chunk, AIMessage) and chunk.content:
-                    yield sse_token(chunk.content)
+                # event is a dict like {"llm": {...state fields...}} or {"tools": {...}}
+
+                # ── Retry status ──────────────────────────────────
+                if "llm" in event:
+                    node_output = event["llm"]
+                    rs = node_output.get("retry_status", "")
+                    if rs and rs != "ok" and rs != last_retry_status:
+                        last_retry_status = rs
+                        attempt_num = node_output.get("model_attempt", 0)
+                        yield f"data: {json.dumps({'retry_status': rs, 'attempt': attempt_num})}\n\n"
+
+                # ── Tool events ───────────────────────────────────
+                if "tools" in event:
+                    tool_messages = event["tools"].get("messages", [])
+                    for tm in tool_messages:
+                        if hasattr(tm, "name") and tm.name:
+                            active_tools.discard(tm.name)
+                            yield sse_tool_event("tool_end", tm.name)
+
+                # ── AI message tokens & tool_calls ────────────────
+                all_msgs = []
+                for node_output in event.values():
+                    if isinstance(node_output, dict):
+                        all_msgs.extend(node_output.get("messages", []))
+
+                for msg in all_msgs:
+                    if isinstance(msg, AIMessage):
+                        if getattr(msg, "tool_calls", None):
+                            for tc in msg.tool_calls:
+                                tn = tc.get("name", "tool")
+                                if tn not in active_tools:
+                                    active_tools.add(tn)
+                                    yield sse_tool_event("tool_start", tn)
+                        elif msg.content:
+                            yield sse_token(msg.content)
 
         except Exception as e:
             error_str = str(e).lower()

graph.py

@@ -1,35 +1,54 @@
 """
-LangGraph — Intelligent Model Router for STEM Copilot.
-
-Routes queries to the best free OpenRouter model based on intent.
-Uses static model pools (excluding Venice) to ensure stability and low latency.
-Supports tool-calling (web search, YouTube transcript) inside a ReAct loop.
+LangGraph — Stem Copilot chat graph.
+
+Architecture (official LangGraph pattern):
+  START → llm_node → (should_retry) ──► tools_node → llm_node  (tool loop)
+                                    └──► END                    (final answer)
+                                    └──► llm_node               (model retry)
+
+State fields:
+  messages       — full conversation (add_messages reducer)
+  model_attempt  — how many model attempts have been made (for retry routing)
+  skipped_models — list of model IDs that failed this turn
+  selected_model — the model ID that produced the final response (for LangSmith)
+  retry_status   — human-readable retry string emitted to frontend ("ok" | "retrying:1/2")
+  force_tool     — "web_search" | "yt_transcript" | None (set from app.py config)
 """
 
-from langgraph.graph import StateGraph, START, END
-from langgraph.graph.message import add_messages
-from langchain_core.messages import (
-    BaseMessage, SystemMessage, HumanMessage, AIMessage, ToolMessage
-)
-from langchain_core.runnables import RunnableConfig
-from langchain_openrouter import ChatOpenRouter  # type:ignore
-from typing import TypedDict, Annotated
+from __future__ import annotations
 
 import sqlite3
-import time
-from langgraph.checkpoint.sqlite import SqliteSaver  # type:ignore
-from config import OPENROUTER_API_KEY, DB_PATH, LLM_TIMEOUT
+from typing import Annotated, TypedDict
+
+from langchain_core.messages import AIMessage, BaseMessage, SystemMessage
+from langchain_core.runnables import RunnableConfig
+from langchain_openrouter import ChatOpenRouter  # type: ignore
+from langgraph.checkpoint.sqlite import SqliteSaver  # type: ignore
+from langgraph.graph import END, START, StateGraph
+from langgraph.graph.message import add_messages
+from langgraph.prebuilt import ToolNode, tools_condition
+
 import prompts
+from config import DB_PATH, OPENROUTER_API_KEY
 from tools import TOOLS
 
+try:
+    from langsmith import get_current_run_tree  # type: ignore
+except ImportError:
+    get_current_run_tree = None  # graceful fallback if langsmith not installed
+
 
 # ── Checkpointer ──────────────────────────────────────────────
 _conn = sqlite3.connect(DB_PATH, check_same_thread=False)
 checkpointer = SqliteSaver(conn=_conn)
 
 
-# ── Static Model Pools (excluding Venice provider) ──
-_STATIC_POOLS = {
+# ── Constants ─────────────────────────────────────────────────
+MAX_RETRIES = 2   # 3 total attempts: attempt 0, 1, 2
+
+
+# ── Static Model Pools ────────────────────────────────────────
+_STATIC_POOLS: dict[str, list[str]] = {
     "reasoning": [
         "nvidia/nemotron-3-ultra-550b-a55b:free",
         "nex-agi/nex-n2-pro:free",
@@ -50,12 +69,13 @@ _STATIC_POOLS = {
     "vision": [
         "nvidia/nemotron-3-nano-omni-30b-a3b-reasoning:free",
         "google/gemma-4-31b-it:free",
-    ]
+    ],
 }
 
+_counters: dict[str, int] = {}
 
-# ── Query Classification ─────────────────────────────────────
 
+# ── Query Classification ──────────────────────────────────────
 _CASUAL_EXACT = frozenset([
     "hi", "hii", "hiii", "hello", "hey", "yo", "sup", "hola",
     "thanks", "thank you", "thankyou", "thx", "ty",
@@ -117,15 +137,13 @@ def _classify(text: str) -> str:
     return "general"
 
 
-# ── Model Picker (round-robin) ────────────────────────────────
-
-_counters: dict[str, int] = {}
-
-
-def _pick(category: str, has_image: bool = False, skip_models: set | None = None) -> tuple[str, str]:
-    """
-    Return (model_id, actual_category) from static pools.
-    """
+# ── Model Picker ──────────────────────────────────────────────
+def _pick(
+    category: str,
+    has_image: bool = False,
+    skip_models: set[str] | None = None,
+) -> tuple[str, str]:
+    """Return (model_id, actual_category) from static pools."""
     skip = skip_models or set()
 
     if has_image:
@@ -137,9 +155,8 @@ def _pick(category: str, has_image: bool = False, skip_models: set | None = None
 
     pool = [m for m in (_STATIC_POOLS.get(category) or _STATIC_POOLS["general"]) if m not in skip]
     if not pool:
-        # Fallback to general list if no model is left in active pool
-        fallback_list = _STATIC_POOLS["casual"] + _STATIC_POOLS["general"]
-        pool = [m for m in fallback_list if m not in skip]
+        fallback = _STATIC_POOLS["casual"] + _STATIC_POOLS["general"]
+        pool = [m for m in fallback if m not in skip]
         if not pool:
             return "nvidia/nemotron-3-nano-30b-a3b:free", category
 
@@ -148,8 +165,7 @@ def _pick(category: str, has_image: bool = False, skip_models: set | None = None
     return pool[idx], category
 
 
-# ── Message helpers ────────────────────────────────────────────
-
+# ── Message helpers ───────────────────────────────────────────
 def _extract_text(messages: list) -> str:
     """Get raw text from the last user message (handles multimodal)."""
     if not messages:
@@ -157,14 +173,15 @@ def _extract_text(messages: list) -> str:
     content = messages[-1].content if hasattr(messages[-1], "content") else ""
     if isinstance(content, list):
         return " ".join(
-            p.get("text", "") for p in content
+            p.get("text", "")
+            for p in content
             if isinstance(p, dict) and p.get("type") == "text"
         )
     return str(content)
 
 
 def _strip_images(messages: list) -> list:
-    """Remove all image_url content from messages. Preserves message types."""
+    """Remove all image_url content from messages."""
     out = []
     for msg in messages:
         if isinstance(msg.content, list):
@@ -183,7 +200,6 @@ def _strip_images(messages: list) -> list:
 
 
 # ── LLM factory ───────────────────────────────────────────────
-
 def _make_llm(api_key: str, model_id: str, bind_tools: bool = False):
     key = (api_key or "").strip() or (OPENROUTER_API_KEY or "").strip()
     if not key:
@@ -195,7 +211,7 @@ def _make_llm(api_key: str, model_id: str, bind_tools: bool = False):
         max_tokens=4096,
         max_retries=0,
         streaming=True,
-        timeout=60,  # 60 seconds timeout per request
+        timeout=20,  # 20s per attempt; 3 attempts = 60s max total
         openrouter_provider={"ignore": ["Venice"]},
     )
     if bind_tools:
@@ -203,48 +219,48 @@ def _make_llm(api_key: str, model_id: str, bind_tools: bool = False):
     return llm
 
 
-# ── Tool dispatcher ───────────────────────────────────────
-
-_TOOL_MAP = {t.name: t for t in TOOLS}
-
-
-def _run_tool(tool_call: dict) -> ToolMessage:
-    """Execute a single tool call dict and return a ToolMessage."""
-    name  = tool_call.get("name", "")
-    args  = tool_call.get("args", {})
-    tc_id = tool_call.get("id", name)
-    tool_fn = _TOOL_MAP.get(name)
-    if tool_fn is None:
-        result = f"Unknown tool: {name}"
-    else:
-        try:
-            result = tool_fn.invoke(args)
-        except Exception as exc:
-            result = f"Tool error: {exc}"
-    return ToolMessage(content=str(result), tool_call_id=tc_id)
-
-
-# ── LangGraph state & node ────────────────────────────────────
-
+# ── Graph State ───────────────────────────────────────────────
+# Extends MessagesState pattern (add_messages reducer on messages field)
+# with retry tracking fields needed by should_retry edge.
 class ChatState(TypedDict):
-    messages: Annotated[list[BaseMessage], add_messages]
-
+    messages:       Annotated[list[BaseMessage], add_messages]
+    model_attempt:  int          # 0, 1, 2 — incremented on failure
+    skipped_models: list[str]    # model IDs that failed this turn
+    selected_model: str          # model ID that succeeded (for LangSmith)
+    retry_status:   str          # "ok" | "retrying:1/2" | "retrying:2/2"
+    force_tool:     str          # "web_search" | "yt_transcript" | ""
 
-def chat_node(state: ChatState, config: RunnableConfig):
-    cfg       = config.get("configurable", {})
-    persona   = cfg.get("persona", "nerd")
-    context   = cfg.get("context", "")
-    language  = cfg.get("language", "auto")
-    username  = cfg.get("username", "")
-    profile   = cfg.get("student_profile", "")
-    api_key   = cfg.get("user_api_key", "")
-    override  = cfg.get("model", "")
-    has_image = cfg.get("has_image", False)
 
-    user_text = _extract_text(state["messages"])
-    category  = _classify(user_text)
+# ── LLM Node ─────────────────────────────────────────────────
+def llm_node(state: ChatState, config: RunnableConfig) -> dict:
+    """
+    Calls the LLM. On success returns the AI message.
+    On failure increments model_attempt and adds model to skipped_models
+    so should_retry can route back here with the next model.
+    """
+    cfg           = config.get("configurable", {})
+    persona       = cfg.get("persona", "nerd")
+    context       = cfg.get("context", "")
+    language      = cfg.get("language", "auto")
+    username      = cfg.get("username", "")
+    profile       = cfg.get("student_profile", "")
+    api_key       = cfg.get("user_api_key", "")
+    override      = cfg.get("model", "")
+    has_image     = cfg.get("has_image", False)
+    force_tool    = cfg.get("force_tool", "")
+
+    attempt       = state.get("model_attempt", 0)
+    skipped       = list(state.get("skipped_models", []))
+    user_text     = _extract_text(state["messages"])
+    category      = _classify(user_text)
+
+    # Pick model — respect override only on first attempt
+    if override and attempt == 0:
+        model_id, actual = override, category
+    else:
+        model_id, actual = _pick(category, has_image=has_image, skip_models=set(skipped))
 
-    messages = list(state["messages"])
+    # Build system prompt
     base_prompt = prompts.build(persona, context, language, username, profile)
 
     if has_image:
@@ -254,70 +270,118 @@ def chat_node(state: ChatState, config: RunnableConfig):
             "Do NOT output safety classifications or moderation labels.\n"
         )
 
-    sys = SystemMessage(content=base_prompt)
-
-    # Try up to 3 models on failures / rate limits
-    skip_models: set[str] = set()
-    last_error = None
+    # Inject tool-forcing directive into system prompt (authoritative — not user message)
+    if force_tool == "web_search":
+        base_prompt += (
+            "\n\n## ACTIVE MODE: WEB SEARCH\n"
+            "The student has explicitly enabled Web Search. "
+            "You MUST call the `web_search` tool with a concise query before answering. "
+            "Do NOT answer from memory alone.\n"
+        )
+    elif force_tool == "yt_transcript":
+        base_prompt += (
+            "\n\n## ACTIVE MODE: YOUTUBE TRANSCRIPT\n"
+            "The student has enabled YouTube mode. "
+            "Extract the YouTube URL or video ID from the user message and call the "
+            "`yt_transcript` tool to retrieve its transcript before answering. "
+            "Do NOT answer without fetching the transcript first.\n"
+        )
 
-    for attempt in range(3):
-        if override and attempt == 0:
-            model_id, actual = override, category
-        else:
-            model_id, actual = _pick(category, has_image=has_image, skip_models=skip_models)
+    sys_msg = SystemMessage(content=base_prompt)
+    messages = state["messages"]
+    send_messages = messages if actual == "vision" else _strip_images(list(messages))
 
-        send_messages = messages if actual == "vision" else _strip_images(messages)
-        print(f"[ROUTER] attempt={attempt+1} category={category} model={model_id} vision={actual == 'vision'}")
+    retry_status = "ok" if attempt == 0 else f"retrying:{attempt}/{MAX_RETRIES}"
+    print(f"[ROUTER] attempt={attempt + 1} category={category} model={model_id}")
 
+    # Tag current LangSmith run with selected model
+    if get_current_run_tree is not None:
         try:
-            llm = _make_llm(api_key, model_id, bind_tools=True)
-
-            # ── ReAct tool-calling loop (max 5 iterations) ───
-            loop_msgs = list(send_messages)
-            for _iter in range(5):
-                resp = llm.invoke([sys] + loop_msgs, config=config)
-
-                # No tool calls → final answer
-                if not getattr(resp, "tool_calls", None):
-                    return {"messages": [resp]}
-
-                # Execute requested tools and collect results
-                print(f"[TOOLS] iter={_iter+1} calls={[tc['name'] for tc in resp.tool_calls]}")
-                loop_msgs.append(resp)
-                for tc in resp.tool_calls:
-                    tool_msg = _run_tool(tc)
-                    loop_msgs.append(tool_msg)
-
-            # Exceeded iterations → final invoke without tools to force answer
-            final_llm = _make_llm(api_key, model_id, bind_tools=False)
-            resp = final_llm.invoke([sys] + loop_msgs, config=config)
-            return {"messages": [resp]}
-
-        except Exception as e:
-            err_str = str(e)
-            last_error = e
-
-            # Rotate on rate-limits, provider auth, timeout, or provider failure
-            is_rate = "429" in err_str or "TooManyRequests" in err_str or "rate" in err_str.lower()
-            is_auth_err = "401" in err_str or "User not found" in err_str or "Unauthorized" in err_str
-            is_ignored = "ignored" in err_str.lower() or "no provider" in err_str.lower() or "404" in err_str
-            is_timeout = "timeout" in err_str.lower() or "timed out" in err_str.lower()
-            is_connection = "connection" in err_str.lower() or "connect" in err_str.lower()
-
-            if is_rate or is_auth_err or is_ignored or is_timeout or is_connection:
-                reason = "rate-limit" if is_rate else ("auth" if is_auth_err else ("ignored" if is_ignored else "timeout/connection"))
-                print(f"[ROUTER] Error ({reason}) on {model_id}, rotating...")
-                skip_models.add(model_id)
-                continue
-            raise
-
-    raise last_error
-
-
-# ── Compile graph ─────────────────────────────────────────────
-_g = StateGraph(ChatState)
-_g.add_node("chat_node", chat_node)
-_g.add_edge(START, "chat_node")
-_g.add_edge("chat_node", END)
-
-chatbot = _g.compile(checkpointer=checkpointer)
+            run = get_current_run_tree()
+            if run:
+                meta = run.extra.setdefault("metadata", {})
+                meta["selected_model"] = model_id
+                meta["model_attempt"]  = attempt
+                meta["model_category"] = actual
+        except Exception:
+            pass  # Never let LangSmith tagging break the chat
+
+    try:
+        llm  = _make_llm(api_key, model_id, bind_tools=True)
+        resp = llm.invoke([sys_msg] + list(send_messages), config=config)
+
+        return {
+            "messages":       [resp],
+            "selected_model": model_id,
+            "retry_status":   "ok",
+            # Do NOT reset model_attempt/skipped here — they stay for the tool loop
+            # but will reset on the next user turn (app.py always starts a fresh state input)
+        }
+
+    except Exception as e:
+        err_str = str(e)
+        print(f"[ROUTER] Error on {model_id}: {err_str[:120]}")
+        return {
+            "skipped_models": skipped + [model_id],
+            "model_attempt":  attempt + 1,
+            "retry_status":   retry_status,
+        }
+
+
+# ── Retry / Route Edge ────────────────────────────────────────
+def should_retry(state: ChatState) -> str:
+    """
+    Conditional edge leaving llm_node.
+
+    Three possible routes:
+      "tools"    — LLM succeeded and wants to call a tool
+      "__end__"  — LLM succeeded with a final answer (tools_condition returns __end__)
+      "llm"      — LLM failed, retry with next model if attempts remain
+    """
+    messages = state.get("messages", [])
+    if not messages:
+        return END
+
+    last = messages[-1]
+
+    # If last message is an AIMessage the LLM succeeded — delegate to tools_condition
+    if isinstance(last, AIMessage):
+        # tools_condition returns "tools" or "__end__"
+        return tools_condition(state)
+
+    # No AIMessage = node returned failure dict without a message
+    attempt = state.get("model_attempt", 0)
+    if attempt <= MAX_RETRIES:
+        return "llm"  # retry
+
+    # All attempts exhausted — return empty response rather than crashing
+    print("[ROUTER] All model attempts exhausted.")
+    return END
+
+
+# ── Tool Node ─────────────────────────────────────────────────
+# handle_tool_errors=True: DDG rate limits and YT fetch errors are caught
+# automatically and returned as ToolMessage strings — graph never crashes.
+tools_node = ToolNode(TOOLS, handle_tool_errors=True)
+
+
+# ── Build Graph ───────────────────────────────────────────────
+_builder = StateGraph(ChatState)
+_builder.add_node("llm",   llm_node)
+_builder.add_node("tools", tools_node)
+
+_builder.add_edge(START, "llm")
+
+_builder.add_conditional_edges(
+    "llm",
+    should_retry,
+    {
+        "tools": "tools",  # LLM wants to call a tool
+        "llm":   "llm",    # model failed → retry with next model
+        END:     END,      # final answer
+    },
+)
+
+_builder.add_edge("tools", "llm")  # after tool execution, back to LLM
+
+chatbot = _builder.compile(checkpointer=checkpointer)

static/app.js

@@ -970,9 +970,39 @@ function closeAllMenus() {
     document.querySelectorAll('.options-menu.show').forEach(m => m.classList.remove('show'));
     document.querySelectorAll('.options-btn.menu-open').forEach(b => b.classList.remove('menu-open'));
     if (userMenu) userMenu.classList.remove('show');
-    // Close ALL style dropdowns — static and dynamic hero ones
     document.querySelectorAll('.style-dropdown.show').forEach(d => d.classList.remove('show'));
     document.querySelectorAll('.style-selector-btn.open').forEach(b => b.classList.remove('open'));
+    // Fix: close attach menus and reset + button icon
+    document.querySelectorAll('.attach-menu.show').forEach(m => m.classList.remove('show'));
+    document.querySelectorAll('.attach-plus-btn.open').forEach(b => b.classList.remove('open'));
+}
+
+function _showRetryBanner(status, attempt) {
+    // Remove any existing banner
+    const existing = document.querySelector('.retry-banner');
+    if (existing) existing.remove();
+
+    if (!status || status === 'ok') return;
+
+    // Build display string: "retrying:1/2" → "Retrying model 1 of 2..."
+    const parts = status.split(':');
+    const label = parts[1] ? `Retrying model ${parts[1].replace('/', ' of ')}…` : 'Retrying…';
+
+    const banner = document.createElement('div');
+    banner.className = 'retry-banner';
+    banner.textContent = label;
+
+    // Attach to the active AI message row
+    const rows = chatContainer.querySelectorAll('.message-row.ai');
+    const lastRow = rows[rows.length - 1];
+    if (lastRow) {
+        const thinkingEl = lastRow.querySelector('.thinking-indicator');
+        if (thinkingEl) thinkingEl.appendChild(banner);
+    }
+}
+
+function _clearRetryBanner() {
+    document.querySelectorAll('.retry-banner').forEach(b => b.remove());
 }
 
 function deleteChat(e, optionEl) {
@@ -1670,6 +1700,10 @@ function streamResponse(text) {
                             _showActionsBar(actionsEl, contentEl);
                             isSending = false; _showAdaptiveBtn(); currentStreamStopped = true; return;
                         }
+                        // Retry status banner
+                        if (data.retry_status) {
+                            _showRetryBanner(data.retry_status, data.attempt || 0);
+                        }
                         if (data.tool_event) {
                             if (data.tool_event === 'tool_start') {
                                 if (pLabel) pLabel.textContent = data.tool === 'web_search' ? 'Searching the web...' : 'Fetching YouTube transcript...';
@@ -1757,6 +1791,7 @@ function _showActionsBar(actionsEl, contentEl) {
 }
 
 function finishStream(thinkingEl, contentEl, rawText, timer, actionsEl) {
+    _clearRetryBanner();
     if (timer) clearTimeout(timer);
     currentRenderTimer = null;
     thinkingEl.style.display = 'none';

static/style.css

@@ -2640,4 +2640,35 @@ textarea, input, select {
     .user .message-content { font-size: 12.5px; }
     .katex-display { overflow-x: auto; font-size: 0.95em; }
     .message-content pre { font-size: 11px; }
+}
+
+/* ── Retry Banner ───────────────────────────────────────────── */
+.retry-banner {
+    display: inline-flex;
+    align-items: center;
+    gap: 6px;
+    margin-left: 10px;
+    padding: 2px 10px;
+    background: var(--bg-card);
+    border: 1px solid var(--border-color);
+    border-radius: 20px;
+    font-size: 11px;
+    color: var(--text-muted);
+    letter-spacing: 0.3px;
+    animation: fadeIn 0.25s ease-out;
+}
+
+.retry-banner::before {
+    content: '';
+    width: 6px;
+    height: 6px;
+    border-radius: 50%;
+    background: var(--brand);
+    animation: dotPulse 1s ease-in-out infinite;
+    flex-shrink: 0;
+}
+
+@keyframes dotPulse {
+    0%, 100% { opacity: 0.3; transform: scale(0.8); }
+    50%       { opacity: 1;   transform: scale(1.1); }
 }

tools.py

@@ -1,19 +1,26 @@
 from __future__ import annotations
 import re
-from langchain_community.tools import DuckDuckGoSearchRun
+from langchain_community.tools import DuckDuckGoSearchResults
 from langchain_core.tools import tool
 
-# DuckDuckGo Search Run tool
-web_search = DuckDuckGoSearchRun(
+
+# ── Web Search ────────────────────────────────────────────────
+# Using DuckDuckGoSearchResults (structured) over DuckDuckGoSearchRun (plain string).
+# num_results=4 keeps context tight for free-tier models.
+# handle_tool_error is handled at the ToolNode level in graph.py.
+web_search = DuckDuckGoSearchResults(
     name="web_search",
+    num_results=4,
     description=(
         "Search the internet for current information. "
-        "Use this when the student asks about recent events, specific facts, "
+        "Use when the student asks about recent events, specific facts, "
         "or anything not covered by the NCERT curriculum context. "
         "Input: a concise search query string."
     ),
 )
 
+
+# ── YouTube Transcript ────────────────────────────────────────
 def _extract_video_id(url_or_id: str) -> str | None:
     """Extract YouTube 11-character video ID from URL or bare ID."""
     patterns = [
@@ -26,6 +33,7 @@ def _extract_video_id(url_or_id: str) -> str | None:
             return m.group(1)
     return None
 
+
 @tool
 def yt_transcript(youtube_url: str) -> str:
     """
@@ -59,5 +67,6 @@ def yt_transcript(youtube_url: str) -> str:
             )
         return f"Error fetching transcript: {exc}"
 
-# Exported tools list for LangGraph
+
+# ── Exported list ─────────────────────────────────────────────
 TOOLS = [web_search, yt_transcript]