Update src/api/agent.py

src/api/agent.py

@@ -81,7 +81,7 @@ class SearchContextPayload(BaseModel):
     ai_tool_query: Optional[str] = None
     primo_boolean_query: Optional[str] = None
     created_at: float = Field(default_factory=time.time)
-    # v3.7 — ambiguity gate for short/numeric/unclear topics
+    # v3.8 — ambiguity gate
     clarification_needed: bool = False
     clarification_message: Optional[str] = None
 
@@ -170,7 +170,18 @@ HOURS_RE = re.compile(
     r"|habshan.*open|san.*open|main campus.*open|ramadan hours?|weekend hours?"
     r"|friday hours?|saturday hours?|sunday hours?|library.*schedule|schedule.*library"
     r"|what.*hours|till.*when|until.*when|what day.*open|which day.*open"
-    r"|what day.*closed|which day.*closed)\b",
+    r"|what day.*closed|which day.*closed"
+    r"|library\s+timing[s]?|timing[s]?\s+library|library\s+time[s]?"
+    r"|library\s+open\s+time|library\s+close\s+time"
+    r"|ku\s+library\s+open|ku\s+library\s+close|ku.*library.*timing"
+    r"|libra[ry]+\s+timing[s]?|libra[ry]+\s+time[s]?"
+    r"|what\s+are\s+the\s+timing[s]?|what.*timing[s]?"
+    r"|is\s+library\s+open|is\s+ku.*open|ku.*open.*now"
+    r"|open\s+time.*library|close\s+time.*library"
+    r"|operating\s+hours?|working\s+hours?.*library|library.*working\s+hours?"
+    r"|when\s+can\s+i.*library|library.*available\s+now"
+    r"|library\s+open$|^library\s+open|library\s+closed$|^library\s+closed"
+    r"|library.*open.*week|library.*close.*week)\b",
     re.IGNORECASE,
 )
 KU_CAMPUS_RE = re.compile(
@@ -1574,8 +1585,7 @@ def _light_strip_retrieval_boilerplate(text: str) -> str:
     cleaned = re.sub(r"^\s*(please\s+)?help me\s+", "", cleaned, flags=re.IGNORECASE)
     cleaned = re.sub(r"^\s*please\s+", "", cleaned, flags=re.IGNORECASE)
     cleaned = re.sub(r"\s+(please|thanks|thank you|asap)$", "", cleaned, flags=re.IGNORECASE)
-    # Strip search intent verbs — these are action signals, not topic content
-    # Pass 1: strip leading intent verb phrases (including compound forms)
+    # Pass 1: strip search intent verbs
     cleaned = re.sub(
         r"^\s*(find|search for|search|look for|get me|show me|give me|fetch|retrieve|"
         r"research on|articles on|papers on|literature on|studies on|"
@@ -1591,7 +1601,7 @@ def _light_strip_retrieval_boilerplate(text: str) -> str:
         r"journals?|publications?|resources?)\s+(on|about|for|regarding|into)\s+",
         "", cleaned, flags=re.IGNORECASE
     )
-    # Pass 3: strip dangling prepositions after intent removal
+    # Pass 3: strip dangling prepositions
     cleaned = re.sub(
         r"^\s*(on|about|for|regarding|concerning|into|around|of|in|the)\s+",
         "", cleaned, flags=re.IGNORECASE
@@ -1699,7 +1709,6 @@ expanded form as OR synonyms inside parentheses. Examples:
 ("RL" OR "reinforcement learning")
 ("DL" OR "deep learning")
 ("CNN" OR "convolutional neural network")
-("NLG" OR "natural language generation")
 Apply this rule to ANY acronym in the query, not just these examples.
 
 BOOLEAN RULES — follow strictly:
@@ -1716,19 +1725,15 @@ BOOLEAN RULES — follow strictly:
 EXAMPLES:
 Input: "find articles on global warming and renewable energy"
 → boolean:("global warming" OR "climate change") AND ("renewable energy" OR "clean energy")
-→ year_from:"", peer_reviewed:false
 
 Input: "find research on NLP"
 → boolean:("NLP" OR "natural language processing")
-→ year_from:"", peer_reviewed:false
 
 Input: "get me papers on AI in healthcare"
 → boolean:("AI" OR "artificial intelligence") AND ("healthcare" OR "medicine" OR "clinical")
-→ year_from:"", peer_reviewed:false
 
 Input: "search ML algorithms"
 → boolean:("ML" OR "machine learning") AND ("algorithms" OR "models" OR "techniques")
-→ year_from:"", peer_reviewed:false
 
 Input: "peer reviewed articles last 5 years on machine learning healthcare"
 → boolean:("machine learning" OR "deep learning" OR "AI") AND ("healthcare" OR "medicine" OR "clinical")
@@ -1736,15 +1741,9 @@ Input: "peer reviewed articles last 5 years on machine learning healthcare"
 
 Input: "impact of global warming in Maldives"
 → boolean:("global warming" OR "climate change") AND ("Maldives" OR "sea level rise" OR "small island")
-→ year_from:"", peer_reviewed:false
 
 Input: "water scarcity solutions in UAE"
 → boolean:("water scarcity" OR "water stress") AND ("UAE" OR "United Arab Emirates" OR "Gulf region")
-→ year_from:"", peer_reviewed:false
-
-Input: "summarize shift in personalized genomic medicine from N-of-1 trials last 24 months"
-→ boolean:("personalized genomic medicine" OR "precision medicine") AND ("N-of-1 trials" OR "scalable precision")
-→ year_from:"2024", peer_reviewed:true
 
 Return ONLY valid JSON:
 {{"corrected":"...","natural":"...","boolean":"(\"A\" OR \"B\") AND (\"C\" OR \"D\")","year_from":"","year_to":"","peer_reviewed":false,"open_access":false}}"""
@@ -1754,17 +1753,12 @@ async def _validate_topic(topic: str, model: str) -> Tuple[bool, str]:
     """
     Stage 2 topic validator — runs after the regex ambiguity gate.
     Catches gibberish/unrecognisable words that passed the gate.
-
-    Returns:
-        (True, corrected_topic)  — topic is recognisable; corrected if typo
-        (False, "")              — topic is gibberish/unrecognisable
-
-    Uses a tiny ~30-token LLM call. Fails open (returns True) on any exception
-    so a validator failure never blocks a legitimate search.
+    Returns (True, corrected_topic) or (False, "").
+    Fails open on any exception so it never blocks a legitimate search.
     """
     settings = get_settings()
     if not settings.openai_api_key and not settings.anthropic_api_key:
-        return True, topic  # No LLM available — fail open
+        return True, topic
     try:
         llm = _get_llm(model, temperature=0, max_tokens=40)
         response = await llm.ainvoke([
@@ -1792,47 +1786,38 @@ async def _validate_topic(topic: str, model: str) -> Tuple[bool, str]:
             is_valid = bool(result.get("valid", True))
             corrected = str(result.get("corrected") or topic).strip()
             return is_valid, corrected
-        return True, topic  # Malformed response — fail open
+        return True, topic
     except Exception as exc:
         logger.warning(f"_validate_topic failed: {exc} — failing open")
-        return True, topic  # Always fail open so validator never blocks search
+        return True, topic
 
 
 async def _build_search_plan(question: str, model: str) -> dict:
     """
-    LLM-driven search plan — ported from app81.py and adapted for LibBee.
-    Returns: corrected, natural, boolean, database_query, year_from, year_to,
-             peer_reviewed, open_access.
+    LLM-driven search plan.
+    Includes:
+    - Ambiguity gate (numbers, single chars, no content words)
+    - Stage 2 LLM topic validator (gibberish detection + typo correction)
     Falls back to regex boolean if LLM fails.
-    Includes ambiguity gate: returns clarification_needed=True for numbers,
-    single characters, or topics too short to build a meaningful boolean.
     """
     settings = get_settings()
     raw_query = _normalize_whitespace(question or "")
     light_query = _light_strip_retrieval_boilerplate(raw_query) or raw_query
 
-    # ── Ambiguity gate ────────────────────────────────────────────────────────
-    # After stripping intent verbs and prepositions, check if what remains
-    # is meaningful enough to build a boolean query.
+    # ── Stage 1: Regex ambiguity gate ────────────────────────────────────────
     _stripped = light_query.strip()
     _is_pure_number  = bool(re.fullmatch(r"[\d\s\.\,\-\/]+", _stripped))
     _is_too_short    = len(_stripped) < 2
     _is_single_char  = bool(re.fullmatch(r"[a-zA-Z0-9]", _stripped))
-    # Check if remaining words are all numbers/single chars — no real content words
     _content_words   = [w for w in _stripped.split() if len(w) > 1 and not re.fullmatch(r"[\d\.\,\-]+", w)]
     _no_content      = len(_content_words) == 0 and len(_stripped) > 0
 
     if _is_pure_number or _is_too_short or _is_single_char or _no_content:
         _display = _stripped or raw_query
         return {
-            "corrected":            raw_query,
-            "natural":              light_query,
-            "boolean":              "",
-            "database_query":       "",
-            "year_from":            "",
-            "year_to":              "",
-            "peer_reviewed":        False,
-            "open_access":          False,
+            "corrected": raw_query, "natural": light_query, "boolean": "",
+            "database_query": "", "year_from": "", "year_to": "",
+            "peer_reviewed": False, "open_access": False,
             "clarification_needed": True,
             "clarification_message": (
                 f"I want to make sure I search for the right thing. "
@@ -1842,25 +1827,14 @@ async def _build_search_plan(question: str, model: str) -> dict:
                 f"the better I can build your search."
             ),
         }
-    # ── End ambiguity gate ────────────────────────────────────────────────────
-
     # ── Stage 2: LLM topic validator ─────────────────────────────────────────
-    # Catches gibberish/unrecognisable words that passed the regex gate.
-    # Typos are silently corrected. Gibberish triggers clarification.
-    # Uses a tiny ~30-token LLM call — much cheaper than running full boolean
-    # builder on garbage input.
     if settings.openai_api_key or settings.anthropic_api_key:
         _valid, _corrected_topic = await _validate_topic(_stripped, model)
         if not _valid:
             return {
-                "corrected":            raw_query,
-                "natural":              light_query,
-                "boolean":              "",
-                "database_query":       "",
-                "year_from":            "",
-                "year_to":              "",
-                "peer_reviewed":        False,
-                "open_access":          False,
+                "corrected": raw_query, "natural": light_query, "boolean": "",
+                "database_query": "", "year_from": "", "year_to": "",
+                "peer_reviewed": False, "open_access": False,
                 "clarification_needed": True,
                 "clarification_message": (
                     f"I couldn't recognise <strong>{_escape(_stripped)}</strong> as a research topic. "
@@ -1869,11 +1843,10 @@ async def _build_search_plan(question: str, model: str) -> dict:
                     f"<em>\"articles on renewable energy in UAE\"</em>."
                 ),
             }
-        # Silently use corrected spelling for the rest of the pipeline
         if _corrected_topic and _corrected_topic.lower() != _stripped.lower():
             logger.info(f"_validate_topic corrected: {_stripped!r} → {_corrected_topic!r}")
             light_query = _corrected_topic
-    # ── End stage 2 ───────────────────────────────────────────────────────────
+    # ─────────────────────────────────────────────────────────────────────────
 
     if settings.openai_api_key or settings.anthropic_api_key:
         try:
@@ -1944,28 +1917,21 @@ async def _build_search_plan(question: str, model: str) -> dict:
 
 
 async def _prepare_queries(question: str, context: SearchContextPayload, model: str, is_follow_up: bool) -> SearchContextPayload:
-    """
-    Build all query forms using _build_search_plan.
-    Updates context.ai_tool_query, primo_boolean_query, and if plan detects
-    year/peer_reviewed/open_access that aren't already set, applies them.
-    If _build_search_plan returns clarification_needed, sets it on context.
-    """
+    """Build all query forms using _build_search_plan."""
     topic = _strip_resource_noise(context.display_topic or context.topic) or context.topic
     q = question if not is_follow_up else f"Find {context.resource_type} on {topic}"
 
     plan = await _build_search_plan(q, model)
 
-    # ── Clarification gate ────────────────────────────────────────────────────
+    # Clarification gate
     if plan.get("clarification_needed"):
         context.clarification_needed = True
         context.clarification_message = plan.get("clarification_message", "")
         return context
-    # ─────────────────────────────────────────────────────────────────────────
 
     context.ai_tool_query        = plan["natural"]
     context.primo_boolean_query  = plan["boolean"]
 
-    # Apply plan's filter detections only if context doesn't already have them set
     if not context.year_from and plan.get("year_from"):
         context.year_from = plan["year_from"]
     if not context.year_to and plan.get("year_to"):
@@ -1983,11 +1949,8 @@ async def _prepare_queries(question: str, context: SearchContextPayload, model:
 
 async def _topic_intro(topic: str, model: str) -> str:
     """
-    Generate a concise 3-sentence topic introduction for academic/medical queries.
-    ~180 tokens. No external API calls — LLM knowledge only.
-
-    LibBee v3.7 approach: provide brief context, then hand off to PRIMO and
-    AI research platforms (Consensus, LeapSpace, Scopus AI) for deep research.
+    3-sentence topic intro — lightweight LLM call (~180 tokens, no external APIs).
+    Prepended to all academic/medical search responses (v3.8).
     """
     settings = get_settings()
     if not settings.openai_api_key and not settings.anthropic_api_key:
@@ -3670,22 +3633,19 @@ async def _run_search_mode(
 ) -> Tuple[str, List[dict], List[dict], str]:
     """
     Search mode — builds PRIMO link + 3-sentence topic intro + AI tools footer.
-    No external academic API calls (v3.7).
-    Includes clarification gate for ambiguous queries (numbers, single chars etc.)
+    No external academic API calls (v3.8).
+    Includes clarification gate for ambiguous/gibberish queries.
     """
     context = await _prepare_queries(question, context, model, is_follow_up)
 
-    # ── Clarification gate ────────────────────────────────────────────────────
-    # If the topic after stripping intent verbs is a number, single character,
-    # or too short to build a meaningful boolean, ask the user to clarify.
+    # Clarification gate
     if context.clarification_needed and context.clarification_message:
         return context.clarification_message, [], [], ""
-    # ─────────────────────────────────────────────────────────────────────────
 
     source_url = _primo_clean_url(context)
     topic = _escape(context.display_topic or context.topic)
 
-    # 3-sentence topic intro — lightweight LLM call, no external APIs
+    # 3-sentence topic intro
     intro = await _topic_intro(context.display_topic or context.topic, model)
 
     answer = _search_trace_block(question, context)