fix: add default model availability check to readiness probe

The /readiness endpoint only verified provider health but did not
check that the configured default model was registered in the Llama
Stack model registry. This allowed pods where model registration
failed during startup to pass readiness and serve 404s on every
inference request.

Add check_default_model_available() that verifies the configured
default model exists in client.models.list(). When the model is
missing, /readiness returns 503 so Kubernetes removes the pod from
the service load balancer.

Ref: RSPEED-2959
Signed-off-by: Major Hayden <major@redhat.com>

Author: major

src/app/endpoints/health.py

@@ -8,13 +8,14 @@
 from enum import Enum
 from typing import Annotated, Any
 
-from fastapi import APIRouter, Depends, Response, status
-from llama_stack_client import APIConnectionError
+from fastapi import APIRouter, Depends, HTTPException, Response, status
+from llama_stack_client import APIConnectionError, APIStatusError
 
 from authentication import get_auth_dependency
 from authentication.interface import AuthTuple
 from authorization.middleware import authorize
 from client import AsyncLlamaStackClientHolder
+from configuration import configuration
 from log import get_logger
 from models.config import Action
 from models.responses import (
@@ -95,6 +96,106 @@ async def get_providers_health_statuses() -> list[ProviderHealthStatus]:
         ]
 
 
+def _model_in_registry(models: list, expected_id: str) -> bool:
+    """Check if a model with the given ID exists in the model list."""
+    return any(model.id == expected_id for model in models)
+
+
+async def _reload_and_check_model(
+    client_holder: AsyncLlamaStackClientHolder,
+    expected_model_id: str,
+) -> tuple[bool, str]:
+    """Attempt to reload the library client and recheck model availability.
+
+    Only called for library mode clients when the default model is missing
+    from the registry after initial lookup.
+
+    Returns:
+        A tuple of (found, reason) where found is True if the model was
+        found after reloading the client.
+    """
+    logger.warning(
+        "Default model %s not found, attempting client reload",
+        expected_model_id,
+    )
+    try:
+        await client_holder.reload_library_client()
+        client = client_holder.get_client()
+        models = await client.models.list()
+        if _model_in_registry(models, expected_model_id):
+            logger.info(
+                "Default model %s found after client reload",
+                expected_model_id,
+            )
+            return True, (
+                f"Default model {expected_model_id} is available after reload"
+            )
+    except (
+        RuntimeError,
+        HTTPException,
+        APIConnectionError,
+        APIStatusError,
+    ) as err:
+        logger.error("Client reload failed: %s", err)
+    return False, ""
+
+
+async def check_default_model_available() -> tuple[bool, str]:
+    """Check that the configured default model is registered in the model registry.
+
+    Verifies the default model from configuration can be found in the Llama
+    Stack client's model list. This catches cases where a pod started
+    successfully and providers report healthy, but model registration failed
+    during initialization.
+
+    If the model is missing and the client is running in library mode, attempts
+    a client reload to re-register models before reporting failure.
+
+    Returns:
+        A tuple of (available, reason) where available is True if the default
+        model was found or no default model is configured, and reason describes
+        the outcome.
+    """
+    inference = configuration.inference
+    if inference is None or not inference.default_model or not inference.default_provider:
+        return True, "No default model configured"
+
+    default_model = inference.default_model
+    default_provider = inference.default_provider
+
+    expected_model_id = f"{default_provider}/{default_model}"
+
+    try:
+        client_holder = AsyncLlamaStackClientHolder()
+        client = client_holder.get_client()
+        models = await client.models.list()
+
+        if _model_in_registry(models, expected_model_id):
+            return True, f"Default model {expected_model_id} is available"
+
+        # Model not found - attempt self-healing reload for library clients
+        if client_holder.is_library_client:
+            found, reason = await _reload_and_check_model(
+                client_holder, expected_model_id
+            )
+            if found:
+                return True, reason
+
+        registered_ids = [m.id for m in models]
+        logger.error(
+            "Default model %s not found in registry. Registered models: %s",
+            expected_model_id,
+            registered_ids,
+        )
+        return False, f"Default model {expected_model_id} not found in model registry"
+    except RuntimeError as e:
+        logger.warning("Client not initialized, skipping model check: %s", e)
+        return False, f"Client not initialized: {e!s}"
+    except (APIConnectionError, APIStatusError) as e:
+        logger.error("Error checking model availability: %s", e)
+        return False, f"Error checking model availability: {e!s}"
+
+
 @router.get("/readiness", responses=get_readiness_responses)
 @authorize(Action.INFO)
 async def readiness_probe_get_method(
@@ -134,11 +235,21 @@ async def readiness_probe_get_method(
         unhealthy_provider_names = [p.provider_id for p in unhealthy_providers]
         reason = f"Providers not healthy: {', '.join(unhealthy_provider_names)}"
         response.status_code = status.HTTP_503_SERVICE_UNAVAILABLE
-    else:
-        ready = True
-        reason = "All providers are healthy"
+        return ReadinessResponse(
+            ready=ready, reason=reason, providers=unhealthy_providers
+        )
+
+    # Check that the default model is registered in the model registry
+    model_available, model_reason = await check_default_model_available()
+    if not model_available:
+        response.status_code = status.HTTP_503_SERVICE_UNAVAILABLE
+        return ReadinessResponse(
+            ready=False, reason=model_reason, providers=unhealthy_providers
+        )
 
-    return ReadinessResponse(ready=ready, reason=reason, providers=unhealthy_providers)
+    return ReadinessResponse(
+        ready=True, reason="All providers are healthy", providers=unhealthy_providers
+    )
 
 
 @router.get("/liveness", responses=get_liveness_responses)

tests/integration/endpoints/test_health_integration.py

@@ -159,6 +159,7 @@ async def test_health_readiness(
     mock_llama_stack_client_health: AsyncMockType,
     test_response: Response,
     test_auth: AuthTuple,
+    mocker: MockerFixture,
 ) -> None:
     """Test that readiness probe endpoint returns readiness status.
 
@@ -180,6 +181,12 @@ async def test_health_readiness(
     """
     _ = mock_llama_stack_client_health
 
+    # Mock check_default_model_available since configuration is not loaded
+    mock_check_model = mocker.patch(
+        "app.endpoints.health.check_default_model_available"
+    )
+    mock_check_model.return_value = (True, "Default model is available")
+
     result = await readiness_probe_get_method(auth=test_auth, response=test_response)
 
     # Verify that service returns readiness response