Update src/api/agent.py

src/api/agent.py

@@ -408,61 +408,24 @@ Respond ONLY with valid JSON. No preamble, no markdown fences.
 # Hours TTL: 60 min  (hours don't change intra-day)
 # Fallback:  library.ku.ac.ae/hours link if API is unreachable.
 
-_LIBCAL_BASE          = "https://kustar.libcal.com"
-_LIBCAL_LOCATION_IDS  = {"main_campus": 6386, "habshan": 25028}
-_LIBCAL_TIMEZONE      = "Asia/Dubai"   # UTC+4
+# LibCal hours are fetched via the Cloudflare Worker (/hours endpoint).
+# The Worker holds the LibCal credentials and is not blocked by LibCal's
+# host allowlist. Direct calls from HF Spaces return 403.
+#
+# Worker secrets required:  LIBCAL_CLIENT_ID, LIBCAL_CLIENT_SECRET
+# Worker endpoint:          {CLOUDFLARE_WORKER_URL}/hours
+# Location IDs (reference): Main Campus=6386, Habshan=25028
 
-# In-process token + hours caches
-_libcal_token_cache: Dict[str, Any] = {}   # {"token": str, "expires_at": float}
+# In-process hours cache — avoids hitting the worker on every hours query
 _libcal_hours_cache: Dict[str, Any] = {}   # {"data": dict, "cached_at": float}
-_LIBCAL_TOKEN_TTL  = 55 * 60   # seconds
-_LIBCAL_HOURS_TTL  = 60 * 60   # seconds
-
-
-async def _libcal_get_token() -> Optional[str]:
-    """
-    Fetch or return a cached OAuth2 client-credentials token for the LibCal API.
-    Credentials come from LIBCAL_CLIENT_ID / LIBCAL_CLIENT_SECRET env vars.
-    """
-    now = time.time()
-    cached = _libcal_token_cache.get("token")
-    expires = _libcal_token_cache.get("expires_at", 0)
-    if cached and now < expires:
-        return cached
-
-    client_id     = os.environ.get("LIBCAL_CLIENT_ID", "").strip()
-    client_secret = os.environ.get("LIBCAL_CLIENT_SECRET", "").strip()
-    if not client_id or not client_secret:
-        logger.warning("LibCal: LIBCAL_CLIENT_ID / LIBCAL_CLIENT_SECRET not set")
-        return None
-
-    try:
-        async with httpx.AsyncClient(timeout=10) as client:
-            r = await client.post(
-                f"{_LIBCAL_BASE}/api/1.1/oauth/token",
-                data={
-                    "client_id":     client_id,
-                    "client_secret": client_secret,
-                    "grant_type":    "client_credentials",
-                },
-                headers={"Content-Type": "application/x-www-form-urlencoded"},
-            )
-            r.raise_for_status()
-            token = r.json().get("access_token")
-            if token:
-                _libcal_token_cache["token"]      = token
-                _libcal_token_cache["expires_at"] = now + _LIBCAL_TOKEN_TTL
-                logger.info("LibCal: token refreshed")
-                return token
-    except Exception as exc:
-        logger.warning("LibCal token fetch failed: %s", exc)
-    return None
+_LIBCAL_HOURS_TTL = 60 * 60               # 60 minutes
 
 
 async def _libcal_fetch_hours() -> Optional[dict]:
     """
-    Fetch today + next 6 days of hours for both locations.
-    Returns a dict keyed by location name, with per-date hours.
+    Fetch today + next 6 days of hours via Cloudflare Worker proxy.
+    The Worker calls LibCal on our behalf (not blocked by LibCal allowlist).
+    Returns dict: {"main_campus": {...}, "habshan": {...}} or None on failure.
     Caches result for _LIBCAL_HOURS_TTL seconds.
     """
     now = time.time()
@@ -470,70 +433,96 @@ async def _libcal_fetch_hours() -> Optional[dict]:
     if _libcal_hours_cache.get("data") and now - cached_at < _LIBCAL_HOURS_TTL:
         return _libcal_hours_cache["data"]
 
-    token = await _libcal_get_token()
-    if not token:
+    settings = get_settings()
+    worker_url = getattr(settings, "cloudflare_worker_url", "").strip()
+    if not worker_url:
+        logger.warning("LibCal: CLOUDFLARE_WORKER_URL not set — cannot fetch hours")
         return None
 
-    # UAE is UTC+4
     from datetime import timezone, timedelta
-    uae_now  = datetime.now(timezone(timedelta(hours=4)))
+    uae_now   = datetime.now(timezone(timedelta(hours=4)))
     date_from = uae_now.strftime("%Y-%m-%d")
     date_to   = (uae_now + timedelta(days=6)).strftime("%Y-%m-%d")
 
-    combined: dict = {}
     try:
         async with httpx.AsyncClient(timeout=10) as client:
