pydantic-ai-slim 1.0.3__py3-none-any.whl → 1.0.5__py3-none-any.whl

pydantic_ai/_parts_manager.py

@@ -71,6 +71,7 @@ class ModelResponsePartsManager:
         *,
         vendor_part_id: VendorId | None,
         content: str,
+        id: str | None = None,
         thinking_tags: tuple[str, str] | None = None,
         ignore_leading_whitespace: bool = False,
     ) -> ModelResponseStreamEvent | None:
@@ -85,6 +86,7 @@ class ModelResponsePartsManager:
                 of text. If None, a new part will be created unless the latest part is already
                 a TextPart.
             content: The text content to append to the appropriate TextPart.
+            id: An optional id for the text part.
             thinking_tags: If provided, will handle content between the thinking tags as thinking parts.
             ignore_leading_whitespace: If True, will ignore leading whitespace in the content.
 
@@ -137,7 +139,7 @@ class ModelResponsePartsManager:
 
             # There is no existing text part that should be updated, so create a new one
             new_part_index = len(self._parts)
-            part = TextPart(content=content)
+            part = TextPart(content=content, id=id)
             if vendor_part_id is not None:
                 self._vendor_id_to_part_index[vendor_part_id] = new_part_index
             self._parts.append(part)
@@ -198,16 +200,16 @@ class ModelResponsePartsManager:
                 existing_thinking_part_and_index = existing_part, part_index
 
         if existing_thinking_part_and_index is None:
-            if content is not None:
+            if content is not None or signature is not None:
                 # There is no existing thinking part that should be updated, so create a new one
                 new_part_index = len(self._parts)
-                part = ThinkingPart(content=content, id=id, signature=signature, provider_name=provider_name)
+                part = ThinkingPart(content=content or '', id=id, signature=signature, provider_name=provider_name)
                 if vendor_part_id is not None:  # pragma: no branch
                     self._vendor_id_to_part_index[vendor_part_id] = new_part_index
                 self._parts.append(part)
                 return PartStartEvent(index=new_part_index, part=part)
             else:
-                raise UnexpectedModelBehavior('Cannot create a ThinkingPart with no content')
+                raise UnexpectedModelBehavior('Cannot create a ThinkingPart with no content or signature')
         else:
             if content is not None or signature is not None:
                 # Update the existing ThinkingPart with the new content and/or signature delta

pydantic_ai/messages.py

@@ -870,6 +870,9 @@ class TextPart:
 
     _: KW_ONLY
 
+    id: str | None = None
+    """An optional identifier of the text part."""
+
     part_kind: Literal['text'] = 'text'
     """Part type identifier, this is available on all parts as a discriminator."""
 

pydantic_ai/models/__init__.py

@@ -718,7 +718,11 @@ def infer_model(model: Model | KnownModelName | str) -> Model:  # noqa: C901
         )
         provider = 'google-vertex'
 
-    if provider == 'cohere':
+    if provider == 'gateway':
+        from ..providers.gateway import infer_model as infer_model_from_gateway
+
+        return infer_model_from_gateway(model_name)
+    elif provider == 'cohere':
         from .cohere import CohereModel
 
         return CohereModel(model_name, provider=provider)

pydantic_ai/models/anthropic.py

@@ -641,7 +641,6 @@ class AnthropicStreamedResponse(StreamedResponse):
                     yield self._parts_manager.handle_thinking_delta(
                         vendor_part_id=event.index,
                         id='redacted_thinking',
-                        content='',
                         signature=current_block.data,
                         provider_name=self.provider_name,
                     )

pydantic_ai/models/bedrock.py

@@ -681,7 +681,6 @@ class BedrockStreamedResponse(StreamedResponse):
                             yield self._parts_manager.handle_thinking_delta(
                                 vendor_part_id=index,
                                 id='redacted_content',
-                                content='',
                                 signature=redacted_content.decode('utf-8'),
                                 provider_name=self.provider_name,
                             )

pydantic_ai/models/google.py

@@ -596,7 +596,6 @@ class GeminiStreamedResponse(StreamedResponse):
                     signature = base64.b64encode(part.thought_signature).decode('utf-8')
                     yield self._parts_manager.handle_thinking_delta(
                         vendor_part_id='thinking',
-                        content='',  # A thought signature may occur without a preceding thinking part, so we add an empty delta so that a new part can be created
                         signature=signature,
                         provider_name=self.provider_name,
                     )

pydantic_ai/models/mistral.py

@@ -82,7 +82,7 @@ try:
     from mistralai.models.usermessage import UserMessage as MistralUserMessage
     from mistralai.types.basemodel import Unset as MistralUnset
     from mistralai.utils.eventstreaming import EventStreamAsync as MistralEventStreamAsync
