Update src/api/search.py

src/api/search.py

@@ -1,25 +1,22 @@
 """
-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
+src/api/search.py — PRIMO + PubMed search helpers for LibBee.
+
+Key fix: _boolean_to_primo_params() converts an LLM-generated Boolean query like
+  ("smart city" OR "urban mobility") AND ("technocentricity" OR "citizen-centric")
+into PRIMO's multi-q-param format:
+  q=any,contains,smart city OR urban mobility,AND&q=any,contains,technocentricity OR citizen-centric
+This is the only format PRIMO accepts for structured boolean searching.
+Sending the raw boolean string as a single q= param causes irrelevant results.
 """
-import logging
-from typing import Optional, List
+import re
+from datetime import datetime
+from typing import Optional
 from urllib.parse import quote
 
-import httpx
-from fastapi import APIRouter
-from pydantic import BaseModel, field_validator
+from pydantic import BaseModel
 
-from src.config import get_settings
-
-logger = logging.getLogger(__name__)
-router = APIRouter()
 
+# ── Models ─────────────────────────────────────────────────────────────────────
 
 class SearchRequest(BaseModel):
     query: str
@@ -29,308 +26,237 @@ 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"
-
-    @field_validator("query")
-    @classmethod
-    def query_not_empty(cls, v: str) -> str:
-        v = v.strip()
-        if not v:
-            raise ValueError("query must not be empty")
-        if len(v) > 500:
-            raise ValueError("query must be under 500 characters")
-        return v
-
-    @field_validator("limit")
-    @classmethod
-    def limit_in_range(cls, v: int) -> int:
-        if not 1 <= v <= 20:
-            raise ValueError("limit must be between 1 and 20")
-        return v
-
-    @field_validator("source")
-    @classmethod
-    def valid_source(cls, v: str) -> str:
-        allowed = {"primo", "pubmed", "scholar"}
-        if v not in allowed:
-            raise ValueError(f"source must be one of: {allowed}")
-        return v
-
-    @field_validator("resource_type")
-    @classmethod
-    def valid_resource_type(cls, v: str) -> str:
-        allowed = {"articles", "books", "both"}
-        if v not in allowed:
-            return "articles"
-        return v
-
-
-def _safe_metrics_increment(key: str) -> None:
-    try:
-        from app import metrics_service
-        metrics_service.incr(key)
-    except Exception:
-        return
+    resource_type: str = "articles"   # "articles" | "books" | "both"
 
 
-def _safe_metrics_bucket(bucket: str, key: str) -> None:
-    try:
-        from app import metrics_service
-        metrics_service.incr_bucket(bucket, key)
-    except Exception:
-        return
-
-
-@router.post("")
-async def search_endpoint(req: SearchRequest):
-    _safe_metrics_increment("search_requests")
-    _safe_metrics_bucket("search_sources", req.source)
-    settings = get_settings()
-    if req.source == "primo":
-        return await search_primo(req, settings.primo_api_key)
-    if req.source == "pubmed":
-        return await search_pubmed(req)
-    return await search_scholar(req)
-
-
-# ── PRIMO ──────────────────────────────────────────────────────────────────────
-
-# ── PRIMO helpers ───────────────────────────────────────────────────────────────
-
-def _first_str(value):
-    if isinstance(value, list) and value:
-        return value[0]
-    if isinstance(value, str):
-        return value
-    return ""
-
-
-def _extract_primo_docid(doc: dict) -> str:
-    pnx = doc.get("pnx", {}) or {}
-    control = pnx.get("control", {}) or {}
-    search_sec = pnx.get("search", {}) or {}
-    candidates: List[str] = [
-        _first_str(control.get("recordid")),
-        _first_str(control.get("sourcerecordid")),
-        _first_str(search_sec.get("recordid")),
-        _first_str(search_sec.get("addsrcrecordid")),
-    ]
-    for key in ("recordid", "pnxId", "id"):
-        val = doc.get(key)
-        if isinstance(val, str):
-            candidates.append(val)
-        elif isinstance(val, list) and val:
-            candidates.append(val[0])
-    for cand in candidates:
-        cand = (cand or "").strip()
-        if cand:
-            return cand
-    return ""
-
-
-def _primo_record_url(doc: dict, query_encoded: str) -> str:
-    delivery = doc.get("delivery", {}) or {}
-    bestlocation = delivery.get("bestlocation", {}) or {}
-    for key in ("link", "url"):
-        val = bestlocation.get(key)
-        if isinstance(val, str) and "fulldisplay" in val:
-            return val
-    links = delivery.get("links", []) or []
-    for link_obj in links:
-        if isinstance(link_obj, dict):
-            val = link_obj.get("link") or link_obj.get("url") or ""
-            if isinstance(val, str) and "fulldisplay" in val:
-                return val
-    docid = _extract_primo_docid(doc)
-    if docid:
-        pnx = doc.get("pnx", {}) or {}
-        control = pnx.get("control", {}) or {}
-        sourceid = _first_str(control.get("sourceid")).lower()
-        context = "PC" if docid.lower().startswith("cdi_") or "central" in sourceid else "L"
-        return (
-            "https://khalifa.primo.exlibrisgroup.com/discovery/fulldisplay"
-            f"?docid={quote(docid)}&context={context}&vid=971KUOSTAR_INST:KU&lang=en&search_scope=MyInst_and_CI&tab=Everything"
-        )
-    return (
-        "https://khalifa.primo.exlibrisgroup.com/discovery/search"
-        f"?query=any,contains,{query_encoded}&vid=971KUOSTAR_INST:KU&lang=en&search_scope=MyInst_and_CI&tab=Everything"
-    )
+# ── PRIMO Boolean → multi-param converter ──────────────────────────────────────
 
-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
+def _boolean_to_primo_params(boolean_query: str) -> str:
     """
-    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)
+    Convert a Boolean query with AND groups + OR alternatives into PRIMO's
+    multi-q-parameter format.
 
-    if req.peer_reviewed:
-        facets.append("facet_tlevel,include,peer_reviewed")
+    PRIMO accepts:
+        q=any,contains,smart city OR urban mobility,AND
+        &q=any,contains,technocentricity OR citizen-centric
 
-    if req.open_access:
-        facets.append("facet_tlevel,include,online_resources")
+    A single q=any,contains,(full boolean string) returns irrelevant results
+    because PRIMO treats parentheses and AND/OR as literal search text.
 
-    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}")
+    Examples:
+        '("smart city" OR "urban mobility") AND ("technocentricity")'
+        → 'q=any,contains,smart city OR urban mobility,AND&q=any,contains,technocentricity'
 
-    for facet in facets:
-        url += f"&multiFacets={quote(facet)}"
-
-    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,
+        '"climate change"'
+        → 'q=any,contains,climate change'
+    """
+    if not boolean_query or not boolean_query.strip():
+        return f"q=any,contains,{quote('library')}"
+
+    # If no AND groups, treat as a simple query
+    has_and = bool(re.search(r'\bAND\b', boolean_query, re.IGNORECASE))
+    has_parens = '(' in boolean_query
+
+    if not (has_and and has_parens):
+        # Simple query: strip quotes and operators, use as-is
+        clean = re.sub(r'["\']', '', boolean_query).strip()
+        clean = re.sub(r'\b(AND|OR|NOT)\b', ' ', clean, flags=re.IGNORECASE)
+        clean = re.sub(r'\s+', ' ', clean).strip()
+        return f"q=any,contains,{quote(clean)}"
+
+    # Parse top-level AND groups by tracking parenthesis depth
+    groups = []
+    depth = 0
+    chunk = ""
+    for char in boolean_query:
+        if char == '(':
+            depth += 1
+            chunk += char
+        elif char == ')':
+            depth -= 1
+            chunk += char
+        else:
+            chunk += char
+        # When we close back to depth 0 and the chunk ends with ' AND '
+        if depth == 0 and chunk.upper().endswith(' AND '):
+            groups.append(chunk[:-5].strip())
+            chunk = ""
+    if chunk.strip():
+        groups.append(chunk.strip())
+
+    if not groups:
+        # Fallback: couldn't parse groups
+        clean = re.sub(r'["\']', '', boolean_query).strip()
+        return f"q=any,contains,{quote(clean)}"
+
+    primo_params = []
+    for i, group in enumerate(groups):
+        g = group.strip()
+        # Strip outer parentheses
+        if g.startswith('(') and g.endswith(')'):
+            g = g[1:-1].strip()
+        # Remove quotes — PRIMO handles phrases without them
+        g = re.sub(r'["\']', '', g)
+        # Normalise OR spacing
+        g = re.sub(r'\s+OR\s+', ' OR ', g, flags=re.IGNORECASE).strip()
+        if not g:
+            continue
+        # Add ,AND connector on all groups except the last
+        suffix = ',AND' if i < len(groups) - 1 else ''
+        primo_params.append(f"q=any,contains,{quote(g)}{suffix}")
+
+    if not primo_params:
+        clean = re.sub(r'["\']', '', boolean_query).strip()
+        return f"q=any,contains,{quote(clean)}"
+
+    return '&'.join(primo_params)
+
+
+# ── PRIMO search ───────────────────────────────────────────────────────────────
+
+def _build_primo_search_link(title: str, record_id: Optional[str] = None) -> Optional[str]:
+    base = 'https://khalifa.primo.exlibrisgroup.com/discovery'
+    if record_id:
+        return f"{base}/fulldisplay?docid={quote(str(record_id))}&vid=971KUOSTAR_INST:KU"
+    clean_title = (title or '').strip()
+    if not clean_title:
+        return None
+    return (
+        f"{base}/search?query=any,contains,{quote(clean_title)}"
+        "&tab=Everything&search_scope=MyInst_and_CI&vid=971KUOSTAR_INST:KU&lang=en"
     )
 
