Upload search.py

src/api/search.py

@@ -1,14 +1,6 @@
-"""
-search.py — LibBee v3
-Key fixes:
-- PRIMO: resource type (articles/books) sent as rtype FACET, not q= keyword
-- PRIMO: year filter sent as facet_searchcreationdate FACET, not keyword
-- PubMed: year filter wired to mindate/maxdate params (was silently ignored before)
-- PubMed: peer_reviewed mapped to free full text filter
-- query sent to both APIs is clean topic keywords only — no rtype noise
-"""
 import logging
-from typing import Optional
+import re
+from typing import Dict, List, Optional
 from urllib.parse import quote
 
 import httpx
@@ -20,6 +12,90 @@ from src.config import get_settings
 logger = logging.getLogger(__name__)
 router = APIRouter()
 
+PRIMO_BASE = "https://khalifa.primo.exlibrisgroup.com/discovery/search?vid=971KUOSTAR_INST:KU"
+PRIMO_AI_BASE = "https://khalifa.primo.exlibrisgroup.com/discovery/researchAssistant?vid=971KUOSTAR_INST:KU&query="
+EBSCO_AI_BASE = "https://research-ebsco-com.khalifa.idm.oclc.org/c/ntdlkp/search?q="
+SCOPUS_AI_BASE = "https://www-scopus-com.khalifa.idm.oclc.org/pages/ai?query="
+LEAPSPACE_BASE = "https://www.sciencedirect.com/leapspace?query="
+CONSENSUS_BASE = "https://consensus.app/results/?q="
+CURRENT_YEAR = 2026
+
+PREFIX_PATTERNS = [
+    r"^summari[sz]e\s+the\s+latest\s+studies\s+in\s+",
+    r"^summari[sz]e\s+the\s+latest\s+research\s+on\s+",
+    r"^summari[sz]e\s+recent\s+studies\s+in\s+",
+    r"^summari[sz]e\s+recent\s+research\s+on\s+",
+    r"^give\s+me\s+a\s+summary\s+of\s+",
+    r"^give\s+me\s+an\s+overview\s+of\s+",
+    r"^give\s+me\s+a\s+brief\s+overview\s+of\s+",
+    r"^find\s+(?:peer[- ]reviewed\s+)?articles?\s+on\s+",
+    r"^find\s+(?:peer[- ]reviewed\s+)?papers?\s+on\s+",
+    r"^find\s+books?\s+on\s+",
+    r"^search\s+for\s+articles?\s+on\s+",
+    r"^search\s+for\s+papers?\s+on\s+",
+    r"^i\s+need\s+(?:peer[- ]reviewed\s+)?articles?\s+on\s+",
+    r"^i\s+need\s+papers?\s+on\s+",
+    r"^i\s+need\s+books?\s+on\s+",
+    r"^show\s+me\s+articles?\s+on\s+",
+    r"^get\s+me\s+articles?\s+on\s+",
+    r"^tell\s+me\s+about\s+",
+    r"^explain\s+",
+    r"^overview\s+of\s+",
+    r"^summary\s+of\s+",
+    r"^latest\s+studies\s+in\s+",
+    r"^latest\s+research\s+on\s+",
+    r"^recent\s+research\s+on\s+",
+    r"^recent\s+studies\s+in\s+",
+]
+
+RESOURCE_NOISE_RE = re.compile(
+    r"\b(articles?|papers?|books?|ebooks?|journals?|publications?|monographs?"
+    r"|peer[- ]reviewed|open[- ]access|studies|study|research|latest|recent)\b",
+    re.IGNORECASE,
+)
+
+STOP_WORDS = {
+    "the", "a", "an", "and", "or", "of", "on", "in", "for", "to", "with", "by",
+    "from", "at", "about", "latest", "recent", "current", "summary", "overview", "brief",
+    "analysis", "review", "deep", "find", "search", "show", "give", "me", "need", "please",
+}
+
+PHRASE_SYNONYMS: Dict[str, List[str]] = {
+    "global warming": ["climate change"],
+    "climate change": ["global warming"],
+    "machine learning": ["artificial intelligence", "AI"],
+    "artificial intelligence": ["AI", "machine learning"],
+    "deep learning": ["neural networks"],
+    "renewable energy": ["clean energy", "sustainable energy"],
+    "energy transition": ["decarbonization"],
+    "cyber security": ["cybersecurity", "information security"],
+    "cybersecurity": ["cyber security", "information security"],
+    "public health": ["population health"],
+    "gene editing": ["CRISPR"],
+    "mental health": ["psychological health"],
+    "higher education": ["tertiary education", "universities"],
+}
+
+TOKEN_SYNONYMS: Dict[str, List[str]] = {
+    "healthcare": ["medicine", "clinical"],
+    "medical": ["clinical", "medicine"],
+    "nursing": ["clinical", "patient care"],
+    "education": ["teaching", "learning"],
+    "students": ["student"],
+    "student": ["students"],
+    "sustainability": ["sustainable development"],
+    "cancer": ["oncology"],
+    "heart": ["cardiovascular"],
+    "brain": ["neurology", "neuroscience"],
+    "politics": ["political"],
+    "engineering": ["engineer*"],
+}
+
+MEDICAL_HINT_RE = re.compile(
+    r"\b(medicine|medical|health|clinical|nursing|pharmacy|biomedical|pubmed|embase|cinahl|cochrane|uptodate|disease|therapy|treatment|diagnosis|patient|hospital|cancer|diabetes)\b",
+    re.IGNORECASE,
+)
+
 
 class SearchRequest(BaseModel):
     query: str