-except ImportError as e:
+except ImportError as e:  # pragma: lax no cover
     raise ImportError(
         'Please install `mistral` to use the Mistral model, '
         'you can use the `mistral` optional group — `pip install "pydantic-ai-slim[mistral]"`'

pydantic_ai/models/openai.py

@@ -190,10 +190,19 @@ class OpenAIResponsesModelSettings(OpenAIChatModelSettings, total=False):
     This can be useful for debugging and understanding the model's reasoning process.
     One of `concise` or `detailed`.
 
-    Check the [OpenAI Computer use documentation](https://platform.openai.com/docs/guides/tools-computer-use#1-send-a-request-to-the-model)
+    Check the [OpenAI Reasoning documentation](https://platform.openai.com/docs/guides/reasoning?api-mode=responses#reasoning-summaries)
     for more details.
     """
 
+    openai_send_reasoning_ids: bool
+    """Whether to send reasoning IDs from the message history to the model. Enabled by default.
+
+    This can result in errors like `"Item 'rs_123' of type 'reasoning' was provided without its required following item."`
+    if the message history you're sending does not match exactly what was received from the Responses API in a previous response,
+    for example if you're using a [history processor](../../message-history.md#processing-message-history).
+    In that case, you'll want to disable this.
+    """
+
     openai_truncation: Literal['disabled', 'auto']
     """The truncation strategy to use for the model response.
 
@@ -859,26 +868,38 @@ class OpenAIResponsesModel(Model):
         for item in response.output:
             if isinstance(item, responses.ResponseReasoningItem):
                 signature = item.encrypted_content
-                for summary in item.summary:
-                    # We use the same id for all summaries so that we can merge them on the round trip.
-                    # We only need to store the signature once.
+                if item.summary:
+                    for summary in item.summary:
+                        # We use the same id for all summaries so that we can merge them on the round trip.
+                        items.append(
+                            ThinkingPart(
+                                content=summary.text,
+                                id=item.id,
+                                signature=signature,
+                                provider_name=self.system if signature else None,
+                            )
+                        )
+                        # We only need to store the signature once.
+                        signature = None
+                elif signature:
                     items.append(
                         ThinkingPart(
-                            content=summary.text,
+                            content='',
                             id=item.id,
                             signature=signature,
-                            provider_name=self.system if signature else None,
+                            provider_name=self.system,
                         )
                     )
-                    signature = None
                 # NOTE: We don't currently handle the raw CoT from gpt-oss `reasoning_text`: https://cookbook.openai.com/articles/gpt-oss/handle-raw-cot
                 # If you need this, please file an issue.
             elif isinstance(item, responses.ResponseOutputMessage):
                 for content in item.content:
                     if isinstance(content, responses.ResponseOutputText):  # pragma: no branch
-                        items.append(TextPart(content.text))
+                        items.append(TextPart(content.text, id=item.id))
             elif isinstance(item, responses.ResponseFunctionToolCall):
-                items.append(ToolCallPart(item.name, item.arguments, tool_call_id=item.call_id))
+                items.append(
+                    ToolCallPart(item.name, item.arguments, tool_call_id=_combine_tool_call_ids(item.call_id, item.id))
+                )
 
         finish_reason: FinishReason | None = None
         provider_details: dict[str, Any] | None = None
@@ -956,7 +977,7 @@ class OpenAIResponsesModel(Model):
         else:
             tool_choice = 'auto'
 
-        instructions, openai_messages = await self._map_messages(messages)
+        instructions, openai_messages = await self._map_messages(messages, model_settings)
         reasoning = self._get_reasoning(model_settings)
 
         text: responses.ResponseTextConfigParam | None = None
@@ -980,10 +1001,15 @@ class OpenAIResponsesModel(Model):
             text = text or {}
             text['verbosity'] = verbosity
 
-        unsupported_model_settings = OpenAIModelProfile.from_profile(self.profile).openai_unsupported_model_settings
+        profile = OpenAIModelProfile.from_profile(self.profile)
+        unsupported_model_settings = profile.openai_unsupported_model_settings
         for setting in unsupported_model_settings:
             model_settings.pop(setting, None)
 
+        include: list[responses.ResponseIncludable] | None = None
+        if profile.openai_supports_encrypted_reasoning_content:
+            include = ['reasoning.encrypted_content']
+
         try:
             extra_headers = model_settings.get('extra_headers', {})
             extra_headers.setdefault('User-Agent', get_user_agent())
@@ -1004,7 +1030,7 @@ class OpenAIResponsesModel(Model):
                 reasoning=reasoning,
                 user=model_settings.get('openai_user', NOT_GIVEN),
                 text=text or NOT_GIVEN,
-                include=['reasoning.encrypted_content'],
+                include=include or NOT_GIVEN,
                 extra_headers=extra_headers,
                 extra_body=model_settings.get('extra_body'),
             )
@@ -1067,7 +1093,7 @@ class OpenAIResponsesModel(Model):
         }
 
     async def _map_messages(  # noqa: C901
-        self, messages: list[ModelMessage]
+        self, messages: list[ModelMessage], model_settings: OpenAIResponsesModelSettings
     ) -> tuple[str | NotGiven, list[responses.ResponseInputItemParam]]:
         """Just maps a `pydantic_ai.Message` to a `openai.types.responses.ResponseInputParam`."""
         openai_messages: list[responses.ResponseInputItemParam] = []
@@ -1079,13 +1105,14 @@ class OpenAIResponsesModel(Model):
                     elif isinstance(part, UserPromptPart):
                         openai_messages.append(await self._map_user_prompt(part))
                     elif isinstance(part, ToolReturnPart):
-                        openai_messages.append(
-                            FunctionCallOutput(
-                                type='function_call_output',
-                                call_id=_guard_tool_call_id(t=part),
-                                output=part.model_response_str(),
-                            )
+                        call_id = _guard_tool_call_id(t=part)
+                        call_id, _ = _split_combined_tool_call_id(call_id)
+                        item = FunctionCallOutput(
+                            type='function_call_output',
+                            call_id=call_id,
+                            output=part.model_response_str(),
                         )
+                        openai_messages.append(item)
                     elif isinstance(part, RetryPromptPart):
                         # TODO(Marcelo): How do we test this conditional branch?
                         if part.tool_name is None:  # pragma: no cover
@@ -1093,40 +1120,81 @@ class OpenAIResponsesModel(Model):
                                 Message(role='user', content=[{'type': 'input_text', 'text': part.model_response()}])
                             )
                         else:
-                            openai_messages.append(
-                                FunctionCallOutput(
-                                    type='function_call_output',
-                                    call_id=_guard_tool_call_id(t=part),
-                                    output=part.model_response(),
-                                )
+                            call_id = _guard_tool_call_id(t=part)
+                            call_id, _ = _split_combined_tool_call_id(call_id)
+                            item = FunctionCallOutput(
+                                type='function_call_output',
+                                call_id=call_id,
+                                output=part.model_response(),
                             )
+                            openai_messages.append(item)
                     else:
                         assert_never(part)
             elif isinstance(message, ModelResponse):
+                message_item: responses.ResponseOutputMessageParam | None = None
                 reasoning_item: responses.ResponseReasoningItemParam | None = None
                 for item in message.parts:
                     if isinstance(item, TextPart):
-                        openai_messages.append(responses.EasyInputMessageParam(role='assistant', content=item.content))
+                        if item.id and item.id.startswith('msg_'):
+                            if message_item is None or message_item['id'] != item.id:  # pragma: no branch
+                                message_item = responses.ResponseOutputMessageParam(
+                                    role='assistant',
+                                    id=item.id or _utils.generate_tool_call_id(),
+                                    content=[],
+                                    type='message',
+                                    status='completed',
+                                )
+                                openai_messages.append(message_item)
+
+                            message_item['content'] = [
+                                *message_item['content'],
+                                responses.ResponseOutputTextParam(
+                                    text=item.content, type='output_text', annotations=[]
+                                ),
+                            ]
+                        else:
+                            openai_messages.append(
+                                responses.EasyInputMessageParam(role='assistant', content=item.content)
+                            )
                     elif isinstance(item, ToolCallPart):
                         openai_messages.append(self._map_tool_call(item))
                     elif isinstance(item, BuiltinToolCallPart | BuiltinToolReturnPart):
                         # We don't currently track built-in tool calls from OpenAI
                         pass
                     elif isinstance(item, ThinkingPart):
-                        if reasoning_item is not None and item.id == reasoning_item['id']:
-                            reasoning_item['summary'] = [
-                                *reasoning_item['summary'],
-                                Summary(text=item.content, type='summary_text'),
-                            ]
-                            continue
+                        if (
+                            item.id
+                            and item.provider_name == self.system
+                            and OpenAIModelProfile.from_profile(
+                                self.profile
+                            ).openai_supports_encrypted_reasoning_content
+                            and model_settings.get('openai_send_reasoning_ids', True)
+                        ):
+                            if (
+                                reasoning_item is None
+                                or reasoning_item['id'] != item.id
+                                and (item.signature or item.content)
+                            ):  # pragma: no branch
+                                reasoning_item = responses.ResponseReasoningItemParam(
+                                    id=item.id,
+                                    summary=[],
+                                    encrypted_content=item.signature,
+                                    type='reasoning',
+                                )
+                                openai_messages.append(reasoning_item)
 
-                        reasoning_item = responses.ResponseReasoningItemParam(
-                            id=item.id or _utils.generate_tool_call_id(),
-                            summary=[Summary(text=item.content, type='summary_text')],
-                            encrypted_content=item.signature if item.provider_name == self.system else None,
-                            type='reasoning',
-                        )
-                        openai_messages.append(reasoning_item)
+                            if item.content:
+                                reasoning_item['summary'] = [
+                                    *reasoning_item['summary'],
+                                    Summary(text=item.content, type='summary_text'),
+                                ]
+                        else:
+                            start_tag, end_tag = self.profile.thinking_tags
+                            openai_messages.append(
+                                responses.EasyInputMessageParam(
+                                    role='assistant', content='\n'.join([start_tag, item.content, end_tag])
+                                )
+                            )
                     else:
                         assert_never(item)
             else:
@@ -1136,12 +1204,18 @@ class OpenAIResponsesModel(Model):
 
     @staticmethod
     def _map_tool_call(t: ToolCallPart) -> responses.ResponseFunctionToolCallParam:
-        return responses.ResponseFunctionToolCallParam(
-            arguments=t.args_as_json_str(),
-            call_id=_guard_tool_call_id(t=t),
+        call_id = _guard_tool_call_id(t=t)
+        call_id, id = _split_combined_tool_call_id(call_id)
+
+        param = responses.ResponseFunctionToolCallParam(
             name=t.tool_name,
+            arguments=t.args_as_json_str(),
+            call_id=call_id,
             type='function_call',
         )
+        if id:  # pragma: no branch
+            param['id'] = id
+        return param
 
     def _map_json_schema(self, o: OutputObjectDefinition) -> responses.ResponseFormatTextJSONSchemaConfigParam:
         response_format_param: responses.ResponseFormatTextJSONSchemaConfigParam = {
@@ -1360,7 +1434,7 @@ class OpenAIResponsesStreamedResponse(StreamedResponse):
                         vendor_part_id=chunk.item.id,
                         tool_name=chunk.item.name,
                         args=chunk.item.arguments,
-                        tool_call_id=chunk.item.call_id,
+                        tool_call_id=_combine_tool_call_ids(chunk.item.call_id, chunk.item.id),
                     )
                 elif isinstance(chunk.item, responses.ResponseReasoningItem):
                     pass
@@ -1376,15 +1450,14 @@ class OpenAIResponsesStreamedResponse(StreamedResponse):
 
             elif isinstance(chunk, responses.ResponseOutputItemDoneEvent):
                 if isinstance(chunk.item, responses.ResponseReasoningItem):
-                    # Add the signature to the part corresponding to the first summary item
-                    signature = chunk.item.encrypted_content
-                    yield self._parts_manager.handle_thinking_delta(
-                        vendor_part_id=f'{chunk.item.id}-0',
-                        id=chunk.item.id,
-                        signature=signature,
-                        provider_name=self.provider_name if signature else None,
-                    )
-                pass
+                    if signature := chunk.item.encrypted_content:  # pragma: no branch
+                        # Add the signature to the part corresponding to the first summary item
+                        yield self._parts_manager.handle_thinking_delta(
+                            vendor_part_id=f'{chunk.item.id}-0',
+                            id=chunk.item.id,
+                            signature=signature,
+                            provider_name=self.provider_name,
+                        )
 
             elif isinstance(chunk, responses.ResponseReasoningSummaryPartAddedEvent):
                 yield self._parts_manager.handle_thinking_delta(
@@ -1411,7 +1484,9 @@ class OpenAIResponsesStreamedResponse(StreamedResponse):
                 pass  # there's nothing we need to do here
 
             elif isinstance(chunk, responses.ResponseTextDeltaEvent):
-                maybe_event = self._parts_manager.handle_text_delta(vendor_part_id=chunk.item_id, content=chunk.delta)
+                maybe_event = self._parts_manager.handle_text_delta(
+                    vendor_part_id=chunk.item_id, content=chunk.delta, id=chunk.item_id
+                )
                 if maybe_event is not None:  # pragma: no branch
                     yield maybe_event
 
@@ -1501,3 +1576,17 @@ def _map_usage(response: chat.ChatCompletion | ChatCompletionChunk | responses.R
             u.input_audio_tokens = response_usage.prompt_tokens_details.audio_tokens or 0
             u.cache_read_tokens = response_usage.prompt_tokens_details.cached_tokens or 0
         return u
+
+
+def _combine_tool_call_ids(call_id: str, id: str | None) -> str:
+    # When reasoning, the Responses API requires the `ResponseFunctionToolCall` to be returned with both the `call_id` and `id` fields.
+    # Our `ToolCallPart` has only the `call_id` field, so we combine the two fields into a single string.
+    return f'{call_id}|{id}' if id else call_id
+
+
+def _split_combined_tool_call_id(combined_id: str) -> tuple[str, str | None]:
+    if '|' in combined_id:
+        call_id, id = combined_id.split('|', 1)
+        return call_id, id
+    else:
+        return combined_id, None  # pragma: no cover

pydantic_ai/profiles/openai.py

@@ -41,6 +41,9 @@ class OpenAIModelProfile(ModelProfile):
     openai_chat_supports_web_search: bool = False
     """Whether the model supports web search in Chat Completions API."""
 
+    openai_supports_encrypted_reasoning_content: bool = False
+    """Whether the model supports including encrypted reasoning content in the response."""
+
     def __post_init__(self):  # pragma: no cover
         if not self.openai_supports_sampling_settings:
             warnings.warn(
@@ -84,6 +87,7 @@ def openai_model_profile(model_name: str) -> ModelProfile:
         openai_unsupported_model_settings=openai_unsupported_model_settings,
         openai_system_prompt_role=openai_system_prompt_role,
         openai_chat_supports_web_search=supports_web_search,
+        openai_supports_encrypted_reasoning_content=is_reasoning_model,
     )
 
 

pydantic_ai/providers/__init__.py

@@ -47,6 +47,9 @@ class Provider(ABC, Generic[InterfaceClient]):
         """The model profile for the named model, if available."""
         return None  # pragma: no cover
 
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}(name={self.name}, base_url={self.base_url})'
+
 
 def infer_provider_class(provider: str) -> type[Provider[Any]]:  # noqa: C901
     """Infers the provider class from the provider name."""

pydantic_ai/providers/anthropic.py

@@ -45,12 +45,15 @@ class AnthropicProvider(Provider[AsyncAnthropicClient]):
     def __init__(self, *, anthropic_client: AsyncAnthropicClient | None = None) -> None: ...
 
     @overload
-    def __init__(self, *, api_key: str | None = None, http_client: httpx.AsyncClient | None = None) -> None: ...
+    def __init__(
+        self, *, api_key: str | None = None, base_url: str | None = None, http_client: httpx.AsyncClient | None = None
+    ) -> None: ...
 
     def __init__(
         self,
         *,
         api_key: str | None = None,
+        base_url: str | None = None,
         anthropic_client: AsyncAnthropicClient | None = None,
         http_client: httpx.AsyncClient | None = None,
     ) -> None:
@@ -59,6 +62,7 @@ class AnthropicProvider(Provider[AsyncAnthropicClient]):
         Args:
             api_key: The API key to use for authentication, if not provided, the `ANTHROPIC_API_KEY` environment variable
                 will be used if available.
+            base_url: The base URL to use for the Anthropic API.
             anthropic_client: An existing [`AsyncAnthropic`](https://github.com/anthropics/anthropic-sdk-python)
                 client to use. If provided, the `api_key` and `http_client` arguments will be ignored.
             http_client: An existing `httpx.AsyncClient` to use for making HTTP requests.
@@ -68,14 +72,14 @@ class AnthropicProvider(Provider[AsyncAnthropicClient]):
             assert api_key is None, 'Cannot provide both `anthropic_client` and `api_key`'
             self._client = anthropic_client
         else:
-            api_key = api_key or os.environ.get('ANTHROPIC_API_KEY')
+            api_key = api_key or os.getenv('ANTHROPIC_API_KEY')
             if not api_key:
                 raise UserError(
                     'Set the `ANTHROPIC_API_KEY` environment variable or pass it via `AnthropicProvider(api_key=...)`'
                     'to use the Anthropic provider.'
                 )
             if http_client is not None:
-                self._client = AsyncAnthropic(api_key=api_key, http_client=http_client)
+                self._client = AsyncAnthropic(api_key=api_key, base_url=base_url, http_client=http_client)
             else:
                 http_client = cached_async_http_client(provider='anthropic')
-                self._client = AsyncAnthropic(api_key=api_key, http_client=http_client)
+                self._client = AsyncAnthropic(api_key=api_key, base_url=base_url, http_client=http_client)

pydantic_ai/providers/cohere.py

@@ -60,14 +60,14 @@ class CohereProvider(Provider[AsyncClientV2]):
             assert api_key is None, 'Cannot provide both `cohere_client` and `api_key`'
             self._client = cohere_client
         else:
-            api_key = api_key or os.environ.get('CO_API_KEY')
+            api_key = api_key or os.getenv('CO_API_KEY')
             if not api_key:
                 raise UserError(
                     'Set the `CO_API_KEY` environment variable or pass it via `CohereProvider(api_key=...)`'
                     'to use the Cohere provider.'
                 )
 
-            base_url = os.environ.get('CO_BASE_URL')
+            base_url = os.getenv('CO_BASE_URL')
             if http_client is not None:
                 self._client = AsyncClientV2(api_key=api_key, httpx_client=http_client, base_url=base_url)
             else:

pydantic_ai/providers/gateway.py

@@ -0,0 +1,187 @@
+"""This module implements the Pydantic AI Gateway provider."""
+
+from __future__ import annotations as _annotations
+
+import os
+from typing import TYPE_CHECKING, Any, Literal, overload
+from urllib.parse import urljoin
+
+import httpx
+
+from pydantic_ai.exceptions import UserError
+from pydantic_ai.models import Model, cached_async_http_client, get_user_agent
+
+if TYPE_CHECKING:
+    from google.genai import Client as GoogleClient
+    from groq import AsyncGroq
+    from openai import AsyncOpenAI
+
+    from pydantic_ai.models.anthropic import AsyncAnthropicClient
+    from pydantic_ai.providers import Provider
+
+
+@overload
+def gateway_provider(
+    upstream_provider: Literal['openai', 'openai-chat', 'openai-responses'],
+    *,
+    api_key: str | None = None,
+    base_url: str | None = None,
+    http_client: httpx.AsyncClient | None = None,
+) -> Provider[AsyncOpenAI]: ...
+
+
+@overload
+def gateway_provider(
+    upstream_provider: Literal['groq'],
+    *,
+    api_key: str | None = None,
+    base_url: str | None = None,
+    http_client: httpx.AsyncClient | None = None,
+) -> Provider[AsyncGroq]: ...
+
+
+@overload
+def gateway_provider(
+    upstream_provider: Literal['google-vertex'],
+    *,
+    api_key: str | None = None,
+    base_url: str | None = None,
+) -> Provider[GoogleClient]: ...
+
+
+@overload
+def gateway_provider(
+    upstream_provider: Literal['anthropic'],
+    *,
+    api_key: str | None = None,
+    base_url: str | None = None,
+) -> Provider[AsyncAnthropicClient]: ...
+
+
+def gateway_provider(
+    upstream_provider: Literal['openai', 'openai-chat', 'openai-responses', 'groq', 'google-vertex', 'anthropic'] | str,
+    *,
+    # Every provider
+    api_key: str | None = None,
+    base_url: str | None = None,
+    # OpenAI & Groq
+    http_client: httpx.AsyncClient | None = None,
+) -> Provider[Any]:
+    """Create a new Gateway provider.
+
+    Args:
+        upstream_provider: The upstream provider to use.
+        api_key: The API key to use for authentication. If not provided, the `PYDANTIC_AI_GATEWAY_API_KEY`
+            environment variable will be used if available.
+        base_url: The base URL to use for the Gateway. If not provided, the `PYDANTIC_AI_GATEWAY_BASE_URL`
+            environment variable will be used if available. Otherwise, defaults to `http://localhost:8787/`.
+        http_client: The HTTP client to use for the Gateway.
+    """
+    api_key = api_key or os.getenv('PYDANTIC_AI_GATEWAY_API_KEY')
+    if not api_key:
+        raise UserError(
+            'Set the `PYDANTIC_AI_GATEWAY_API_KEY` environment variable or pass it via `gateway_provider(api_key=...)`'
+            ' to use the Pydantic AI Gateway provider.'
+        )
+
+    base_url = base_url or os.getenv('PYDANTIC_AI_GATEWAY_BASE_URL', 'http://localhost:8787')
+    http_client = http_client or cached_async_http_client(provider=f'gateway-{upstream_provider}')
+    http_client.event_hooks = {'request': [_request_hook]}
+
+    if upstream_provider in ('openai', 'openai-chat'):
+        from .openai import OpenAIProvider
+
+        return OpenAIProvider(api_key=api_key, base_url=urljoin(base_url, 'openai'), http_client=http_client)
+    elif upstream_provider == 'openai-responses':
+        from .openai import OpenAIProvider
+
+        return OpenAIProvider(api_key=api_key, base_url=urljoin(base_url, 'openai'), http_client=http_client)
+    elif upstream_provider == 'groq':
+        from .groq import GroqProvider
+
+        return GroqProvider(api_key=api_key, base_url=urljoin(base_url, 'groq'), http_client=http_client)
+    elif upstream_provider == 'anthropic':
+        from anthropic import AsyncAnthropic
+
+        from .anthropic import AnthropicProvider
+
+        return AnthropicProvider(
+            anthropic_client=AsyncAnthropic(
+                auth_token=api_key,
+                base_url=urljoin(base_url, 'anthropic'),
+                http_client=http_client,
+            )
+        )
+    elif upstream_provider == 'google-vertex':
+        from google.genai import Client as GoogleClient
+
+        from .google import GoogleProvider
+
+        return GoogleProvider(
+            client=GoogleClient(
+                vertexai=True,
+                api_key='unset',
+                http_options={
+                    'base_url': f'{base_url}/google-vertex',
+                    'headers': {'User-Agent': get_user_agent(), 'Authorization': api_key},
+                    # TODO(Marcelo): Until https://github.com/googleapis/python-genai/issues/1357 is solved.
+                    'async_client_args': {
+                        'transport': httpx.AsyncHTTPTransport(),
+                        'event_hooks': {'request': [_request_hook]},
+                    },
+                },
+            )
+        )
+    else:  # pragma: no cover
+        raise UserError(f'Unknown provider: {upstream_provider}')
+
+
+def infer_model(model_name: str) -> Model:
+    """Infer the model class that will be used to make requests to the gateway.
+
+    Args:
+        model_name: The name of the model to infer. Must be in the format "provider/model_name".
+
+    Returns:
+        The model class that will be used to make requests to the gateway.
+    """
+    try:
+        upstream_provider, model_name = model_name.split('/', 1)
+    except ValueError:
+        raise UserError(f'The model name "{model_name}" is not in the format "provider/model_name".')
+
+    if upstream_provider in ('openai', 'openai-chat'):
+        from pydantic_ai.models.openai import OpenAIChatModel
+
+        return OpenAIChatModel(model_name, provider=gateway_provider('openai'))
+    elif upstream_provider == 'openai-responses':
+        from pydantic_ai.models.openai import OpenAIResponsesModel
+
+        return OpenAIResponsesModel(model_name, provider=gateway_provider('openai'))
+    elif upstream_provider == 'groq':
+        from pydantic_ai.models.groq import GroqModel
+
+        return GroqModel(model_name, provider=gateway_provider('groq'))
+    elif upstream_provider == 'anthropic':
+        from pydantic_ai.models.anthropic import AnthropicModel
+
+        return AnthropicModel(model_name, provider=gateway_provider('anthropic'))
+    elif upstream_provider == 'google-vertex':
+        from pydantic_ai.models.google import GoogleModel
+
+        return GoogleModel(model_name, provider=gateway_provider('google-vertex'))
+    raise UserError(f'Unknown upstream provider: {upstream_provider}')
+
+
+async def _request_hook(request: httpx.Request) -> httpx.Request:
+    """Request hook for the gateway provider.
+
+    It adds the `"traceparent"` header to the request.
+    """
+    from opentelemetry.propagate import inject
+
+    headers: dict[str, Any] = {}
+    inject(headers)
+    request.headers.update(headers)
+
+    return request

pydantic_ai/providers/google.py

@@ -106,13 +106,13 @@ class GoogleProvider(Provider[Client]):
             else:
                 self._client = Client(
                     vertexai=vertexai,
-                    project=project or os.environ.get('GOOGLE_CLOUD_PROJECT'),
+                    project=project or os.getenv('GOOGLE_CLOUD_PROJECT'),
                     # From https://github.com/pydantic/pydantic-ai/pull/2031/files#r2169682149:
                     # Currently `us-central1` supports the most models by far of any region including `global`, but not
                     # all of them. `us-central1` has all google models but is missing some Anthropic partner models,
                     # which use `us-east5` instead. `global` has fewer models but higher availability.
                     # For more details, check: https://cloud.google.com/vertex-ai/generative-ai/docs/learn/locations#available-regions
-                    location=location or os.environ.get('GOOGLE_CLOUD_LOCATION') or 'us-central1',
+                    location=location or os.getenv('GOOGLE_CLOUD_LOCATION') or 'us-central1',
                     credentials=credentials,
                     http_options=http_options,
                 )

pydantic_ai/providers/google_gla.py

@@ -39,7 +39,7 @@ class GoogleGLAProvider(Provider[httpx.AsyncClient]):
                 will be used if available.
             http_client: An existing `httpx.AsyncClient` to use for making HTTP requests.
         """
-        api_key = api_key or os.environ.get('GEMINI_API_KEY')
+        api_key = api_key or os.getenv('GEMINI_API_KEY')
         if not api_key:
             raise UserError(
                 'Set the `GEMINI_API_KEY` environment variable or pass it via `GoogleGLAProvider(api_key=...)`'

pydantic_ai/providers/groq.py

@@ -53,7 +53,7 @@ class GroqProvider(Provider[AsyncGroq]):
 
     @property
     def base_url(self) -> str:
-        return os.environ.get('GROQ_BASE_URL', 'https://api.groq.com')
+        return str(self.client.base_url)
 
     @property
     def client(self) -> AsyncGroq:
@@ -85,12 +85,15 @@ class GroqProvider(Provider[AsyncGroq]):
     def __init__(self, *, groq_client: AsyncGroq | None = None) -> None: ...
 
     @overload
-    def __init__(self, *, api_key: str | None = None, http_client: httpx.AsyncClient | None = None) -> None: ...
+    def __init__(
+        self, *, api_key: str | None = None, base_url: str | None = None, http_client: httpx.AsyncClient | None = None
+    ) -> None: ...
 
     def __init__(
         self,
         *,
         api_key: str | None = None,
+        base_url: str | None = None,
         groq_client: AsyncGroq | None = None,
         http_client: httpx.AsyncClient | None = None,
     ) -> None:
@@ -99,6 +102,8 @@ class GroqProvider(Provider[AsyncGroq]):
         Args:
             api_key: The API key to use for authentication, if not provided, the `GROQ_API_KEY` environment variable
                 will be used if available.
+            base_url: The base url for the Groq requests. If not provided, the `GROQ_BASE_URL` environment variable
+                will be used if available. Otherwise, defaults to Groq's base url.
             groq_client: An existing
                 [`AsyncGroq`](https://github.com/groq/groq-python?tab=readme-ov-file#async-usage)
                 client to use. If provided, `api_key` and `http_client` must be `None`.
@@ -107,9 +112,11 @@ class GroqProvider(Provider[AsyncGroq]):
         if groq_client is not None:
             assert http_client is None, 'Cannot provide both `groq_client` and `http_client`'
             assert api_key is None, 'Cannot provide both `groq_client` and `api_key`'
+            assert base_url is None, 'Cannot provide both `groq_client` and `base_url`'
             self._client = groq_client
         else:
-            api_key = api_key or os.environ.get('GROQ_API_KEY')
+            api_key = api_key or os.getenv('GROQ_API_KEY')
+            base_url = base_url or os.getenv('GROQ_BASE_URL', 'https://api.groq.com')
 
             if not api_key:
                 raise UserError(
@@ -117,7 +124,7 @@ class GroqProvider(Provider[AsyncGroq]):
                     'to use the Groq provider.'
                 )
             elif http_client is not None:
-                self._client = AsyncGroq(base_url=self.base_url, api_key=api_key, http_client=http_client)
+                self._client = AsyncGroq(base_url=base_url, api_key=api_key, http_client=http_client)
             else:
                 http_client = cached_async_http_client(provider='groq')
-                self._client = AsyncGroq(base_url=self.base_url, api_key=api_key, http_client=http_client)
+                self._client = AsyncGroq(base_url=base_url, api_key=api_key, http_client=http_client)

pydantic_ai/providers/heroku.py

@@ -65,14 +65,14 @@ class HerokuProvider(Provider[AsyncOpenAI]):
             assert api_key is None, 'Cannot provide both `openai_client` and `api_key`'
             self._client = openai_client
         else:
-            api_key = api_key or os.environ.get('HEROKU_INFERENCE_KEY')
+            api_key = api_key or os.getenv('HEROKU_INFERENCE_KEY')
             if not api_key:
                 raise UserError(
                     'Set the `HEROKU_INFERENCE_KEY` environment variable or pass it via `HerokuProvider(api_key=...)`'
                     'to use the Heroku provider.'
                 )
 
-            base_url = base_url or os.environ.get('HEROKU_INFERENCE_URL', 'https://us.inference.heroku.com')
+            base_url = base_url or os.getenv('HEROKU_INFERENCE_URL', 'https://us.inference.heroku.com')
             base_url = base_url.rstrip('/') + '/v1'
 
             if http_client is not None:

pydantic_ai/providers/huggingface.py

@@ -95,7 +95,7 @@ class HuggingFaceProvider(Provider[AsyncInferenceClient]):
                 defaults to "auto", which will select the first available provider for the model, the first of the providers available for the model, sorted by the user's order in https://hf.co/settings/inference-providers.
                 If `base_url` is passed, then `provider_name` is not used.
         """
-        api_key = api_key or os.environ.get('HF_TOKEN')
+        api_key = api_key or os.getenv('HF_TOKEN')
 
         if api_key is None:
             raise UserError(

pydantic_ai/providers/mistral.py

@@ -67,7 +67,7 @@ class MistralProvider(Provider[Mistral]):
             assert base_url is None, 'Cannot provide both `mistral_client` and `base_url`'
             self._client = mistral_client
         else:
-            api_key = api_key or os.environ.get('MISTRAL_API_KEY')
+            api_key = api_key or os.getenv('MISTRAL_API_KEY')
 
             if not api_key:
                 raise UserError(

pydantic_ai/providers/openai.py

@@ -1,6 +1,7 @@
 from __future__ import annotations as _annotations
 
 import os
+from typing import overload
 
 import httpx
 
@@ -36,6 +37,18 @@ class OpenAIProvider(Provider[AsyncOpenAI]):
     def model_profile(self, model_name: str) -> ModelProfile | None:
         return openai_model_profile(model_name)
 
+    @overload
+    def __init__(self, *, openai_client: AsyncOpenAI) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        base_url: str | None = None,
+        api_key: str | None = None,
+        openai_client: None = None,
+        http_client: httpx.AsyncClient | None = None,
+    ) -> None: ...
+
     def __init__(
         self,
         base_url: str | None = None,

{pydantic_ai_slim-1.0.3.dist-info → pydantic_ai_slim-1.0.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai-slim
-Version: 1.0.3
+Version: 1.0.5
 Summary: Agent Framework / shim to use Pydantic with LLMs, slim package
 Project-URL: Homepage, https://github.com/pydantic/pydantic-ai/tree/main/pydantic_ai_slim
 Project-URL: Source, https://github.com/pydantic/pydantic-ai/tree/main/pydantic_ai_slim
@@ -33,7 +33,7 @@ Requires-Dist: genai-prices>=0.0.23
 Requires-Dist: griffe>=1.3.2
 Requires-Dist: httpx>=0.27
 Requires-Dist: opentelemetry-api>=1.28.0
-Requires-Dist: pydantic-graph==1.0.3
+Requires-Dist: pydantic-graph==1.0.5
 Requires-Dist: pydantic>=2.10
 Requires-Dist: typing-inspection>=0.4.0
 Provides-Extra: a2a
@@ -57,7 +57,7 @@ Requires-Dist: dbos>=1.13.0; extra == 'dbos'
 Provides-Extra: duckduckgo
 Requires-Dist: ddgs>=9.0.0; extra == 'duckduckgo'
 Provides-Extra: evals
-Requires-Dist: pydantic-evals==1.0.3; extra == 'evals'
+Requires-Dist: pydantic-evals==1.0.5; extra == 'evals'
 Provides-Extra: google
 Requires-Dist: google-genai>=1.31.0; extra == 'google'
 Provides-Extra: groq

{pydantic_ai_slim-1.0.3.dist-info → pydantic_ai_slim-1.0.5.dist-info}/RECORD

@@ -8,7 +8,7 @@ pydantic_ai/_griffe.py,sha256=BphvTL00FHxsSY56GM-bNyCOdwrpL0T3LbDQITWUK_Q,5280
 pydantic_ai/_mcp.py,sha256=PuvwnlLjv7YYOa9AZJCrklevBug99zGMhwJCBGG7BHQ,5626
 pydantic_ai/_otel_messages.py,sha256=qLu81aBDEAsUTW6efBzWRXNDMICTrUUBpcGbCEyXr4o,1480
 pydantic_ai/_output.py,sha256=phJ9AQYUlhQhAVikL0FpPn_Vm05V_yK3VYmCUUtH778,38296
-pydantic_ai/_parts_manager.py,sha256=qcHBJOM-AxC5iXxt7J6NvPFUIbyPUTE_O18Jiw6uUpA,17903
+pydantic_ai/_parts_manager.py,sha256=1l6RoyhuiDzbZyHP0asYFm63-nuswrIv1H8O8017qAY,18035
 pydantic_ai/_run_context.py,sha256=AFSTtOBbUAnPpM-V5_b5fLMVAFbEBX4oOdYsGR9ayt4,1824
 pydantic_ai/_system_prompt.py,sha256=WdDW_DTGHujcFFaK-J7J6mA4ZDJZ0IOKpyizJA-1Y5Q,1142
 pydantic_ai/_thinking_part.py,sha256=x80-Vkon16GOyq3W6f2qzafTVPC5dCgF7QD3k8ZMmYU,1304
@@ -20,7 +20,7 @@ pydantic_ai/direct.py,sha256=zMsz6poVgEq7t7L_8FWM6hmKdqTzjyQYL5xzQt_59Us,14951
 pydantic_ai/exceptions.py,sha256=zsXZMKf2BJuVsfuHl1fWTkogLU37bd4yq7D6BKHAzVs,4968
 pydantic_ai/format_prompt.py,sha256=37imBG2Fgpn-_RfAFalOX8Xc_XpGH2gY9tnhJDvxfk8,4243
 pydantic_ai/mcp.py,sha256=cmgi3Nq_qe1cTqs-R92WMfZw6bwjSqy2R6NiR7isPcQ,30364
-pydantic_ai/messages.py,sha256=gP5Tzjq3TfOJZuA98kK7oOMTX7gAH6yvW7uDfQYLRIY,55787
+pydantic_ai/messages.py,sha256=bq9Ps-CsYkXdkq4eu1gmIoiLiYsFTwEzB4fXUF_neic,55865
 pydantic_ai/output.py,sha256=wzNgVKJgxyXtSH-uNbRxIaUNLidxlQcwWYT2o1gY2hE,12037
 pydantic_ai/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pydantic_ai/result.py,sha256=FrJbd0nwaRVIxGH_EhV-ITQvrrd-JaDya9EDsE5-Pps,25389
@@ -52,20 +52,20 @@ pydantic_ai/durable_exec/temporal/_toolset.py,sha256=HxmQ5vut7Zd5eyrC27eNNn5_CHA
 pydantic_ai/ext/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pydantic_ai/ext/aci.py,sha256=sUllKDNO-LOMurbFgxwRHuzNlBkSa3aVBqXfEm-A_vo,2545
 pydantic_ai/ext/langchain.py,sha256=iLVEZv1kcLkdIHo3us2yfdi0kVqyJ6qTaCt9BoLWm4k,2335
-pydantic_ai/models/__init__.py,sha256=30HXKHE_iGcAMdGfanYY_UEmyyM16bKg-PPf0jZPcbo,36091
-pydantic_ai/models/anthropic.py,sha256=3QAgeshsDQ40E_knZaxy00GmyiYM7Wz0lOVSKYhBxFU,32804
-pydantic_ai/models/bedrock.py,sha256=79Uyi-aeee9EVksOoUd0IXORaTbwUc8AzphS2Nipo28,33437
+pydantic_ai/models/__init__.py,sha256=na9M98DMJ0VpsYhcJ9WI80EI0278XJEJ9jIE_hlW6q4,36256
+pydantic_ai/models/anthropic.py,sha256=-dH4qYSRlRD1XiC1wR89oGHKnFTjxP8zQh0scQDkTCk,32768
+pydantic_ai/models/bedrock.py,sha256=wHo65QNEsfsb1UaUv_TpvJ0WrgFoKoegB6I3eDVnORI,33393
 pydantic_ai/models/cohere.py,sha256=Oly6wpw7Xj0z-690foknLK2z2F9ukDOjxQCGBFFJKkk,13898
 pydantic_ai/models/fallback.py,sha256=XJ74wRxVT4dF0uewHH3is9I-zcLBK8KFIhpK3BB6mRw,5526
 pydantic_ai/models/function.py,sha256=9ZuRDQXChiA_S3a_M9tmmYQwlyuUEFZ20aYrnPqdTz8,14599
 pydantic_ai/models/gemini.py,sha256=DYEaOnwGmo9FUGVkRRrydGuQwYhnO-Cq5grTurLWgb4,39376
-pydantic_ai/models/google.py,sha256=BztYqxeGO2k6uJP4Rv4QSW8oLCnmus9t7V3w0NyCqEc,34921
+pydantic_ai/models/google.py,sha256=i8dMi3wyeSTT8CFgbDd9gxKUhahgkBEXNXjLqs2utwI,34758
 pydantic_ai/models/groq.py,sha256=G17TeyQeIAYG7hANe1LkZhj41xScB8VYum3AK7Q5KRA,26769
 pydantic_ai/models/huggingface.py,sha256=f1tZObCJkcbiUCwNoPyuiaRaGYuj0GBFmbA8yFd-tHY,21176
 pydantic_ai/models/instrumented.py,sha256=DCnyG7HXgV-W2EWac8oZb2A8PL8yarXeU7Rt97l4w_s,21421
 pydantic_ai/models/mcp_sampling.py,sha256=qnLCO3CB5bNQ86SpWRA-CSSOVcCCLPwjHtcNFvW9wHs,3461
-pydantic_ai/models/mistral.py,sha256=FXZ7QnVJSi9j8V1z0Bz56N_WhQOjiDVYGy5tIV76KU4,33630
-pydantic_ai/models/openai.py,sha256=GCsKTlAn1n0yqWkWqcsihhcCNPdKLbl1NlICbmmcSZg,69533
+pydantic_ai/models/mistral.py,sha256=ru8EHwFS0xZBN6s1tlssUdjxjQyjB9L_8kFH7qq5U_g,33654
+pydantic_ai/models/openai.py,sha256=AsAqJIjTeN2d-WX0wPLM9phbEZHoR8PvWkfplRWUp7U,74021
 pydantic_ai/models/test.py,sha256=1kBwi7pSUt9_K1U-hokOilplxJWPQ3KRKH_s8bYmt_s,19969
 pydantic_ai/models/wrapper.py,sha256=9MeHW7mXPsEK03IKL0rtjeX6QgXyZROOOzLh72GiX2k,2148
 pydantic_ai/profiles/__init__.py,sha256=V6uGAVJuIaYRuZOQjkdIyFfDKD5py18RC98njnHOFug,3293
@@ -81,29 +81,30 @@ pydantic_ai/profiles/harmony.py,sha256=_81tOGOYGTH3Za67jjtdINvASTTM5_CTyc1Ej2KHJ
 pydantic_ai/profiles/meta.py,sha256=JdZcpdRWx8PY1pU9Z2i_TYtA0Cpbg23xyFrV7eXnooY,309
 pydantic_ai/profiles/mistral.py,sha256=ll01PmcK3szwlTfbaJLQmfd0TADN8lqjov9HpPJzCMQ,217
 pydantic_ai/profiles/moonshotai.py,sha256=e1RJnbEvazE6aJAqfmYLYGNtwNwg52XQDRDkcLrv3fU,272
-pydantic_ai/profiles/openai.py,sha256=aOmuA4g1bz-JHirJoEpah7tmZPYrdISMPkvh87jSb4I,9365
+pydantic_ai/profiles/openai.py,sha256=YmIm_2YoIcUrQ22XVcBy9mdXMAF-5glUdYme2jY_5nc,9592
 pydantic_ai/profiles/qwen.py,sha256=9SnTpMKndxNQMFyumyaOczJa5JGWbYQdpVKKW4OzKjk,749
-pydantic_ai/providers/__init__.py,sha256=QlFpPM_kGnF_YAzwB9Dgmxx4Emp33x0bh831H_xKDXE,4478
-pydantic_ai/providers/anthropic.py,sha256=bDFNAE4WB66Dn7YDnI3dv6yBbMmM9Kzt2kalM4Fq8WQ,3158
+pydantic_ai/providers/__init__.py,sha256=ksqF_HFRWiFsoXwz4lIQSA2VRvfQTCliRIDVepvBkiE,4598
+pydantic_ai/providers/anthropic.py,sha256=4Cy5S2lnU_hThp8wkDPwWev1Mzmiztw4otFsfrpL8F8,3336
 pydantic_ai/providers/azure.py,sha256=msYyeQoHATxCJkiF1N05lPSJivh-SWKK1463WF6xTK4,5823
 pydantic_ai/providers/bedrock.py,sha256=t4ADWFYJKxW-Al5-lOSlb4p-5YiTEOU_O7owcVSP3CU,6522
 pydantic_ai/providers/cerebras.py,sha256=2zgsNxup_7OEPOXnbJHMYnVRDnB9UYTQnOO4wv7xnYA,3436
-pydantic_ai/providers/cohere.py,sha256=-F0prLuI2aDtHNZakd1GlyvgFLio-fo5n6fRbyPMvro,2858
+pydantic_ai/providers/cohere.py,sha256=5__UI6PdNz1eqGda2ylBwUuenpNG9MJN-fDSbFO0euQ,2848
 pydantic_ai/providers/deepseek.py,sha256=JSc7dQbB-l7_Phf61ZLb4_c1oym9fHea_h2Yq88uoL8,3032
 pydantic_ai/providers/fireworks.py,sha256=-jMRxbt353nENdpxuDpC4zJZ9wlJBcWa4wdcUk4cXKo,3594
+pydantic_ai/providers/gateway.py,sha256=2O7nepvn8s3IbMSAdRZ8V_ag0VmjDKjvc9gGCb99AEE,6675
 pydantic_ai/providers/github.py,sha256=Mp6-piXuRe5R0Iu4p0N06aIZgX7rJe5KRzCjt9E4OK4,4378
-pydantic_ai/providers/google.py,sha256=iLXcKUl5r7wdLuZtT1IM3obGZi7ecLM_PDyWdQKDncI,6038
-pydantic_ai/providers/google_gla.py,sha256=dLkDxps5gEtxsQiDbs1e88lXLYeX4i2qnJtDiFFJ0Ng,1965
+pydantic_ai/providers/google.py,sha256=rYLZa1LUkOXKu39_VIF7u3buYC78IWiYwCEiS0vRJH8,6028
+pydantic_ai/providers/google_gla.py,sha256=X_gxItZg8IGGK0RRsa8lXA_vQtPHEiIDLpfg2u9s5oY,1960
 pydantic_ai/providers/google_vertex.py,sha256=tAR3L1DZPDvGOJsKyGkIRPeXL7wjly4CvqTWMK1ozVQ,9752
 pydantic_ai/providers/grok.py,sha256=s9Y_iYkYCBc7UbP2ppGOUdAP_04xrkmPBHq3q3Qr9eE,3109
-pydantic_ai/providers/groq.py,sha256=3XuYqvugToJhTf7kQCdtdaTpFsiqAu_pwnIQnHm04uo,4913
-pydantic_ai/providers/heroku.py,sha256=wA36vh0ldpdaj33FPtfo4roY_MhaCqErjLyGtcbC6Xs,2958
-pydantic_ai/providers/huggingface.py,sha256=MLAv-Z99Kii5Faolq97_0Ir1LUKH9CwRmJFaI5RvwW4,4914
+pydantic_ai/providers/groq.py,sha256=axqy1Hko3NISSzwHACGZddwLZDGup89o13eRwBboU8I,5321
+pydantic_ai/providers/heroku.py,sha256=ADohwsLz25jpqxVjtv9hFhMrJui7AGak5j3hbTIHZPc,2948
+pydantic_ai/providers/huggingface.py,sha256=_Bvi2qdbOB8E9mhiJX3fVoUDZWPCTduCFASZT9JhnI8,4909
 pydantic_ai/providers/litellm.py,sha256=3hTCjHWRG_1c4S9JSNm0BDBDi4q6BVVZ3OLSXhTndNM,5079
-pydantic_ai/providers/mistral.py,sha256=ZxfOQNB2RADtHeGLQrhxHwq6cXpBi3LMgIUa_9wXoug,3088
+pydantic_ai/providers/mistral.py,sha256=pHcWHb2Wf9ZcqQl_Lp84ZvepO0Hmyb1CiqCTbur9S-s,3083
 pydantic_ai/providers/moonshotai.py,sha256=LwasmxCZCPkq1pb1uDtZTEb_nE55bAtX3QXgLmuNlHE,3260
 pydantic_ai/providers/ollama.py,sha256=_bxons0p8g0RSPNV8iq3AScVS1ym27QTW4zhDqSakgY,4633
-pydantic_ai/providers/openai.py,sha256=xCpR2c7QnYQukiJJKiFTSaGSewPFht7ekTasJDjSimA,3071
+pydantic_ai/providers/openai.py,sha256=SKRsYRUW_zu24iKAM7KJ-6j8GQDIjjxll4AWY1uB3Vs,3410
 pydantic_ai/providers/openrouter.py,sha256=PXGgHPtlQQHKFaSnmiswWZ3dTvmT9PAg-NvfRYGjrPw,4154
 pydantic_ai/providers/together.py,sha256=Dln_NgCul1XVOQtNaYvqWrNjOWj9XzA8n4NwNMKkbLk,3450
 pydantic_ai/providers/vercel.py,sha256=Q7pPvzaoh7Uiqq7CD8TxaWnXnXRKYgWJRwQXSYm0ZKQ,4257
@@ -119,8 +120,8 @@ pydantic_ai/toolsets/prefixed.py,sha256=0KwcDkW8OM36ZUsOLVP5h-Nj2tPq78L3_E2c-1Fb
 pydantic_ai/toolsets/prepared.py,sha256=Zjfz6S8In6PBVxoKFN9sKPN984zO6t0awB7Lnq5KODw,1431
 pydantic_ai/toolsets/renamed.py,sha256=JuLHpi-hYPiSPlaTpN8WiXLiGsywYK0axi2lW2Qs75k,1637
 pydantic_ai/toolsets/wrapper.py,sha256=KRzF1p8dncHbva8CE6Ud-IC5E_aygIHlwH5atXK55k4,1673
-pydantic_ai_slim-1.0.3.dist-info/METADATA,sha256=NHnWG1OWAS7GaA51ZBBz0bV0OI3qM3Qc4LLF5BYIleA,4627
-pydantic_ai_slim-1.0.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-pydantic_ai_slim-1.0.3.dist-info/entry_points.txt,sha256=kbKxe2VtDCYS06hsI7P3uZGxcVC08-FPt1rxeiMpIps,50
-pydantic_ai_slim-1.0.3.dist-info/licenses/LICENSE,sha256=vA6Jc482lEyBBuGUfD1pYx-cM7jxvLYOxPidZ30t_PQ,1100
-pydantic_ai_slim-1.0.3.dist-info/RECORD,,
+pydantic_ai_slim-1.0.5.dist-info/METADATA,sha256=Q3hdkuEKOT2YbEgzFhTBzofRVHl_wZZMFc5nXCgsTEY,4627
+pydantic_ai_slim-1.0.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pydantic_ai_slim-1.0.5.dist-info/entry_points.txt,sha256=kbKxe2VtDCYS06hsI7P3uZGxcVC08-FPt1rxeiMpIps,50
+pydantic_ai_slim-1.0.5.dist-info/licenses/LICENSE,sha256=vA6Jc482lEyBBuGUfD1pYx-cM7jxvLYOxPidZ30t_PQ,1100
+pydantic_ai_slim-1.0.5.dist-info/RECORD,,