Development: Add better error reporting

app/core/custom_exceptions.py

@@ -5,26 +5,63 @@ class RequiresAuthenticationException(HTTPException):
     def __init__(self):
         super().__init__(
             status_code=status.HTTP_401_UNAUTHORIZED,
-            detail="Requires authentication",
+            detail={
+                "type": "not_authenticated",
+                "errorMessage": "Requires authentication",
+            },
         )
 
 
 class PermissionDeniedException(HTTPException):
     def __init__(self):
         super().__init__(
-            status_code=status.HTTP_403_FORBIDDEN, detail="Permission denied"
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail={
+                "type": "not_authorized",
+                "errorMessage": "Permission denied",
+            },
         )
 
 
-class BadDataException(HTTPException):
+class InternalServerException(HTTPException):
     def __init__(self, error_message: str):
         super().__init__(
-            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
-            detail=[
-                {
-                    "loc": [],
-                    "msg": error_message,
-                    "type": "value_error.bad_data",
-                }
-            ],
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail={
+                "type": "other",
+                "errorMessage": error_message,
+            },
+        )
+
+
+class MissingParameterException(HTTPException):
+    def __init__(self, error_message: str):
+        super().__init__(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail={
+                "type": "missing_parameter",
+                "errorMessage": error_message,
+            },
+        )
+
+
+class InvalidTemplateException(HTTPException):
+    def __init__(self, error_message: str):
+        super().__init__(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail={
+                "type": "invalid_template",
+                "errorMessage": error_message,
+            },
+        )
+
+
+class InvalidModelException(HTTPException):
+    def __init__(self, error_message: str):
+        super().__init__(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail={
+                "type": "invalid_model",
+                "errorMessage": error_message,
+            },
         )

app/models/dtos.py

@@ -24,7 +24,7 @@ class Template(BaseModel):
         content: str
 
     template: Template
-    preferred_model: LLMModel = Field(..., alias="preferredModel")
+    preferred_model: str = Field(..., alias="preferredModel")
     parameters: dict
 
 

app/routes/messages.py

@@ -1,9 +1,16 @@
 from fastapi import APIRouter, Depends
 from datetime import datetime, timezone
 
-from app.core.custom_exceptions import BadDataException
+from parsimonious.exceptions import IncompleteParseError
+
+from app.core.custom_exceptions import (
+    MissingParameterException,
+    InvalidTemplateException,
+    InternalServerException,
+    InvalidModelException,
+)
 from app.dependencies import PermissionsValidator
-from app.models.dtos import SendMessageRequest, SendMessageResponse
+from app.models.dtos import SendMessageRequest, SendMessageResponse, LLMModel
 from app.services.guidance_wrapper import GuidanceWrapper
 
 router = APIRouter(tags=["messages"])
@@ -13,16 +20,25 @@
     "/api/v1/messages", dependencies=[Depends(PermissionsValidator())]
 )
 def send_message(body: SendMessageRequest) -> SendMessageResponse:
+    try:
+        model = LLMModel(body.preferred_model)
+    except ValueError as e:
+        raise InvalidModelException(str(e))
+
     guidance = GuidanceWrapper(
-        model=body.preferred_model,
+        model=model,
         handlebars=body.template.content,
         parameters=body.parameters,
     )
 
     try:
         content = guidance.query()
-    except (KeyError, ValueError) as e:
-        raise BadDataException(str(e))
+    except KeyError as e:
+        raise MissingParameterException(str(e))
+    except (SyntaxError, IncompleteParseError) as e:
+        raise InvalidTemplateException(str(e))
+    except BaseException as e:
+        raise InternalServerException(str(e))
 
     # Turn content into an array if it's not already
     if not isinstance(content, list):

tests/routes/messages_test.py

@@ -76,15 +76,12 @@ def test_send_message_raise_value_error(test_client, headers, mocker):
         "parameters": {"query": "Some query"},
     }
     response = test_client.post("/api/v1/messages", headers=headers, json=body)
-    assert response.status_code == 422
+    assert response.status_code == 500
     assert response.json() == {
-        "detail": [
-            {
-                "loc": [],
-                "msg": "value error message",
-                "type": "value_error.bad_data",
-            }
-        ]
+        "detail": {
+            "type": "other",
+            "errorMessage": "value error message",
+        }
     }
 
 
@@ -101,26 +98,29 @@ def test_send_message_raise_key_error(test_client, headers, mocker):
         "parameters": {"query": "Some query"},
     }
     response = test_client.post("/api/v1/messages", headers=headers, json=body)
-    assert response.status_code == 422
+    assert response.status_code == 400
     assert response.json() == {
-        "detail": [
-            {
-                "loc": [],
-                "msg": "'key error message'",
-                "type": "value_error.bad_data",
-            }
-        ]
+        "detail": {
+            "type": "missing_parameter",
+            "errorMessage": "'key error message'",
+        }
     }
 
 
 def test_send_message_with_wrong_api_key(test_client):
     headers = {"Authorization": "wrong api key"}
     response = test_client.post("/api/v1/messages", headers=headers, json={})
     assert response.status_code == 403
-    assert response.json()["detail"] == "Permission denied"
+    assert response.json()["detail"] == {
+        "type": "not_authorized",
+        "errorMessage": "Permission denied",
+    }
 
 
 def test_send_message_without_authorization_header(test_client):
     response = test_client.post("/api/v1/messages", json={})
     assert response.status_code == 401
-    assert response.json()["detail"] == "Requires authentication"
+    assert response.json()["detail"] == {
+        "type": "not_authenticated",
+        "errorMessage": "Requires authentication",
+    }