@@ -29,8 +105,8 @@ class SearchRequest(BaseModel):
     open_access: bool = False
     year_from: Optional[str] = None
     year_to: Optional[str] = None
-    # resource_type controls rtype FACET — NOT injected into q= keyword query
-    resource_type: str = "articles"  # "articles" | "books" | "both"
+    resource_type: str = "articles"  # articles | books | both
+    boolean_query: Optional[str] = None
 
     @field_validator("query")
     @classmethod
@@ -61,9 +137,17 @@ class SearchRequest(BaseModel):
     @classmethod
     def valid_resource_type(cls, v: str) -> str:
         allowed = {"articles", "books", "both"}
-        if v not in allowed:
-            return "articles"
-        return v
+        return v if v in allowed else "articles"
+
+
+class SearchPlanRequest(BaseModel):
+    question: str
+    peer_reviewed: bool = False
+    open_access: bool = False
+    year_from: Optional[str] = None
+    year_to: Optional[str] = None
+    resource_type: Optional[str] = None
+
 
 
 def _safe_metrics_increment(key: str) -> None:
@@ -74,6 +158,7 @@ def _safe_metrics_increment(key: str) -> None:
         return
 
 
+
 def _safe_metrics_bucket(bucket: str, key: str) -> None:
     try:
         from app import metrics_service
@@ -82,6 +167,222 @@ def _safe_metrics_bucket(bucket: str, key: str) -> None:
         return
 
 
