Improve /health to probe SearXNG and LLM connectivity

Instead of always returning "healthy", the endpoint now makes
lightweight HTTP probes to SearXNG (GET /) and the LLM backend
(GET /models, only when summary is enabled). Returns per-check
status and overall "healthy" or "degraded".

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: SkylarKelty

artemis/main.py

@@ -23,6 +23,8 @@
 from collections.abc import AsyncGenerator
 from contextlib import asynccontextmanager
 
+import httpx
+
 from fastapi import Depends, FastAPI, HTTPException, Request, status
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import JSONResponse, StreamingResponse
@@ -491,16 +493,41 @@ async def root() -> dict[str, str]:
 
 @app.get("/health")
 async def health() -> dict[str, object]:
-    """Health check endpoint.
+    """Health check endpoint with dependency probes.
 
-    Returns service status and configuration info including:
-    - Whether summarization is enabled
-    - Whether authentication is required
-    - Whether the summary circuit is open (due to failures)
+    Probes SearXNG connectivity and (if summary is enabled) the LLM
+    backend. Returns per-check status and an overall status of
+    "healthy" or "degraded".
     """
     settings = get_settings()
+    checks: dict[str, str] = {}
+
+    # Probe SearXNG
+    try:
+        async with httpx.AsyncClient(timeout=httpx.Timeout(5.0)) as client:
+            resp = await client.get(f"{settings.searxng_api_base}/")
+            checks["searxng"] = "ok" if resp.status_code < 400 else f"http_{resp.status_code}"
+    except Exception as exc:
+        checks["searxng"] = f"error: {type(exc).__name__}"
+
+    # Probe LLM backend (only if summarization is enabled)
+    if settings.enable_summary:
+        try:
+            headers: dict[str, str] = {}
+            if settings.litellm_api_key:
+                headers["Authorization"] = f"Bearer {settings.litellm_api_key}"
+            async with httpx.AsyncClient(timeout=httpx.Timeout(5.0)) as client:
+                resp = await client.get(
+                    f"{settings.litellm_base_url}/models", headers=headers,
+                )
+                checks["llm"] = "ok" if resp.status_code < 400 else f"http_{resp.status_code}"
+        except Exception as exc:
+            checks["llm"] = f"error: {type(exc).__name__}"
+
+    all_ok = all(v == "ok" for v in checks.values())
     return {
-        "status": "healthy",
+        "status": "healthy" if all_ok else "degraded",
+        "checks": checks,
         "summary_enabled": settings.enable_summary,
         "auth_enabled": bool(settings.artemis_api_key),
         "summary_circuit_open": summary_circuit.opened_until > time.time(),

tests/test_api_extended.py

@@ -81,23 +81,44 @@ def test_root_returns_message(self) -> None:
         self.assertIn("message", response.json())
         self.assertIn("Artemis", response.json()["message"])
 
-    def test_health_returns_status(self) -> None:
+    @patch("artemis.main.httpx.AsyncClient")
+    def test_health_returns_status(self, mock_client_cls: MagicMock) -> None:
+        mock_resp = MagicMock(status_code=200)
+        mock_ctx = AsyncMock()
+        mock_ctx.__aenter__ = AsyncMock(return_value=mock_ctx)
+        mock_ctx.__aexit__ = AsyncMock(return_value=False)
+        mock_ctx.get = AsyncMock(return_value=mock_resp)
+        mock_client_cls.return_value = mock_ctx
+
         response = self.client.get("/health")
         self.assertEqual(response.status_code, 200)
         body = response.json()
-        self.assertEqual(body["status"], "healthy")
+        self.assertIn(body["status"], ("healthy", "degraded"))
+        self.assertIn("checks", body)
         self.assertIn("summary_enabled", body)
         self.assertIn("auth_enabled", body)
         self.assertIn("summary_circuit_open", body)
 
     def test_health_reports_circuit_open(self) -> None:
         summary_circuit.opened_until = time.time() + 300
-        response = self.client.get("/health")
+        with patch("artemis.main.httpx.AsyncClient") as mock_cls:
+            mock_ctx = AsyncMock()
+            mock_ctx.__aenter__ = AsyncMock(return_value=mock_ctx)
+            mock_ctx.__aexit__ = AsyncMock(return_value=False)
+            mock_ctx.get = AsyncMock(return_value=MagicMock(status_code=200))
+            mock_cls.return_value = mock_ctx
+            response = self.client.get("/health")
         self.assertTrue(response.json()["summary_circuit_open"])
 
     def test_health_reports_circuit_closed(self) -> None:
         summary_circuit.opened_until = 0.0
-        response = self.client.get("/health")
+        with patch("artemis.main.httpx.AsyncClient") as mock_cls:
+            mock_ctx = AsyncMock()
+            mock_ctx.__aenter__ = AsyncMock(return_value=mock_ctx)
+            mock_ctx.__aexit__ = AsyncMock(return_value=False)
+            mock_ctx.get = AsyncMock(return_value=MagicMock(status_code=200))
+            mock_cls.return_value = mock_ctx
+            response = self.client.get("/health")
         self.assertFalse(response.json()["summary_circuit_open"])