pydantic-ai-slim 0.0.44__py3-none-any.whl → 0.0.46__py3-none-any.whl

pydantic_ai/models/gemini.py

@@ -1,19 +1,19 @@
 from __future__ import annotations as _annotations
 
 import base64
-import os
 import re
 from collections.abc import AsyncIterator, Sequence
 from contextlib import asynccontextmanager
 from copy import deepcopy
 from dataclasses import dataclass, field
 from datetime import datetime
-from typing import Annotated, Any, Literal, Protocol, Union, cast, overload
+from typing import Annotated, Any, Literal, Protocol, Union, cast
 from uuid import uuid4
 
+import httpx
 import pydantic
-from httpx import USE_CLIENT_DEFAULT, AsyncClient as AsyncHTTPClient, Response as HTTPResponse
-from typing_extensions import NotRequired, TypedDict, assert_never, deprecated
+from httpx import USE_CLIENT_DEFAULT, Response as HTTPResponse
+from typing_extensions import NotRequired, TypedDict, assert_never
 
 from pydantic_ai.providers import Provider, infer_provider
 
@@ -85,78 +85,36 @@ class GeminiModel(Model):
     Apart from `__init__`, all methods are private or match those of the base class.
     """
 
-    client: AsyncHTTPClient = field(repr=False)
+    client: httpx.AsyncClient = field(repr=False)
 
     _model_name: GeminiModelName = field(repr=False)
-    _provider: Literal['google-gla', 'google-vertex'] | Provider[AsyncHTTPClient] | None = field(repr=False)
+    _provider: Literal['google-gla', 'google-vertex'] | Provider[httpx.AsyncClient] | None = field(repr=False)
     _auth: AuthProtocol | None = field(repr=False)
     _url: str | None = field(repr=False)
     _system: str = field(default='gemini', repr=False)
 
-    @overload
     def __init__(
         self,
         model_name: GeminiModelName,
         *,
-        provider: Literal['google-gla', 'google-vertex'] | Provider[AsyncHTTPClient] = 'google-gla',
-    ) -> None: ...
-
-    @deprecated('Use the `provider` argument instead of the `api_key`, `http_client`, and `url_template` arguments.')
-    @overload
-    def __init__(
-        self,
-        model_name: GeminiModelName,
-        *,
-        provider: None = None,
-        api_key: str | None = None,
-        http_client: AsyncHTTPClient | None = None,
-        url_template: str = 'https://generativelanguage.googleapis.com/v1beta/models/{model}:',
-    ) -> None: ...
-
-    def __init__(
-        self,
-        model_name: GeminiModelName,
-        *,
-        provider: Literal['google-gla', 'google-vertex'] | Provider[AsyncHTTPClient] | None = None,
-        api_key: str | None = None,
-        http_client: AsyncHTTPClient | None = None,
-        url_template: str = 'https://generativelanguage.googleapis.com/v1beta/models/{model}:',
+        provider: Literal['google-gla', 'google-vertex'] | Provider[httpx.AsyncClient] = 'google-gla',
     ):
         """Initialize a Gemini model.
 
         Args:
             model_name: The name of the model to use.