+
+def _normalize_whitespace(text: str) -> str:
+    return re.sub(r"\s+", " ", (text or "").strip())
+
+
+
+def _strip_resource_noise(query: str) -> str:
+    cleaned = RESOURCE_NOISE_RE.sub(" ", query or "")
+    cleaned = re.sub(r"\s+(AND|OR)\s+(AND|OR)\s+", " AND ", cleaned, flags=re.IGNORECASE)
+    cleaned = re.sub(r"^\s*(AND|OR)\s+", "", cleaned, flags=re.IGNORECASE)
+    cleaned = re.sub(r"\s+(AND|OR)\s*$", "", cleaned, flags=re.IGNORECASE)
+    return _normalize_whitespace(cleaned)
+
+
+
+def _extract_topic(question: str) -> str:
+    q = _normalize_whitespace(question)
+    lower = q.lower()
+    for pat in PREFIX_PATTERNS:
+        lower_after = re.sub(pat, "", lower, count=1)
+        if lower_after != lower:
+            lower = lower_after
+            break
+    lower = re.sub(r"\b(last|past)\s+\d{1,2}\s+years?\b", " ", lower)
+    lower = re.sub(r"\bfrom\s+(19|20)\d{2}\s+(?:to|and|-)+\s+(19|20)\d{2}\b", " ", lower)
+    lower = re.sub(r"\b(19|20)\d{2}\b", " ", lower)
+    lower = _strip_resource_noise(lower)
+    return lower.strip(" .?") or _strip_resource_noise(question)
+
+
+
+def _derive_resource_type_from_text(question: str, override: Optional[str] = None) -> str:
+    if override in {"articles", "books", "both"}:
+        return override
+    q = (question or "").lower()
+    if any(x in q for x in ["books", "book", "ebook", "ebooks"]):
+        return "books"
+    if any(x in q for x in ["articles", "article", "papers", "paper", "journals", "journal", "studies", "study"]):
+        return "articles"
+    return "both"
+
+
+
+def _is_medical_query(question: str) -> bool:
+    return bool(MEDICAL_HINT_RE.search(question or ""))
+
+
+
+def _quote_term(term: str) -> str:
+    term = _normalize_whitespace(term)
+    if not term:
+        return ""
+    if "*" in term:
+        return term
+    if " " in term or "-" in term:
+        return f'"{term}"'
+    return term
+
+
+
+def _longest_phrase_match(tokens: List[str], start: int) -> Optional[str]:
+    max_len = min(3, len(tokens) - start)
+    for length in range(max_len, 0, -1):
+        phrase = " ".join(tokens[start:start + length]).lower()
+        if phrase in PHRASE_SYNONYMS:
+            return phrase
+    return None
+
+
+
+def _concept_groups(topic: str) -> List[List[str]]:
+    topic = _normalize_whitespace(topic).lower()
+    raw_tokens = [t for t in re.findall(r"[a-z0-9]+", topic) if t not in STOP_WORDS and len(t) > 2]
+    groups: List[List[str]] = []
+    i = 0
+    while i < len(raw_tokens):
+        phrase = _longest_phrase_match(raw_tokens, i)
+        if phrase:
+            synonyms = PHRASE_SYNONYMS.get(phrase, [])
+            group = [phrase] + [s for s in synonyms if s.lower() != phrase]
+            groups.append(group)
+            i += len(phrase.split())
+            continue
+        token = raw_tokens[i]
+        group = [token]
+        group.extend([s for s in TOKEN_SYNONYMS.get(token, []) if s.lower() != token])
+        groups.append(group)
+        i += 1
+
+    if not groups and topic:
+        return [[topic]]
+
+    # collapse duplicate/single-token noise but preserve order
+    cleaned_groups: List[List[str]] = []
+    seen_primary = set()
+    for group in groups:
+        primary = group[0].lower()
+        if primary in seen_primary:
+            continue
+        seen_primary.add(primary)
+        unique_terms = []
+        seen_terms = set()
+        for term in group:
+            norm = term.lower()
+            if norm in seen_terms:
+                continue
+            seen_terms.add(norm)
+            unique_terms.append(term)
+        cleaned_groups.append(unique_terms)
+    return cleaned_groups[:4]
+
+
+
+def build_primo_boolean_query(topic: str) -> str:
+    clean_topic = _strip_resource_noise(topic)
+    groups = _concept_groups(clean_topic)
+    clauses: List[str] = []
+    for group in groups:
+        if not group:
+            continue
+        if len(group) == 1:
+            clauses.append(_quote_term(group[0]))
+        else:
+            clauses.append("(" + " OR ".join(_quote_term(term) for term in group) + ")")
+    if not clauses:
+        return _quote_term(clean_topic or topic)
+    return " AND ".join(clauses)
+
+
+
+def _primo_facets(resource_type: str = "both", peer_reviewed: bool = False, open_access: bool = False, year_from: Optional[str] = None, year_to: Optional[str] = None) -> List[str]:
+    facets: List[str] = []
+    if resource_type == "articles":
+        facets.append("rtype,include,articles")
+    elif resource_type == "books":
+        facets.append("rtype,include,books")
+    if peer_reviewed:
+        facets.append("tlevel,include,peer_reviewed")
+    if open_access:
+        facets.append("tlevel,include,online_resources")
+    if year_from or year_to:
+        yf = year_from or "0001"
+        yt = year_to or "9999"
+        facets.append(f"searchcreationdate,include,{yf}|,|{yt}")
+    return facets
+
+
+
+def build_primo_discovery_url(boolean_query: str, resource_type: str = "both", peer_reviewed: bool = False, open_access: bool = False, year_from: Optional[str] = None, year_to: Optional[str] = None, tab: str = "Everything", scope: str = "MyInst_and_CI") -> str:
+    url = (
+        f"{PRIMO_BASE}&query=any,contains,{quote(boolean_query)}"
+        f"&tab={tab}&search_scope={scope}&lang=en&mode=advanced&offset=0"
+    )
+    for facet in _primo_facets(resource_type, peer_reviewed, open_access, year_from, year_to):
+        url += f"&facet={quote(facet)}"
+    return url
+
+
+
+def build_pubmed_url(query: str, year_from: Optional[str] = None, year_to: Optional[str] = None, peer_reviewed: bool = False) -> str:
+    clean_query = _strip_resource_noise(query) or query
+    term = clean_query
+    if peer_reviewed:
+        term = f"({term}) AND Journal Article[pt]"
+    url = f"https://pubmed.ncbi.nlm.nih.gov/?term={quote(term)}"
+    if year_from or year_to:
+        yf = year_from or "1900"
+        yt = year_to or str(CURRENT_YEAR)
+        url += f"&filter=datesearch.y_custom&dates.from={yf}&dates.to={yt}"
+    return url
+
+
+async def _grammar_refine_query(text: str) -> str:
+    settings = get_settings()
+    if not settings.openai_api_key:
+        return _normalize_whitespace(text)
+    try:
+        from langchain_openai import ChatOpenAI
+        llm = ChatOpenAI(model="gpt-4o-mini", temperature=0, max_tokens=60, openai_api_key=settings.openai_api_key)
+        response = await llm.ainvoke([
+            {"role": "system", "content": "Rewrite the user's search query in clear grammatical English. Keep meaning exactly the same. Return one sentence only."},
+            {"role": "user", "content": text},
+        ])
+        return _normalize_whitespace(response.content) or _normalize_whitespace(text)
+    except Exception:
+        return _normalize_whitespace(text)
+
+
+@router.post("/plan")
+async def search_plan_endpoint(req: SearchPlanRequest):
+    _safe_metrics_increment("search_plans")
+    topic = _extract_topic(req.question)
+    resource_type = _derive_resource_type_from_text(req.question, req.resource_type)
+    boolean_query = build_primo_boolean_query(topic)
+    ai_tool_query = await _grammar_refine_query(req.question)
+    is_medical = _is_medical_query(req.question) or _is_medical_query(topic)
+
+    return {
+        "topic": topic,
+        "display_topic": topic.title(),
+        "resource_type": resource_type,
+        "is_medical": is_medical,
+        "ai_tool_query": ai_tool_query,
+        "primo_boolean_query": boolean_query,
+        "primo_all_url": build_primo_discovery_url(boolean_query, "both", req.peer_reviewed, req.open_access, req.year_from, req.year_to, "Everything", "MyInst_and_CI"),
+        "primo_articles_url": build_primo_discovery_url(boolean_query, "articles", req.peer_reviewed, req.open_access, req.year_from, req.year_to, "CentralIndex", "CentralIndex"),
+        "primo_books_url": build_primo_discovery_url(boolean_query, "books", req.peer_reviewed, req.open_access, req.year_from, req.year_to, "Everything", "MyInst_and_CI"),
+        "primo_ai_url": f"{PRIMO_AI_BASE}{quote(ai_tool_query)}",
+        "pubmed_url": build_pubmed_url(topic, req.year_from, req.year_to, req.peer_reviewed) if is_medical else None,
+        "ebsco_ai_url": f"{EBSCO_AI_BASE}{quote(ai_tool_query)}",
+        "scopus_ai_url": f"{SCOPUS_AI_BASE}{quote(ai_tool_query)}",
+        "leapspace_url": f"{LEAPSPACE_BASE}{quote(ai_tool_query)}",
+        "consensus_url": f"{CONSENSUS_BASE}{quote(ai_tool_query)}",
+    }
+
+
 @router.post("")
 async def search_endpoint(req: SearchRequest):
     _safe_metrics_increment("search_requests")
