pydantic-ai-slim 0.0.43__tar.gz → 0.0.45__tar.gz

{pydantic_ai_slim-0.0.43 → pydantic_ai_slim-0.0.45}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai-slim
-Version: 0.0.43
+Version: 0.0.45
 Summary: Agent Framework / shim to use Pydantic with LLMs, slim package
 Author-email: Samuel Colvin <samuel@pydantic.dev>
 License-Expression: MIT
@@ -29,7 +29,7 @@ Requires-Dist: exceptiongroup; python_version < '3.11'
 Requires-Dist: griffe>=1.3.2
 Requires-Dist: httpx>=0.27
 Requires-Dist: opentelemetry-api>=1.28.0
-Requires-Dist: pydantic-graph==0.0.43
+Requires-Dist: pydantic-graph==0.0.45
 Requires-Dist: pydantic>=2.10
 Requires-Dist: typing-inspection>=0.4.0
 Provides-Extra: anthropic
@@ -53,7 +53,7 @@ Requires-Dist: mcp>=1.4.1; (python_version >= '3.10') and extra == 'mcp'
 Provides-Extra: mistral
 Requires-Dist: mistralai>=1.2.5; extra == 'mistral'
 Provides-Extra: openai
-Requires-Dist: openai>=1.65.1; extra == 'openai'
+Requires-Dist: openai>=1.67.0; extra == 'openai'
 Provides-Extra: tavily
 Requires-Dist: tavily-python>=0.5.0; extra == 'tavily'
 Provides-Extra: vertexai

{pydantic_ai_slim-0.0.43 → pydantic_ai_slim-0.0.45}/pydantic_ai/_cli.py

@@ -37,7 +37,7 @@ except ImportError as _import_error:
 from pydantic_ai.agent import Agent
 from pydantic_ai.messages import ModelMessage, PartDeltaEvent, TextPartDelta
 
-__version__ = version('pydantic-ai')
+__version__ = version('pydantic-ai-slim')
 
 
 class SimpleCodeBlock(CodeBlock):

{pydantic_ai_slim-0.0.43 → pydantic_ai_slim-0.0.45}/pydantic_ai/_griffe.py

@@ -22,8 +22,16 @@ def doc_descriptions(
 ) -> tuple[str, dict[str, str]]:
     """Extract the function description and parameter descriptions from a function's docstring.
 
+    The function parses the docstring using the specified format (or infers it if 'auto')
+    and extracts both the main description and parameter descriptions. If a returns section
+    is present in the docstring, the main description will be formatted as XML.
+
     Returns:
-        A tuple of (main function description, parameter descriptions).
+        A tuple containing:
+        - str: Main description string, which may be either:
+            * Plain text if no returns section is present
+            * XML-formatted if returns section exists, including <summary> and <returns> tags
+        - dict[str, str]: Dictionary mapping parameter names to their descriptions
     """
     doc = func.__doc__
     if doc is None:
@@ -33,7 +41,14 @@ def doc_descriptions(
     parent = cast(GriffeObject, sig)
 
     docstring_style = _infer_docstring_style(doc) if docstring_format == 'auto' else docstring_format
-    docstring = Docstring(doc, lineno=1, parser=docstring_style, parent=parent)
+    docstring = Docstring(
+        doc,
+        lineno=1,
+        parser=docstring_style,
+        parent=parent,
+        # https://mkdocstrings.github.io/griffe/reference/docstrings/#google-options
+        parser_options={'returns_named_value': False, 'returns_multiple_items': False},
+    )
     with _disable_griffe_logging():
         sections = docstring.parse()
 
@@ -45,6 +60,18 @@ def doc_descriptions(
     if main := next((p for p in sections if p.kind == DocstringSectionKind.text), None):
         main_desc = main.value
 
+    if return_ := next((p for p in sections if p.kind == DocstringSectionKind.returns), None):
+        return_statement = return_.value[0]
+        return_desc = return_statement.description
+        return_type = return_statement.annotation
+        type_tag = f'<type>{return_type}</type>\n' if return_type else ''
+        return_xml = f'<returns>\n{type_tag}<description>{return_desc}</description>\n</returns>'
+
+        if main_desc:
+            main_desc = f'<summary>{main_desc}</summary>\n{return_xml}'
+        else:
+            main_desc = return_xml
+
     return main_desc, params
 
 

{pydantic_ai_slim-0.0.43 → pydantic_ai_slim-0.0.45}/pydantic_ai/_parts_manager.py

@@ -29,6 +29,8 @@ from pydantic_ai.messages import (
     ToolCallPartDelta,
 )
 
+from ._utils import generate_tool_call_id as _generate_tool_call_id
+
 VendorId = Hashable
 """
 Type alias for a vendor identifier, which can be any hashable type (e.g., a string, UUID, etc.)
@@ -221,7 +223,11 @@ class ModelResponsePartsManager:
             ModelResponseStreamEvent: A `PartStartEvent` indicating that a new tool call part
             has been added to the manager, or replaced an existing part.
         """
-        new_part = ToolCallPart(tool_name=tool_name, args=args, tool_call_id=tool_call_id)
+        new_part = ToolCallPart(
+            tool_name=tool_name,
+            args=args,
+            tool_call_id=tool_call_id or _generate_tool_call_id(),
+        )
         if vendor_part_id is None:
             # vendor_part_id is None, so we unconditionally append a new ToolCallPart to the end of the list
             new_part_index = len(self._parts)

{pydantic_ai_slim-0.0.43 → pydantic_ai_slim-0.0.45}/pydantic_ai/_utils.py

@@ -2,6 +2,7 @@ from __future__ import annotations as _annotations
 
 import asyncio
 import time
+import uuid
 from collections.abc import AsyncIterable, AsyncIterator, Iterator
 from contextlib import asynccontextmanager, suppress
 from dataclasses import dataclass, is_dataclass
@@ -195,12 +196,17 @@ def now_utc() -> datetime:
     return datetime.now(tz=timezone.utc)
 
 
-def guard_tool_call_id(
-    t: _messages.ToolCallPart | _messages.ToolReturnPart | _messages.RetryPromptPart, model_source: str
-) -> str:
-    """Type guard that checks a `tool_call_id` is not None both for static typing and runtime."""
-    assert t.tool_call_id is not None, f'{model_source} requires `tool_call_id` to be set: {t}'
-    return t.tool_call_id
+def guard_tool_call_id(t: _messages.ToolCallPart | _messages.ToolReturnPart | _messages.RetryPromptPart) -> str:
+    """Type guard that either returns the tool call id or generates a new one if it's None."""
+    return t.tool_call_id or generate_tool_call_id()
+
+
+def generate_tool_call_id() -> str:
+    """Generate a tool call id.
+
+    Ensure that the tool call id is unique.
+    """
+    return f'pyd_ai_{uuid.uuid4().hex}'
 
 
 class PeekableAsyncStream(Generic[T]):

{pydantic_ai_slim-0.0.43 → pydantic_ai_slim-0.0.45}/pydantic_ai/agent.py

@@ -13,7 +13,7 @@ from pydantic.json_schema import GenerateJsonSchema
 from typing_extensions import TypeGuard, TypeVar, deprecated
 
 from pydantic_graph import End, Graph, GraphRun, GraphRunContext
-from pydantic_graph._utils import get_event_loop
+from pydantic_graph._utils import run_until_complete
 
 from . import (
     _agent_graph,
@@ -567,7 +567,7 @@ class Agent(Generic[AgentDepsT, ResultDataT]):
         """
         if infer_name and self.name is None:
             self._infer_name(inspect.currentframe())
-        return get_event_loop().run_until_complete(
+        return run_until_complete(
             self.run(
                 user_prompt,
                 result_type=result_type,

{pydantic_ai_slim-0.0.43 → pydantic_ai_slim-0.0.45}/pydantic_ai/exceptions.py

@@ -3,9 +3,9 @@ from __future__ import annotations as _annotations
 import json
 import sys
 
-if sys.version_info < (3, 11):
+if sys.version_info < (3, 11):  # pragma: no cover
     from exceptiongroup import ExceptionGroup
-else:
+else:  # pragma: no cover
     ExceptionGroup = ExceptionGroup
 
 __all__ = (

{pydantic_ai_slim-0.0.43 → pydantic_ai_slim-0.0.45}/pydantic_ai/messages.py

@@ -12,7 +12,7 @@ import pydantic_core
 from opentelemetry._events import Event
 from typing_extensions import TypeAlias
 
-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 .exceptions import UnexpectedModelBehavior
 
 
@@ -268,8 +268,8 @@ class ToolReturnPart:
     content: Any
     """The return value."""
 
-    tool_call_id: str | None = None
-    """Optional tool call identifier, this is used by some models including OpenAI."""
+    tool_call_id: str
+    """The tool call identifier, this is used by some models including OpenAI."""
 
     timestamp: datetime = field(default_factory=_now_utc)
     """The timestamp, when the tool returned."""
@@ -328,8 +328,11 @@ class RetryPromptPart:
     tool_name: str | None = None
     """The name of the tool that was called, if any."""
 
-    tool_call_id: str | None = None
-    """Optional tool call identifier, this is used by some models including OpenAI."""
+    tool_call_id: str = field(default_factory=_generate_tool_call_id)
+    """The tool call identifier, this is used by some models including OpenAI.
+
+    In case the tool call id is not provided by the model, PydanticAI will generate a random one.
+    """
 
     timestamp: datetime = field(default_factory=_now_utc)
     """The timestamp, when the retry was triggered."""
@@ -406,8 +409,11 @@ class ToolCallPart:
     This is stored either as a JSON string or a Python dictionary depending on how data was received.
     """
 
-    tool_call_id: str | None = None
-    """Optional tool call identifier, this is used by some models including OpenAI."""
+    tool_call_id: str = field(default_factory=_generate_tool_call_id)
+    """The tool call identifier, this is used by some models including OpenAI.
+
+    In case the tool call id is not provided by the model, PydanticAI will generate a random one.
+    """
 
     part_kind: Literal['tool-call'] = 'tool-call'
     """Part type identifier, this is available on all parts as a discriminator."""
@@ -564,11 +570,7 @@ class ToolCallPartDelta:
         if self.tool_name_delta is None or self.args_delta is None:
             return None
 
-        return ToolCallPart(
-            self.tool_name_delta,
-            self.args_delta,
-            self.tool_call_id,
-        )
+        return ToolCallPart(self.tool_name_delta, self.args_delta, self.tool_call_id or _generate_tool_call_id())
 
     @overload
     def apply(self, part: ModelResponsePart) -> ToolCallPart: ...
@@ -620,20 +622,11 @@ class ToolCallPartDelta:
             delta = replace(delta, args_delta=updated_args_delta)
 
         if self.tool_call_id:
-            # Set the tool_call_id if it wasn't present, otherwise error if it has changed
-            if delta.tool_call_id is not None and delta.tool_call_id != self.tool_call_id:
-                raise UnexpectedModelBehavior(
-                    f'Cannot apply a new tool_call_id to a ToolCallPartDelta that already has one ({delta=}, {self=})'
-                )
             delta = replace(delta, tool_call_id=self.tool_call_id)
 
         # If we now have enough data to create a full ToolCallPart, do so
         if delta.tool_name_delta is not None and delta.args_delta is not None:
-            return ToolCallPart(
-                delta.tool_name_delta,
-                delta.args_delta,
-                delta.tool_call_id,
-            )
+            return ToolCallPart(delta.tool_name_delta, delta.args_delta, delta.tool_call_id or _generate_tool_call_id())
 
         return delta
 
@@ -656,11 +649,6 @@ class ToolCallPartDelta:
             part = replace(part, args=updated_dict)
 
         if self.tool_call_id:
-            # Replace the tool_call_id entirely if given
-            if part.tool_call_id is not None and part.tool_call_id != self.tool_call_id:
-                raise UnexpectedModelBehavior(
-                    f'Cannot apply a new tool_call_id to a ToolCallPartDelta that already has one ({part=}, {self=})'
-                )
             part = replace(part, tool_call_id=self.tool_call_id)
         return part
 

{pydantic_ai_slim-0.0.43 → pydantic_ai_slim-0.0.45}/pydantic_ai/models/__init__.py

@@ -12,7 +12,7 @@ from contextlib import asynccontextmanager, contextmanager
 from dataclasses import dataclass, field
 from datetime import datetime
 from functools import cache
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, cast
 
 import httpx
 from typing_extensions import Literal
@@ -133,8 +133,6 @@ KnownModelName = Literal[
     'gpt-4-turbo-2024-04-09',
     'gpt-4-turbo-preview',
     'gpt-4-vision-preview',
-    'gpt-4.5-preview',
-    'gpt-4.5-preview-2025-02-27',
     'gpt-4o',
     'gpt-4o-2024-05-13',
     'gpt-4o-2024-08-06',
@@ -146,6 +144,10 @@ KnownModelName = Literal[
     'gpt-4o-mini-2024-07-18',
     'gpt-4o-mini-audio-preview',
     'gpt-4o-mini-audio-preview-2024-12-17',
+    'gpt-4o-mini-search-preview',
+    'gpt-4o-mini-search-preview-2025-03-11',
+    'gpt-4o-search-preview',
+    'gpt-4o-search-preview-2025-03-11',
     'groq:gemma2-9b-it',
     'groq:llama-3.1-8b-instant',
     'groq:llama-3.2-11b-vision-preview',
@@ -189,8 +191,6 @@ KnownModelName = Literal[
     'openai:gpt-4-turbo-2024-04-09',
     'openai:gpt-4-turbo-preview',
     'openai:gpt-4-vision-preview',
-    'openai:gpt-4.5-preview',
-    'openai:gpt-4.5-preview-2025-02-27',
     'openai:gpt-4o',
     'openai:gpt-4o-2024-05-13',
     'openai:gpt-4o-2024-08-06',
@@ -202,6 +202,10 @@ KnownModelName = Literal[
     'openai:gpt-4o-mini-2024-07-18',
     'openai:gpt-4o-mini-audio-preview',
     'openai:gpt-4o-mini-audio-preview-2024-12-17',
+    'openai:gpt-4o-mini-search-preview',
+    'openai:gpt-4o-mini-search-preview-2025-03-11',
+    'openai:gpt-4o-search-preview',
+    'openai:gpt-4o-search-preview-2025-03-11',
     'openai:o1',
     'openai:o1-2024-12-17',
     'openai:o1-mini',
@@ -379,6 +383,7 @@ def infer_model(model: Model | KnownModelName) -> Model:
 
     try:
         provider, model_name = model.split(':', maxsplit=1)
+        provider = cast(str, provider)
     except ValueError:
         model_name = model
         # TODO(Marcelo): We should deprecate this way.
@@ -397,8 +402,7 @@ def infer_model(model: Model | KnownModelName) -> Model:
     if provider == 'cohere':
         from .cohere import CohereModel
 
-        # TODO(Marcelo): Missing provider API.
-        return CohereModel(model_name)
+        return CohereModel(model_name, provider=provider)
     elif provider in ('deepseek', 'openai'):
         from .openai import OpenAIModel
 
@@ -410,22 +414,19 @@ def infer_model(model: Model | KnownModelName) -> Model:
     elif provider == 'groq':
         from .groq import GroqModel
 
-        # TODO(Marcelo): Missing provider API.
-        return GroqModel(model_name)
+        return GroqModel(model_name, provider=provider)
     elif provider == 'mistral':
         from .mistral import MistralModel
 
-        # TODO(Marcelo): Missing provider API.
-        return MistralModel(model_name)
+        return MistralModel(model_name, provider=provider)
     elif provider == 'anthropic':
         from .anthropic import AnthropicModel
 
-        # TODO(Marcelo): Missing provider API.
-        return AnthropicModel(model_name)
+        return AnthropicModel(model_name, provider=provider)
     elif provider == 'bedrock':
         from .bedrock import BedrockConverseModel
 
-        return BedrockConverseModel(model_name)
+        return BedrockConverseModel(model_name, provider=provider)
     else:
         raise UserError(f'Unknown model: {model}')
 

{pydantic_ai_slim-0.0.43 → pydantic_ai_slim-0.0.45}/pydantic_ai/models/anthropic.py

@@ -10,8 +10,7 @@ from json import JSONDecodeError, loads as json_loads
 from typing import Any, Literal, Union, cast, overload
 
 from anthropic.types import DocumentBlockParam
-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
@@ -112,34 +111,11 @@ class AnthropicModel(Model):
     _model_name: AnthropicModelName = field(repr=False)
     _system: str = field(default='anthropic', repr=False)
 
-    @overload
     def __init__(
         self,
         model_name: AnthropicModelName,
         *,
         provider: Literal['anthropic'] | Provider[AsyncAnthropic] = 'anthropic',
-    ) -> None: ...
-
-    @deprecated('Use the `provider` parameter instead of `api_key`, `anthropic_client`, and `http_client`.')
-    @overload
-    def __init__(
-        self,
-        model_name: AnthropicModelName,
-        *,
-        provider: None = None,
-        api_key: str | None = None,
-        anthropic_client: AsyncAnthropic | None = None,
-        http_client: AsyncHTTPClient | None = None,
-    ) -> None: ...
-
-    def __init__(
-        self,
-        model_name: AnthropicModelName,
-        *,
-        provider: Literal['anthropic'] | Provider[AsyncAnthropic] | None = None,
-        api_key: str | None = None,
-        anthropic_client: AsyncAnthropic | None = None,
-        http_client: AsyncHTTPClient | None = None,
     ):
         """Initialize an Anthropic model.
 
@@ -148,27 +124,12 @@ class AnthropicModel(Model):
                 [here](https://docs.anthropic.com/en/docs/about-claude/models).
             provider: The provider to use for the Anthropic API. Can be either the string 'anthropic' or an
                 instance of `Provider[AsyncAnthropic]`. If not provided, the other parameters will be used.
-            api_key: The API key to use for authentication, if not provided, the `ANTHROPIC_API_KEY` environment variable
-                will be used if available.
-            anthropic_client: An existing
-                [`AsyncAnthropic`](https://github.com/anthropics/anthropic-sdk-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 anthropic_client is not None:
-            assert http_client is None, 'Cannot provide both `anthropic_client` and `http_client`'
-            assert api_key is None, 'Cannot provide both `anthropic_client` and `api_key`'
-            self.client = anthropic_client
-        elif 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())
+        if isinstance(provider, str):
+            provider = infer_provider(provider)
+        self.client = provider.client
 
     @property
     def base_url(self) -> str:
@@ -326,7 +287,7 @@ class AnthropicModel(Model):
                             user_content_params.append(content)
                     elif isinstance(request_part, ToolReturnPart):
                         tool_result_block_param = ToolResultBlockParam(
-                            tool_use_id=_guard_tool_call_id(t=request_part, model_source='Anthropic'),
+                            tool_use_id=_guard_tool_call_id(t=request_part),
                             type='tool_result',
                             content=request_part.model_response_str(),
                             is_error=False,
@@ -337,7 +298,7 @@ class AnthropicModel(Model):
                             retry_param = TextBlockParam(type='text', text=request_part.model_response())
                         else:
                             retry_param = ToolResultBlockParam(
-                                tool_use_id=_guard_tool_call_id(t=request_part, model_source='Anthropic'),
+                                tool_use_id=_guard_tool_call_id(t=request_part),
                                 type='tool_result',
                                 content=request_part.model_response(),
                                 is_error=True,
@@ -351,7 +312,7 @@ class AnthropicModel(Model):
                         assistant_content_params.append(TextBlockParam(text=response_part.content, type='text'))
                     else:
                         tool_use_block_param = ToolUseBlockParam(
-                            id=_guard_tool_call_id(t=response_part, model_source='Anthropic'),
+                            id=_guard_tool_call_id(t=response_part),
                             type='tool_use',
                             name=response_part.tool_name,
                             input=response_part.args_as_dict(),

{pydantic_ai_slim-0.0.43 → pydantic_ai_slim-0.0.45}/pydantic_ai/models/bedrock.py

@@ -143,14 +143,15 @@ class BedrockConverseModel(Model):
             model_name: The name of the model to use.
             model_name: The name of the Bedrock model to use. List of model names available
                 [here](https://docs.aws.amazon.com/bedrock/latest/userguide/models-supported.html).
-            provider: The provider to use. Defaults to `'bedrock'`.
+            provider: The provider to use for authentication and API access. Can be either the string
+                'bedrock' or an instance of `Provider[BaseClient]`. If not provided, a new provider will be
+                created using the other parameters.
         """
         self._model_name = model_name
 
         if isinstance(provider, str):
-            self.client = infer_provider(provider).client
-        else:
-            self.client = cast('BedrockRuntimeClient', provider.client)
+            provider = infer_provider(provider)
+        self.client = cast('BedrockRuntimeClient', provider.client)
 
     def _get_tools(self, model_request_parameters: ModelRequestParameters) -> list[ToolTypeDef]:
         tools = [self._map_tool_definition(r) for r in model_request_parameters.function_tools]
@@ -345,7 +346,7 @@ class BedrockConverseModel(Model):
                         content.append({'text': item.content})
                     else:
                         assert isinstance(item, ToolCallPart)
-                        content.append(self._map_tool_call(item))  # FIXME: MISSING key
+                        content.append(self._map_tool_call(item))
                 bedrock_messages.append({'role': 'assistant', 'content': content})
             else:
                 assert_never(m)
@@ -394,13 +395,8 @@ class BedrockConverseModel(Model):
 
     @staticmethod
     def _map_tool_call(t: ToolCallPart) -> ContentBlockOutputTypeDef:
-        assert t.tool_call_id is not None
         return {
-            'toolUse': {
-                'toolUseId': t.tool_call_id,
-                'name': t.tool_name,
-                'input': t.args_as_dict(),
-            }
+            'toolUse': {'toolUseId': _utils.guard_tool_call_id(t=t), 'name': t.tool_name, 'input': t.args_as_dict()}
         }
 
 

{pydantic_ai_slim-0.0.43 → pydantic_ai_slim-0.0.45}/pydantic_ai/models/cohere.py

@@ -6,11 +6,10 @@ from itertools import chain
 from typing import Literal, Union, cast
 
 from cohere import TextAssistantMessageContentItem
-from httpx import AsyncClient as AsyncHTTPClient
 from typing_extensions import assert_never
 
 from .. import ModelHTTPError, result
-from .._utils import guard_tool_call_id as _guard_tool_call_id
+from .._utils import generate_tool_call_id as _generate_tool_call_id, guard_tool_call_id as _guard_tool_call_id
 from ..messages import (
     ModelMessage,
     ModelRequest,
@@ -23,6 +22,7 @@ from ..messages import (
     ToolReturnPart,
     UserPromptPart,
 )
+from ..providers import Provider, infer_provider
 from ..settings import ModelSettings
 from ..tools import ToolDefinition
 from . import (
@@ -104,28 +104,22 @@ class CohereModel(Model):
         self,
         model_name: CohereModelName,
         *,
-        api_key: str | None = None,
-        cohere_client: AsyncClientV2 | None = None,
-        http_client: AsyncHTTPClient | None = None,
+        provider: Literal['cohere'] | Provider[AsyncClientV2] = 'cohere',
     ):
         """Initialize an Cohere model.
 
         Args:
             model_name: The name of the Cohere model to use. List of model names
                 available [here](https://docs.cohere.com/docs/models#command).
-            api_key: The API key to use for authentication, if not provided, the
-                `CO_API_KEY` environment variable will be used if available.
-            cohere_client: An existing Cohere async 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.
+            provider: The provider to use for authentication and API access. Can be either the string
+                'cohere' or an instance of `Provider[AsyncClientV2]`. If not provided, a new provider will be
+                created using the other parameters.
         """
         self._model_name: CohereModelName = model_name
-        if cohere_client is not None:
-            assert http_client is None, 'Cannot provide both `cohere_client` and `http_client`'
-            assert api_key is None, 'Cannot provide both `cohere_client` and `api_key`'
-            self.client = cohere_client
-        else:
-            self.client = AsyncClientV2(api_key=api_key, httpx_client=http_client)
+
+        if isinstance(provider, str):
+            provider = infer_provider(provider)
+        self.client = provider.client
 
     @property
     def base_url(self) -> str:
@@ -191,7 +185,7 @@ class CohereModel(Model):
                     ToolCallPart(
                         tool_name=c.function.name,
                         args=c.function.arguments,
-                        tool_call_id=c.id,
+                        tool_call_id=c.id or _generate_tool_call_id(),
                     )
                 )
         return ModelResponse(parts=parts, model_name=self._model_name)
@@ -228,7 +222,7 @@ class CohereModel(Model):
     @staticmethod
     def _map_tool_call(t: ToolCallPart) -> ToolCallV2:
         return ToolCallV2(
-            id=_guard_tool_call_id(t=t, model_source='Cohere'),
+            id=_guard_tool_call_id(t=t),
             type='function',
             function=ToolCallV2Function(
                 name=t.tool_name,
@@ -260,7 +254,7 @@ class CohereModel(Model):
             elif isinstance(part, ToolReturnPart):
                 yield ToolChatMessageV2(
                     role='tool',
-                    tool_call_id=_guard_tool_call_id(t=part, model_source='Cohere'),
+                    tool_call_id=_guard_tool_call_id(t=part),
                     content=part.model_response_str(),
                 )
             elif isinstance(part, RetryPromptPart):
@@ -269,7 +263,7 @@ class CohereModel(Model):
                 else:
                     yield ToolChatMessageV2(
                         role='tool',
-                        tool_call_id=_guard_tool_call_id(t=part, model_source='Cohere'),
+                        tool_call_id=_guard_tool_call_id(t=part),
                         content=part.model_response(),
                     )
             else: