pydantic-ai-slim 0.0.26__tar.gz → 0.0.27__tar.gz

{pydantic_ai_slim-0.0.26 → pydantic_ai_slim-0.0.27}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai-slim
-Version: 0.0.26
+Version: 0.0.27
 Summary: Agent Framework / shim to use Pydantic with LLMs, slim package
 Author-email: Samuel Colvin <samuel@pydantic.dev>
 License-Expression: MIT
@@ -25,10 +25,11 @@ Classifier: Topic :: Internet
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.9
 Requires-Dist: eval-type-backport>=0.2.0
+Requires-Dist: exceptiongroup; python_version < '3.11'
 Requires-Dist: griffe>=1.3.2
 Requires-Dist: httpx>=0.27
 Requires-Dist: logfire-api>=1.2.0
-Requires-Dist: pydantic-graph==0.0.26
+Requires-Dist: pydantic-graph==0.0.27
 Requires-Dist: pydantic>=2.10
 Provides-Extra: anthropic
 Requires-Dist: anthropic>=0.40.0; extra == 'anthropic'

{pydantic_ai_slim-0.0.26 → pydantic_ai_slim-0.0.27}/pydantic_ai/__init__.py

@@ -1,7 +1,15 @@
 from importlib.metadata import version
 
 from .agent import Agent, EndStrategy, HandleResponseNode, ModelRequestNode, UserPromptNode, capture_run_messages
-from .exceptions import AgentRunError, ModelRetry, UnexpectedModelBehavior, UsageLimitExceeded, UserError
+from .exceptions import (
+    AgentRunError,
+    FallbackExceptionGroup,
+    ModelHTTPError,
+    ModelRetry,
+    UnexpectedModelBehavior,
+    UsageLimitExceeded,
+    UserError,
+)
 from .messages import AudioUrl, BinaryContent, ImageUrl
 from .tools import RunContext, Tool
 