@@ -94,73 +395,53 @@ async def search_endpoint(req: SearchRequest):
     return await search_scholar(req)
 
 
-# ── PRIMO ──────────────────────────────────────────────────────────────────────
-
 async def search_primo(req: SearchRequest, api_key: str):
-    """
-    Send clean topic keywords to q=any,contains.
-    Resource type, peer review, open access, and year are all FACETS — never keywords.
-
-    PRIMO facet reference:
-        facet_rtype,include,articles   → journal articles
-        facet_rtype,include,books      → books / ebooks
-        facet_tlevel,include,peer_reviewed
-        facet_tlevel,include,online_resources  (open access proxy)
-        facet_searchcreationdate,include,YYYY|,|YYYY
-    """
     if not api_key:
         logger.warning("PRIMO_API_KEY not configured")
         _safe_metrics_bucket("errors", "primo_missing_api_key")
         return {"error": "PRIMO_API_KEY not configured", "results": [], "source": "PRIMO"}
 
-    # ── The query sent to PRIMO must be ONLY topic keywords ──────────────────
-    # Strip any residual resource-type words that may have slipped through
-    # topic extraction (belt-and-braces defence).
     clean_query = _strip_resource_noise(req.query)
     if not clean_query:
-        clean_query = req.query  # fallback if stripping removes everything
-
-    query_encoded = quote(clean_query)
-
-    url = (
-        f"https://api-eu.hosted.exlibrisgroup.com/primo/v1/search"
-        f"?vid=971KUOSTAR_INST:KU&tab=Everything&scope=MyInst_and_CI"
-        f"&q=any,contains,{query_encoded}&lang=en&sort=rank&limit={req.limit}"
-        f"&offset=0&mode=advanced&apikey={api_key}"
-    )
-
-    # ── Build facets — resource type, quality, year ───────────────────────────
-    facets = []
-
-    # Resource type → rtype facet (NOT a keyword)
-    if req.resource_type == "articles":
-        facets.append("facet_rtype,include,articles")
-    elif req.resource_type == "books":
-        facets.append("facet_rtype,include,books")
-    # "both" → no rtype facet (search everything)
-
-    if req.peer_reviewed:
-        facets.append("facet_tlevel,include,peer_reviewed")
-
-    if req.open_access:
-        facets.append("facet_tlevel,include,online_resources")
-
-    if req.year_from or req.year_to:
-        yf = req.year_from or "0001"
-        yt = req.year_to or "9999"
-        facets.append(f"facet_searchcreationdate,include,{yf}|,|{yt}")
-
-    for facet in facets:
-        url += f"&multiFacets={quote(facet)}"
+        clean_query = req.query
 