-    try:
-        async with httpx.AsyncClient(timeout=20) as client:
-            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}")
-                return {"error": f"PRIMO API error: {r.status_code}", "results": [], "source": "PRIMO"}
 
-            data = r.json()
-            docs = data.get("docs", [])
-            results = []
-            for doc in docs[: req.limit]:
-                pnx = doc.get("pnx", {})
-                d = pnx.get("display", {})
-                results.append({
-                    "title": (d.get("title") or ["Untitled"])[0],
-                    "creator": "; ".join(d.get("creator") or d.get("contributor") or []) or "Unknown",
-                    "date": (d.get("date") or [""])[0],
-                    "type": (d.get("type") or [""])[0],
-                    "source": (d.get("source") or [""])[0],
-                    "primo_url": _primo_record_url(doc, query_encoded),
-                    "_source": "PRIMO",
-                })
-            return {
-                "total": data.get("info", {}).get("total", 0),
-                "results": results,
-                "source": "PRIMO",
-            }
-
-    except httpx.TimeoutException:
-        _safe_metrics_bucket("errors", "primo_timeout")
-        return {"error": "PRIMO API timed out — please try again", "results": [], "source": "PRIMO"}
-    except Exception as exc:
-        logger.error("PRIMO search error: %s", exc, exc_info=True)
-        _safe_metrics_bucket("errors", "primo_exception")
-        return {"error": str(exc), "results": [], "source": "PRIMO"}
-
-
-def _strip_resource_noise(query: str) -> str:
+async def search_primo(req: SearchRequest, api_key: str) -> dict:
     """
-    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.
+    Search the PRIMO API.
+    Converts boolean queries to multi-param format for accurate results.
     """
-    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)
+    import httpx
 
+    if not api_key:
+        return {"error": "PRIMO_API_KEY not configured", "results": [], "total": 0}
 
-# ── PubMed ─────────────────────────────────────────────────────────────────────
+    # Decide query format: boolean multi-param vs plain query
+    query_str = (req.query or "").strip()
+    has_bool = bool(re.search(r'\b(AND|OR)\b', query_str)) and '(' in query_str
 
-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
+    if has_bool:
+        query_params = _boolean_to_primo_params(query_str)
+    else:
+        # Plain topic: quote-strip and encode
+        clean = re.sub(r'["\']', '', query_str).strip()
+        query_params = f"q=any,contains,{quote(clean)}"
 
-    # Add peer-reviewed as a PubMed publication-type filter (appended to term)
-    term = clean_query
+    # Facets
+    facets = ""
     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 = ""
+        facets += "&qInclude=facet_tlevel,exact,peer_reviewed"
+    if req.open_access:
+        facets += "&qInclude=facet_tlevel,exact,open_access"
     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,
+        yt = req.year_to or str(datetime.now().year)
+        facets += f"&multiFacets=facet_searchcreationdate,include,{yf}%7C,%7C{yt}"
+    if req.resource_type == "books":
+        facets += "&qInclude=facet_rtype,exact,books"
+    elif req.resource_type == "articles":
+        facets += "&qInclude=facet_rtype,exact,articles"
+
+    vid = "971KUOSTAR_INST:KU"
+    qs = (
+        f"?vid={vid}&tab=Everything&scope=MyInst_and_CI"
+        f"&{query_params}"
+        f"&lang=en&sort=rank&limit={req.limit}&offset=0&mode=advanced"
+        f"&apikey={api_key}{facets}"
     )
 
