fix(rlsapi_v1): add model auto-discovery fallback to _get_default_model_id

When no default model/provider is configured, fall back to querying
Llama Stack for available LLM models instead of hard-failing with 503.
This matches the existing behavior of the query endpoint's
select_model_for_responses() and fixes E2E failures in RBAC mode where
the inference config block is absent.

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

Author: major

src/app/endpoints/rlsapi_v1.py

@@ -122,39 +122,58 @@ def _build_instructions(systeminfo: RlsapiV1SystemInfo) -> str:
     return f"{base_prompt}\n\nUser's system: {system_context}"
 
 
-def _get_default_model_id() -> str:
-    """Get the default model ID from configuration.
+async def _get_default_model_id() -> str:
+    """Get the default model ID from configuration or auto-discovery.
 
-    Returns the model identifier in Llama Stack format (provider/model).
+    Model selection precedence:
+    1. If default model and provider are configured, use them.
+    2. Otherwise, query Llama Stack for available LLM models and select the first one.
 
     Returns:
-        The model identifier string.
+        The model identifier string in "provider/model" format.
 
     Raises:
-        HTTPException: If no model can be determined from configuration.
+        HTTPException: If no model can be determined from configuration or discovery.
     """
-    if configuration.inference is None:
-        msg = "No inference configuration available"
+    # 1. Try configured defaults
+    if configuration.inference is not None:
+        model_id = configuration.inference.default_model
+        provider_id = configuration.inference.default_provider
+
+        if model_id and provider_id:
+            return f"{provider_id}/{model_id}"
+
+    # 2. Auto-discover from Llama Stack
+    client = AsyncLlamaStackClientHolder().get_client()
+    try:
+        models = await client.models.list()
+    except APIConnectionError as e:
+        error_response = ServiceUnavailableResponse(
+            backend_name="Llama Stack",
+            cause=str(e),
+        )
+        raise HTTPException(**error_response.model_dump()) from e
+    except APIStatusError as e:
+        error_response = InternalServerErrorResponse.generic()
+        raise HTTPException(**error_response.model_dump()) from e
+
+    llm_models = [
+        m
+        for m in models
+        if m.custom_metadata and m.custom_metadata.get("model_type") == "llm"
+    ]
+    if not llm_models:
+        msg = "No LLM model found in available models"
         logger.error(msg)
         error_response = ServiceUnavailableResponse(
-            backend_name="inference service (configuration)",
+            backend_name="inference service",
             cause=msg,
         )
         raise HTTPException(**error_response.model_dump())
 
-    model_id = configuration.inference.default_model
-    provider_id = configuration.inference.default_provider
-
-    if model_id and provider_id:
-        return f"{provider_id}/{model_id}"
-
-    msg = "No default model configured for rlsapi v1 inference"
-    logger.error(msg)
-    error_response = ServiceUnavailableResponse(
-        backend_name="inference service (configuration)",
-        cause=msg,
-    )
-    raise HTTPException(**error_response.model_dump())
+    model = llm_models[0]
+    logger.info("Auto-discovered LLM model for rlsapi v1: %s", model.id)
+    return model.id
 
 
 async def retrieve_simple_response(
@@ -178,7 +197,7 @@ async def retrieve_simple_response(
         HTTPException: 503 if no model is configured.
     """
     client = AsyncLlamaStackClientHolder().get_client()
-    model_id = _get_default_model_id()
+    model_id = await _get_default_model_id()
 
     logger.debug("Using model %s for rlsapi v1 inference", model_id)
 
