fix: move _servers_with_live_health before @router .get decorator; fix db try block indent

app_part1.py

@@ -88,15 +88,13 @@ async def init_db_pool() -> asyncpg.Pool:
 async def lifespan(app: FastAPI):
     global db_pool
     try:
-        try:
         db_pool = await init_db_pool()
         logger.info("Database pool initialized.")
-    except Exception as _db_err:
-        logger.error("Database pool failed: %s", _db_err)
-        db_pool = None
-        logger.info("Database pool initialized.")
     except Exception as exc:
-        logger.error("Failed to initialize Postgres pool. Falling back to memory: %s", exc)
+        logger.error(
+            "Failed to initialize Postgres pool. Falling back to memory: %s",
+            exc,
+        )
         db_pool = None
     yield
     if db_pool is not None:

mcp_routes.py

@@ -441,7 +441,99 @@ async def dispatch_mcp_jsonrpc(payload: Optional[Dict[str, Any]]) -> Dict[str, A
     return {"jsonrpc": "2.0", "id": req_id, "error": {"code": -32601, "message": f"Method not found: {method}"}}
 
 
+def _servers_with_live_health() -> List[Dict[str, Any]]:
+    """
+    Build the MCP server health view from the actual registered runtime
+    configuration.
+
+    This function is deliberately synchronous because mcp_health() invokes
+    it directly. It performs no recursive HTTP call against this service,
+    avoiding /api/mcp -> health -> /api/mcp recursion.
+
+    Local builtin MCP infrastructure is healthy when its registered runtime
+    contract is present. Remote/stdio servers are reported according to
+    their discovered registry state when available.
+    """
+    servers: List[Dict[str, Any]] = []
+
+    # Registered local MCP servers are the authoritative local contract.
+    for server in REGISTERED_SERVERS:
+        item = dict(server)
+
+        transport = str(item.get("transport_type", "")).lower()
+        endpoint = item.get("endpoint_url")
+
+        if transport == "http":
+            # The builtin HTTP MCP server is part of this running process.
+            # Do not probe its own endpoint from inside /api/mcp.
+            if item.get("server_id") == "mcp-core-builtin-01":
+                status = "healthy"
+                health_source = "local_runtime"
+            elif endpoint:
+                # Remote HTTP endpoints cannot safely be synchronously
+                # self-probed here without introducing latency/recursion.
+                status = "configured"
+                health_source = "registered_endpoint"
+            else:
+                status = "not_configured"
+                health_source = "configuration"
+        elif transport == "stdio":
+            # stdio servers require an active subprocess/session. Merely
+            # having a registry record does not prove that a process exists.
+            status = "configured"
+            health_source = "registered_transport"
+        else:
+            status = "configured"
+            health_source = "registered_transport"
+
+        item["health"] = {
+            "status": status,
+            "healthy": status == "healthy",
+            "source": health_source,
+            "checked_at": time.time(),
+        }
+
+        servers.append(item)
+
+    # Include externally registered servers when the registry exposes them.
+    # Registry failures must not make the core MCP health endpoint fail.
+    try:
+        discovered = list_servers()
+        if discovered:
+            known_ids = {str(x.get("server_id")) for x in servers}
+            for remote in discovered:
+                if not isinstance(remote, dict):
+                    continue
+
+                remote_id = str(
+                    remote.get("server_id")
+                    or remote.get("id")
+                    or remote.get("name")
+                    or ""
+                )
+
+                if remote_id and remote_id in known_ids:
+                    continue
+
+                item = dict(remote)
+                item["health"] = {
+                    "status": "discovered",
+                    "healthy": False,
+                    "source": "remote_registry",
+                    "checked_at": time.time(),
+                }
+                servers.append(item)
+    except Exception:
+        # MCP health must remain available even when an optional remote
+        # registry is unavailable.
+        pass
+
+    return servers
+
+
 @router.get("/api/mcp")
+
+
 async def mcp_health() -> JSONResponse:
     live_servers = _servers_with_live_health()
     seen: List[str] = []