pydantic-ai-slim 1.0.7__tar.gz → 1.0.8__tar.gz

{pydantic_ai_slim-1.0.7 → pydantic_ai_slim-1.0.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai-slim
-Version: 1.0.7
+Version: 1.0.8
 Summary: Agent Framework / shim to use Pydantic with LLMs, slim package
 Project-URL: Homepage, https://github.com/pydantic/pydantic-ai/tree/main/pydantic_ai_slim
 Project-URL: Source, https://github.com/pydantic/pydantic-ai/tree/main/pydantic_ai_slim
@@ -33,7 +33,7 @@ Requires-Dist: genai-prices>=0.0.23
 Requires-Dist: griffe>=1.3.2
 Requires-Dist: httpx>=0.27
 Requires-Dist: opentelemetry-api>=1.28.0
-Requires-Dist: pydantic-graph==1.0.7
+Requires-Dist: pydantic-graph==1.0.8
 Requires-Dist: pydantic>=2.10
 Requires-Dist: typing-inspection>=0.4.0
 Provides-Extra: a2a
@@ -57,7 +57,7 @@ Requires-Dist: dbos>=1.13.0; extra == 'dbos'
 Provides-Extra: duckduckgo
 Requires-Dist: ddgs>=9.0.0; extra == 'duckduckgo'
 Provides-Extra: evals
-Requires-Dist: pydantic-evals==1.0.7; extra == 'evals'
+Requires-Dist: pydantic-evals==1.0.8; extra == 'evals'
 Provides-Extra: google
 Requires-Dist: google-genai>=1.31.0; extra == 'google'
 Provides-Extra: groq

{pydantic_ai_slim-1.0.7 → pydantic_ai_slim-1.0.8}/pydantic_ai/_agent_graph.py

@@ -8,6 +8,7 @@ from collections import defaultdict, deque
 from collections.abc import AsyncIterator, Awaitable, Callable, Iterator, Sequence
 from contextlib import asynccontextmanager, contextmanager
 from contextvars import ContextVar
+from copy import deepcopy
 from dataclasses import field, replace
 from typing import TYPE_CHECKING, Any, Generic, Literal, TypeGuard, cast
 
@@ -186,9 +187,8 @@ class UserPromptNode(AgentNode[DepsT, NodeRunEndT]):
                 messages = ctx_messages.messages
                 ctx_messages.used = True
 
-        message_history = _clean_message_history(ctx.state.message_history)
-        # Add message history to the `capture_run_messages` list, which will be empty at this point
-        messages.extend(message_history)
+        # Replace the `capture_run_messages` list with the message history
+        messages[:] = _clean_message_history(ctx.state.message_history)
         # Use the `capture_run_messages` list as the message history so that new messages are added to it
         ctx.state.message_history = messages
         ctx.deps.new_message_index = len(messages)
@@ -455,7 +455,18 @@ class ModelRequestNode(AgentNode[DepsT, NodeRunEndT]):
         # This will raise errors for any tool name conflicts
         ctx.deps.tool_manager = await ctx.deps.tool_manager.for_run_step(run_context)
 
-        message_history = await _process_message_history(ctx.state, ctx.deps.history_processors, run_context)
+        original_history = ctx.state.message_history[:]
+        message_history = await _process_message_history(original_history, ctx.deps.history_processors, run_context)
+        # Never merge the new `ModelRequest` with the one preceding it, to keep `new_messages()` from accidentally including part of the existing message history
+        message_history = [*_clean_message_history(message_history[:-1]), message_history[-1]]
+        # `ctx.state.message_history` is the same list used by `capture_run_messages`, so we should replace its contents, not the reference
+        ctx.state.message_history[:] = message_history
+        # Update the new message index to ensure `result.new_messages()` returns the correct messages
+        ctx.deps.new_message_index -= len(original_history) - len(message_history)
+
+        # Do one more cleaning pass to merge possible consecutive trailing `ModelRequest`s into one, with tool call parts before user parts,
+        # but don't store it in the message history on state.
+        # See `tests/test_tools.py::test_parallel_tool_return_with_deferred` for an example where this is necessary
         message_history = _clean_message_history(message_history)
 
         model_request_parameters = await _prepare_request_parameters(ctx)
@@ -465,7 +476,7 @@ class ModelRequestNode(AgentNode[DepsT, NodeRunEndT]):
         usage = ctx.state.usage
         if ctx.deps.usage_limits.count_tokens_before_request:
             # Copy to avoid modifying the original usage object with the counted usage
-            usage = dataclasses.replace(usage)
+            usage = deepcopy(usage)
 
             counted_usage = await ctx.deps.model.count_tokens(message_history, model_settings, model_request_parameters)
             usage.incr(counted_usage)
@@ -1086,12 +1097,11 @@ def build_agent_graph(
 
 
 async def _process_message_history(
-    state: GraphAgentState,
+    messages: list[_messages.ModelMessage],
     processors: Sequence[HistoryProcessor[DepsT]],
     run_context: RunContext[DepsT],
 ) -> list[_messages.ModelMessage]:
     """Process message history through a sequence of processors."""
-    messages = state.message_history
     for processor in processors:
         takes_ctx = is_takes_ctx(processor)
 
@@ -1109,8 +1119,12 @@ async def _process_message_history(
                 sync_processor = cast(_HistoryProcessorSync, processor)
                 messages = await run_in_executor(sync_processor, messages)
 
-    # Replaces the message history in the state with the processed messages
-    state.message_history = messages
+    if len(messages) == 0:
+        raise exceptions.UserError('Processed history cannot be empty.')
+
+    if not isinstance(messages[-1], _messages.ModelRequest):
+        raise exceptions.UserError('Processed history must end with a `ModelRequest`.')
+
     return messages
 
 

{pydantic_ai_slim-1.0.7 → pydantic_ai_slim-1.0.8}/pydantic_ai/ag_ui.py

@@ -559,15 +559,15 @@ async def _handle_tool_result_event(
         content=result.model_response_str(),
     )
 
-    # Now check for  AG-UI events returned by the tool calls.
-    content = result.content
-    if isinstance(content, BaseEvent):
-        yield content
-    elif isinstance(content, str | bytes):  # pragma: no branch
+    # Now check for AG-UI events returned by the tool calls.
+    possible_event = result.metadata or result.content
+    if isinstance(possible_event, BaseEvent):
+        yield possible_event
+    elif isinstance(possible_event, str | bytes):  # pragma: no branch
         # Avoid iterable check for strings and bytes.
         pass
-    elif isinstance(content, Iterable):  # pragma: no branch
-        for item in content:  # type: ignore[reportUnknownMemberType]
+    elif isinstance(possible_event, Iterable):  # pragma: no branch
+        for item in possible_event:  # type: ignore[reportUnknownMemberType]
             if isinstance(item, BaseEvent):  # pragma: no branch
                 yield item
 

{pydantic_ai_slim-1.0.7 → pydantic_ai_slim-1.0.8}/pydantic_ai/agent/__init__.py

@@ -614,12 +614,10 @@ class Agent(AbstractAgent[AgentDepsT, OutputDataT]):
             instrumentation_settings = None
             tracer = NoOpTracer()
 
-        graph_deps = _agent_graph.GraphAgentDeps[
-            AgentDepsT, RunOutputDataT
-        ](
+        graph_deps = _agent_graph.GraphAgentDeps[AgentDepsT, RunOutputDataT](
             user_deps=deps,
             prompt=user_prompt,
-            new_message_index=0,  # This will be set in `UserPromptNode` based on the length of the cleaned message history
+            new_message_index=len(message_history) if message_history else 0,
             model=model_used,
             model_settings=model_settings,
             usage_limits=usage_limits,

{pydantic_ai_slim-1.0.7 → pydantic_ai_slim-1.0.8}/pydantic_ai/models/__init__.py

@@ -783,6 +783,8 @@ def cached_async_http_client(*, provider: str | None = None, timeout: int = 600,
     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.
 
+    Each client will get its own transport with its own connection pool. The default pool size is defined by `httpx.DEFAULT_LIMITS`.
+
     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.
@@ -793,6 +795,8 @@ def cached_async_http_client(*, provider: str | None = None, timeout: int = 600,
     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.
+        # Since there is no API from `functools.cache` to clear the cache for a specific
+        #  key, clear the entire cache here as a workaround.
         _cached_async_http_client.cache_clear()
         client = _cached_async_http_client(provider=provider, timeout=timeout, connect=connect)
     return client
@@ -801,17 +805,11 @@ def cached_async_http_client(*, provider: str | None = None, timeout: int = 600,
 @cache
 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()
-
-
 DataT = TypeVar('DataT', str, bytes)
 
 

{pydantic_ai_slim-1.0.7 → pydantic_ai_slim-1.0.8}/pydantic_ai/result.py

@@ -1,7 +1,7 @@
 from __future__ import annotations as _annotations
 
 from collections.abc import AsyncIterator, Awaitable, Callable, Iterable
-from copy import copy
+from copy import deepcopy
 from dataclasses import dataclass, field
 from datetime import datetime
 from typing import Generic, cast, overload
@@ -56,7 +56,7 @@ class AgentStream(Generic[AgentDepsT, OutputDataT]):
     _initial_run_ctx_usage: RunUsage = field(init=False)
 
     def __post_init__(self):
-        self._initial_run_ctx_usage = copy(self._run_ctx.usage)
+        self._initial_run_ctx_usage = deepcopy(self._run_ctx.usage)
 
     async def stream_output(self, *, debounce_by: float | None = 0.1) -> AsyncIterator[OutputDataT]:
         """Asynchronously stream the (validated) agent outputs."""
@@ -322,9 +322,7 @@ class StreamedRunResult(Generic[AgentDepsT, OutputDataT]):
             self.all_messages(output_tool_return_content=output_tool_return_content)
         )
 
-    def new_messages(
-        self, *, output_tool_return_content: str | None = None
-    ) -> list[_messages.ModelMessage]:  # pragma: no cover
+    def new_messages(self, *, output_tool_return_content: str | None = None) -> list[_messages.ModelMessage]:
         """Return new messages associated with this run.
 
         Messages from older runs are excluded.

{pydantic_ai_slim-1.0.7 → pydantic_ai_slim-1.0.8}/pydantic_ai/usage.py

@@ -135,7 +135,7 @@ class RunUsage(UsageBase):
     """Number of successful tool calls executed during the run."""
 
     input_tokens: int = 0
-    """Total number of text input/prompt tokens."""
+    """Total number of input/prompt tokens."""
 
     cache_write_tokens: int = 0
     """Total number of tokens written to the cache."""
@@ -150,7 +150,7 @@ class RunUsage(UsageBase):
     """Total number of audio tokens read from the cache."""
 
     output_tokens: int = 0
-    """Total number of text output/completion tokens."""
+    """Total number of output/completion tokens."""
 
     details: dict[str, int] = dataclasses.field(default_factory=dict)
     """Any extra details returned by the model."""