pydantic-ai-slim 0.0.43__py3-none-any.whl → 0.0.45__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/instrumented.py

@@ -118,7 +118,7 @@ class InstrumentedModel(WrapperModel):
         model_settings: ModelSettings | None,
         model_request_parameters: ModelRequestParameters,
     ) -> tuple[ModelResponse, Usage]:
-        with self._instrument(messages, model_settings) as finish:
+        with self._instrument(messages, model_settings, model_request_parameters) as finish:
             response, usage = await super().request(messages, model_settings, model_request_parameters)
             finish(response, usage)
             return response, usage
@@ -130,7 +130,7 @@ class InstrumentedModel(WrapperModel):
         model_settings: ModelSettings | None,
         model_request_parameters: ModelRequestParameters,
     ) -> AsyncIterator[StreamedResponse]:
-        with self._instrument(messages, model_settings) as finish:
+        with self._instrument(messages, model_settings, model_request_parameters) as finish:
             response_stream: StreamedResponse | None = None
             try:
                 async with super().request_stream(
@@ -146,6 +146,7 @@ class InstrumentedModel(WrapperModel):
         self,
         messages: list[ModelMessage],
         model_settings: ModelSettings | None,
+        model_request_parameters: ModelRequestParameters,
     ) -> Iterator[Callable[[ModelResponse, Usage], None]]:
         operation = 'chat'
         span_name = f'{operation} {self.model_name}'
@@ -155,6 +156,13 @@ class InstrumentedModel(WrapperModel):
         attributes: dict[str, AttributeValue] = {
             'gen_ai.operation.name': operation,
             **self.model_attributes(self.wrapped),
+            'model_request_parameters': json.dumps(InstrumentedModel.serialize_any(model_request_parameters)),
+            'logfire.json_schema': json.dumps(
+                {
+                    'type': 'object',
+                    'properties': {'model_request_parameters': {'type': 'object'}},
+                }
+            ),
         }
 
         if model_settings:
@@ -207,7 +215,10 @@ class InstrumentedModel(WrapperModel):
                     'logfire.json_schema': json.dumps(
                         {
                             'type': 'object',
-                            'properties': {attr_name: {'type': 'array'}},
+                            'properties': {
+                                attr_name: {'type': 'array'},
+                                'model_request_parameters': {'type': 'object'},
+                            },
                         }
                     ),
                 }

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):
@@ -99,44 +103,14 @@ class OpenAIModel(Model):
     system_prompt_role: OpenAISystemPromptRole | None = field(default=None)
 
     _model_name: OpenAIModelName = field(repr=False)
-    _system: str = 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,
-        system: str = 'openai',
-    ) -> 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,
-        system: str = 'openai',
-    ) -> 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,
-        system: str = 'openai',
     ):
         """Initialize an OpenAI model.
 
@@ -145,47 +119,14 @@ 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.
-            system: The model provider used, defaults to `openai`. This is for observability purposes, you must
-                customize the `base_url` and `api_key` to use a different provider.
         """
         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
-        self._system = system
 
     @property
     def base_url(self) -> str:
@@ -279,7 +220,7 @@ class OpenAIModel(Model):
                 tool_choice=tool_choice or NOT_GIVEN,
                 stream=stream,
                 stream_options={'include_usage': True} if stream else NOT_GIVEN,
-                max_tokens=model_settings.get('max_tokens', NOT_GIVEN),
+                max_completion_tokens=model_settings.get('max_tokens', NOT_GIVEN),
                 temperature=model_settings.get('temperature', NOT_GIVEN),
                 top_p=model_settings.get('top_p', NOT_GIVEN),
                 timeout=model_settings.get('timeout', NOT_GIVEN),
@@ -288,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:
@@ -354,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()},
         )
@@ -384,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):
@@ -393,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/__init__.py

@@ -77,5 +77,9 @@ def infer_provider(provider: str) -> Provider[Any]:
         from .mistral import MistralProvider
 
         return MistralProvider()
+    elif provider == 'cohere':
+        from .cohere import CohereProvider
+
+        return CohereProvider()
     else:  # pragma: no cover
         raise ValueError(f'Unknown provider: {provider}')

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