@@ -17,6 +25,8 @@ __all__ = (
     # exceptions
     'AgentRunError',
     'ModelRetry',
+    'ModelHTTPError',
+    'FallbackExceptionGroup',
     'UnexpectedModelBehavior',
     'UsageLimitExceeded',
     'UserError',

{pydantic_ai_slim-0.0.26 → pydantic_ai_slim-0.0.27}/pydantic_ai/agent.py

@@ -365,7 +365,7 @@ class Agent(Generic[AgentDepsT, ResultDataT]):
                 HandleResponseNode(
                     model_response=ModelResponse(
                         parts=[TextPart(content='Paris', part_kind='text')],
-                        model_name='function:model_logic',
+                        model_name='gpt-4o',
                         timestamp=datetime.datetime(...),
                         kind='response',
                     )
@@ -1214,7 +1214,7 @@ class AgentRun(Generic[AgentDepsT, ResultDataT]):
             HandleResponseNode(
                 model_response=ModelResponse(
                     parts=[TextPart(content='Paris', part_kind='text')],
-                    model_name='function:model_logic',
+                    model_name='gpt-4o',
                     timestamp=datetime.datetime(...),
                     kind='response',
                 )
@@ -1357,7 +1357,7 @@ class AgentRun(Generic[AgentDepsT, ResultDataT]):
                     HandleResponseNode(
                         model_response=ModelResponse(
                             parts=[TextPart(content='Paris', part_kind='text')],
-                            model_name='function:model_logic',
+                            model_name='gpt-4o',
                             timestamp=datetime.datetime(...),
                             kind='response',
                         )

{pydantic_ai_slim-0.0.26 → pydantic_ai_slim-0.0.27}/pydantic_ai/exceptions.py

@@ -1,8 +1,22 @@
 from __future__ import annotations as _annotations
 
 import json
+import sys
 
-__all__ = 'ModelRetry', 'UserError', 'AgentRunError', 'UnexpectedModelBehavior', 'UsageLimitExceeded'
+if sys.version_info < (3, 11):
+    from exceptiongroup import ExceptionGroup
+else:
+    ExceptionGroup = ExceptionGroup
+
+__all__ = (
+    'ModelRetry',
+    'UserError',
+    'AgentRunError',
+    'UnexpectedModelBehavior',
+    'UsageLimitExceeded',
+    'ModelHTTPError',
+    'FallbackExceptionGroup',
+)
 
 
 class ModelRetry(Exception):
@@ -72,3 +86,30 @@ class UnexpectedModelBehavior(AgentRunError):
             return f'{self.message}, body:\n{self.body}'
         else:
             return self.message
+
+
+class ModelHTTPError(AgentRunError):
+    """Raised when an model provider response has a status code of 4xx or 5xx."""
+
+    status_code: int
+    """The HTTP status code returned by the API."""
+
+    model_name: str
+    """The name of the model associated with the error."""
+
+    body: object | None
+    """The body of the response, if available."""
+
+    message: str
+    """The error message with the status code and response body, if available."""
+
+    def __init__(self, status_code: int, model_name: str, body: object | None = None):
+        self.status_code = status_code
+        self.model_name = model_name
+        self.body = body
+        message = f'status_code: {status_code}, model_name: {model_name}, body: {body}'
+        super().__init__(message)
+
+
+class FallbackExceptionGroup(ExceptionGroup):
+    """A group of exceptions that can be raised when all fallback models fail."""

{pydantic_ai_slim-0.0.26 → pydantic_ai_slim-0.0.27}/pydantic_ai/models/anthropic.py

@@ -11,7 +11,7 @@ from typing import Any, Literal, Union, cast, overload
 from httpx import AsyncClient as AsyncHTTPClient
 from typing_extensions import assert_never
 
-from .. import UnexpectedModelBehavior, _utils, usage
+from .. import ModelHTTPError, UnexpectedModelBehavior, _utils, usage
 from .._utils import guard_tool_call_id as _guard_tool_call_id
 from ..messages import (
     BinaryContent,
@@ -39,7 +39,7 @@ from . import (
 )
 
 try:
-    from anthropic import NOT_GIVEN, AsyncAnthropic, AsyncStream
+    from anthropic import NOT_GIVEN, APIStatusError, AsyncAnthropic, AsyncStream
     from anthropic.types import (
         ImageBlockParam,
         Message as AnthropicMessage,
@@ -220,19 +220,24 @@ class AnthropicModel(Model):
 
         system_prompt, anthropic_messages = await self._map_message(messages)
 
-        return await self.client.messages.create(
-            max_tokens=model_settings.get('max_tokens', 1024),
-            system=system_prompt or NOT_GIVEN,
-            messages=anthropic_messages,
-            model=self._model_name,
-            tools=tools or NOT_GIVEN,
-            tool_choice=tool_choice or NOT_GIVEN,
-            stream=stream,
-            temperature=model_settings.get('temperature', NOT_GIVEN),
-            top_p=model_settings.get('top_p', NOT_GIVEN),
-            timeout=model_settings.get('timeout', NOT_GIVEN),
-            metadata=model_settings.get('anthropic_metadata', NOT_GIVEN),
-        )
+        try:
+            return await self.client.messages.create(
+                max_tokens=model_settings.get('max_tokens', 1024),
+                system=system_prompt or NOT_GIVEN,
+                messages=anthropic_messages,
+                model=self._model_name,
+                tools=tools or NOT_GIVEN,
+                tool_choice=tool_choice or NOT_GIVEN,
+                stream=stream,
+                temperature=model_settings.get('temperature', NOT_GIVEN),
+                top_p=model_settings.get('top_p', NOT_GIVEN),
+                timeout=model_settings.get('timeout', NOT_GIVEN),
+                metadata=model_settings.get('anthropic_metadata', NOT_GIVEN),
+            )
+        except APIStatusError as e:
+            if (status_code := e.status_code) >= 400:
+                raise ModelHTTPError(status_code=status_code, model_name=self.model_name, body=e.body) from e
+            raise
 
     def _process_response(self, response: AnthropicMessage) -> ModelResponse:
         """Process a non-streamed response, and prepare a message to return."""

{pydantic_ai_slim-0.0.26 → pydantic_ai_slim-0.0.27}/pydantic_ai/models/cohere.py

@@ -9,7 +9,7 @@ from cohere import TextAssistantMessageContentItem
 from httpx import AsyncClient as AsyncHTTPClient
 from typing_extensions import assert_never
 
-from .. import result
+from .. import ModelHTTPError, result
 from .._utils import guard_tool_call_id as _guard_tool_call_id
 from ..messages import (
     ModelMessage,
@@ -45,6 +45,7 @@ try:
         ToolV2Function,
         UserChatMessageV2,
     )
+    from cohere.core.api_error import ApiError
     from cohere.v2.client import OMIT
 except ImportError as _import_error:
     raise ImportError(
@@ -154,17 +155,22 @@ class CohereModel(Model):
     ) -> ChatResponse:
         tools = self._get_tools(model_request_parameters)
         cohere_messages = list(chain(*(self._map_message(m) for m in messages)))
-        return await self.client.chat(
-            model=self._model_name,
-            messages=cohere_messages,
-            tools=tools or OMIT,
-            max_tokens=model_settings.get('max_tokens', OMIT),
-            temperature=model_settings.get('temperature', OMIT),
-            p=model_settings.get('top_p', OMIT),
-            seed=model_settings.get('seed', OMIT),
-            presence_penalty=model_settings.get('presence_penalty', OMIT),
-            frequency_penalty=model_settings.get('frequency_penalty', OMIT),
-        )
+        try:
+            return await self.client.chat(
+                model=self._model_name,
+                messages=cohere_messages,
+                tools=tools or OMIT,
+                max_tokens=model_settings.get('max_tokens', OMIT),
+                temperature=model_settings.get('temperature', OMIT),
+                p=model_settings.get('top_p', OMIT),
+                seed=model_settings.get('seed', OMIT),
+                presence_penalty=model_settings.get('presence_penalty', OMIT),
+                frequency_penalty=model_settings.get('frequency_penalty', OMIT),
+            )
+        except ApiError as e:
+            if (status_code := e.status_code) and status_code >= 400:
+                raise ModelHTTPError(status_code=status_code, model_name=self.model_name, body=e.body) from e
+            raise
 
     def _process_response(self, response: ChatResponse) -> ModelResponse:
         """Process a non-streamed response, and prepare a message to return."""

pydantic_ai_slim-0.0.27/pydantic_ai/models/fallback.py

@@ -0,0 +1,116 @@
+from __future__ import annotations as _annotations
+
+from collections.abc import AsyncIterator
+from contextlib import AsyncExitStack, asynccontextmanager
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Callable
+
+from ..exceptions import FallbackExceptionGroup, ModelHTTPError
+from . import KnownModelName, Model, ModelRequestParameters, StreamedResponse, infer_model
+
+if TYPE_CHECKING:
+    from ..messages import ModelMessage, ModelResponse
+    from ..settings import ModelSettings
+    from ..usage import Usage
+
+
+@dataclass(init=False)
+class FallbackModel(Model):
+    """A model that uses one or more fallback models upon failure.
+
+    Apart from `__init__`, all methods are private or match those of the base class.
+    """
+
+    models: list[Model]
+
+    _model_name: str = field(repr=False)
+    _fallback_on: Callable[[Exception], bool]
+
+    def __init__(
+        self,
+        default_model: Model | KnownModelName,
+        *fallback_models: Model | KnownModelName,
+        fallback_on: Callable[[Exception], bool] | tuple[type[Exception], ...] = (ModelHTTPError,),
+    ):
+        """Initialize a fallback model instance.
+
+        Args:
+            default_model: The name or instance of the default model to use.
+            fallback_models: The names or instances of the fallback models to use upon failure.
+            fallback_on: A callable or tuple of exceptions that should trigger a fallback.
+        """
+        self.models = [infer_model(default_model), *[infer_model(m) for m in fallback_models]]
+        self._model_name = f'FallBackModel[{", ".join(model.model_name for model in self.models)}]'
+
+        if isinstance(fallback_on, tuple):
+            self._fallback_on = _default_fallback_condition_factory(fallback_on)
+        else:
+            self._fallback_on = fallback_on
+
+    async def request(
+        self,
+        messages: list[ModelMessage],
+        model_settings: ModelSettings | None,
+        model_request_parameters: ModelRequestParameters,
+    ) -> tuple[ModelResponse, Usage]:
+        """Try each model in sequence until one succeeds.
+
+        In case of failure, raise a FallbackExceptionGroup with all exceptions.
+        """
+        exceptions: list[Exception] = []
+
+        for model in self.models:
+            try:
+                return await model.request(messages, model_settings, model_request_parameters)
+            except Exception as exc:
+                if self._fallback_on(exc):
+                    exceptions.append(exc)
+                    continue
+                raise exc
+
+        raise FallbackExceptionGroup('All models from FallbackModel failed', exceptions)
+
+    @asynccontextmanager
+    async def request_stream(
+        self,
+        messages: list[ModelMessage],
+        model_settings: ModelSettings | None,
+        model_request_parameters: ModelRequestParameters,
+    ) -> AsyncIterator[StreamedResponse]:
+        """Try each model in sequence until one succeeds."""
+        exceptions: list[Exception] = []
+
+        for model in self.models:
+            async with AsyncExitStack() as stack:
+                try:
+                    response = await stack.enter_async_context(
+                        model.request_stream(messages, model_settings, model_request_parameters)
+                    )
+                except Exception as exc:
+                    if self._fallback_on(exc):
+                        exceptions.append(exc)
+                        continue
+                    raise exc
+                yield response
+                return
+
+        raise FallbackExceptionGroup('All models from FallbackModel failed', exceptions)
+
+    @property
+    def model_name(self) -> str:
+        """The model name."""
+        return self._model_name
+
+    @property
+    def system(self) -> str | None:
+        """The system / model provider, n/a for fallback models."""
+        return None
+
+
+def _default_fallback_condition_factory(exceptions: tuple[type[Exception], ...]) -> Callable[[Exception], bool]:
+    """Create a default fallback condition for the given exceptions."""
+
+    def fallback_condition(exception: Exception) -> bool:
+        return isinstance(exception, exceptions)
+
+    return fallback_condition

{pydantic_ai_slim-0.0.26 → pydantic_ai_slim-0.0.27}/pydantic_ai/models/function.py

@@ -48,15 +48,23 @@ class FunctionModel(Model):
     _system: str | None = field(default=None, repr=False)
 
     @overload
-    def __init__(self, function: FunctionDef) -> None: ...
+    def __init__(self, function: FunctionDef, *, model_name: str | None = None) -> None: ...
 
     @overload
-    def __init__(self, *, stream_function: StreamFunctionDef) -> None: ...
+    def __init__(self, *, stream_function: StreamFunctionDef, model_name: str | None = None) -> None: ...
 
     @overload
-    def __init__(self, function: FunctionDef, *, stream_function: StreamFunctionDef) -> None: ...
+    def __init__(
+        self, function: FunctionDef, *, stream_function: StreamFunctionDef, model_name: str | None = None
+    ) -> None: ...
 
-    def __init__(self, function: FunctionDef | None = None, *, stream_function: StreamFunctionDef | None = None):
+    def __init__(
+        self,
+        function: FunctionDef | None = None,
+        *,
+        stream_function: StreamFunctionDef | None = None,
+        model_name: str | None = None,
+    ):
         """Initialize a `FunctionModel`.
 
         Either `function` or `stream_function` must be provided, providing both is allowed.
@@ -64,6 +72,7 @@ class FunctionModel(Model):
         Args:
             function: The function to call for non-streamed requests.
             stream_function: The function to call for streamed requests.
+            model_name: The name of the model. If not provided, a name is generated from the function names.
         """
         if function is None and stream_function is None:
             raise TypeError('Either `function` or `stream_function` must be provided')
@@ -72,7 +81,7 @@ class FunctionModel(Model):
 
         function_name = self.function.__name__ if self.function is not None else ''
         stream_function_name = self.stream_function.__name__ if self.stream_function is not None else ''
-        self._model_name = f'function:{function_name}:{stream_function_name}'
+        self._model_name = model_name or f'function:{function_name}:{stream_function_name}'
 
     async def request(
         self,
@@ -95,7 +104,7 @@ class FunctionModel(Model):
             response_ = await _utils.run_in_executor(self.function, messages, agent_info)
             assert isinstance(response_, ModelResponse), response_
             response = response_
-        response.model_name = f'function:{self.function.__name__}'
+        response.model_name = self._model_name
         # TODO is `messages` right here? Should it just be new messages?
         return response, _estimate_usage(chain(messages, [response]))
 
@@ -123,7 +132,7 @@ class FunctionModel(Model):
         if isinstance(first, _utils.Unset):
             raise ValueError('Stream function must return at least one item')
 
-        yield FunctionStreamedResponse(_model_name=f'function:{self.stream_function.__name__}', _iter=response_stream)
+        yield FunctionStreamedResponse(_model_name=self._model_name, _iter=response_stream)
 
     @property
     def model_name(self) -> str:

{pydantic_ai_slim-0.0.26 → pydantic_ai_slim-0.0.27}/pydantic_ai/models/gemini.py

@@ -15,7 +15,7 @@ import pydantic
 from httpx import USE_CLIENT_DEFAULT, AsyncClient as AsyncHTTPClient, Response as HTTPResponse
 from typing_extensions import NotRequired, TypedDict, assert_never
 
-from .. import UnexpectedModelBehavior, _utils, exceptions, usage
+from .. import ModelHTTPError, UnexpectedModelBehavior, UserError, _utils, usage
 from ..messages import (
     AudioUrl,
     BinaryContent,
@@ -112,7 +112,7 @@ class GeminiModel(Model):
             if env_api_key := os.getenv('GEMINI_API_KEY'):
                 api_key = env_api_key
             else:
-                raise exceptions.UserError('API key must be provided or set in the GEMINI_API_KEY environment variable')
+                raise UserError('API key must be provided or set in the GEMINI_API_KEY environment variable')
         self.http_client = http_client or cached_async_http_client()
         self._auth = ApiKeyAuth(api_key)
         self._url = url_template.format(model=model_name)
@@ -233,9 +233,11 @@ class GeminiModel(Model):
             headers=headers,
             timeout=model_settings.get('timeout', USE_CLIENT_DEFAULT),
         ) as r:
-            if r.status_code != 200:
+            if (status_code := r.status_code) != 200:
                 await r.aread()
-                raise exceptions.UnexpectedModelBehavior(f'Unexpected response from gemini {r.status_code}', r.text)
+                if status_code >= 400:
+                    raise ModelHTTPError(status_code=status_code, model_name=self.model_name, body=r.text)
+                raise UnexpectedModelBehavior(f'Unexpected response from gemini {status_code}', r.text)
             yield r
 
     def _process_response(self, response: _GeminiResponse) -> ModelResponse:
@@ -318,10 +320,14 @@ class GeminiModel(Model):
                     content.append({'text': item})
                 elif isinstance(item, BinaryContent):
                     base64_encoded = base64.b64encode(item.data).decode('utf-8')
-                    content.append(_GeminiInlineDataPart(data=base64_encoded, mime_type=item.media_type))
+                    content.append(
+                        _GeminiInlineDataPart(inline_data={'data': base64_encoded, 'mime_type': item.media_type})
+                    )
                 elif isinstance(item, (AudioUrl, ImageUrl)):
                     try:
-                        content.append(_GeminiFileDataData(file_uri=item.url, mime_type=item.media_type))
+                        content.append(
+                            _GeminiFileDataPart(file_data={'file_uri': item.url, 'mime_type': item.media_type})
+                        )
                     except ValueError:
                         # Download the file if can't find the mime type.
                         client = cached_async_http_client()
@@ -329,7 +335,9 @@ class GeminiModel(Model):
                         response.raise_for_status()
                         base64_encoded = base64.b64encode(response.content).decode('utf-8')
                         content.append(
-                            _GeminiInlineDataPart(data=base64_encoded, mime_type=response.headers['Content-Type'])
+                            _GeminiInlineDataPart(
+                                inline_data={'data': base64_encoded, 'mime_type': response.headers['Content-Type']}
+                            )
                         )
                 else:
                     assert_never(item)
@@ -526,20 +534,28 @@ class _GeminiTextPart(TypedDict):
     text: str
 
 
+class _GeminiInlineData(TypedDict):
+    data: str
+    mime_type: Annotated[str, pydantic.Field(alias='mimeType')]
+
+
 class _GeminiInlineDataPart(TypedDict):
     """See <https://ai.google.dev/api/caching#Blob>."""
 
-    data: str
-    mime_type: Annotated[str, pydantic.Field(alias='mimeType')]
+    inline_data: Annotated[_GeminiInlineData, pydantic.Field(alias='inlineData')]
 
 
-class _GeminiFileDataData(TypedDict):
+class _GeminiFileData(TypedDict):
     """See <https://ai.google.dev/api/caching#FileData>."""
 
     file_uri: Annotated[str, pydantic.Field(alias='fileUri')]
     mime_type: Annotated[str, pydantic.Field(alias='mimeType')]
 
 
+class _GeminiFileDataPart(TypedDict):
+    file_data: Annotated[_GeminiFileData, pydantic.Field(alias='fileData')]
+
+
 class _GeminiFunctionCallPart(TypedDict):
     function_call: Annotated[_GeminiFunctionCall, pydantic.Field(alias='functionCall')]
 
@@ -563,7 +579,7 @@ def _process_response_from_parts(
                 )
             )
         elif 'function_response' in part:
-            raise exceptions.UnexpectedModelBehavior(
+            raise UnexpectedModelBehavior(
                 f'Unsupported response from Gemini, expected all parts to be function calls or text, got: {part!r}'
             )
     return ModelResponse(parts=items, model_name=model_name, timestamp=timestamp or _utils.now_utc())
@@ -615,7 +631,7 @@ _GeminiPartUnion = Annotated[
         Annotated[_GeminiFunctionCallPart, pydantic.Tag('function_call')],
         Annotated[_GeminiFunctionResponsePart, pydantic.Tag('function_response')],
         Annotated[_GeminiInlineDataPart, pydantic.Tag('inline_data')],
-        Annotated[_GeminiFileDataData, pydantic.Tag('file_data')],
+        Annotated[_GeminiFileDataPart, pydantic.Tag('file_data')],
     ],
     pydantic.Discriminator(_part_discriminator),
 ]
@@ -778,7 +794,7 @@ class _GeminiJsonSchema:
             # noinspection PyTypeChecker
             key = re.sub(r'^#/\$defs/', '', ref)
             if key in refs_stack:
-                raise exceptions.UserError('Recursive `$ref`s in JSON Schema are not supported by Gemini')
+                raise UserError('Recursive `$ref`s in JSON Schema are not supported by Gemini')
             refs_stack += (key,)
             schema_def = self.defs[key]
             self._simplify(schema_def, refs_stack)
@@ -812,7 +828,7 @@ class _GeminiJsonSchema:
     def _object(self, schema: dict[str, Any], refs_stack: tuple[str, ...]) -> None:
         ad_props = schema.pop('additionalProperties', None)
         if ad_props:
-            raise exceptions.UserError('Additional properties in JSON Schema are not supported by Gemini')
+            raise UserError('Additional properties in JSON Schema are not supported by Gemini')
 
         if properties := schema.get('properties'):  # pragma: no branch
             for value in properties.values():

{pydantic_ai_slim-0.0.26 → pydantic_ai_slim-0.0.27}/pydantic_ai/models/groq.py

@@ -11,7 +11,7 @@ from typing import Literal, Union, cast, overload
 from httpx import AsyncClient as AsyncHTTPClient
 from typing_extensions import assert_never
 
-from .. import UnexpectedModelBehavior, _utils, usage
+from .. import ModelHTTPError, UnexpectedModelBehavior, _utils, usage
 from .._utils import guard_tool_call_id as _guard_tool_call_id
 from ..messages import (
     BinaryContent,
@@ -39,7 +39,7 @@ from . import (
 )
 
 try:
-    from groq import NOT_GIVEN, AsyncGroq, AsyncStream
+    from groq import NOT_GIVEN, APIStatusError, AsyncGroq, AsyncStream
     from groq.types import chat
     from groq.types.chat.chat_completion_content_part_image_param import ImageURL
 except ImportError as _import_error:
@@ -197,23 +197,28 @@ class GroqModel(Model):
 
         groq_messages = list(chain(*(self._map_message(m) for m in messages)))
 
-        return await self.client.chat.completions.create(
-            model=str(self._model_name),
-            messages=groq_messages,
-            n=1,
-            parallel_tool_calls=model_settings.get('parallel_tool_calls', NOT_GIVEN),
-            tools=tools or NOT_GIVEN,
-            tool_choice=tool_choice or NOT_GIVEN,
-            stream=stream,
-            max_tokens=model_settings.get('max_tokens', NOT_GIVEN),
-            temperature=model_settings.get('temperature', NOT_GIVEN),
-            top_p=model_settings.get('top_p', NOT_GIVEN),
-            timeout=model_settings.get('timeout', NOT_GIVEN),
-            seed=model_settings.get('seed', NOT_GIVEN),
-            presence_penalty=model_settings.get('presence_penalty', NOT_GIVEN),
-            frequency_penalty=model_settings.get('frequency_penalty', NOT_GIVEN),
-            logit_bias=model_settings.get('logit_bias', NOT_GIVEN),
-        )
+        try:
+            return await self.client.chat.completions.create(
+                model=str(self._model_name),
+                messages=groq_messages,
+                n=1,
+                parallel_tool_calls=model_settings.get('parallel_tool_calls', NOT_GIVEN),
+                tools=tools or NOT_GIVEN,
+                tool_choice=tool_choice or NOT_GIVEN,
+                stream=stream,
+                max_tokens=model_settings.get('max_tokens', NOT_GIVEN),
+                temperature=model_settings.get('temperature', NOT_GIVEN),
+                top_p=model_settings.get('top_p', NOT_GIVEN),
+                timeout=model_settings.get('timeout', NOT_GIVEN),
+                seed=model_settings.get('seed', NOT_GIVEN),
+                presence_penalty=model_settings.get('presence_penalty', NOT_GIVEN),
+                frequency_penalty=model_settings.get('frequency_penalty', NOT_GIVEN),
+                logit_bias=model_settings.get('logit_bias', NOT_GIVEN),
+            )
+        except APIStatusError as e:
+            if (status_code := e.status_code) >= 400:
+                raise ModelHTTPError(status_code=status_code, model_name=self.model_name, body=e.body) from e
+            raise
 
     def _process_response(self, response: chat.ChatCompletion) -> ModelResponse:
         """Process a non-streamed response, and prepare a message to return."""

{pydantic_ai_slim-0.0.26 → pydantic_ai_slim-0.0.27}/pydantic_ai/models/mistral.py

@@ -13,7 +13,7 @@ import pydantic_core
 from httpx import AsyncClient as AsyncHTTPClient, Timeout
 from typing_extensions import assert_never
 
-from .. import UnexpectedModelBehavior, _utils
+from .. import ModelHTTPError, UnexpectedModelBehavior, _utils
 from .._utils import now_utc as _now_utc
 from ..messages import (
     BinaryContent,
@@ -59,6 +59,7 @@ try:
         ChatCompletionResponse as MistralChatCompletionResponse,
         CompletionEvent as MistralCompletionEvent,
         Messages as MistralMessages,
+        SDKError,
         Tool as MistralTool,
         ToolCall as MistralToolCall,
     )
@@ -184,19 +185,25 @@ class MistralModel(Model):
         model_request_parameters: ModelRequestParameters,
     ) -> MistralChatCompletionResponse:
         """Make a non-streaming request to the model."""
-        response = await self.client.chat.complete_async(
-            model=str(self._model_name),
-            messages=list(chain(*(self._map_message(m) for m in messages))),
-            n=1,
-            tools=self._map_function_and_result_tools_definition(model_request_parameters) or UNSET,
-            tool_choice=self._get_tool_choice(model_request_parameters),
-            stream=False,
-            max_tokens=model_settings.get('max_tokens', UNSET),
-            temperature=model_settings.get('temperature', UNSET),
-            top_p=model_settings.get('top_p', 1),
-            timeout_ms=self._get_timeout_ms(model_settings.get('timeout')),
-            random_seed=model_settings.get('seed', UNSET),
-        )
+        try:
+            response = await self.client.chat.complete_async(
+                model=str(self._model_name),
+                messages=list(chain(*(self._map_message(m) for m in messages))),
+                n=1,
+                tools=self._map_function_and_result_tools_definition(model_request_parameters) or UNSET,
+                tool_choice=self._get_tool_choice(model_request_parameters),
+                stream=False,
+                max_tokens=model_settings.get('max_tokens', UNSET),
+                temperature=model_settings.get('temperature', UNSET),
+                top_p=model_settings.get('top_p', 1),
+                timeout_ms=self._get_timeout_ms(model_settings.get('timeout')),
+                random_seed=model_settings.get('seed', UNSET),
+            )
+        except SDKError as e:
+            if (status_code := e.status_code) >= 400:
+                raise ModelHTTPError(status_code=status_code, model_name=self.model_name, body=e.body) from e
+            raise
+
         assert response, 'A unexpected empty response from Mistral.'
         return response
 

{pydantic_ai_slim-0.0.26 → pydantic_ai_slim-0.0.27}/pydantic_ai/models/openai.py

@@ -11,7 +11,7 @@ from typing import Literal, Union, cast, overload
 from httpx import AsyncClient as AsyncHTTPClient
 from typing_extensions import assert_never
 
-from .. import UnexpectedModelBehavior, _utils, usage
+from .. import ModelHTTPError, UnexpectedModelBehavior, _utils, usage
 from .._utils import guard_tool_call_id as _guard_tool_call_id
 from ..messages import (
     AudioUrl,
@@ -40,7 +40,7 @@ from . import (
 )
 
 try:
-    from openai import NOT_GIVEN, AsyncOpenAI, AsyncStream
+    from openai import NOT_GIVEN, APIStatusError, AsyncOpenAI, AsyncStream
     from openai.types import ChatModel, chat
     from openai.types.chat import (
         ChatCompletionChunk,
@@ -224,25 +224,30 @@ class OpenAIModel(Model):
             async for msg in self._map_message(m):
                 openai_messages.append(msg)
 
-        return await self.client.chat.completions.create(
-            model=self._model_name,
-            messages=openai_messages,
-            n=1,
-            parallel_tool_calls=model_settings.get('parallel_tool_calls', NOT_GIVEN),
-            tools=tools or NOT_GIVEN,
-            tool_choice=tool_choice or NOT_GIVEN,
-            stream=stream,
-            stream_options={'include_usage': True} if stream else NOT_GIVEN,
-            max_tokens=model_settings.get('max_tokens', NOT_GIVEN),
-            temperature=model_settings.get('temperature', NOT_GIVEN),
-            top_p=model_settings.get('top_p', NOT_GIVEN),
-            timeout=model_settings.get('timeout', NOT_GIVEN),
-            seed=model_settings.get('seed', NOT_GIVEN),
-            presence_penalty=model_settings.get('presence_penalty', NOT_GIVEN),
-            frequency_penalty=model_settings.get('frequency_penalty', NOT_GIVEN),
-            logit_bias=model_settings.get('logit_bias', NOT_GIVEN),
-            reasoning_effort=model_settings.get('openai_reasoning_effort', NOT_GIVEN),
-        )
+        try:
+            return await self.client.chat.completions.create(
+                model=self._model_name,
+                messages=openai_messages,
+                n=1,
+                parallel_tool_calls=model_settings.get('parallel_tool_calls', NOT_GIVEN),
+                tools=tools or NOT_GIVEN,
+                tool_choice=tool_choice or NOT_GIVEN,
+                stream=stream,
+                stream_options={'include_usage': True} if stream else NOT_GIVEN,
+                max_tokens=model_settings.get('max_tokens', NOT_GIVEN),
+                temperature=model_settings.get('temperature', NOT_GIVEN),
+                top_p=model_settings.get('top_p', NOT_GIVEN),
+                timeout=model_settings.get('timeout', NOT_GIVEN),
+                seed=model_settings.get('seed', NOT_GIVEN),
+                presence_penalty=model_settings.get('presence_penalty', NOT_GIVEN),
+                frequency_penalty=model_settings.get('frequency_penalty', NOT_GIVEN),
+                logit_bias=model_settings.get('logit_bias', NOT_GIVEN),
+                reasoning_effort=model_settings.get('openai_reasoning_effort', NOT_GIVEN),
+            )
+        except APIStatusError as e:
+            if (status_code := e.status_code) >= 400:
+                raise ModelHTTPError(status_code=status_code, model_name=self.model_name, body=e.body) from e
+            raise
 
     def _process_response(self, response: chat.ChatCompletion) -> ModelResponse:
         """Process a non-streamed response, and prepare a message to return."""

{pydantic_ai_slim-0.0.26 → pydantic_ai_slim-0.0.27}/pyproject.toml

@@ -4,11 +4,9 @@ build-backend = "hatchling.build"
 
 [project]
 name = "pydantic-ai-slim"
-version = "0.0.26"
+version = "0.0.27"
 description = "Agent Framework / shim to use Pydantic with LLMs, slim package"
-authors = [
-    { name = "Samuel Colvin", email = "samuel@pydantic.dev" },
-]
+authors = [{ name = "Samuel Colvin", email = "samuel@pydantic.dev" }]
 license = "MIT"
 readme = "README.md"
 classifiers = [
@@ -39,7 +37,8 @@ dependencies = [
     "httpx>=0.27",
     "logfire-api>=1.2.0",
     "pydantic>=2.10",
-    "pydantic-graph==0.0.26",
+    "pydantic-graph==0.0.27",
+    "exceptiongroup; python_version < '3.11'",
 ]
 
 [project.optional-dependencies]