-            provider: The provider to use for the model.
-            api_key: The API key to use for authentication, if not provided, the `GEMINI_API_KEY` environment variable
-                will be used if available.
-            http_client: An existing `httpx.AsyncClient` to use for making HTTP requests.
-            url_template: The URL template to use for making requests, you shouldn't need to change this,
-                docs [here](https://ai.google.dev/gemini-api/docs/quickstart?lang=rest#make-first-request),
-                `model` is substituted with the model name, and `function` is added to the end of the URL.
+            provider: The provider to use for authentication and API access. Can be either the string
+                'google-gla' or 'google-vertex' or an instance of `Provider[httpx.AsyncClient]`.
+                If not provided, a new provider will be created using the other parameters.
         """
         self._model_name = model_name
         self._provider = provider
 
-        if provider is not None:
-            if isinstance(provider, str):
-                provider = infer_provider(provider)
-            self._system = provider.name
-            self.client = provider.client
-            self._url = str(self.client.base_url)
-        else:
-            if api_key is None:
-                if env_api_key := os.getenv('GEMINI_API_KEY'):
-                    api_key = env_api_key
-                else:
-                    raise UserError('API key must be provided or set in the GEMINI_API_KEY environment variable')
-            self.client = http_client or cached_async_http_client()
-            self._auth = ApiKeyAuth(api_key)
-            self._url = url_template.format(model=model_name)
-
-    @property
-    def auth(self) -> AuthProtocol:
-        assert self._auth is not None, 'Auth not initialized'
-        return self._auth
+        if isinstance(provider, str):
+            provider = infer_provider(provider)
+        self._system = provider.name
+        self.client = provider.client
+        self._url = str(self.client.base_url)
 
     @property
     def base_url(self) -> str:
@@ -252,18 +210,10 @@ class GeminiModel(Model):
         if generation_config:
             request_data['generation_config'] = generation_config
 
-        headers = {
-            'Content-Type': 'application/json',
-            'User-Agent': get_user_agent(),
-        }
-        if self._provider is None:  # pragma: no cover
-            url = self.base_url + ('streamGenerateContent' if streamed else 'generateContent')
-            headers.update(await self.auth.headers())
-        else:
-            url = f'/{self._model_name}:{"streamGenerateContent" if streamed else "generateContent"}'
+        headers = {'Content-Type': 'application/json', 'User-Agent': get_user_agent()}
+        url = f'/{self._model_name}:{"streamGenerateContent" if streamed else "generateContent"}'
 
         request_json = _gemini_request_ta.dump_json(request_data, by_alias=True)
-
         async with self.client.stream(
             'POST',
             url,
@@ -603,12 +553,7 @@ def _process_response_from_parts(
         if 'text' in part:
             items.append(TextPart(content=part['text']))
         elif 'function_call' in part:
-            items.append(
-                ToolCallPart(
-                    tool_name=part['function_call']['name'],
-                    args=part['function_call']['args'],
-                )
-            )
+            items.append(ToolCallPart(tool_name=part['function_call']['name'], args=part['function_call']['args']))
         elif 'function_response' in part:
             raise UnexpectedModelBehavior(
                 f'Unsupported response from Gemini, expected all parts to be function calls or text, got: {part!r}'

pydantic_ai/models/groq.py

@@ -8,8 +8,7 @@ from datetime import datetime, timezone
 from itertools import chain
 from typing import Literal, Union, cast, overload
 
-from httpx import AsyncClient as AsyncHTTPClient
-from typing_extensions import assert_never, deprecated
+from typing_extensions import assert_never
 
 from .. import ModelHTTPError, UnexpectedModelBehavior, _utils, usage
 from .._utils import guard_tool_call_id as _guard_tool_call_id
@@ -32,7 +31,7 @@ from ..messages import (
 from ..providers import Provider, infer_provider
 from ..settings import ModelSettings
 from ..tools import ToolDefinition
-from . import Model, ModelRequestParameters, StreamedResponse, cached_async_http_client, check_allow_model_requests
+from . import Model, ModelRequestParameters, StreamedResponse, check_allow_model_requests
 
 try:
     from groq import NOT_GIVEN, APIStatusError, AsyncGroq, AsyncStream
@@ -90,35 +89,7 @@ class GroqModel(Model):
     _model_name: GroqModelName = field(repr=False)
     _system: str = field(default='groq', repr=False)
 
-    @overload
-    def __init__(
-        self,
-        model_name: GroqModelName,
-        *,
-        provider: Literal['groq'] | Provider[AsyncGroq] = 'groq',
-    ) -> None: ...
-
-    @deprecated('Use the `provider` parameter instead of `api_key`, `groq_client`, and `http_client`.')
-    @overload
-    def __init__(
-        self,
-        model_name: GroqModelName,
-        *,
-        provider: None = None,
-        api_key: str | None = None,
-        groq_client: AsyncGroq | None = None,
-        http_client: AsyncHTTPClient | None = None,
-    ) -> None: ...
-
-    def __init__(
-        self,
-        model_name: GroqModelName,
-        *,
-        provider: Literal['groq'] | Provider[AsyncGroq] | None = None,
-        api_key: str | None = None,
-        groq_client: AsyncGroq | None = None,
-        http_client: AsyncHTTPClient | None = None,
-    ):
+    def __init__(self, model_name: GroqModelName, *, provider: Literal['groq'] | Provider[AsyncGroq] = 'groq'):
         """Initialize a Groq model.
 
         Args:
@@ -127,27 +98,12 @@ class GroqModel(Model):
             provider: The provider to use for authentication and API access. Can be either the string
                 'groq' or an instance of `Provider[AsyncGroq]`. If not provided, a new provider will be
                 created using the other parameters.
-            api_key: The API key to use for authentication, if not provided, the `GROQ_API_KEY` environment variable
-                will be used if available.
-            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`.
-            http_client: An existing `httpx.AsyncClient` to use for making HTTP requests.
         """
         self._model_name = model_name
 
-        if provider is not None:
-            if isinstance(provider, str):
-                provider = infer_provider(provider)
-            self.client = provider.client
-        elif 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`'
-            self.client = groq_client
-        elif http_client is not None:
-            self.client = AsyncGroq(api_key=api_key, http_client=http_client)
-        else:
-            self.client = AsyncGroq(api_key=api_key, http_client=cached_async_http_client())
+        if isinstance(provider, str):
+            provider = infer_provider(provider)
+        self.client = provider.client
 
     @property
     def base_url(self) -> str:
@@ -309,7 +265,7 @@ class GroqModel(Model):
     @staticmethod
     def _map_tool_call(t: ToolCallPart) -> chat.ChatCompletionMessageToolCallParam:
         return chat.ChatCompletionMessageToolCallParam(
-            id=_guard_tool_call_id(t=t, model_source='Groq'),
+            id=_guard_tool_call_id(t=t),
             type='function',
             function={'name': t.tool_name, 'arguments': t.args_as_json_str()},
         )
@@ -335,7 +291,7 @@ class GroqModel(Model):
             elif isinstance(part, ToolReturnPart):
                 yield chat.ChatCompletionToolMessageParam(
                     role='tool',
-                    tool_call_id=_guard_tool_call_id(t=part, model_source='Groq'),
+                    tool_call_id=_guard_tool_call_id(t=part),
                     content=part.model_response_str(),
                 )
             elif isinstance(part, RetryPromptPart):
@@ -344,7 +300,7 @@ class GroqModel(Model):
                 else:
                     yield chat.ChatCompletionToolMessageParam(
                         role='tool',
-                        tool_call_id=_guard_tool_call_id(t=part, model_source='Groq'),
+                        tool_call_id=_guard_tool_call_id(t=part),
                         content=part.model_response(),
                     )
 

pydantic_ai/models/mistral.py

@@ -1,20 +1,19 @@
 from __future__ import annotations as _annotations
 
 import base64
-import os
 from collections.abc import AsyncIterable, AsyncIterator, Iterable
 from contextlib import asynccontextmanager
 from dataclasses import dataclass, field
 from datetime import datetime, timezone
 from itertools import chain
-from typing import Any, Callable, Literal, Union, cast, overload
+from typing import Any, Literal, Union, cast
 
 import pydantic_core
-from httpx import AsyncClient as AsyncHTTPClient, Timeout
-from typing_extensions import assert_never, deprecated
+from httpx import Timeout
+from typing_extensions import assert_never
 
 from .. import ModelHTTPError, UnexpectedModelBehavior, _utils
-from .._utils import now_utc as _now_utc
+from .._utils import generate_tool_call_id as _generate_tool_call_id, now_utc as _now_utc
 from ..messages import (
     BinaryContent,
     DocumentUrl,
@@ -39,7 +38,6 @@ from . import (
     Model,
     ModelRequestParameters,
     StreamedResponse,
-    cached_async_http_client,
     check_allow_model_requests,
 )
 
@@ -113,65 +111,28 @@ class MistralModel(Model):
     _model_name: MistralModelName = field(repr=False)
     _system: str = field(default='mistral_ai', repr=False)
 
-    @overload
     def __init__(
         self,
         model_name: MistralModelName,
         *,
         provider: Literal['mistral'] | Provider[Mistral] = 'mistral',
         json_mode_schema_prompt: str = """Answer in JSON Object, respect the format:\n```\n{schema}\n```\n""",
-    ) -> None: ...
-
-    @overload
-    @deprecated('Use the `provider` parameter instead of `api_key`, `client` and `http_client`.')
-    def __init__(
-        self,
-        model_name: MistralModelName,
-        *,
-        provider: None = None,
-        api_key: str | Callable[[], str | None] | None = None,
-        client: Mistral | None = None,
-        http_client: AsyncHTTPClient | None = None,
-        json_mode_schema_prompt: str = """Answer in JSON Object, respect the format:\n```\n{schema}\n```\n""",
-    ) -> None: ...
-
-    def __init__(
-        self,
-        model_name: MistralModelName,
-        *,
-        provider: Literal['mistral'] | Provider[Mistral] | None = None,
-        api_key: str | Callable[[], str | None] | None = None,
-        client: Mistral | None = None,
-        http_client: AsyncHTTPClient | None = None,
-        json_mode_schema_prompt: str = """Answer in JSON Object, respect the format:\n```\n{schema}\n```\n""",
     ):
         """Initialize a Mistral model.
 
         Args:
+            model_name: The name of the model to use.
             provider: The provider to use for authentication and API access. Can be either the string
                 'mistral' or an instance of `Provider[Mistral]`. If not provided, a new provider will be
                 created using the other parameters.
-            model_name: The name of the model to use.
-            api_key: The API key to use for authentication, if unset uses `MISTRAL_API_KEY` environment variable.
-            client: An existing `Mistral` client to use, if provided, `api_key` and `http_client` must be `None`.
-            http_client: An existing `httpx.AsyncClient` to use for making HTTP requests.
             json_mode_schema_prompt: The prompt to show when the model expects a JSON object as input.
         """
         self._model_name = model_name
         self.json_mode_schema_prompt = json_mode_schema_prompt
 
-        if provider is not None:
-            if isinstance(provider, str):
-                # TODO(Marcelo): We should add an integration test with VCR when I get the API key.
-                provider = infer_provider(provider)  # pragma: no cover
-            self.client = provider.client
-        elif client is not None:
-            assert http_client is None, 'Cannot provide both `mistral_client` and `http_client`'
-            assert api_key is None, 'Cannot provide both `mistral_client` and `api_key`'
-            self.client = client
-        else:
-            api_key = api_key or os.getenv('MISTRAL_API_KEY')
-            self.client = Mistral(api_key=api_key, async_client=http_client or cached_async_http_client())
+        if isinstance(provider, str):
+            provider = infer_provider(provider)
+        self.client = provider.client
 
     @property
     def base_url(self) -> str:
@@ -380,16 +341,16 @@ class MistralModel(Model):
     @staticmethod
     def _map_mistral_to_pydantic_tool_call(tool_call: MistralToolCall) -> ToolCallPart:
         """Maps a MistralToolCall to a ToolCall."""
-        tool_call_id = tool_call.id or None
+        tool_call_id = tool_call.id or _generate_tool_call_id()
         func_call = tool_call.function
 
         return ToolCallPart(func_call.name, func_call.arguments, tool_call_id)
 
     @staticmethod
-    def _map_pydantic_to_mistral_tool_call(t: ToolCallPart) -> MistralToolCall:
+    def _map_tool_call(t: ToolCallPart) -> MistralToolCall:
         """Maps a pydantic-ai ToolCall to a MistralToolCall."""
         return MistralToolCall(
-            id=t.tool_call_id,
+            id=_utils.guard_tool_call_id(t=t),
             type='function',
             function=MistralFunctionCall(name=t.tool_name, arguments=t.args),
         )
@@ -502,7 +463,7 @@ class MistralModel(Model):
                 if isinstance(part, TextPart):
                     content_chunks.append(MistralTextChunk(text=part.content))
                 elif isinstance(part, ToolCallPart):
-                    tool_calls.append(cls._map_pydantic_to_mistral_tool_call(part))
+                    tool_calls.append(cls._map_tool_call(part))
                 else:
                     assert_never(part)
             yield MistralAssistantMessage(content=content_chunks, tool_calls=tool_calls)

pydantic_ai/models/openai.py

@@ -1,15 +1,13 @@
 from __future__ import annotations as _annotations
 
 import base64
-import os
 from collections.abc import AsyncIterable, AsyncIterator
 from contextlib import asynccontextmanager
 from dataclasses import dataclass, field
 from datetime import datetime, timezone
 from typing import Literal, Union, cast, overload
 
-from httpx import AsyncClient as AsyncHTTPClient
-from typing_extensions import assert_never, deprecated
+from typing_extensions import assert_never
 
 from pydantic_ai.providers import Provider, infer_provider
 
@@ -75,7 +73,7 @@ allows this model to be used more easily with other model types (ie, Ollama, Dee
 OpenAISystemPromptRole = Literal['system', 'developer', 'user']
 
 
-class OpenAIModelSettings(ModelSettings):
+class OpenAIModelSettings(ModelSettings, total=False):
     """Settings used for an OpenAI model request."""
 
     openai_reasoning_effort: chat.ChatCompletionReasoningEffort
@@ -85,6 +83,12 @@ class OpenAIModelSettings(ModelSettings):
     result in faster responses and fewer tokens used on reasoning in a response.
     """
 
+    user: str
+    """A unique identifier representing the end-user, which can help OpenAI monitor and detect abuse.
+
+    See [OpenAI's safety best practices](https://platform.openai.com/docs/guides/safety-best-practices#end-user-ids) for more details.
+    """
+
 
 @dataclass(init=False)
 class OpenAIModel(Model):
@@ -101,39 +105,12 @@ class OpenAIModel(Model):
     _model_name: OpenAIModelName = field(repr=False)
     _system: str = field(default='openai', repr=False)
 
-    @overload
     def __init__(
         self,
         model_name: OpenAIModelName,
         *,
         provider: Literal['openai', 'deepseek', 'azure'] | Provider[AsyncOpenAI] = 'openai',
         system_prompt_role: OpenAISystemPromptRole | None = None,
-    ) -> None: ...
-
-    @deprecated('Use the `provider` parameter instead of `base_url`, `api_key`, `openai_client` and `http_client`.')
-    @overload
-    def __init__(
-        self,
-        model_name: OpenAIModelName,
-        *,
-        provider: None = None,
-        base_url: str | None = None,
-        api_key: str | None = None,
-        openai_client: AsyncOpenAI | None = None,
-        http_client: AsyncHTTPClient | None = None,
-        system_prompt_role: OpenAISystemPromptRole | None = None,
-    ) -> None: ...
-
-    def __init__(
-        self,
-        model_name: OpenAIModelName,
-        *,
-        provider: Literal['openai', 'deepseek', 'azure'] | Provider[AsyncOpenAI] | None = None,
-        base_url: str | None = None,
-        api_key: str | None = None,
-        openai_client: AsyncOpenAI | None = None,
-        http_client: AsyncHTTPClient | None = None,
-        system_prompt_role: OpenAISystemPromptRole | None = None,
     ):
         """Initialize an OpenAI model.
 
@@ -142,43 +119,13 @@ class OpenAIModel(Model):
                 [here](https://github.com/openai/openai-python/blob/v1.54.3/src/openai/types/chat_model.py#L7)
                 (Unfortunately, despite being ask to do so, OpenAI do not provide `.inv` files for their API).
             provider: The provider to use. Defaults to `'openai'`.
-            base_url: The base url for the OpenAI requests. If not provided, the `OPENAI_BASE_URL` environment variable
-                will be used if available. Otherwise, defaults to OpenAI's base url.
-            api_key: The API key to use for authentication, if not provided, the `OPENAI_API_KEY` environment variable
-                will be used if available.
-            openai_client: An existing
-                [`AsyncOpenAI`](https://github.com/openai/openai-python?tab=readme-ov-file#async-usage)
-                client to use. If provided, `base_url`, `api_key`, and `http_client` must be `None`.
-            http_client: An existing `httpx.AsyncClient` to use for making HTTP requests.
             system_prompt_role: The role to use for the system prompt message. If not provided, defaults to `'system'`.
                 In the future, this may be inferred from the model name.
         """
         self._model_name = model_name
-
-        if provider is not None:
-            if isinstance(provider, str):
-                provider = infer_provider(provider)
-            self.client = provider.client
-        else:  # pragma: no cover
-            # This is a workaround for the OpenAI client requiring an API key, whilst locally served,
-            # openai compatible models do not always need an API key, but a placeholder (non-empty) key is required.
-            if (
-                api_key is None
-                and 'OPENAI_API_KEY' not in os.environ
-                and base_url is not None
-                and openai_client is None
-            ):
-                api_key = 'api-key-not-set'
-
-            if openai_client is not None:
-                assert http_client is None, 'Cannot provide both `openai_client` and `http_client`'
-                assert base_url is None, 'Cannot provide both `openai_client` and `base_url`'
-                assert api_key is None, 'Cannot provide both `openai_client` and `api_key`'
-                self.client = openai_client
-            elif http_client is not None:
-                self.client = AsyncOpenAI(base_url=base_url, api_key=api_key, http_client=http_client)
-            else:
-                self.client = AsyncOpenAI(base_url=base_url, api_key=api_key, http_client=cached_async_http_client())
+        if isinstance(provider, str):
+            provider = infer_provider(provider)
+        self.client = provider.client
         self.system_prompt_role = system_prompt_role
 
     @property
@@ -282,6 +229,7 @@ class OpenAIModel(Model):
                 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),
+                user=model_settings.get('user', NOT_GIVEN),
             )
         except APIStatusError as e:
             if (status_code := e.status_code) >= 400:
@@ -348,7 +296,7 @@ class OpenAIModel(Model):
     @staticmethod
     def _map_tool_call(t: ToolCallPart) -> chat.ChatCompletionMessageToolCallParam:
         return chat.ChatCompletionMessageToolCallParam(
-            id=_guard_tool_call_id(t=t, model_source='OpenAI'),
+            id=_guard_tool_call_id(t=t),
             type='function',
             function={'name': t.tool_name, 'arguments': t.args_as_json_str()},
         )
@@ -378,7 +326,7 @@ class OpenAIModel(Model):
             elif isinstance(part, ToolReturnPart):
                 yield chat.ChatCompletionToolMessageParam(
                     role='tool',
-                    tool_call_id=_guard_tool_call_id(t=part, model_source='OpenAI'),
+                    tool_call_id=_guard_tool_call_id(t=part),
                     content=part.model_response_str(),
                 )
             elif isinstance(part, RetryPromptPart):
@@ -387,7 +335,7 @@ class OpenAIModel(Model):
                 else:
                     yield chat.ChatCompletionToolMessageParam(
                         role='tool',
-                        tool_call_id=_guard_tool_call_id(t=part, model_source='OpenAI'),
+                        tool_call_id=_guard_tool_call_id(t=part),
                         content=part.model_response(),
                     )
             else:

pydantic_ai/providers/anthropic.py

@@ -5,7 +5,9 @@ from typing import overload
 
 import httpx
 
+from pydantic_ai.exceptions import UserError
 from pydantic_ai.models import cached_async_http_client
+from pydantic_ai.providers import Provider
 
 try:
     from anthropic import AsyncAnthropic
@@ -16,9 +18,6 @@ except ImportError as _import_error:  # pragma: no cover
     ) from _import_error
 
 
-from . import Provider
-
-
 class AnthropicProvider(Provider[AsyncAnthropic]):
     """Provider for Anthropic API."""
 
@@ -62,8 +61,8 @@ class AnthropicProvider(Provider[AsyncAnthropic]):
             self._client = anthropic_client
         else:
             api_key = api_key or os.environ.get('ANTHROPIC_API_KEY')
-            if api_key is None:
-                raise ValueError(
+            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.'
                 )
@@ -71,4 +70,5 @@ class AnthropicProvider(Provider[AsyncAnthropic]):
             if http_client is not None:
                 self._client = AsyncAnthropic(api_key=api_key, http_client=http_client)
             else:
-                self._client = AsyncAnthropic(api_key=api_key, http_client=cached_async_http_client())
+                http_client = cached_async_http_client(provider='anthropic')
+                self._client = AsyncAnthropic(api_key=api_key, http_client=http_client)

pydantic_ai/providers/azure.py

@@ -6,7 +6,9 @@ from typing import overload
 import httpx
 from openai import AsyncOpenAI
 
+from pydantic_ai.exceptions import UserError
 from pydantic_ai.models import cached_async_http_client
+from pydantic_ai.providers import Provider
 
 try:
     from openai import AsyncAzureOpenAI
@@ -17,9 +19,6 @@ except ImportError as _import_error:  # pragma: no cover
     ) from _import_error
 
 
-from . import Provider
-
-
 class AzureProvider(Provider[AsyncOpenAI]):
     """Provider for Azure OpenAI API.
 
@@ -83,22 +82,22 @@ class AzureProvider(Provider[AsyncOpenAI]):
             self._client = openai_client
         else:
             azure_endpoint = azure_endpoint or os.getenv('AZURE_OPENAI_ENDPOINT')
-            if azure_endpoint is None:  # pragma: no cover
-                raise ValueError(
+            if not azure_endpoint:  # pragma: no cover
+                raise UserError(
                     'Must provide one of the `azure_endpoint` argument or the `AZURE_OPENAI_ENDPOINT` environment variable'
                 )
 
-            if api_key is None and 'OPENAI_API_KEY' not in os.environ:  # pragma: no cover
-                raise ValueError(
+            if not api_key and 'OPENAI_API_KEY' not in os.environ:  # pragma: no cover
+                raise UserError(
                     'Must provide one of the `api_key` argument or the `OPENAI_API_KEY` environment variable'
                 )
 
-            if api_version is None and 'OPENAI_API_VERSION' not in os.environ:  # pragma: no cover
-                raise ValueError(
+            if not api_version and 'OPENAI_API_VERSION' not in os.environ:  # pragma: no cover
+                raise UserError(
                     'Must provide one of the `api_version` argument or the `OPENAI_API_VERSION` environment variable'
                 )
 
-            http_client = http_client or cached_async_http_client()
+            http_client = http_client or cached_async_http_client(provider='azure')
             self._client = AsyncAzureOpenAI(
                 azure_endpoint=azure_endpoint,
                 api_key=api_key,

pydantic_ai/providers/bedrock.py

@@ -2,6 +2,7 @@ from __future__ import annotations as _annotations
 
 from typing import overload
 
+from pydantic_ai.exceptions import UserError
 from pydantic_ai.providers import Provider
 
 try:
@@ -73,4 +74,4 @@ class BedrockProvider(Provider[BaseClient]):
                     region_name=region_name,
                 )
             except NoRegionError as exc:  # pragma: no cover
-                raise ValueError('You must provide a `region_name` or a boto3 client for Bedrock Runtime.') from exc
+                raise UserError('You must provide a `region_name` or a boto3 client for Bedrock Runtime.') from exc