Update src/api/agent.py

src/api/agent.py

@@ -1,5 +1,5 @@
 """
-agent.py — LibBee v3.6
+agent.py — LibBee v3.7
 
 ╔══════════════════════════════════════════════════════════════════╗
 ║  TABLE OF CONTENTS                                              ║
@@ -14,7 +14,7 @@ agent.py — LibBee v3.6
 ║  §8   Topic Extraction                                          ║
 ║  §9   Query Builders (PRIMO boolean, PubMed URL)                ║
 ║  §10  Search Preparation & Planning                             ║
-║  §11  Search Runners (OpenAlex, Semantic Scholar, PRIMO, PubMed)║
+║  §11  Search Runners (PRIMO, PubMed) ← v3.7                    ║
 ║  §12  Response Builders (badges, thought blocks, SVG mascots)   ║
 ║  §13  Hardcoded Answers (campus, fulltext, DB recs, theses...)  ║
 ║  §14  Follow-up System                                          ║
@@ -22,12 +22,29 @@ agent.py — LibBee v3.6
 ║  §16  FastAPI Endpoint & Utility Routes                         ║
 ╚══════════════════════════════════════════════════════════════════╝
 
-Changes over v3.5:
-- §4 LibCal Events: EVENTS_RE + _libcal_fetch_events() +
-  _events_answer() — live upcoming events from KU LibCal calendar
-  via Cloudflare Worker /events proxy. 30-min cache.
-- Routing: EVENTS_RE check added in _agent_query_inner.
-- worker.js: /events endpoint added (v3.6).
+Changes over v3.6 (v3.7):
+- §11  _semantic_scholar_search, _openalex_search, _generate_cited_summary,
+       _extractive_snapshot_from_papers, and _research_snapshot removed.
+       Approach: LibBee navigates, not synthesizes. Deep research is handed
+       off to Consensus, LeapSpace, Scopus AI, PRIMO AI — platforms built
+       for that purpose. See git history to restore these functions.
+- §11  _topic_intro() added — lightweight 3-sentence LLM topic intro
+       (~180 tokens, no external API calls) prepended to all academic/medical
+       search responses.
+- §12  _run_search_mode() updated — single PRIMO link (all resources) with
+       filter hint instead of separate articles/books links.
+- §14  _search_follow_up() simplified — removed filter chips (peer reviewed,
+       date range, resource type). Replaced with 4 purposeful chips:
+       alternative search terms, best databases, full text help, search strategy.
+       Users apply filters directly in PRIMO/database platforms.
+- §14  summarize_topic follow-up action removed.
+- §3   SUMMARY_RE removed — no longer used for routing.
+- §15  summary_mode / deep_research_mode detection removed from
+       _agent_query_inner search_academic handler.
+- §15  Inline _CATALOGUE_RE / _BOOK_RE compilation removed — was firing
+       per-request. Catalogue block removed entirely (PRIMO boolean handles
+       all resource types).
+- §15  asyncio.get_running_loop() replaces deprecated get_event_loop().
 """
 # ── §1 Imports ────────────────────────────────────────────────────────────────
 
@@ -209,18 +226,6 @@ CURRENT_INFO_RE = re.compile(
     r"|news|update|updated|prime minister|ceo|minister|king|ruler|who won)\b",
     re.IGNORECASE,
 )
