feat: add OpenAI-compatible error handling to m serve

Add proper exception handling to the chat completion endpoint in
cli/serve/app.py to prevent unhandled exceptions from crashing the
server.

Implements OpenAI API error format for the `m serve` endpoint to ensure
compatibility with OpenAI client libraries and tools.

Signed-off-by: Mark Sturdevant <mark.sturdevant@ibm.com>

Author: markstur

cli/serve/app.py

@@ -8,9 +8,17 @@
 
 import typer
 import uvicorn
-from fastapi import FastAPI
+from fastapi import FastAPI, Request
+from fastapi.responses import JSONResponse
 
-from .models import ChatCompletion, ChatCompletionMessage, ChatCompletionRequest, Choice
+from .models import (
+    ChatCompletion,
+    ChatCompletionMessage,
+    ChatCompletionRequest,
+    Choice,
+    OpenAIError,
+    OpenAIErrorResponse,
+)
 
 app = FastAPI(
     title="M serve OpenAI API Compatible Server",
@@ -29,35 +37,69 @@ def load_module_from_path(path: str):
     return module
 
 
+def create_openai_error_response(
+    status_code: int, message: str, error_type: str, param: str | None = None
+) -> JSONResponse:
+    """Create an OpenAI-compatible error response."""
+    error_response = OpenAIErrorResponse(
+        error=OpenAIError(message=message, type=error_type, param=param)
+    )
+    return JSONResponse(
+        status_code=status_code, content=error_response.model_dump(mode="json")
+    )
+
+
 def make_chat_endpoint(module):
     """Makes a chat endpoint using a custom module."""
 
-    async def endpoint(request: ChatCompletionRequest) -> ChatCompletion:
-        completion_id = f"chatcmpl-{uuid.uuid4().hex[:29]}"
-        created_timestamp = int(time.time())
-
-        output = module.serve(
-            input=request.messages,
-            requirements=request.requirements,
-            model_options={
-                k: v for k, v in request if k not in ["messages", "requirements"]
-            },
-        )
-
-        return ChatCompletion(
-            id=completion_id,
-            model=request.model,
-            created=created_timestamp,
-            choices=[
-                Choice(
-                    index=0,
-                    message=ChatCompletionMessage(
-                        content=output.value, role="assistant"
-                    ),
-                )
-            ],
-            object="chat.completion",  # type: ignore
-        )  # type: ignore
+    async def endpoint(request: ChatCompletionRequest):
+        try:
+            completion_id = f"chatcmpl-{uuid.uuid4().hex[:29]}"
+            created_timestamp = int(time.time())
+
+            output = module.serve(
+                input=request.messages,
+                requirements=request.requirements,
+                model_options={
+                    k: v for k, v in request if k not in ["messages", "requirements"]
+                },
+            )
+
+            return ChatCompletion(
+                id=completion_id,
+                model=request.model,
+                created=created_timestamp,
+                choices=[
+                    Choice(
+                        index=0,
+                        message=ChatCompletionMessage(
+                            content=output.value, role="assistant"
+                        ),
+                    )
+                ],
+                object="chat.completion",  # type: ignore
+            )  # type: ignore
+        except AttributeError as e:
+            # Handle missing 'value' attribute or other attribute errors
+            return create_openai_error_response(
+                status_code=500,
+                message=f"Internal server error: {e!s}",
+                error_type="server_error",
+            )
+        except ValueError as e:
+            # Handle validation errors or invalid input
+            return create_openai_error_response(
+                status_code=400,
+                message=f"Invalid request: {e!s}",
+                error_type="invalid_request_error",
+            )
+        except Exception as e:
+            # Catch-all for any other unexpected errors
+            return create_openai_error_response(
+                status_code=500,
+                message=f"Internal server error: {e!s}",
+                error_type="server_error",
+            )
 
     endpoint.__name__ = f"chat_{module.__name__}_endpoint"
     return endpoint
@@ -79,7 +121,7 @@ def serve(
         route_path,
         make_chat_endpoint(module),
         methods=["POST"],
-        response_model=ChatCompletion,
+        response_model=None,  # Allow both ChatCompletion and error responses
     )
     typer.echo(f"Serving {route_path} at http://{host}:{port}")
     uvicorn.run(app, host=host, port=port)

cli/serve/models.py

@@ -36,6 +36,8 @@ class LogitBias(BaseModel):
 
 
 class ChatCompletionRequest(BaseModel):
+    model_config = {"extra": "allow"}
+
     model: str
     messages: list[ChatMessage]
     requirements: list[str | None] | None = Field(default_factory=list)
@@ -59,9 +61,6 @@ class ChatCompletionRequest(BaseModel):
     # For future/undocumented fields
     extra: dict[str, Any] = Field(default_factory=dict)
 
-    class Config:
-        extra = "allow"
-
 
 # Taking this from OpenAI types https://github.com/openai/openai-python/blob/main/src/openai/types/chat/chat_completion.py,
 class ChatCompletionMessage(BaseModel):
@@ -101,3 +100,26 @@ class ChatCompletion(BaseModel):
 
     object: Literal["chat.completion"]
     """The object type, which is always `chat.completion`."""
+
+
+class OpenAIError(BaseModel):
+    """OpenAI API error object."""
+
+    message: str
+    """A human-readable error message."""
+
+    type: str
+    """The type of error (e.g., 'invalid_request_error', 'server_error')."""
+
+    param: str | None = None
+    """The parameter that caused the error, if applicable."""
+
+    code: str | None = None
+    """An error code, if applicable."""
+
+
+class OpenAIErrorResponse(BaseModel):
+    """OpenAI API error response wrapper."""
+
+    error: OpenAIError
+    """The error object."""

test/cli/test_serve_errors.py

@@ -0,0 +1,137 @@
+"""Tests for the OpenAI-compatible serve endpoint."""
+
+from unittest.mock import Mock
+
+import pytest
+from fastapi.testclient import TestClient
+
+from cli.serve.app import app, make_chat_endpoint
+from cli.serve.models import ChatCompletionRequest, ChatMessage
+
+
+@pytest.fixture
+def mock_module_success():
+    """Create a mock module that returns a successful response."""
+    module = Mock()
+    module.__name__ = "test_module"
+    output = Mock()
+    output.value = "Test response"
+    module.serve = Mock(return_value=output)
+    return module
+
+
+@pytest.fixture
+def mock_module_attribute_error():
+    """Create a mock module that raises AttributeError."""
+    module = Mock()
+    module.__name__ = "test_module"
+    output = Mock(spec=[])  # No 'value' attribute
+    module.serve = Mock(return_value=output)
+    return module
+
+
+@pytest.fixture
+def mock_module_value_error():
+    """Create a mock module that raises ValueError."""
+    module = Mock()
+    module.__name__ = "test_module"
+    module.serve = Mock(side_effect=ValueError("Invalid input"))
+    return module
+
+
+@pytest.fixture
+def mock_module_generic_error():
+    """Create a mock module that raises a generic exception."""
+    module = Mock()
+    module.__name__ = "test_module"
+    module.serve = Mock(side_effect=RuntimeError("Unexpected error"))
+    return module
+
+
+@pytest.fixture
+def sample_request():
+    """Create a sample chat completion request."""
+    return ChatCompletionRequest(
+        model="test-model",
+        messages=[ChatMessage(role="user", content="Hello")],
+        requirements=None,
+    )
+
+
+@pytest.mark.unit
+def test_successful_completion(mock_module_success, sample_request):
+    """Test successful chat completion."""
+    endpoint = make_chat_endpoint(mock_module_success)
+    client = TestClient(app)
+
+    # Add the endpoint to the app
+    app.add_api_route("/test/completions", endpoint, methods=["POST"])
+
+    response = client.post("/test/completions", json=sample_request.model_dump())
+
+    assert response.status_code == 200
+    data = response.json()
+    assert data["choices"][0]["message"]["content"] == "Test response"
+    assert data["model"] == "test-model"
+    assert "id" in data
+    assert data["object"] == "chat.completion"
+
+
+@pytest.mark.unit
+def test_attribute_error_handling(mock_module_attribute_error, sample_request):
+    """Test handling of AttributeError (e.g., missing 'value' attribute)."""
+    endpoint = make_chat_endpoint(mock_module_attribute_error)
+    client = TestClient(app)
+
+    app.add_api_route("/test/attribute-error", endpoint, methods=["POST"])
+
+    response = client.post("/test/attribute-error", json=sample_request.model_dump())
+
+    assert response.status_code == 500
+    data = response.json()
+    assert "error" in data
+    assert data["error"]["type"] == "server_error"
+    assert "Internal server error" in data["error"]["message"]
+
+
+@pytest.mark.unit
+def test_value_error_handling(mock_module_value_error, sample_request):
+    """Test handling of ValueError (validation errors)."""
+    endpoint = make_chat_endpoint(mock_module_value_error)
+    client = TestClient(app)
+
+    app.add_api_route("/test/value-error", endpoint, methods=["POST"])
+
+    response = client.post("/test/value-error", json=sample_request.model_dump())
+
+    assert response.status_code == 400
+    data = response.json()
+    assert "error" in data
+    assert data["error"]["type"] == "invalid_request_error"
+    assert "Invalid request" in data["error"]["message"]
+    assert "Invalid input" in data["error"]["message"]
+
+
+@pytest.mark.unit
+def test_generic_error_handling(mock_module_generic_error, sample_request):
+    """Test handling of generic exceptions."""
+    endpoint = make_chat_endpoint(mock_module_generic_error)
+    client = TestClient(app)
+
+    app.add_api_route("/test/generic-error", endpoint, methods=["POST"])
+
+    response = client.post("/test/generic-error", json=sample_request.model_dump())
+
+    assert response.status_code == 500
+    data = response.json()
+    assert "error" in data
+    assert data["error"]["type"] == "server_error"
+    assert "Internal server error" in data["error"]["message"]
+    assert "Unexpected error" in data["error"]["message"]
+
+
+@pytest.mark.unit
+def test_endpoint_name_generation(mock_module_success):
+    """Test that endpoint names are generated correctly."""
+    endpoint = make_chat_endpoint(mock_module_success)
+    assert endpoint.__name__ == "chat_test_module_endpoint"