+    base = "https://api-eu.hosted.exlibrisgroup.com/primo/v1/search"
+    results = []
+    total = 0
+
+    async with httpx.AsyncClient(timeout=15) as client:
+        for region in ["api-eu", "api-na", "api-ap"]:
+            url = base.replace("api-eu", region) + qs
+            try:
+                r = await client.get(url, headers={"Accept": "application/json"})
+                if r.status_code == 200:
+                    data = r.json()
+                    total = data.get("info", {}).get("total", 0)
+                    for doc in data.get("docs", []):
+                        pnx = doc.get("pnx", {})
+                        d = pnx.get("display", {})
+                        a = pnx.get("addata", {})
+                        s = pnx.get("search", {})
+                        c = pnx.get("control", {})
+                        l = pnx.get("links", {})
+                        record_id = (c.get("recordid") or [None])[0]
+                        title = (d.get("title") or ["Untitled"])[0]
+                        primo_url = _build_primo_search_link(title, record_id)
+                        doi = (a.get("doi") or [None])[0]
+                        raw_link = (l.get("openurl") or l.get("linktorsrc") or [None])[0]
+                        results.append({
+                            "record_id": record_id,
+                            "title": title,
+                            "creator": "; ".join(
+                                d.get("creator") or d.get("contributor") or []
+                            ) or "Unknown",
+                            "date": (
+                                s.get("creationdate") or a.get("risdate") or a.get("date") or [""]
+                            )[0],
+                            "type": (d.get("type") or [""])[0],
+                            "source": (d.get("source") or a.get("jtitle") or [""])[0],
+                            "description": ((d.get("description") or [""])[0] or "")[:400],
+                            "doi": doi,
+                            "primo_url": primo_url,
+                            "link": raw_link or primo_url,
+                            "open_access": (d.get("oa") or [""])[0] == "free_for_read",
+                            "_source": "PRIMO",
+                        })
+                    return {"total": total, "results": results, "source": "PRIMO"}
+            except Exception:
+                continue
+
+    return {"error": "PRIMO API unavailable", "results": [], "total": 0, "source": "PRIMO"}
+
+
+# ── PubMed search ──────────────────────────────────────────────────────────────
+
+async def search_pubmed(req: SearchRequest) -> dict:
+    """Search PubMed via E-utilities."""
+    import httpx
+
+    base = "https://eutils.ncbi.nlm.nih.gov/entrez/eutils"
+    query = (req.query or "").strip()
+
+    # Build date filter if needed
+    if req.year_from or req.year_to:
+        yf = req.year_from or "1900"
+        yt = req.year_to or str(datetime.now().year)
+        query = f"({query}) AND ({yf}:{yt}[dp])"
+
     try:
         async with httpx.AsyncClient(timeout=15) as client:
-            search_url = (
-                f"https://eutils.ncbi.nlm.nih.gov/entrez/eutils/esearch.fcgi"
-                f"?db=pubmed&term={query_encoded}&retmax={req.limit}&retmode=json{date_params}"
+            r = await client.get(
+                f"{base}/esearch.fcgi",
+                params={
+                    "db": "pubmed", "term": query,
+                    "retmax": req.limit, "retmode": "json", "sort": "relevance"
+                }
             )
-            r = await client.get(search_url)
             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", [])
+            count = int(r.json().get("esearchresult", {}).get("count", 0))
             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"
+            r2 = await client.get(
+                f"{base}/esummary.fcgi",
+                params={"db": "pubmed", "id": ",".join(ids), "retmode": "json"}
             )
-            r2 = await client.get(fetch_url)
             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", {})
@@ -339,67 +265,24 @@ async def search_pubmed(req: SearchRequest):
                 rec = data.get(pid, {})
                 if not isinstance(rec, dict):
                     continue
-                author_list = rec.get("authors", [])
-                authors = ", ".join(a.get("name", "") for a in author_list[:3])
-                if len(author_list) > 3:
+                authors_list = rec.get("authors", [])
+                authors = ", ".join(a.get("name", "") for a in authors_list[:3])
+                if len(authors_list) > 3:
                     authors += " et al."
+                eloc = rec.get("elocationid", "")
+                doi = eloc.replace("doi: ", "") if "doi:" in eloc else None
                 results.append({
                     "title": rec.get("title", ""),
                     "creator": authors,
                     "date": rec.get("pubdate", ""),
                     "source": rec.get("fulljournalname", rec.get("source", "")),
+                    "doi": doi,
                     "pmid": pid,
                     "link": f"https://pubmed.ncbi.nlm.nih.gov/{pid}/",
                     "type": "Journal Article",
                     "_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",
-        }
-        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:
-                _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", []):
-                author_list = paper.get("authors") or []
-                authors = ", ".join(a.get("name", "") for a in author_list[:3])
-                if len(author_list) > 3:
-                    authors += " et al."
-                paper_id = paper.get("paperId")
-                results.append({
-                    "title": paper.get("title", ""),
-                    "creator": authors,
-                    "date": str(paper.get("year", "")),
-                    "source": paper.get("venue", ""),
-                    "citations": paper.get("citationCount", 0),
-                    "link": f"https://www.semanticscholar.org/paper/{paper_id}" if paper_id else "",
-                    "type": "Article",
-                    "_source": "Semantic Scholar",
-                })
-            return {"total": data.get("total", 0), "results": results, "source": "Semantic Scholar"}
+            return {"total": count, "results": results, "source": "PubMed"}
 
-    except Exception as exc:
-        logger.error("Semantic Scholar search error: %s", exc)
-        _safe_metrics_bucket("errors", "semantic_exception")
-        return {"error": str(exc), "results": [], "source": "Semantic Scholar"}
+    except Exception as e:
+        return {"error": f"PubMed: {str(e)}", "results": [], "source": "PubMed"}