pydantic-ai-slim 0.0.44__tar.gz → 0.0.46__tar.gz

{pydantic_ai_slim-0.0.44 → pydantic_ai_slim-0.0.46}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai-slim
-Version: 0.0.44
+Version: 0.0.46
 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.44
+Requires-Dist: pydantic-graph==0.0.46
 Requires-Dist: pydantic>=2.10
 Requires-Dist: typing-inspection>=0.4.0
 Provides-Extra: anthropic

{pydantic_ai_slim-0.0.44 → pydantic_ai_slim-0.0.46}/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.44 → pydantic_ai_slim-0.0.46}/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.44 → pydantic_ai_slim-0.0.46}/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 run_until_complete
+from pydantic_graph._utils import get_event_loop
 
 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 run_until_complete(
+        return get_event_loop().run_until_complete(
             self.run(
                 user_prompt,
                 result_type=result_type,

{pydantic_ai_slim-0.0.44 → pydantic_ai_slim-0.0.46}/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.44 → pydantic_ai_slim-0.0.46}/pydantic_ai/mcp.py

@@ -188,11 +188,35 @@ class MCPServerHTTP(MCPServer):
     For example for a server running locally, this might be `http://localhost:3001/sse`.
     """
 
+    headers: dict[str, Any] | None = None
+    """Optional HTTP headers to be sent with each request to the SSE endpoint.
+
+    These headers will be passed directly to the underlying `httpx.AsyncClient`.
+    Useful for authentication, custom headers, or other HTTP-specific configurations.
+    """
+
+    timeout: float = 5
+    """Initial connection timeout in seconds for establishing the SSE connection.
+
+    This timeout applies to the initial connection setup and handshake.
+    If the connection cannot be established within this time, the operation will fail.
+    """
+
+    sse_read_timeout: float = 60 * 5
+    """Maximum time in seconds to wait for new SSE messages before timing out.
+
+    This timeout applies to the long-lived SSE connection after it's established.
+    If no new messages are received within this time, the connection will be considered stale
+    and may be closed. Defaults to 5 minutes (300 seconds).
+    """
+
     @asynccontextmanager
     async def client_streams(
         self,
     ) -> AsyncIterator[
         tuple[MemoryObjectReceiveStream[JSONRPCMessage | Exception], MemoryObjectSendStream[JSONRPCMessage]]
     ]:  # pragma: no cover
-        async with sse_client(url=self.url) as (read_stream, write_stream):
+        async with sse_client(
+            url=self.url, headers=self.headers, timeout=self.timeout, sse_read_timeout=self.sse_read_timeout
+        ) as (read_stream, write_stream):
             yield read_stream, write_stream

{pydantic_ai_slim-0.0.44 → pydantic_ai_slim-0.0.46}/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.44 → pydantic_ai_slim-0.0.46}/pydantic_ai/models/__init__.py

@@ -431,32 +431,41 @@ def infer_model(model: Model | KnownModelName) -> Model:
         raise UserError(f'Unknown model: {model}')
 
 
-def cached_async_http_client(timeout: int = 600, connect: int = 5) -> httpx.AsyncClient:
-    """Cached HTTPX async client so multiple agents and calls can share the same client.
+def cached_async_http_client(*, provider: str | None = None, timeout: int = 600, connect: int = 5) -> httpx.AsyncClient:
+    """Cached HTTPX async client that creates a separate client for each provider.
+
+    The client is cached based on the provider parameter. If provider is None, it's used for non-provider specific
+    requests (like downloading images). Multiple agents and calls can share the same client when they use the same provider.
 
     There are good reasons why in production you should use a `httpx.AsyncClient` as an async context manager as
     described in [encode/httpx#2026](https://github.com/encode/httpx/pull/2026), but when experimenting or showing
-    examples, it's very useful not to, this allows multiple Agents to use a single client.
+    examples, it's very useful not to.
 
     The default timeouts match those of OpenAI,
     see <https://github.com/openai/openai-python/blob/v1.54.4/src/openai/_constants.py#L9>.
     """
-    client = _cached_async_http_client(timeout=timeout, connect=connect)
+    client = _cached_async_http_client(provider=provider, timeout=timeout, connect=connect)
     if client.is_closed:
         # This happens if the context manager is used, so we need to create a new client.
         _cached_async_http_client.cache_clear()
-        client = _cached_async_http_client(timeout=timeout, connect=connect)
+        client = _cached_async_http_client(provider=provider, timeout=timeout, connect=connect)
     return client
 
 
 @cache
-def _cached_async_http_client(timeout: int = 600, connect: int = 5) -> httpx.AsyncClient:
+def _cached_async_http_client(provider: str | None, timeout: int = 600, connect: int = 5) -> httpx.AsyncClient:
     return httpx.AsyncClient(
+        transport=_cached_async_http_transport(),
         timeout=httpx.Timeout(timeout=timeout, connect=connect),
         headers={'User-Agent': get_user_agent()},
     )
 
 
+@cache
+def _cached_async_http_transport() -> httpx.AsyncHTTPTransport:
+    return httpx.AsyncHTTPTransport()
+
+
 @cache
 def get_user_agent() -> str:
     """Get the user agent string for the HTTP client."""

{pydantic_ai_slim-0.0.44 → pydantic_ai_slim-0.0.46}/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.44 → pydantic_ai_slim-0.0.46}/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.44 → pydantic_ai_slim-0.0.46}/pydantic_ai/models/cohere.py

@@ -3,14 +3,13 @@ from __future__ import annotations as _annotations
 from collections.abc import Iterable
 from dataclasses import dataclass, field
 from itertools import chain
-from typing import Literal, Union, cast, overload
+from typing import Literal, Union, cast
 
 from cohere import TextAssistantMessageContentItem
-from httpx import AsyncClient as AsyncHTTPClient
-from typing_extensions import assert_never, deprecated
+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,
@@ -29,7 +28,6 @@ from ..tools import ToolDefinition
 from . import (
     Model,
     ModelRequestParameters,
-    cached_async_http_client,
     check_allow_model_requests,
 )
 
@@ -102,37 +100,11 @@ class CohereModel(Model):
     _model_name: CohereModelName = field(repr=False)
     _system: str = field(default='cohere', repr=False)
 
-    @overload
     def __init__(
         self,
         model_name: CohereModelName,
         *,
         provider: Literal['cohere'] | Provider[AsyncClientV2] = 'cohere',
-        api_key: None = None,
-        cohere_client: None = None,
-        http_client: None = None,
-    ) -> None: ...
-
-    @deprecated('Use the `provider` parameter instead of `api_key`, `cohere_client`, and `http_client`.')
-    @overload
-    def __init__(
-        self,
-        model_name: CohereModelName,
-        *,
-        provider: None = None,
-        api_key: str | None = None,
-        cohere_client: AsyncClientV2 | None = None,
-        http_client: AsyncHTTPClient | None = None,
-    ) -> None: ...
-
-    def __init__(
-        self,
-        model_name: CohereModelName,
-        *,
-        provider: Literal['cohere'] | Provider[AsyncClientV2] | None = None,
-        api_key: str | None = None,
-        cohere_client: AsyncClientV2 | None = None,
-        http_client: AsyncHTTPClient | None = None,
     ):
         """Initialize an Cohere model.
 
@@ -142,24 +114,12 @@ class CohereModel(Model):
             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.
-            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.
         """
         self._model_name: CohereModelName = model_name
 
-        if provider is not None:
-            if isinstance(provider, str):
-                provider = infer_provider(provider)
-            self.client = provider.client
-        elif 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 or cached_async_http_client())
+        if isinstance(provider, str):
+            provider = infer_provider(provider)
+        self.client = provider.client
 
     @property
     def base_url(self) -> str:
@@ -225,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)
@@ -262,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,
@@ -294,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):
@@ -303,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: