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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai-slim
-Version: 0.0.45
+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.45
+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.45 → 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.45 → 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.45 → 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.45 → pydantic_ai_slim-0.0.46}/pydantic_ai/providers/anthropic.py

@@ -70,4 +70,5 @@ class AnthropicProvider(Provider[AsyncAnthropic]):
             if http_client is not None:
                 self._client = AsyncAnthropic(api_key=api_key, http_client=http_client)
             else:
-                self._client = AsyncAnthropic(api_key=api_key, http_client=cached_async_http_client())
+                http_client = cached_async_http_client(provider='anthropic')
+                self._client = AsyncAnthropic(api_key=api_key, http_client=http_client)

{pydantic_ai_slim-0.0.45 → pydantic_ai_slim-0.0.46}/pydantic_ai/providers/azure.py

@@ -97,7 +97,7 @@ class AzureProvider(Provider[AsyncOpenAI]):
                     'Must provide one of the `api_version` argument or the `OPENAI_API_VERSION` environment variable'
                 )
 
-            http_client = http_client or cached_async_http_client()
+            http_client = http_client or cached_async_http_client(provider='azure')
             self._client = AsyncAzureOpenAI(
                 azure_endpoint=azure_endpoint,
                 api_key=api_key,

{pydantic_ai_slim-0.0.45 → pydantic_ai_slim-0.0.46}/pydantic_ai/providers/cohere.py

@@ -66,6 +66,5 @@ class CohereProvider(Provider[AsyncClientV2]):
             if http_client is not None:
                 self._client = AsyncClientV2(api_key=api_key, httpx_client=http_client, base_url=base_url)
             else:
-                self._client = AsyncClientV2(
-                    api_key=api_key, httpx_client=cached_async_http_client(), base_url=base_url
-                )
+                http_client = cached_async_http_client(provider='cohere')
+                self._client = AsyncClientV2(api_key=api_key, httpx_client=http_client, base_url=base_url)

{pydantic_ai_slim-0.0.45 → pydantic_ai_slim-0.0.46}/pydantic_ai/providers/deepseek.py

@@ -65,4 +65,5 @@ class DeepSeekProvider(Provider[AsyncOpenAI]):
         elif http_client is not None:
             self._client = AsyncOpenAI(base_url=self.base_url, api_key=api_key, http_client=http_client)
         else:
-            self._client = AsyncOpenAI(base_url=self.base_url, api_key=api_key, http_client=cached_async_http_client())
+            http_client = cached_async_http_client(provider='deepseek')
+            self._client = AsyncOpenAI(base_url=self.base_url, api_key=api_key, http_client=http_client)

{pydantic_ai_slim-0.0.45 → pydantic_ai_slim-0.0.46}/pydantic_ai/providers/google_gla.py

@@ -39,7 +39,7 @@ class GoogleGLAProvider(Provider[httpx.AsyncClient]):
                 'to use the Google GLA provider.'
             )
 
-        self._client = http_client or cached_async_http_client()
+        self._client = http_client or cached_async_http_client(provider='google-gla')
         self._client.base_url = self.base_url
         # https://cloud.google.com/docs/authentication/api-keys-use#using-with-rest
         self._client.headers['X-Goog-Api-Key'] = api_key

{pydantic_ai_slim-0.0.45 → pydantic_ai_slim-0.0.46}/pydantic_ai/providers/google_vertex.py

@@ -97,7 +97,7 @@ class GoogleVertexProvider(Provider[httpx.AsyncClient]):
         if service_account_file and service_account_info:
             raise ValueError('Only one of `service_account_file` or `service_account_info` can be provided.')
 
-        self._client = http_client or cached_async_http_client()
+        self._client = http_client or cached_async_http_client(provider='google-vertex')
         self.service_account_file = service_account_file
         self.service_account_info = service_account_info
         self.project_id = project_id

{pydantic_ai_slim-0.0.45 → pydantic_ai_slim-0.0.46}/pydantic_ai/providers/groq.py

@@ -71,6 +71,5 @@ class GroqProvider(Provider[AsyncGroq]):
             elif http_client is not None:
                 self._client = AsyncGroq(base_url=self.base_url, api_key=api_key, http_client=http_client)
             else:
-                self._client = AsyncGroq(
-                    base_url=self.base_url, api_key=api_key, http_client=cached_async_http_client()
-                )
+                http_client = cached_async_http_client(provider='groq')
+                self._client = AsyncGroq(base_url=self.base_url, api_key=api_key, http_client=http_client)

{pydantic_ai_slim-0.0.45 → pydantic_ai_slim-0.0.46}/pydantic_ai/providers/mistral.py

@@ -69,4 +69,5 @@ class MistralProvider(Provider[Mistral]):
             elif http_client is not None:
                 self._client = Mistral(api_key=api_key, async_client=http_client)
             else:
-                self._client = Mistral(api_key=api_key, async_client=cached_async_http_client())
+                http_client = cached_async_http_client(provider='mistral')
+                self._client = Mistral(api_key=api_key, async_client=http_client)

{pydantic_ai_slim-0.0.45 → pydantic_ai_slim-0.0.46}/pydantic_ai/providers/openai.py

@@ -63,4 +63,5 @@ class OpenAIProvider(Provider[AsyncOpenAI]):
         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())
+            http_client = cached_async_http_client(provider='openai')
+            self._client = AsyncOpenAI(base_url=base_url, api_key=api_key, http_client=http_client)

{pydantic_ai_slim-0.0.45 → pydantic_ai_slim-0.0.46}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "pydantic-ai-slim"
-version = "0.0.45"
+version = "0.0.46"
 description = "Agent Framework / shim to use Pydantic with LLMs, slim package"
 authors = [{ name = "Samuel Colvin", email = "samuel@pydantic.dev" }]
 license = "MIT"
@@ -36,7 +36,7 @@ dependencies = [
     "griffe>=1.3.2",
     "httpx>=0.27",
     "pydantic>=2.10",
-    "pydantic-graph==0.0.45",
+    "pydantic-graph==0.0.46",
     "exceptiongroup; python_version < '3.11'",
     "opentelemetry-api>=1.28.0",
     "typing-inspection>=0.4.0",