chore: pr feedback

Signed-off-by: Ion Koutsouris <[email protected]>

Author: ion-elgreco

pydantic_ai_slim/pydantic_ai/fastapi/agent_router.py

@@ -1,30 +1,25 @@
-import logging
 from typing import Any
 
 try:
     from fastapi import APIRouter, HTTPException
     from fastapi.responses import StreamingResponse
-    from openai.types import ErrorObject
     from openai.types.chat.chat_completion import ChatCompletion
     from openai.types.model import Model
-    from openai.types.responses import Response
+    from openai.types.responses import Response as OpenAIResponse
 except ImportError as _import_error:  # pragma: no cover
     raise ImportError(
-        'Please install the `openai` package to enable the fastapi openai compatible endpoint, '
-        'you can use the `openai` and `fastapi` optional group — `pip install "pydantic-ai-slim[openai,fastapi]"`'
+        'Please install the `openai` and `fastapi` packages to enable the fastapi openai compatible endpoint, '
+        'you can use the `chat-completion` optional group — `pip install "pydantic-ai-slim[chat-completion]"`'
     ) from _import_error
 
 from pydantic_ai.fastapi.api import AgentChatCompletionsAPI, AgentModelsAPI, AgentResponsesAPI
 from pydantic_ai.fastapi.data_models import (
     ChatCompletionRequest,
-    ErrorResponse,
     ModelsResponse,
     ResponsesRequest,
 )
 from pydantic_ai.fastapi.registry import AgentRegistry
 
-logger = logging.getLogger(__name__)
-
 
 class AgentAPIRouter(APIRouter):
     """FastAPI Router for Pydantic Agent."""
@@ -34,8 +29,8 @@ def __init__(
         agent_registry: AgentRegistry,
         disable_response_api: bool = False,
         disable_completions_api: bool = False,
-        *args: tuple[Any],
-        **kwargs: tuple[Any],
+        *args: Any,
+        **kwargs: Any,
     ):
         super().__init__(*args, **kwargs)
         self.registry = agent_registry
@@ -48,118 +43,42 @@ def __init__(
         # Registers OpenAI/v1 API routes
         self._register_routes()
 
-    def _register_routes(self) -> None:  # noqa: C901
+    def _register_routes(self) -> None:
         if self.enable_completions_api:
 
-            @self.post(
-                '/v1/chat/completions',
-                response_model=ChatCompletion,
-            )
-            async def chat_completions(  # type: ignore
+            @self.post('/v1/chat/completions', response_model=ChatCompletion)
+            async def chat_completions(
                 request: ChatCompletionRequest,
             ) -> ChatCompletion | StreamingResponse:
-                if not request.messages:
-                    raise HTTPException(
-                        status_code=400,
-                        detail=ErrorResponse(
-                            error=ErrorObject(
-                                type='invalid_request_error',
-                                message='Messages cannot be empty',
-                            ),
-                        ).model_dump(),
-                    )
-                try:
-                    if getattr(request, 'stream', False):
-                        return StreamingResponse(
-                            self.completions_api.create_streaming_completion(request),
-                            media_type='text/event-stream',
-                            headers={
-                                'Cache-Control': 'no-cache',
-                                'Connection': 'keep-alive',
-                                'Content-Type': 'text/plain; charset=utf-8',
-                            },
-                        )
-                    else:
-                        return await self.completions_api.create_completion(request)
-                except Exception as e:
-                    logger.error(f'Error in chat completion: {e}', exc_info=True)
-                    raise HTTPException(
-                        status_code=500,
-                        detail=ErrorResponse(
-                            error=ErrorObject(
-                                type='internal_server_error',
-                                message=str(e),
-                            ),
-                        ).model_dump(),
+                if getattr(request, 'stream', False):
+                    return StreamingResponse(
+                        self.completions_api.create_streaming_completion(request),
+                        media_type='text/event-stream',
+                        headers={
+                            'Cache-Control': 'no-cache',
+                            'Connection': 'keep-alive',
+                            'Content-Type': 'text/plain; charset=utf-8',
+                        },
                     )
+                else:
+                    return await self.completions_api.create_completion(request)
 
         if self.enable_responses_api:
 
-            @self.post(
-                '/v1/responses',
-                response_model=Response,
-            )
-            async def responses(  # type: ignore
+            @self.post('/v1/responses', response_model=OpenAIResponse)
+            async def responses(
                 request: ResponsesRequest,
-            ) -> Response:
-                if not request.input:
-                    raise HTTPException(
-                        status_code=400,
-                        detail=ErrorResponse(
-                            error=ErrorObject(
-                                type='invalid_request_error',
-                                message='Messages cannot be empty',
-                            ),
-                        ).model_dump(),
-                    )
-                try:
-                    if getattr(request, 'stream', False):
-                        # TODO: add streaming support for responses api
-                        raise HTTPException(status_code=501)
-                    else:
-                        return await self.responses_api.create_response(request)
-                except Exception as e:
-                    logger.error(f'Error in responses: {e}', exc_info=True)
-                    raise HTTPException(
-                        status_code=500,
-                        detail=ErrorResponse(
-                            error=ErrorObject(
-                                type='internal_server_error',
-                                message=str(e),
-                            ),
-                        ).model_dump(),
-                    )
+            ) -> OpenAIResponse:
+                if getattr(request, 'stream', False):
+                    # TODO: add streaming support for responses api
+                    raise HTTPException(status_code=501)
+                else:
+                    return await self.responses_api.create_response(request)
 
         @self.get('/v1/models', response_model=ModelsResponse)
-        async def get_models() -> ModelsResponse:  # type: ignore
-            try:
-                return await self.models_api.list_models()
-            except Exception as e:
-                logger.error(f'Error listing models: {e}', exc_info=True)
-                raise HTTPException(
-                    status_code=500,
-                    detail=ErrorResponse(
-                        error=ErrorObject(
-                            type='internal_server_error',
-                            message=f'Error retrieving models: {str(e)}',
-                        ),
-                    ).model_dump(),
-                )
+        async def get_models() -> ModelsResponse:
+            return await self.models_api.list_models()
 
         @self.get('/v1/models' + '/{model_id}', response_model=Model)
-        async def get_model(model_id: str) -> Model:  # type: ignore
-            try:
-                return await self.models_api.get_model(model_id)
-            except HTTPException:
-                raise
-            except Exception as e:
-                logger.error(f'Error fetching model info: {e}', exc_info=True)
-                raise HTTPException(
-                    status_code=500,
-                    detail=ErrorResponse(
-                        error=ErrorObject(
-                            type='internal_server_error',
-                            message=f'Error retrieving model: {str(e)}',
-                        ),
-                    ).model_dump(),
-                )
+        async def get_model(model_id: str) -> Model:
+            return await self.models_api.get_model(model_id)

pydantic_ai_slim/pydantic_ai/fastapi/api/completions.py

@@ -1,5 +1,4 @@
 import json
-import logging
 import time
 from collections.abc import AsyncGenerator
 from typing import Any
@@ -11,8 +10,8 @@
     from openai.types.chat.chat_completion_chunk import ChatCompletionChunk, Choice as Chunkhoice, ChoiceDelta
 except ImportError as _import_error:  # pragma: no cover
     raise ImportError(
-        'Please install the `openai` package to enable the fastapi openai compatible endpoint, '
-        'you can use the `openai` and `fastapi` optional group — `pip install "pydantic-ai-slim[openai,fastapi]"`'
+        'Please install the `openai` and `fastapi` packages to enable the fastapi openai compatible endpoint, '
+        'you can use the `chat-completion` optional group — `pip install "pydantic-ai-slim[chat-completion]"`'
     ) from _import_error
 
 from pydantic import TypeAdapter
@@ -26,8 +25,6 @@
 from pydantic_ai.fastapi.registry import AgentRegistry
 from pydantic_ai.settings import ModelSettings
 
-logger = logging.getLogger(__name__)
-
 
 class AgentChatCompletionsAPI:
     """Chat completions API openai <-> pydantic-ai conversion."""
@@ -60,23 +57,18 @@ async def create_completion(self, request: ChatCompletionRequest) -> ChatComplet
         model_settings_ta = TypeAdapter(ModelSettings)
         messages = openai_chat_completions_2pai(messages=request.messages)
 
-        try:
-            async with agent:
-                result = await agent.run(
-                    message_history=messages,
-                    model_settings=model_settings_ta.validate_python(
-                        {k: v for k, v in request.model_dump().items() if v is not None},
-                    ),
-                )
-
-            return pai_result_to_openai_completions(
-                result=result,
-                model=model_name,
+        async with agent:
+            result = await agent.run(
+                message_history=messages,
+                model_settings=model_settings_ta.validate_python(
+                    {k: v for k, v in request.model_dump().items() if v is not None},
+                ),
             )
 
-        except Exception as e:
-            logger.error(f'Error creating completion: {e}')
-            raise
+        return pai_result_to_openai_completions(
+            result=result,
+            model=model_name,
+        )
 
     async def create_streaming_completion(self, request: ChatCompletionRequest) -> AsyncGenerator[str]:
         """Create a streaming chat completion."""

pydantic_ai_slim/pydantic_ai/fastapi/api/models.py

@@ -1,4 +1,3 @@
-import logging
 import time
 
 try:
@@ -7,8 +6,8 @@
     from openai.types.model import Model
 except ImportError as _import_error:  # pragma: no cover
     raise ImportError(
-        'Please install the `openai` package to enable the fastapi openai compatible endpoint, '
-        'you can use the `openai` and `fastapi` optional group — `pip install "pydantic-ai-slim[openai,fastapi]"`'
+        'Please install the `openai` and `fastapi` packages to enable the fastapi openai compatible endpoint, '
+        'you can use the `chat-completion` optional group — `pip install "pydantic-ai-slim[chat-completion]"`'
     ) from _import_error
 
 from pydantic_ai.fastapi.data_models import (
@@ -17,8 +16,6 @@
 )
 from pydantic_ai.fastapi.registry import AgentRegistry
 
-logger = logging.getLogger(__name__)
-
 
 class AgentModelsAPI:
     """Models API for pydantic-ai agents."""

pydantic_ai_slim/pydantic_ai/fastapi/api/responses.py

@@ -1,4 +1,3 @@
-import logging
 from collections.abc import AsyncGenerator
 
 try:
@@ -7,8 +6,8 @@
     from openai.types.responses import Response
 except ImportError as _import_error:  # pragma: no cover
     raise ImportError(
-        'Please install the `openai` package to enable the fastapi openai compatible endpoint, '
-        'you can use the `openai` and `fastapi` optional group — `pip install "pydantic-ai-slim[openai,fastapi]"`'
+        'Please install the `openai` and `fastapi` packages to enable the fastapi openai compatible endpoint, '
+        'you can use the `chat-completion` optional group — `pip install "pydantic-ai-slim[chat-completion]"`'
     ) from _import_error
 
 from pydantic_ai import Agent
@@ -22,8 +21,6 @@
     OpenAIResponsesModelSettings,
 )
 
-logger = logging.getLogger(__name__)
-
 
 class AgentResponsesAPI:
     """Responses API openai <-> pydantic-ai conversion."""
@@ -56,19 +53,15 @@ async def create_response(self, request: ResponsesRequest) -> Response:
         model_settings = OpenAIResponsesModelSettings(openai_previous_response_id='auto')
         messages = openai_responses_input_to_pai(items=request.input)
 
-        try:
-            async with agent:
-                result = await agent.run(
-                    message_history=messages,
-                    model_settings=model_settings,
-                )
-            return pai_result_to_openai_responses(
-                result=result,
-                model=model_name,
+        async with agent:
+            result = await agent.run(
+                message_history=messages,
+                model_settings=model_settings,
             )
-        except Exception as e:
-            logger.error(f'Error creating completion: {e}')
-            raise
+        return pai_result_to_openai_responses(
+            result=result,
+            model=model_name,
+        )
 
     async def create_streaming_response(self, request: ResponsesRequest) -> AsyncGenerator[str]:
         """Create a streaming chat completion."""

pydantic_ai_slim/pydantic_ai/fastapi/convert/convert_messages.py

@@ -21,8 +21,8 @@
     from openai.types.responses.response_usage import InputTokensDetails, OutputTokensDetails
 except ImportError as _import_error:  # pragma: no cover
     raise ImportError(
-        'Please install the `openai` package to enable the fastapi openai compatible endpoint, '
-        'you can use the `openai` and `fastapi` optional group — `pip install "pydantic-ai-slim[openai,fastapi]"`'
+        'Please install the `openai` and `fastapi` packages to enable the fastapi openai compatible endpoint, '
+        'you can use the `chat-completion` optional group — `pip install "pydantic-ai-slim[chat-completion]"`'
     ) from _import_error
 
 from pydantic import TypeAdapter

pydantic_ai_slim/pydantic_ai/fastapi/data_models/models.py

@@ -22,8 +22,8 @@
     )
 except ImportError as _import_error:  # pragma: no cover
     raise ImportError(
-        'Please install the `openai` package to enable the fastapi openai compatible endpoint, '
-        'you can use the `openai` and `fastapi` optional group — `pip install "pydantic-ai-slim[openai,fastapi]"`'
+        'Please install the `openai` and `fastapi` packages to enable the fastapi openai compatible endpoint, '
+        'you can use the `chat-completion` optional group — `pip install "pydantic-ai-slim[chat-completion]"`'
     ) from _import_error
 from pydantic import BaseModel, ConfigDict, Field
 

pydantic_ai_slim/pyproject.toml

@@ -68,7 +68,6 @@ dependencies = [
 logfire = ["logfire[httpx]>=3.14.1"]
 # Models
 openai = ["openai>=1.107.2"]
-fastapi = ["fastapi"]
 cohere = ["cohere>=5.18.0; platform_system != 'Emscripten'"]
 vertexai = ["google-auth>=2.36.0", "requests>=2.32.2"]
 google = ["google-genai>=1.46.0"]
@@ -112,6 +111,8 @@ temporal = ["temporalio==1.18.0"]
 dbos = ["dbos>=1.14.0"]
 # Prefect
 prefect = ["prefect>=3.4.21"]
+# Chat completions/responses endpoint
+chat-completion = ["openai>=1.107.2", "fastapi"]
 
 [tool.hatch.metadata]
 allow-direct-references = true

pyproject.toml

@@ -46,7 +46,7 @@ requires-python = ">=3.10"
 
 [tool.hatch.metadata.hooks.uv-dynamic-versioning]
 dependencies = [
-    "pydantic-ai-slim[openai,vertexai,google,groq,anthropic,mistral,cohere,bedrock,huggingface,cli,mcp,fastmcp,evals,ag-ui,retries,temporal,logfire,ui,fastapi]=={{ version }}",
+    "pydantic-ai-slim[openai,vertexai,google,groq,anthropic,mistral,cohere,bedrock,huggingface,cli,mcp,fastmcp,evals,ag-ui,retries,temporal,logfire,ui,chat-completion]=={{ version }}",
 ]
 
 [tool.hatch.metadata.hooks.uv-dynamic-versioning.optional-dependencies]