pydantic-ai-slim 1.4.0__tar.gz → 1.5.0__tar.gz

{pydantic_ai_slim-1.4.0 → pydantic_ai_slim-1.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai-slim
-Version: 1.4.0
+Version: 1.5.0
 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.35
 Requires-Dist: griffe>=1.3.2
 Requires-Dist: httpx>=0.27
 Requires-Dist: opentelemetry-api>=1.28.0
-Requires-Dist: pydantic-graph==1.4.0
+Requires-Dist: pydantic-graph==1.5.0
 Requires-Dist: pydantic>=2.10
 Requires-Dist: typing-inspection>=0.4.0
 Provides-Extra: a2a
@@ -57,7 +57,7 @@ Requires-Dist: dbos>=1.14.0; extra == 'dbos'
 Provides-Extra: duckduckgo
 Requires-Dist: ddgs>=9.0.0; extra == 'duckduckgo'
 Provides-Extra: evals
-Requires-Dist: pydantic-evals==1.4.0; extra == 'evals'
+Requires-Dist: pydantic-evals==1.5.0; extra == 'evals'
 Provides-Extra: google
 Requires-Dist: google-genai>=1.46.0; extra == 'google'
 Provides-Extra: groq

{pydantic_ai_slim-1.4.0 → pydantic_ai_slim-1.5.0}/pydantic_ai/_agent_graph.py

@@ -20,7 +20,8 @@ from pydantic_ai._instrumentation import DEFAULT_INSTRUMENTATION_VERSION
 from pydantic_ai._tool_manager import ToolManager
 from pydantic_ai._utils import dataclasses_no_defaults_repr, get_union_args, is_async_callable, run_in_executor
 from pydantic_ai.builtin_tools import AbstractBuiltinTool
-from pydantic_graph import BaseNode, Graph, GraphRunContext
+from pydantic_graph import BaseNode, GraphRunContext
+from pydantic_graph.beta import Graph, GraphBuilder
 from pydantic_graph.nodes import End, NodeRunEndT
 
 from . import _output, _system_prompt, exceptions, messages as _messages, models, result, usage as _usage
@@ -1162,22 +1163,32 @@ def build_agent_graph(
     name: str | None,
     deps_type: type[DepsT],
     output_type: OutputSpec[OutputT],
-) -> Graph[GraphAgentState, GraphAgentDeps[DepsT, result.FinalResult[OutputT]], result.FinalResult[OutputT]]:
+) -> Graph[
+    GraphAgentState,
+    GraphAgentDeps[DepsT, OutputT],
+    UserPromptNode[DepsT, OutputT],
+    result.FinalResult[OutputT],
+]:
     """Build the execution [Graph][pydantic_graph.Graph] for a given agent."""
-    nodes = (
-        UserPromptNode[DepsT],
-        ModelRequestNode[DepsT],
-        CallToolsNode[DepsT],
-        SetFinalResult[DepsT],
-    )
-    graph = Graph[GraphAgentState, GraphAgentDeps[DepsT, Any], result.FinalResult[OutputT]](
-        nodes=nodes,
+    g = GraphBuilder(
         name=name or 'Agent',
         state_type=GraphAgentState,
-        run_end_type=result.FinalResult[OutputT],
+        deps_type=GraphAgentDeps[DepsT, OutputT],
+        input_type=UserPromptNode[DepsT, OutputT],
+        output_type=result.FinalResult[OutputT],
         auto_instrument=False,
     )
-    return graph
+
+    g.add(
+        g.edge_from(g.start_node).to(UserPromptNode[DepsT, OutputT]),
+        g.node(UserPromptNode[DepsT, OutputT]),
+        g.node(ModelRequestNode[DepsT, OutputT]),
+        g.node(CallToolsNode[DepsT, OutputT]),
+        g.node(
+            SetFinalResult[DepsT, OutputT],
+        ),
+    )
+    return g.build(validate_graph_structure=False)
 
 
 async def _process_message_history(

{pydantic_ai_slim-1.4.0 → pydantic_ai_slim-1.5.0}/pydantic_ai/_utils.py

@@ -147,7 +147,7 @@ async def group_by_temporal(
         aiterable: The async iterable to group.
         soft_max_interval: Maximum interval over which to group items, this should avoid a trickle of items causing
             a group to never be yielded. It's a soft max in the sense that once we're over this time, we yield items
-            as soon as `aiter.__anext__()` returns. If `None`, no grouping/debouncing is performed
+            as soon as `anext(aiter)` returns. If `None`, no grouping/debouncing is performed
 
     Returns:
         A context manager usable as an async iterable of lists of items produced by the input async iterable.
@@ -171,7 +171,7 @@ async def group_by_temporal(
         buffer: list[T] = []
         group_start_time = time.monotonic()
 
-        aiterator = aiterable.__aiter__()
+        aiterator = aiter(aiterable)
         while True:
             if group_start_time is None:
                 # group hasn't started, we just wait for the maximum interval
@@ -182,9 +182,9 @@ async def group_by_temporal(
 
             # if there's no current task, we get the next one
             if task is None:
-                # aiter.__anext__() returns an Awaitable[T], not a Coroutine which asyncio.create_task expects
+                # anext(aiter) returns an Awaitable[T], not a Coroutine which asyncio.create_task expects
                 # so far, this doesn't seem to be a problem
-                task = asyncio.create_task(aiterator.__anext__())  # pyright: ignore[reportArgumentType]
+                task = asyncio.create_task(anext(aiterator))  # pyright: ignore[reportArgumentType]
 
             # we use asyncio.wait to avoid cancelling the coroutine if it's not done
             done, _ = await asyncio.wait((task,), timeout=wait_time)
@@ -284,10 +284,10 @@ class PeekableAsyncStream(Generic[T]):
 
         # Otherwise, we need to fetch the next item from the underlying iterator.
         if self._source_iter is None:
-            self._source_iter = self._source.__aiter__()
+            self._source_iter = aiter(self._source)
 
         try:
-            self._buffer = await self._source_iter.__anext__()
+            self._buffer = await anext(self._source_iter)
         except StopAsyncIteration:
             self._exhausted = True
             return UNSET
@@ -318,10 +318,10 @@ class PeekableAsyncStream(Generic[T]):
 
         # Otherwise, fetch the next item from the source.
         if self._source_iter is None:
-            self._source_iter = self._source.__aiter__()
+            self._source_iter = aiter(self._source)
 
         try:
-            return await self._source_iter.__anext__()
+            return await anext(self._source_iter)
         except StopAsyncIteration:
             self._exhausted = True
             raise

{pydantic_ai_slim-1.4.0 → pydantic_ai_slim-1.5.0}/pydantic_ai/agent/__init__.py

@@ -15,7 +15,6 @@ from pydantic.json_schema import GenerateJsonSchema
 from typing_extensions import Self, TypeVar, deprecated
 
 from pydantic_ai._instrumentation import DEFAULT_INSTRUMENTATION_VERSION, InstrumentationNames
-from pydantic_graph import Graph
 
 from .. import (
     _agent_graph,
@@ -41,7 +40,6 @@ from ..builtin_tools import AbstractBuiltinTool
 from ..models.instrumented import InstrumentationSettings, InstrumentedModel, instrument_model
 from ..output import OutputDataT, OutputSpec
 from ..profiles import ModelProfile
-from ..result import FinalResult
 from ..run import AgentRun, AgentRunResult
 from ..settings import ModelSettings, merge_model_settings
 from ..tools import (
@@ -566,9 +564,7 @@ class Agent(AbstractAgent[AgentDepsT, OutputDataT]):
         tool_manager = ToolManager[AgentDepsT](toolset)
 
         # Build the graph
-        graph: Graph[_agent_graph.GraphAgentState, _agent_graph.GraphAgentDeps[AgentDepsT, Any], FinalResult[Any]] = (
-            _agent_graph.build_agent_graph(self.name, self._deps_type, output_type_)
-        )
+        graph = _agent_graph.build_agent_graph(self.name, self._deps_type, output_type_)
 
         # Build the initial state
         usage = usage or _usage.RunUsage()
@@ -628,7 +624,7 @@ class Agent(AbstractAgent[AgentDepsT, OutputDataT]):
             instrumentation_settings=instrumentation_settings,
         )
 
-        start_node = _agent_graph.UserPromptNode[AgentDepsT](
+        user_prompt_node = _agent_graph.UserPromptNode[AgentDepsT](
             user_prompt=user_prompt,
             deferred_tool_results=deferred_tool_results,
             instructions=instructions_literal,
@@ -655,7 +651,7 @@ class Agent(AbstractAgent[AgentDepsT, OutputDataT]):
 
         try:
             async with graph.iter(
-                start_node,
+                inputs=user_prompt_node,
                 state=state,
                 deps=graph_deps,
                 span=use_span(run_span) if run_span.is_recording() else None,

{pydantic_ai_slim-1.4.0 → pydantic_ai_slim-1.5.0}/pydantic_ai/durable_exec/temporal/__init__.py

@@ -36,6 +36,17 @@ __all__ = [
     'TemporalWrapperToolset',
 ]
 
+# We need eagerly import the anyio backends or it will happens inside workflow code and temporal has issues
+# Note: It's difficult to add a test that covers this because pytest presumably does these imports itself
+# when you have a @pytest.mark.anyio somewhere.
+# I suppose we could add a test that runs a python script in a separate process, but I have not done that...
+import anyio._backends._asyncio  # pyright: ignore[reportUnusedImport]
+
+try:
+    import anyio._backends._trio  # noqa F401  # pyright: ignore[reportUnusedImport]
+except ImportError:
+    pass
+
 
 class PydanticAIPlugin(ClientPlugin, WorkerPlugin):
     """Temporal client and worker plugin for Pydantic AI."""

{pydantic_ai_slim-1.4.0 → pydantic_ai_slim-1.5.0}/pydantic_ai/durable_exec/temporal/_function_toolset.py

@@ -2,11 +2,12 @@ from __future__ import annotations
 
 from collections.abc import Callable
 from dataclasses import dataclass
-from typing import Annotated, Any, Literal, assert_never
+from typing import Annotated, Any, Literal
 
 from pydantic import ConfigDict, Discriminator, with_config
 from temporalio import activity, workflow
 from temporalio.workflow import ActivityConfig
+from typing_extensions import assert_never
 
 from pydantic_ai import FunctionToolset, ToolsetTool
 from pydantic_ai.exceptions import ApprovalRequired, CallDeferred, ModelRetry, UserError

{pydantic_ai_slim-1.4.0 → pydantic_ai_slim-1.5.0}/pydantic_ai/exceptions.py

@@ -159,7 +159,7 @@ class ModelHTTPError(AgentRunError):
         super().__init__(message)
 
 
-class FallbackExceptionGroup(ExceptionGroup):
+class FallbackExceptionGroup(ExceptionGroup[Any]):
     """A group of exceptions that can be raised when all fallback models fail."""
 
 

{pydantic_ai_slim-1.4.0 → pydantic_ai_slim-1.5.0}/pydantic_ai/messages.py

@@ -480,7 +480,7 @@ class BinaryContent:
     """
 
     _identifier: Annotated[str | None, pydantic.Field(alias='identifier', default=None, exclude=True)] = field(
-        compare=False, default=None
+        compare=False, default=None, repr=False
     )
 
     kind: Literal['binary'] = 'binary'

{pydantic_ai_slim-1.4.0 → pydantic_ai_slim-1.5.0}/pydantic_ai/providers/google.py

@@ -13,7 +13,8 @@ from pydantic_ai.providers import Provider
 
 try:
     from google.auth.credentials import Credentials
-    from google.genai import Client
+    from google.genai._api_client import BaseApiClient
+    from google.genai.client import Client, DebugConfig
     from google.genai.types import HttpOptions
 except ImportError as _import_error:
     raise ImportError(
@@ -114,7 +115,7 @@ class GoogleProvider(Provider[Client]):
                 base_url=base_url,
                 headers={'User-Agent': get_user_agent()},
                 httpx_async_client=http_client,
-                # TODO: Remove once https://github.com/googleapis/python-genai/pull/1509#issuecomment-3430028790 is solved.
+                # TODO: Remove once https://github.com/googleapis/python-genai/issues/1565 is solved.
                 async_client_args={'transport': httpx.AsyncHTTPTransport()},
             )
             if not vertexai:
@@ -186,9 +187,37 @@ More details [here](https://cloud.google.com/vertex-ai/generative-ai/docs/learn/
 
 
 class _SafelyClosingClient(Client):
+    @staticmethod
+    def _get_api_client(
+        vertexai: bool | None = None,
+        api_key: str | None = None,
+        credentials: Credentials | None = None,
+        project: str | None = None,
+        location: str | None = None,
+        debug_config: DebugConfig | None = None,
+        http_options: HttpOptions | None = None,
+    ) -> BaseApiClient:
+        return _NonClosingApiClient(
+            vertexai=vertexai,
+            api_key=api_key,
+            credentials=credentials,
+            project=project,
+            location=location,
+            http_options=http_options,
+        )
+
     def close(self) -> None:
         # This is called from `Client.__del__`, even if `Client.__init__` raised an error before `self._api_client` is set, which would raise an `AttributeError` here.
+        # TODO: Remove once https://github.com/googleapis/python-genai/issues/1567 is solved.
         try:
             super().close()
         except AttributeError:
             pass
+
+
+class _NonClosingApiClient(BaseApiClient):
+    async def aclose(self) -> None:
+        # The original implementation also calls `await self._async_httpx_client.aclose()`, but we don't want to close our `cached_async_http_client` or the one the user passed in.
+        # TODO: Remove once https://github.com/googleapis/python-genai/issues/1566 is solved.
+        if self._aiohttp_session:
+            await self._aiohttp_session.close()  # pragma: no cover

{pydantic_ai_slim-1.4.0 → pydantic_ai_slim-1.5.0}/pydantic_ai/run.py

@@ -1,12 +1,14 @@
 from __future__ import annotations as _annotations
 
 import dataclasses
-from collections.abc import AsyncIterator
+from collections.abc import AsyncIterator, Sequence
 from copy import deepcopy
 from datetime import datetime
 from typing import TYPE_CHECKING, Any, Generic, Literal, overload
 
-from pydantic_graph import End, GraphRun, GraphRunContext
+from pydantic_graph import BaseNode, End, GraphRunContext
+from pydantic_graph.beta.graph import EndMarker, GraphRun, GraphTask, JoinItem
+from pydantic_graph.beta.step import NodeStep
 
 from . import (
     _agent_graph,
@@ -112,12 +114,8 @@ class AgentRun(Generic[AgentDepsT, OutputDataT]):
 
         This is the next node that will be used during async iteration, or if a node is not passed to `self.next(...)`.
         """
-        next_node = self._graph_run.next_node
-        if isinstance(next_node, End):
-            return next_node
-        if _agent_graph.is_agent_node(next_node):
-            return next_node
-        raise exceptions.AgentRunError(f'Unexpected node type: {type(next_node)}')  # pragma: no cover
+        task = self._graph_run.next_task
+        return self._task_to_node(task)
 
     @property
     def result(self) -> AgentRunResult[OutputDataT] | None:
@@ -126,13 +124,13 @@ class AgentRun(Generic[AgentDepsT, OutputDataT]):
         Once the run returns an [`End`][pydantic_graph.nodes.End] node, `result` is populated
         with an [`AgentRunResult`][pydantic_ai.agent.AgentRunResult].
         """
-        graph_run_result = self._graph_run.result
-        if graph_run_result is None:
+        graph_run_output = self._graph_run.output
+        if graph_run_output is None:
             return None
         return AgentRunResult(
-            graph_run_result.output.output,
-            graph_run_result.output.tool_name,
-            graph_run_result.state,
+            graph_run_output.output,
+            graph_run_output.tool_name,
+            self._graph_run.state,
             self._graph_run.deps.new_message_index,
             self._traceparent(required=False),
         )
@@ -147,11 +145,28 @@ class AgentRun(Generic[AgentDepsT, OutputDataT]):
         self,
     ) -> _agent_graph.AgentNode[AgentDepsT, OutputDataT] | End[FinalResult[OutputDataT]]:
         """Advance to the next node automatically based on the last returned node."""
-        next_node = await self._graph_run.__anext__()
-        if _agent_graph.is_agent_node(node=next_node):
-            return next_node
-        assert isinstance(next_node, End), f'Unexpected node type: {type(next_node)}'
-        return next_node
+        task = await anext(self._graph_run)
+        return self._task_to_node(task)
+
+    def _task_to_node(
+        self, task: EndMarker[FinalResult[OutputDataT]] | JoinItem | Sequence[GraphTask]
+    ) -> _agent_graph.AgentNode[AgentDepsT, OutputDataT] | End[FinalResult[OutputDataT]]:
+        if isinstance(task, Sequence) and len(task) == 1:
+            first_task = task[0]
+            if isinstance(first_task.inputs, BaseNode):  # pragma: no branch
+                base_node: BaseNode[
+                    _agent_graph.GraphAgentState,
+                    _agent_graph.GraphAgentDeps[AgentDepsT, OutputDataT],
+                    FinalResult[OutputDataT],
+                ] = first_task.inputs  # type: ignore[reportUnknownMemberType]
+                if _agent_graph.is_agent_node(node=base_node):  # pragma: no branch
+                    return base_node
+        if isinstance(task, EndMarker):
+            return End(task.value)
+        raise exceptions.AgentRunError(f'Unexpected node: {task}')  # pragma: no cover
+
+    def _node_to_task(self, node: _agent_graph.AgentNode[AgentDepsT, OutputDataT]) -> GraphTask:
+        return GraphTask(NodeStep(type(node)).id, inputs=node, fork_stack=())
 
     async def next(
         self,
@@ -222,11 +237,12 @@ class AgentRun(Generic[AgentDepsT, OutputDataT]):
         """
         # Note: It might be nice to expose a synchronous interface for iteration, but we shouldn't do it
         # on this class, or else IDEs won't warn you if you accidentally use `for` instead of `async for` to iterate.
-        next_node = await self._graph_run.next(node)
-        if _agent_graph.is_agent_node(next_node):
-            return next_node
-        assert isinstance(next_node, End), f'Unexpected node type: {type(next_node)}'
-        return next_node
+        task = [self._node_to_task(node)]
+        try:
+            task = await self._graph_run.next(task)
+        except StopAsyncIteration:
+            pass
+        return self._task_to_node(task)
 
     # TODO (v2): Make this a property
     def usage(self) -> _usage.RunUsage:
@@ -234,7 +250,7 @@ class AgentRun(Generic[AgentDepsT, OutputDataT]):
         return self._graph_run.state.usage
 
     def __repr__(self) -> str:  # pragma: no cover
-        result = self._graph_run.result
+        result = self._graph_run.output
         result_repr = '<run not finished>' if result is None else repr(result.output)
         return f'<{type(self).__name__} result={result_repr} usage={self.usage()}>'