-SUMMARY_RE = re.compile(
-    r"\b(summar(y|ize|ise|izing|ising)|overview|explain|what is|what are|describe"
-    r"|tell me about|give me a summary|give me an overview|give me a brief"
-    r"|brief (summary|overview|explanation|description)"
-    r"|research (overview|summary|landscape|state)"
-    r"|state of (the art|research|the field)"
-    r"|recent (advances?|developments?|progress|trends?)"
-    r"|current (state|trends?|advances?|research)"
-    r"|deep analysis|analysis of|review of|literature review|deep research|deep dive"
-    r"|what do we know about|how does|how do)\b",
-    re.IGNORECASE,
-)
 DATABASE_RECOMMEND_RE = re.compile(
     r"("
     # explicit recommendation phrasing
@@ -777,15 +782,11 @@ async def _events_answer(days: int = 30) -> str:
     """
     Return upcoming library events from LibCal.
     Falls back to library events calendar link if unavailable.
-    _libcal_fetch_events returns:
-      None  — API/network failure
-      []    — API succeeded but no events in the window
-      [...]  — events found
     """
     EVENTS_URL = "https://kustar.libcal.com/calendar/events"
     events = await _libcal_fetch_events(days=days, limit=15)
 
-    if events is None:
+    if not events:
         return (
             "<strong>📅 Khalifa University Library Events</strong><br><br>"
             "Live event data is currently unavailable. Browse all upcoming events here:<br>"
@@ -793,7 +794,7 @@ async def _events_answer(days: int = 30) -> str:
             f'style="font-weight:700;color:#003366">{EVENTS_URL}</a>'
         )
 
-    if len(events) == 0:
+    if not events:
         return (
             "<strong>📅 Khalifa University Library Events</strong><br><br>"
             f"No upcoming events found in the next {days} days.<br><br>"
@@ -938,10 +939,6 @@ def _build_history_messages(history: List[ChatMessage]) -> List[dict]:
     return msgs
 
 
-def _is_summary_request(question: str) -> bool:
-    return bool(SUMMARY_RE.search(question or ""))
-
-
 def _is_greeting_menu_followup(question: str, history: List[ChatMessage]) -> bool:
     if not GREETING_FOLLOWUP_RE.match((question or "").strip()):
         return False
@@ -973,12 +970,12 @@ def _looks_medical_search(question: str) -> bool:
     q = (question or "").lower()
     if not any(kw in q for kw in MEDICAL_KEYWORDS):
         return False
-    return bool(MEDICAL_SEARCH_RE.search(q) or RESEARCH_CUE_RE.search(q) or SUMMARY_RE.search(q))
+    return bool(MEDICAL_SEARCH_RE.search(q) or RESEARCH_CUE_RE.search(q))
 
 
 def _looks_research_question(question: str) -> bool:
     q = question or ""
-    return bool(RESEARCH_CUE_RE.search(q) or SUMMARY_RE.search(q))
+    return bool(RESEARCH_CUE_RE.search(q))
 
 
 def _rule_based_classify(question: str) -> Dict[str, str]:
@@ -1799,216 +1796,45 @@ async def _prepare_queries(question: str, context: SearchContextPayload, model:
 
 
 # ── §11 Search Runners ────────────────────────────────────────────────────────
-
-# ── Semantic Scholar + Summary ────────────────────────────────────────────────
-
-async def _semantic_scholar_search(topic: str, limit: int = 8) -> List[dict]:
-    clean_topic = _strip_resource_noise(topic)
-    if not clean_topic:
-        clean_topic = topic
-    try:
-        params = {
-            "query": clean_topic,
-            "limit": limit,
-            "fields": "title,authors,year,venue,abstract,externalIds,openAccessPdf",
-        }
-        async with httpx.AsyncClient(timeout=15) as client:
-            r = await client.get("https://api.semanticscholar.org/graph/v1/paper/search", params=params)
-            if r.status_code != 200:
-                logger.warning(f"Semantic Scholar {r.status_code} for '{clean_topic}'")
-                return []
-            data = r.json()
-            results = []
-            for paper in data.get("data", []):
-                abstract = paper.get("abstract") or ""
-                if not abstract or len(abstract) < 50:
-                    continue
-                author_list = paper.get("authors") or []
-                first_author_last = author_list[0].get("name", "Unknown").split()[-1] if author_list else "Unknown"
-                year = paper.get("year") or "n.d."
-                paper_id = paper.get("paperId", "")
-                doi = (paper.get("externalIds") or {}).get("DOI", "")
-                pdf_url = (paper.get("openAccessPdf") or {}).get("url", "")
-                link = (
-                    pdf_url
-                    or (f"https://doi.org/{doi}" if doi else "")
-                    or (f"https://www.semanticscholar.org/paper/{paper_id}" if paper_id else "#")
-                )
-                results.append({
-                    "title": paper.get("title", "Untitled"),
-                    "authors": (
-                        ", ".join(a.get("name", "") for a in author_list[:3])
-                        + (" et al." if len(author_list) > 3 else "")
-                    ),
-                    "first_author": first_author_last,
-                    "year": year,
-                    "citation_key": f"{first_author_last}, {year}",
-                    "venue": paper.get("venue", ""),
-                    "abstract": abstract[:700],
-                    "link": link,
-                    "_source": "Semantic Scholar",
-                })
-            return results
-    except Exception as e:
-        logger.error(f"Semantic Scholar search failed: {e}")
-        return []
+#
+# v3.7 NOTE: _semantic_scholar_search, _openalex_search, _generate_cited_summary,
+# _extractive_snapshot_from_papers, and _research_snapshot were removed in v3.7.
+# Approach: LibBee navigates to research platforms, it does not synthesize.
+# Deep research is handled by Consensus, LeapSpace, Scopus AI, PRIMO AI.
+# See git history to restore these functions if needed.
 
 
-async def _openalex_search(topic: str, limit: int = 8) -> List[dict]:
+async def _topic_intro(topic: str, model: str) -> str:
     """
-    Search OpenAlex using ?search= — same relevance engine as the browser link.
-    Passes the full corrected natural language query, strips only boolean operators.
-    """
-    try:
-        from urllib.parse import quote as _oa_quote
-        # Strip boolean operators only — keep all keywords including proper nouns
-        clean = re.sub(r'\b(AND|OR|NOT)\b|[()"\'\\]', ' ', topic, flags=re.IGNORECASE)
-        clean = re.sub(r'\s+', ' ', clean).strip()[:200]
-        encoded = _oa_quote(clean, safe='')
-        select = "id,title,authorships,publication_year,primary_location,abstract_inverted_index,doi,cited_by_count,open_access"
-        url = (
-            f"https://api.openalex.org/works"
-            f"?search={encoded}"
-            f"&filter=has_abstract:true,type:article,is_paratext:false"
-            f"&sort=relevance_score:desc"
-            f"&per_page={limit}"
-            f"&select={select}"
-        )
-        headers = {"User-Agent": "LibBee/3.2 (mailto:libse@ku.ac.ae)"}
-        async with httpx.AsyncClient(timeout=10) as client:
-            r = await client.get(url, headers=headers)
-            if r.status_code != 200:
-                logger.warning(f"OpenAlex search failed: {r.status_code}")
-                return []
-            works = r.json().get("results", [])
-
-            results = []
-            for work in works:
-                title = work.get("title") or "Untitled"
-
-                # Reconstruct abstract from inverted index
-                inv = work.get("abstract_inverted_index") or {}
-                abstract = ""
-                if inv:
-                    word_positions = []
-                    for word, positions in inv.items():
-                        for pos in positions:
-                            word_positions.append((pos, word))
-                    word_positions.sort(key=lambda x: x[0])
-                    abstract = " ".join(w for _, w in word_positions)[:700]
-
-                if not abstract:
-                    continue
-
-                authorships = work.get("authorships") or []
-                author_names = [
-                    a.get("author", {}).get("display_name", "")
-                    for a in authorships[:4]
-                    if a.get("author", {}).get("display_name")
-                ]
-                authors_str = ", ".join(author_names[:3])
-                if len(author_names) > 3:
-                    authors_str += " et al."
-                first_last = author_names[0].split()[-1] if author_names else "Unknown"
-
-                year = str(work.get("publication_year") or "n.d.")
-                doi = (work.get("doi") or "").replace("https://doi.org/", "")
-                oa_url = (work.get("open_access") or {}).get("oa_url") or ""
-                link = (
-                    oa_url if oa_url
-                    else (f"https://doi.org/{doi}" if doi else "")
-                    or work.get("id", "https://openalex.org")
-                )
-                venue = (
-                    ((work.get("primary_location") or {}).get("source") or {})
-                    .get("display_name") or ""
-                )
-
-                results.append({
-                    "title": title,
-                    "authors": authors_str or "Unknown",
-                    "first_author": first_last,
-                    "year": year,
-                    "citation_key": f"{first_last}, {year}",
-                    "venue": venue,
-                    "abstract": abstract,
-                    "link": link,
-                    "_source": "OpenAlex",
-                })
-
-            logger.info(f"OpenAlex: {len(results)} papers for '{clean[:50]}'")
-            return results
-
-    except Exception as e:
-        logger.warning(f"OpenAlex search failed: {e}")
-        return []
-
+    Generate a concise 3-sentence topic introduction for academic/medical queries.
+    ~180 tokens. No external API calls — LLM knowledge only.
 
-async def _generate_cited_summary(topic: str, papers: List[dict], model: str) -> str:
+    LibBee v3.7 approach: provide brief context, then hand off to PRIMO and
+    AI research platforms (Consensus, LeapSpace, Scopus AI) for deep research.
+    """
     settings = get_settings()
     if not settings.openai_api_key and not settings.anthropic_api_key:
         return ""
-    if not papers:
-        return ""
-    context_text = ""
-    for i, paper in enumerate(papers, 1):
-        context_text += (
-            f"[{i}] {paper['citation_key']}: {paper['title']}\n"
-            f"Abstract: {paper['abstract']}\n\n"
-        )
-    system = (
-        "You are a research librarian writing a concise academic literature snapshot. "
-        "Using ONLY the numbered references provided, write a 4-6 sentence summary on the given topic. "
-        "Use in-text citations as [1], [2], [3] etc. referring to the numbered references. "
-        "Cite at least 4 different references. "
-        "Use HTML <br><br> for paragraph breaks. Do not use bullet points or markdown. "
-        "Only state what is explicitly supported by the abstracts. "
-        "Do NOT invent content."
-    )
     try:
-        llm = _get_llm(model, temperature=0.2, max_tokens=560)
+        llm = _get_llm(model, temperature=0.2, max_tokens=180)
         response = await llm.ainvoke([
-            {"role": "system", "content": system},
-            {"role": "user", "content": f"Topic: {topic}\n\nReferences:\n{context_text}\nWrite the summary."},
+            {"role": "system", "content": (
+                "You are LibBee, the Khalifa University Library AI Assistant. "
+                "Write exactly 3 clear, factual sentences introducing the given research topic "
+                "for a university student or researcher. "
+                "Cover: what the topic is, why it matters, and one key area of current research interest. "
+                "Use HTML <br> for line breaks only if needed. No markdown, no bullet points, no headings. "
+                "Be concise and informative."
+            )},
+            {"role": "user", "content": f"Research topic: {topic}"},
         ])
-        summary = response.content.strip()
-        for i in range(len(papers), 0, -1):
-            paper = papers[i - 1]
-            title_escaped = _escape(paper["title"])
-            cite_html = (
-                f'<a href="{paper["link"]}" target="_blank" '
-                f'title="{title_escaped}" '
-                f'style="color:#1e40af;font-weight:600;text-decoration:none">'
-                f'[{paper["citation_key"]}]</a>'
-            )
-            summary = summary.replace(f"[{i}]", cite_html)
-        return summary
+        intro = response.content.strip()
+        return intro if intro else ""
     except Exception as e:
-        logger.error(f"Summary generation failed: {e}")
+        logger.warning(f"_topic_intro failed: {e}")
         return ""
 
 
-def _extractive_snapshot_from_papers(topic: str, papers: List[dict]) -> str:
-    if not papers:
-        return ""
-    statements: List[str] = []
-    for paper in papers[:4]:
-        sentences = re.split(r"(?<=[.!?])\s+", paper.get("abstract", ""))
-        lead = sentences[0].strip() if sentences else ""
-        if not lead:
-            continue
-        citation = (
-            f'<a href="{paper["link"]}" target="_blank" '
-            f'style="color:#1e40af;font-weight:600;text-decoration:none">'
-            f'[{_escape(paper["citation_key"])}]</a>'
-        )
-        statements.append(f"{_escape(lead)} {citation}")
-    if not statements:
-        return f"Recent literature on <strong>{_escape(topic)}</strong> is available in the cited papers below."
-    intro = f"Recent literature on <strong>{_escape(topic)}</strong>:<br><br>"
-    return intro + "<br><br>".join(statements[:4])
-
-
 # ── §12 Response Builders ─────────────────────────────────────────────────────
 
 # ── PRIMO / PubMed Search Wrappers ────────────────────────────────────────────
@@ -3108,30 +2934,37 @@ def _highly_cited_note(topic_escaped: str) -> str:
     )
 
 
-# ── Research Snapshot ─────────────────────────────────────────────────────────
-
-async def _research_snapshot(context: SearchContextPayload, model: str) -> Tuple[str, List[dict], List[dict]]:
+async def _run_search_mode(
+    question: str, context: SearchContextPayload, model: str, is_follow_up: bool
+) -> Tuple[str, List[dict], List[dict], str]:
     """
-    Research snapshot — no API calls.
-    Shows PRIMO browser link + AI tools footer only.
+    Search mode — builds PRIMO link + topic intro + AI tools footer.
+    No external academic API calls (v3.7).
     """
-    topic = context.topic
-    primo_url = _primo_clean_url(context)
-    answer = _search_trace_block(f"Research on {topic}", context)
+    context = await _prepare_queries(question, context, model, is_follow_up)
+    source_url = _primo_clean_url(context)
+    topic = _escape(context.display_topic or context.topic)
+
+    # 3-sentence topic intro — lightweight LLM call, no external APIs
+    intro = await _topic_intro(context.display_topic or context.topic, model)
+
+    answer = _search_trace_block(question, context)
+    if intro:
+        answer += f'<div style="margin-bottom:12px;color:#374151;font-size:.88rem;line-height:1.7">{intro}</div>'
+    answer += _search_answer_intro(context, is_follow_up)
     answer += (
-        f"<strong>📚 Research starting points: {_escape(topic)}</strong><br><br>"
-        "Your query has been prepared and pre-loaded across multiple platforms. "
-        "Click any platform below to search instantly, or use the boolean search tip "
-        "to search directly in any KU database."
-        f'<br><br><a href="{primo_url}" target="_blank" style="color:#003366;font-weight:700">'
-        f'Search PRIMO for: {_escape(topic)} →</a>'
+        f'<br><br>'
+        f'<a href="{source_url}" target="_blank" '
+        f'style="display:inline-block;padding:9px 18px;background:#003366;color:#fff;'
+        f'border-radius:8px;font-weight:700;text-decoration:none;font-size:.88rem">'
+        f'🔍 Search PRIMO Library Discovery for: {topic} →</a>'
+        f'<br><div style="margin-top:6px;font-size:.78rem;color:#6b7280">'
+        f'💡 Inside PRIMO you can filter by <strong>Articles</strong>, <strong>Books</strong>, '
+        f'<strong>Peer Reviewed</strong>, date range, and more.</div>'
     )
     answer += _ai_tools_footer(context)
-    return answer, [], []
-
-# ── §14 Follow-up System ──────────────────────────────────────────────────────
 
-# ── Follow-up System ──────────────────────────────────────────────────────────
+    return answer, [], [], source_url
 
 def _filters_summary(context: SearchContextPayload) -> str:
     filters: List[str] = []
@@ -3193,25 +3026,6 @@ def _parse_refinement_action(question: str) -> Optional[str]:
     # Alternative search terms — NEW
     if ALT_TERMS_RE.search(q):
         return "alt_terms"
-    # summarize_topic: ONLY match short/topicless follow-ups like "summarize this",
-    # "give me an overview", "what does the literature say" — NOT questions that
-    # include an explicit new topic like "summarize quantum physics".
-    # A question with 4+ non-stop content words almost certainly has its own topic
-    # and should be handled as a fresh query, not a follow-up.
-    if re.search(r"\b(summar(y|ize|ise)|overview|brief|what does the literature say|research snapshot)\b", q):
-        _STOP = {
-            'a','an','the','of','on','in','for','to','with','by','from','at','is','are',
-            'was','were','be','been','have','has','had','do','does','did','will','would',
-            'could','should','may','its','this','that','these','those','about','me','my',
-            'give','show','tell','please','can','you','i','need','want','get','find',
-            'research','summary','overview','summarize','summarise','brief','literature',
-        }
-        content_words = [t for t in re.findall(r'[a-z0-9]+', q)
-                         if t not in _STOP and (len(t) > 2 or t in {'ai','ml','nlp','cv','rl','dl','uae','ku','iot'})]
-        # Any explicit topic word → treat as a fresh query, not a follow-up
-        if content_words:
-            return None
-        return "summarize_topic"
     if re.search(r"\bpubmed\b", q):
         return "search_pubmed"
     if re.search(r"\bprimo\b", q):
@@ -3350,37 +3164,42 @@ async def _generate_topic_follow_ups(topic: str, model: str) -> List[dict]:
 async def _search_follow_up(
     context: SearchContextPayload, model: str, summary_mode: bool = False
 ) -> Tuple[str, List[dict]]:
+    """
+    Follow-up chips after academic/medical search.
+    v3.7: Filter chips removed (peer reviewed, date range, resource type, summarize).
+    Users apply filters directly in PRIMO and database platforms.
+    Only chips that add value LibBee provides that platforms cannot:
+      - Alternative search terms (LLM-generated synonyms)
+      - Best databases for this subject
+      - How to get full text
+      - Refine search strategy
+    """
     topic = context.display_topic or context.topic
-    suggestions: List[dict] = []
-    topic_follow_ups = await _generate_topic_follow_ups(topic, model)
-    suggestions.extend(topic_follow_ups)
-
-    filter_suggestions: List[dict] = []
-    if summary_mode:
-        filter_suggestions.append({
-            "label": f"Show KU-accessible articles on {topic}",
-            "question": f"Find KU-accessible articles on {topic}",
-            "action": "articles_only",
+    suggestions: List[dict] = [
+        {
+            "label": "💡 Alternative search terms",
+            "question": f"Suggest alternative search terms for {topic}",
+            "action": "alt_terms",
             "context_id": context.context_id,
-        })
-        if context.intent == "search_medical" and context.source != "pubmed":
-            filter_suggestions.append({
-                "label": "Search PubMed instead",
-                "question": f"Search PubMed for {topic}",
-                "action": "search_pubmed",
-                "context_id": context.context_id,
-            })
-        filter_suggestions.append({
-            "label": "Research snapshot",
-            "question": f"Give me a brief research snapshot on {topic}",
-            "action": "summarize_topic",
-            "context_id": context.context_id,
-        })
-
-    suggestions.extend(filter_suggestions[:2])
+        },
+        {
+            "label": "🗄️ Best databases for this subject",
+            "question": f"Best databases for {topic}",
+        },
+        {
+            "label": "📄 How do I get full text?",
+            "question": "How do I get full text for an article?",
+        },
+        {
+            "label": "🔍 Refine my search strategy",
+            "question": f"Help me refine my search strategy for {topic}",
+        },
+    ]
+    # Add topic-specific follow-ups from LLM
+    topic_follow_ups = await _generate_topic_follow_ups(topic, model)
+    suggestions = topic_follow_ups + suggestions
     question_text = (
-        f"Here are some related angles you might want to explore on <strong>{_escape(topic)}</strong>. "
-        "Or I can refine the search with filters — just ask."
+        f"Here are some ways I can help further with <strong>{_escape(topic)}</strong>:"
     )
     return question_text, suggestions[:5]
 
@@ -3476,6 +3295,7 @@ async def _run_search_mode(
 
     return answer, [], [], source_url
 
+
 def _sort_and_trim_contexts(contexts: List[SearchContextPayload]) -> List[SearchContextPayload]:
     dedup: Dict[str, SearchContextPayload] = {}
     for ctx in contexts:
@@ -3703,73 +3523,6 @@ async def _agent_query_inner(
 
     is_follow_up, follow_up_action, base_context = _detect_follow_up(question, client_state)
 
-    if is_follow_up and base_context:
-        _safe_metrics_increment("follow_up_hits")
-        context = _apply_follow_up_action(base_context, follow_up_action)
-
-        if follow_up_action in {"summarize_topic", "deep_research_tools", "best_databases"}:
-            context = await _prepare_queries(question, context, model, True)
-            if follow_up_action == "summarize_topic":
-                answer, search_results, sources = await _research_snapshot(context, model)
-            else:
-                # deep_research_tools / best_databases follow-up
-                answer = (
-                    f"{_search_trace_block(question, context)}"
-                    f"<strong>Research guide for {_escape(context.display_topic or context.topic)}</strong><br><br>"
-                    f"Here are the best AI tools and resources for a deep dive on this topic."
-                    + _source_badge("libbee")
-                    + _ai_tools_footer(context)
-                )
-                search_results = []
-                sources = []
-            follow_up_question, follow_up_suggestions = await _search_follow_up(context, model, summary_mode=True)
-            _safe_metrics_increment("search_handoffs")
-            return AgentResponse(
-                answer=answer,
-                intent=context.intent,
-                tools_used=["follow_up_resolution", follow_up_action],
-                search_results=search_results,
-                sources=sources,
-                model_used=model,
-                response_time=time.time() - start_time,
-                corrected_query=context.topic,
-                natural_query=context.ai_tool_query,
-                database_query=context.primo_boolean_query,
-                ai_tool_query=context.ai_tool_query,
-                primo_boolean_query=context.primo_boolean_query,
-                primo_search_url=_primo_clean_url(context),
-                primo_ai_url=_tool_urls(context).get("primo_ai"),
-                pubmed_search_url=_tool_urls(context).get("pubmed"),
-                follow_up_question=follow_up_question,
-                follow_up_suggestions=follow_up_suggestions,
-                search_context=_context_to_dict(context),
-                is_follow_up=True,
-            )
-
-        answer, search_results, sources, source_url = await _run_search_mode(question, context, model, True)
-        follow_up_question, follow_up_suggestions = await _search_follow_up(context, model)
-        return AgentResponse(
-            answer=answer,
-            intent=context.intent,
-            tools_used=["follow_up_resolution", follow_up_action or "contextual_refinement"],
-            search_results=search_results,
-            sources=sources,
-            model_used=model,
-            response_time=time.time() - start_time,
-            corrected_query=context.topic,
-            natural_query=context.ai_tool_query,
-            database_query=context.primo_boolean_query,
-            ai_tool_query=context.ai_tool_query,
-            primo_boolean_query=context.primo_boolean_query,
-            primo_search_url=source_url,
-            primo_ai_url=_tool_urls(context).get("primo_ai"),
-            pubmed_search_url=_tool_urls(context).get("pubmed"),
-            follow_up_question=follow_up_question,
-            follow_up_suggestions=follow_up_suggestions,
-            search_context=_context_to_dict(context),
-            is_follow_up=True,
-        )
-
     if is_follow_up and base_context:
         _safe_metrics_increment("follow_up_hits")
         context = _apply_follow_up_action(base_context, follow_up_action)
@@ -3790,29 +3543,23 @@ async def _agent_query_inner(
                 is_follow_up=True,
             )
 
-        if follow_up_action in {"summarize_topic", "deep_research_tools", "best_databases"}:
+        if follow_up_action in {"deep_research_tools", "best_databases"}:
             context = await _prepare_queries(question, context, model, True)
-            if follow_up_action == "summarize_topic":
-                answer, search_results, sources = await _research_snapshot(context, model)
-            else:
-                # deep_research_tools / best_databases follow-up
-                answer = (
-                    f"{_search_trace_block(question, context)}"
-                    f"<strong>Research guide for {_escape(context.display_topic or context.topic)}</strong><br><br>"
-                    f"Here are the best AI tools and resources for a deep dive on this topic."
-                    + _source_badge("libbee")
-                    + _ai_tools_footer(context)
-                )
-                search_results = []
-                sources = []
-            follow_up_question, follow_up_suggestions = await _search_follow_up(context, model, summary_mode=True)
+            answer = (
+                f"{_search_trace_block(question, context)}"
+                f"<strong>Research guide for {_escape(context.display_topic or context.topic)}</strong><br><br>"
+                f"Here are the best AI tools and resources for a deep dive on this topic."
+                + _source_badge("libbee")
+                + _ai_tools_footer(context)
+            )
+            follow_up_question, follow_up_suggestions = await _search_follow_up(context, model)
             _safe_metrics_increment("search_handoffs")
             return AgentResponse(
                 answer=answer,
                 intent=context.intent,
                 tools_used=["follow_up_resolution", follow_up_action],
-                search_results=search_results,
-                sources=sources,
+                search_results=[],
+                sources=[],
                 model_used=model,
                 response_time=time.time() - start_time,
                 corrected_query=context.topic,
@@ -4081,6 +3828,7 @@ async def _agent_query_inner(
                 _prepare_queries(question, _ctx_books, model, False),
             )
             # No API — just build PRIMO links for articles and books
+            _ctx_articles = await _prepare_queries(question, _ctx_articles, model, False)
             _src_url_a = _primo_clean_url(_ctx_articles)
             _src_url_b = _primo_clean_url(_ctx_books)
 
@@ -4131,44 +3879,9 @@ async def _agent_query_inner(
         )
 
         context = await _prepare_queries(question, context, model, False)
-        summary_mode = _is_summary_request(question)
-        deep_research_mode = bool(re.search(
-            r"\b(deep research|deep dive|systematic review|full literature review|exhaustive)\b",
-            question, re.IGNORECASE,
-        ))
         is_highly_cited = bool(HIGHLY_CITED_RE.search(question))
 
-        if summary_mode or deep_research_mode:
-            answer, search_results, sources = await _research_snapshot(context, model)
-            if deep_research_mode and "Research guide" not in answer and "AI tools" not in answer:
-                answer += f"<br><br>{_ai_tools_footer(context)}"
-            if is_highly_cited:
-                answer += _highly_cited_note(_escape(topic))
-            follow_up_question, follow_up_suggestions = await _search_follow_up(context, model, summary_mode=True)
-            _safe_metrics_increment("search_handoffs")
-            return AgentResponse(
-                answer=answer,
-                intent=intent,
-                tools_used=["research_snapshot"],
-                search_results=search_results,
-                sources=sources,
-                model_used=model,
-                response_time=time.time() - start_time,
-                corrected_query=context.topic,
-                natural_query=context.ai_tool_query,
-                database_query=context.primo_boolean_query,
-                ai_tool_query=context.ai_tool_query,
-                primo_boolean_query=context.primo_boolean_query,
-                primo_search_url=_primo_clean_url(context),
-                primo_ai_url=_tool_urls(context).get("primo_ai"),
-                pubmed_search_url=_tool_urls(context).get("pubmed"),
-                follow_up_question=follow_up_question,
-                follow_up_suggestions=follow_up_suggestions,
-                search_context=_context_to_dict(context),
-            )
-
         answer, search_results, sources, source_url = await _run_search_mode(question, context, model, False)
-        # Append highly-cited guidance if requested
         if is_highly_cited:
             answer += _highly_cited_note(_escape(topic))
         follow_up_question, follow_up_suggestions = await _search_follow_up(context, model)