-    logger.info(
-        "PRIMO query=%r resource_type=%s peer_reviewed=%s year=%s-%s",
-        clean_query, req.resource_type, req.peer_reviewed, req.year_from, req.year_to,
-    )
+    boolean_query = req.boolean_query or build_primo_boolean_query(clean_query)
+    query_for_api = boolean_query
+
+    def _build_api_url(query_text: str) -> str:
+        url = (
+            f"https://api-eu.hosted.exlibrisgroup.com/primo/v1/search"
+            f"?vid=971KUOSTAR_INST:KU&tab=Everything&scope=MyInst_and_CI"
+            f"&q=any,contains,{quote(query_text)}&lang=en&sort=rank&limit={req.limit}"
+            f"&offset=0&mode=advanced&apikey={api_key}"
+        )
+        api_facets = []
+        if req.resource_type == "articles":
+            api_facets.append("facet_rtype,include,articles")
+        elif req.resource_type == "books":
+            api_facets.append("facet_rtype,include,books")
+        if req.peer_reviewed:
+            api_facets.append("facet_tlevel,include,peer_reviewed")
+        if req.open_access:
+            api_facets.append("facet_tlevel,include,online_resources")
+        if req.year_from or req.year_to:
+            yf = req.year_from or "0001"
+            yt = req.year_to or "9999"
+            api_facets.append(f"facet_searchcreationdate,include,{yf}|,|{yt}")
+        for facet in api_facets:
+            url += f"&multiFacets={quote(facet)}"
+        return url
+
+    logger.info("PRIMO boolean=%r clean_query=%r resource_type=%s", boolean_query, clean_query, req.resource_type)
 
     try:
         async with httpx.AsyncClient(timeout=20) as client:
+            url = _build_api_url(query_for_api)
             r = await client.get(url, headers={"Accept": "application/json"})
+            if r.status_code == 400 and boolean_query != clean_query:
+                logger.warning("PRIMO 400 on boolean query; falling back to clean keywords")
+                url = _build_api_url(clean_query)
+                r = await client.get(url, headers={"Accept": "application/json"})
             logger.info("PRIMO status=%s", r.status_code)
             if r.status_code != 200:
                 _safe_metrics_bucket("errors", f"primo_{r.status_code}")
@@ -168,6 +449,7 @@ async def search_primo(req: SearchRequest, api_key: str):
 
             data = r.json()
             docs = data.get("docs", [])
+            discovery_url = build_primo_discovery_url(boolean_query, req.resource_type, req.peer_reviewed, req.open_access, req.year_from, req.year_to)
             results = []
             for doc in docs[: req.limit]:
                 pnx = doc.get("pnx", {})
@@ -178,17 +460,10 @@ async def search_primo(req: SearchRequest, api_key: str):
                     "date": (d.get("date") or [""])[0],
                     "type": (d.get("type") or [""])[0],
                     "source": (d.get("source") or [""])[0],
-                    "primo_url": (
-                        f"https://khalifa.primo.exlibrisgroup.com/discovery/search"
-                        f"?query=any,contains,{query_encoded}&vid=971KUOSTAR_INST:KU"
-                    ),
+                    "primo_url": discovery_url,
                     "_source": "PRIMO",
                 })
-            return {
-                "total": data.get("info", {}).get("total", 0),
-                "results": results,
-                "source": "PRIMO",
-            }
+            return {"total": data.get("info", {}).get("total", 0), "results": results, "source": "PRIMO"}
 
     except httpx.TimeoutException:
         _safe_metrics_bucket("errors", "primo_timeout")
@@ -199,58 +474,20 @@ async def search_primo(req: SearchRequest, api_key: str):
         return {"error": str(exc), "results": [], "source": "PRIMO"}
 
 
-def _strip_resource_noise(query: str) -> str:
-    """
-    Remove resource-type and filter words that should be facets, not q= keywords.
-    Called as a belt-and-braces guard before sending to PRIMO/PubMed.
-    """
-    noise = re.compile(
-        r"\b(articles?|papers?|books?|ebooks?|journals?|publications?|monographs?"
-        r"|peer[- ]reviewed|open[- ]access|studies|study|research)\b",
-        re.IGNORECASE,
-    )
-    cleaned = noise.sub(" ", query)
-    # Collapse leftover AND/OR operators with no operands
-    cleaned = re.sub(r"\s+(AND|OR)\s+(AND|OR)\s+", " AND ", cleaned, flags=re.IGNORECASE)
-    cleaned = re.sub(r"^\s*(AND|OR)\s+", "", cleaned, flags=re.IGNORECASE)
-    cleaned = re.sub(r"\s+(AND|OR)\s*$", "", cleaned, flags=re.IGNORECASE)
-    return re.sub(r"\s+", " ", cleaned).strip()
-
-
-import re  # noqa: E402 (needed for _strip_resource_noise above)
-
-
-# ── PubMed ─────────────────────────────────────────────────────────────────────
-
 async def search_pubmed(req: SearchRequest):
