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

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.'
                 )

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,18 +82,18 @@ 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'
                 )
 

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

pydantic_ai/providers/cohere.py

@@ -4,7 +4,9 @@ import os
 
 from httpx import AsyncClient as AsyncHTTPClient
 
+from pydantic_ai.exceptions import UserError
 from pydantic_ai.models import cached_async_http_client
+from pydantic_ai.providers import Provider
 
 try:
     from cohere import AsyncClientV2
@@ -15,9 +17,6 @@ except ImportError as _import_error:  # pragma: no cover
     ) from _import_error
 
 
-from . import Provider
-
-
 class CohereProvider(Provider[AsyncClientV2]):
     """Provider for Cohere API."""
 
@@ -57,8 +56,8 @@ class CohereProvider(Provider[AsyncClientV2]):
             self._client = cohere_client
         else:
             api_key = api_key or os.environ.get('CO_API_KEY')
-            if api_key is None:
-                raise ValueError(
+            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.'
                 )

pydantic_ai/providers/deepseek.py

@@ -6,7 +6,9 @@ from typing import overload
 from httpx import AsyncClient as AsyncHTTPClient
 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 AsyncOpenAI
@@ -16,8 +18,6 @@ except ImportError as _import_error:  # pragma: no cover
         'you can use the `openai` optional group — `pip install "pydantic-ai-slim[openai]"`'
     ) from _import_error
 
-from . import Provider
-
 
 class DeepSeekProvider(Provider[AsyncOpenAI]):
     """Provider for DeepSeek API."""
@@ -54,8 +54,8 @@ class DeepSeekProvider(Provider[AsyncOpenAI]):
         http_client: AsyncHTTPClient | None = None,
     ) -> None:
         api_key = api_key or os.getenv('DEEPSEEK_API_KEY')
-        if api_key is None and openai_client is None:
-            raise ValueError(
+        if not api_key and openai_client is None:
+            raise UserError(
                 'Set the `DEEPSEEK_API_KEY` environment variable or pass it via `DeepSeekProvider(api_key=...)`'
                 'to use the DeepSeek provider.'
             )

pydantic_ai/providers/google_gla.py

@@ -4,6 +4,7 @@ import os
 
 import httpx
 
+from pydantic_ai.exceptions import UserError
 from pydantic_ai.models import cached_async_http_client
 from pydantic_ai.providers import Provider
 
@@ -32,8 +33,8 @@ class GoogleGLAProvider(Provider[httpx.AsyncClient]):
             http_client: An existing `httpx.AsyncClient` to use for making HTTP requests.
         """
         api_key = api_key or os.environ.get('GEMINI_API_KEY')
-        if api_key is None:
-            raise ValueError(
+        if not api_key:
+            raise UserError(
                 'Set the `GEMINI_API_KEY` environment variable or pass it via `GoogleGLAProvider(api_key=...)`'
                 'to use the Google GLA provider.'
             )

pydantic_ai/providers/google_vertex.py

@@ -9,9 +9,8 @@ import anyio.to_thread
 import httpx
 
 from pydantic_ai.exceptions import UserError
-
-from ..models import cached_async_http_client
-from . import Provider
+from pydantic_ai.models import cached_async_http_client
+from pydantic_ai.providers import Provider
 
 try:
     import google.auth

pydantic_ai/providers/groq.py

@@ -5,7 +5,9 @@ from typing import overload
 
 from httpx import AsyncClient as AsyncHTTPClient
 
+from pydantic_ai.exceptions import UserError
 from pydantic_ai.models import cached_async_http_client
+from pydantic_ai.providers import Provider
 
 try:
     from groq import AsyncGroq
@@ -16,9 +18,6 @@ except ImportError as _import_error:  # pragma: no cover
     ) from _import_error
 
 
-from . import Provider
-
-
 class GroqProvider(Provider[AsyncGroq]):
     """Provider for Groq API."""
 
@@ -64,8 +63,8 @@ class GroqProvider(Provider[AsyncGroq]):
         else:
             api_key = api_key or os.environ.get('GROQ_API_KEY')
 
-            if api_key is None:
-                raise ValueError(
+            if not api_key:
+                raise UserError(
                     'Set the `GROQ_API_KEY` environment variable or pass it via `GroqProvider(api_key=...)`'
                     'to use the Groq provider.'
                 )

pydantic_ai/providers/mistral.py

@@ -5,7 +5,9 @@ from typing import overload
 
 from httpx import AsyncClient as AsyncHTTPClient
 
+from pydantic_ai.exceptions import UserError
 from pydantic_ai.models import cached_async_http_client
+from pydantic_ai.providers import Provider
 
 try:
     from mistralai import Mistral
@@ -16,9 +18,6 @@ except ImportError as e:  # pragma: no cover
     ) from e
 
 
-from . import Provider
-
-
 class MistralProvider(Provider[Mistral]):
     """Provider for Mistral API."""
 
@@ -62,8 +61,8 @@ class MistralProvider(Provider[Mistral]):
         else:
             api_key = api_key or os.environ.get('MISTRAL_API_KEY')
 
-            if api_key is None:
-                raise ValueError(
+            if not api_key:
+                raise UserError(
                     'Set the `MISTRAL_API_KEY` environment variable or pass it via `MistralProvider(api_key=...)`'
                     'to use the Mistral provider.'
                 )