@@ -306,7 +325,7 @@ async def infer_endpoint(
 
     input_source = infer_request.get_input_source()
     instructions = _build_instructions(infer_request.context.systeminfo)
-    model_id = _get_default_model_id()
+    model_id = await _get_default_model_id()
     mcp_tools = await get_mcp_tools()
     logger.debug(
         "Request %s: Combined input source length: %d", request_id, len(input_source)

tests/unit/app/endpoints/test_rlsapi_v1.py

@@ -229,69 +229,88 @@ def test_build_instructions_no_customization(mocker: MockerFixture) -> None:
 # --- Test _get_default_model_id ---
 
 
-def test_get_default_model_id_success(mock_configuration: AppConfig) -> None:
+@pytest.mark.asyncio
+async def test_get_default_model_id_success(mock_configuration: AppConfig) -> None:
     """Test _get_default_model_id returns properly formatted model ID."""
-    model_id = _get_default_model_id()
+    model_id = await _get_default_model_id()
     assert model_id == "openai/gpt-4-turbo"
 
 
 @pytest.mark.parametrize(
-    ("config_setup", "expected_cause"),
+    "failure_mode",
     [
-        pytest.param(
-            "missing_model",
-            "No default model configured",
-            id="missing_model_config",
-        ),
-        pytest.param(
-            "none_inference",
-            "No inference configuration available",
-            id="none_inference_config",
-        ),
+        pytest.param("no_llm_models", id="no_llm_models_found"),
+        pytest.param("connection_error", id="connection_error"),
     ],
 )
-def test_get_default_model_id_errors(
+@pytest.mark.asyncio
+async def test_get_default_model_id_errors(
     mocker: MockerFixture,
     minimal_config: AppConfig,
-    config_setup: str,
-    expected_cause: str,
+    failure_mode: str,
 ) -> None:
-    """Test _get_default_model_id raises HTTPException with ServiceUnavailableResponse shape."""
-    if config_setup == "missing_model":
-        # Config exists but no model/provider defaults
-        mocker.patch("app.endpoints.rlsapi_v1.configuration", minimal_config)
+    """Test _get_default_model_id fallback failures raise 503 responses."""
+    mocker.patch("app.endpoints.rlsapi_v1.configuration", minimal_config)
+
+    mock_embedding_model = mocker.Mock()
+    mock_embedding_model.custom_metadata = {"model_type": "embedding"}
+    mock_embedding_model.id = "sentence-transformers/all-mpnet-base-v2"
+
+    mock_client = mocker.Mock()
+    mock_client.models = mocker.Mock()
+
+    if failure_mode == "no_llm_models":
+        mock_client.models.list = mocker.AsyncMock(return_value=[mock_embedding_model])
     else:
-        # inference is None
-        mock_config = mocker.Mock()
-        mock_config.inference = None
-        mocker.patch("app.endpoints.rlsapi_v1.configuration", mock_config)
+        mock_client.models.list = mocker.AsyncMock(
+            side_effect=APIConnectionError(request=mocker.Mock())
+        )
+
+    mock_client_holder = mocker.Mock()
+    mock_client_holder.get_client.return_value = mock_client
+    mocker.patch(
+        "app.endpoints.rlsapi_v1.AsyncLlamaStackClientHolder",
+        return_value=mock_client_holder,
+    )
 
     with pytest.raises(HTTPException) as exc_info:
-        _get_default_model_id()
+        await _get_default_model_id()
 
     assert exc_info.value.status_code == 503
-    assert expected_cause in str(exc_info.value.detail)
-    # Verify ServiceUnavailableResponse produces dict with response+cause keys
     detail: dict[str, str] = exc_info.value.detail  # type: ignore[assignment]
     assert set(detail.keys()) == {"response", "cause"}
 
 
-def test_config_error_503_matches_llm_error_503_shape(
+@pytest.mark.asyncio
+async def test_config_error_503_matches_llm_error_503_shape(
     mocker: MockerFixture,
+    minimal_config: AppConfig,
 ) -> None:
-    """Test that configuration error 503s have the same shape as LLM error 503s.
+    """Test that auto-discovery 503s have the same shape as LLM error 503s.
 
-    Both _get_default_model_id() configuration errors and APIConnectionError
+    Both _get_default_model_id() no-LLM auto-discovery errors and APIConnectionError
     handlers use ServiceUnavailableResponse, producing identical detail shapes
     with 'response' and 'cause' keys.
     """
-    # Trigger a configuration error 503
-    mock_config = mocker.Mock()
-    mock_config.inference = None
-    mocker.patch("app.endpoints.rlsapi_v1.configuration", mock_config)
+    mocker.patch("app.endpoints.rlsapi_v1.configuration", minimal_config)
+
+    mock_embedding_model = mocker.Mock()
+    mock_embedding_model.custom_metadata = {"model_type": "embedding"}
+    mock_embedding_model.id = "sentence-transformers/all-mpnet-base-v2"
+
+    mock_client = mocker.Mock()
+    mock_client.models = mocker.Mock()
+    mock_client.models.list = mocker.AsyncMock(return_value=[mock_embedding_model])
+
+    mock_client_holder = mocker.Mock()
+    mock_client_holder.get_client.return_value = mock_client
+    mocker.patch(
+        "app.endpoints.rlsapi_v1.AsyncLlamaStackClientHolder",
+        return_value=mock_client_holder,
+    )
 
     with pytest.raises(HTTPException) as config_exc:
-        _get_default_model_id()
+        await _get_default_model_id()
 
     # Build an LLM connection error 503 using the same response model
     llm_response = ServiceUnavailableResponse(
@@ -306,6 +325,39 @@ def test_config_error_503_matches_llm_error_503_shape(
     assert set(config_detail.keys()) == set(llm_detail.keys()) == {"response", "cause"}
 
 
+@pytest.mark.asyncio
+async def test_get_default_model_id_auto_discovery_success(
+    mocker: MockerFixture, minimal_config: AppConfig
+) -> None:
+    """Test _get_default_model_id returns first discovered LLM model ID."""
+    mocker.patch("app.endpoints.rlsapi_v1.configuration", minimal_config)
+
+    mock_llm_model = mocker.Mock()
+    mock_llm_model.custom_metadata = {"model_type": "llm"}
+    mock_llm_model.id = "openai/gpt-4o-mini"
+
+    mock_embedding_model = mocker.Mock()
+    mock_embedding_model.custom_metadata = {"model_type": "embedding"}
+    mock_embedding_model.id = "sentence-transformers/all-mpnet-base-v2"
+
+    mock_client = mocker.Mock()
+    mock_client.models = mocker.Mock()
+    mock_client.models.list = mocker.AsyncMock(
+        return_value=[mock_embedding_model, mock_llm_model]
+    )
+
+    mock_client_holder = mocker.Mock()
+    mock_client_holder.get_client.return_value = mock_client
+    mocker.patch(
+        "app.endpoints.rlsapi_v1.AsyncLlamaStackClientHolder",
+        return_value=mock_client_holder,
+    )
+
+    model_id = await _get_default_model_id()
+
+    assert model_id == "openai/gpt-4o-mini"
+
+
 # --- Test retrieve_simple_response ---