pydantic-ai-slim 1.0.3__tar.gz → 1.0.4__tar.gz

{pydantic_ai_slim-1.0.3 → pydantic_ai_slim-1.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai-slim
-Version: 1.0.3
+Version: 1.0.4
 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.4
 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.4; extra == 'evals'
 Provides-Extra: google
 Requires-Dist: google-genai>=1.31.0; extra == 'google'
 Provides-Extra: groq

{pydantic_ai_slim-1.0.3 → pydantic_ai_slim-1.0.4}/pydantic_ai/_parts_manager.py

@@ -198,16 +198,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_slim-1.0.3 → pydantic_ai_slim-1.0.4}/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_slim-1.0.3 → pydantic_ai_slim-1.0.4}/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_slim-1.0.3 → pydantic_ai_slim-1.0.4}/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_slim-1.0.3 → pydantic_ai_slim-1.0.4}/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_slim-1.0.3 → pydantic_ai_slim-1.0.4}/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_slim-1.0.3 → pydantic_ai_slim-1.0.4}/pydantic_ai/models/openai.py

@@ -878,7 +878,9 @@ class OpenAIResponsesModel(Model):
                     if isinstance(content, responses.ResponseOutputText):  # pragma: no branch
                         items.append(TextPart(content.text))
             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
@@ -980,10 +982,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 +1011,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'),
             )
@@ -1079,13 +1086,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,13 +1101,14 @@ 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):
@@ -1136,12 +1145,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 +1375,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
@@ -1501,3 +1516,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_slim-1.0.3 → pydantic_ai_slim-1.0.4}/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_slim-1.0.3 → pydantic_ai_slim-1.0.4}/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_slim-1.0.3 → pydantic_ai_slim-1.0.4}/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_slim-1.0.3 → pydantic_ai_slim-1.0.4}/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_slim-1.0.4/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_slim-1.0.3 → pydantic_ai_slim-1.0.4}/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_slim-1.0.3 → pydantic_ai_slim-1.0.4}/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_slim-1.0.3 → pydantic_ai_slim-1.0.4}/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_slim-1.0.3 → pydantic_ai_slim-1.0.4}/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_slim-1.0.3 → pydantic_ai_slim-1.0.4}/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_slim-1.0.3 → pydantic_ai_slim-1.0.4}/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_slim-1.0.3 → pydantic_ai_slim-1.0.4}/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,