-            for name, loc_id in _LIBCAL_LOCATION_IDS.items():
-                r = await client.get(
-                    f"{_LIBCAL_BASE}/api/1.1/hours/{loc_id}",
-                    params={"from": date_from, "to": date_to},
-                    headers={"Authorization": f"Bearer {token}"},
-                )
-                r.raise_for_status()
-                data = r.json()
-                # LibCal returns a list of location objects; we want the first
-                locations = data if isinstance(data, list) else [data]
-                if locations:
-                    combined[name] = locations[0]
-
-        _libcal_hours_cache["data"]      = combined
-        _libcal_hours_cache["cached_at"] = now
-        logger.info("LibCal: hours refreshed for %d locations", len(combined))
-        return combined
-
+            r = await client.get(
+                f"{worker_url.rstrip('/')}/hours",
+                params={"from": date_from, "to": date_to},
+            )
+            r.raise_for_status()
+            data = r.json()
+            if data.get("error"):
+                logger.warning("LibCal worker error: %s", data["error"])
+                return None
+            _libcal_hours_cache["data"]      = data
+            _libcal_hours_cache["cached_at"] = now
+            logger.info("LibCal: hours refreshed via worker")
+            return data
     except Exception as exc:
         logger.warning("LibCal hours fetch failed: %s", exc)
         return None
 
 
 def _parse_libcal_time(raw: str) -> str:
-    """Normalise LibCal time strings: '8am' → '8:00 AM', '7:30am' → '7:30 AM'."""
+    """Normalise LibCal time strings: '8:00am' → '8:00 AM', '7:30am' → '7:30 AM'."""
+    if not raw:
+        return raw
     raw = raw.strip().replace("\u2013", "-").replace("–", "-")
     raw = re.sub(r"\s+", "", raw)
-    raw = raw.replace("am", " AM").replace("pm", " PM")
+    # Insert space before AM/PM
+    raw = re.sub(r"(?i)(am|pm)$", lambda m: " " + m.group(1).upper(), raw)
     return raw
 
 
 def _format_libcal_day(day_data: dict) -> str:
-    """Return a human-readable hours string for one day entry from LibCal."""
-    status = (day_data.get("status") or "").lower()
-    if status in ("closed", "0"):
-        note = day_data.get("note", "")
-        return f"Closed{f' ({note})' if note else ''}"
+    """
+    Return a human-readable hours string for one day entry from LibCal API v1.1.
+
+    LibCal returns several possible structures:
+      Structure A: {"status": "open",   "hours": [{"from": "8:00am", "to": "5:00pm"}]}
+      Structure B: {"status": "open",   "opens": "8:00am", "closes": "5:00pm"}
+      Structure C: {"status": "closed", "note": "Eid Al Adha"}
+      Structure D: {"status": "24hours"}
+    """
+    if not day_data or not isinstance(day_data, dict):
+        return "See hours page"
+
+    status = str(day_data.get("status") or "").lower().strip()
+    note   = str(day_data.get("note") or "").strip()
+
+    if status in ("closed", "0", "false"):
+        return f"Closed{f' — {note}' if note else ''}"
     if status == "24hours":
         return "Open 24 hours"
-    opens  = day_data.get("opens", "") or ""
-    closes = day_data.get("closes", "") or ""
+
+    # Structure A — hours array (LibCal API v1.1 standard)
+    hours_list = day_data.get("hours") or []
+    if hours_list and isinstance(hours_list, list):
+        first = hours_list[0]
+        f = first.get("from") or first.get("opens") or ""
+        t = first.get("to")   or first.get("closes") or ""
+        if f and t:
+            return f"{_parse_libcal_time(f)} – {_parse_libcal_time(t)}"
+
+    # Structure B — opens/closes at top level
+    opens  = day_data.get("opens")  or day_data.get("open")  or ""
+    closes = day_data.get("closes") or day_data.get("close") or ""
     if opens and closes:
         return f"{_parse_libcal_time(opens)} – {_parse_libcal_time(closes)}"
-    # Some LibCal responses put hours in a nested "times" list
-    times = day_data.get("times", [])
+
+    # Structure C — times list (some LibCal versions)
+    times = day_data.get("times") or []
     if times and isinstance(times, list):
         first = times[0]
-        o = first.get("from", "") or first.get("opens", "")
-        c = first.get("to", "")   or first.get("closes", "")
-        if o and c:
-            return f"{_parse_libcal_time(o)} – {_parse_libcal_time(c)}"
+        f = first.get("from") or first.get("opens") or ""
+        t = first.get("to")   or first.get("closes") or ""
+        if f and t:
+            return f"{_parse_libcal_time(f)} – {_parse_libcal_time(t)}"
+
+    if status in ("open",):
+        return "Open — see hours page for times"
+
     return "See hours page"