-    """
-    Year filters use mindate/maxdate params — NOT injected into the search term.
-    Peer-reviewed filter uses [pt] (publication type) in the term.
-    """
-    # Build clean term — topic keywords only
     clean_query = _strip_resource_noise(req.query)
     if not clean_query:
         clean_query = req.query
-
-    # Add peer-reviewed as a PubMed publication-type filter (appended to term)
     term = clean_query
     if req.peer_reviewed:
         term = f"({term}) AND Journal Article[pt]"
-
     query_encoded = quote(term)
-
-    # Date params (separate from search term — correct PubMed approach)
     date_params = ""
     if req.year_from or req.year_to:
         yf = req.year_from or "1900"
         yt = req.year_to or "3000"
         date_params = f"&mindate={yf}&maxdate={yt}&datetype=pdat"
-
-    logger.info(
-        "PubMed term=%r peer_reviewed=%s year=%s-%s",
-        term, req.peer_reviewed, req.year_from, req.year_to,
-    )
-
+    logger.info("PubMed term=%r peer_reviewed=%s year=%s-%s", term, req.peer_reviewed, req.year_from, req.year_to)
     try:
         async with httpx.AsyncClient(timeout=15) as client:
             search_url = (
@@ -261,11 +498,9 @@ async def search_pubmed(req: SearchRequest):
             if r.status_code != 200:
                 _safe_metrics_bucket("errors", "pubmed_search_failed")
                 return {"error": "PubMed search failed", "results": [], "source": "PubMed"}
-
             ids = r.json().get("esearchresult", {}).get("idlist", [])
             if not ids:
                 return {"total": 0, "results": [], "source": "PubMed"}
-
             fetch_url = (
                 f"https://eutils.ncbi.nlm.nih.gov/entrez/eutils/esummary.fcgi"
                 f"?db=pubmed&id={','.join(ids)}&retmode=json"
@@ -274,7 +509,6 @@ async def search_pubmed(req: SearchRequest):
             if r2.status_code != 200:
                 _safe_metrics_bucket("errors", "pubmed_fetch_failed")
                 return {"error": "PubMed fetch failed", "results": [], "source": "PubMed"}
-
             data = r2.json().get("result", {})
             results = []
             for pid in ids:
@@ -296,31 +530,20 @@ async def search_pubmed(req: SearchRequest):
                     "_source": "PubMed",
                 })
             return {"total": len(ids), "results": results, "source": "PubMed"}
-
     except Exception as exc:
         logger.error("PubMed search error: %s", exc)
         _safe_metrics_bucket("errors", "pubmed_exception")
         return {"error": str(exc), "results": [], "source": "PubMed"}
 
 
-# ── Semantic Scholar ───────────────────────────────────────────────────────────
-
 async def search_scholar(req: SearchRequest):
     try:
-        params = {
-            "query": req.query,
-            "limit": req.limit,
-            "fields": "title,authors,year,venue,externalIds,citationCount",
-        }
+        params = {"query": req.query, "limit": req.limit, "fields": "title,authors,year,venue,externalIds,citationCount"}
         async with httpx.AsyncClient(timeout=15) as client:
-            r = await client.get(
-                "https://api.semanticscholar.org/graph/v1/paper/search",
-                params=params,
-            )
+            r = await client.get("https://api.semanticscholar.org/graph/v1/paper/search", params=params)
             if r.status_code != 200:
                 _safe_metrics_bucket("errors", f"semantic_{r.status_code}")
                 return {"error": f"Semantic Scholar API: {r.status_code}", "results": [], "source": "Semantic Scholar"}
-
             data = r.json()
             results = []
             for paper in data.get("data", []):
@@ -340,7 +563,6 @@ async def search_scholar(req: SearchRequest):
                     "_source": "Semantic Scholar",
                 })
             return {"total": data.get("total", 0), "results": results, "source": "Semantic Scholar"}
-
     except Exception as exc:
         logger.error("Semantic Scholar search error: %s", exc)
         _safe_metrics_bucket("errors", "semantic_exception")