pydantic-ai-slim 1.8.0__py3-none-any.whl → 1.9.1__py3-none-any.whl

pydantic_ai/agent/abstract.py

@@ -49,7 +49,7 @@ if TYPE_CHECKING:
     from starlette.routing import BaseRoute, Route
     from starlette.types import ExceptionHandler, Lifespan
 
-    from ..ag_ui import AGUIApp
+    from pydantic_ai.ui.ag_ui.app import AGUIApp
 
 
 T = TypeVar('T')
@@ -654,6 +654,9 @@ class AbstractAgent(Generic[AgentDepsT, OutputDataT], ABC):
                 PartStartEvent(index=0, part=TextPart(content='The capital of ')),
                 FinalResultEvent(tool_name=None, tool_call_id=None),
                 PartDeltaEvent(index=0, delta=TextPartDelta(content_delta='France is Paris. ')),
+                PartEndEvent(
+                    index=0, part=TextPart(content='The capital of France is Paris. ')
+                ),
                 AgentRunResultEvent(
                     result=AgentRunResult(output='The capital of France is Paris. ')
                 ),
@@ -990,11 +993,14 @@ class AbstractAgent(Generic[AgentDepsT, OutputDataT], ABC):
     async def __aexit__(self, *args: Any) -> bool | None:
         raise NotImplementedError
 
+    # TODO (v2): Remove in favor of using `AGUIApp` directly -- we don't have `to_temporal()` or `to_vercel_ai()` either.
     def to_ag_ui(
         self,
         *,
         # Agent.iter parameters
         output_type: OutputSpec[OutputDataT] | None = None,
+        message_history: Sequence[_messages.ModelMessage] | None = None,
+        deferred_tool_results: DeferredToolResults | None = None,
         model: models.Model | models.KnownModelName | str | None = None,
         deps: AgentDepsT = None,
         model_settings: ModelSettings | None = None,
@@ -1035,12 +1041,14 @@ class AbstractAgent(Generic[AgentDepsT, OutputDataT], ABC):
         uvicorn app:app --host 0.0.0.0 --port 8000
         ```
 
-        See [AG-UI docs](../ag-ui.md) for more information.
+        See [AG-UI docs](../ui/ag-ui.md) for more information.
 
         Args:
             output_type: Custom output type to use for this run, `output_type` may only be used if the agent has
                 no output validators since output validators would expect an argument that matches the agent's
                 output type.
+            message_history: History of the conversation so far.
+            deferred_tool_results: Optional results for deferred tool calls in the message history.
             model: Optional model to use for this run, required if `model` was not set when creating the agent.
             deps: Optional dependencies to use for this run.
             model_settings: Optional settings to use for this model's request.
@@ -1070,12 +1078,14 @@ class AbstractAgent(Generic[AgentDepsT, OutputDataT], ABC):
         Returns:
             An ASGI application for running Pydantic AI agents with AG-UI protocol support.
         """
-        from ..ag_ui import AGUIApp
+        from pydantic_ai.ui.ag_ui.app import AGUIApp
 
         return AGUIApp(
             agent=self,
             # Agent.iter parameters
             output_type=output_type,
+            message_history=message_history,
+            deferred_tool_results=deferred_tool_results,
             model=model,
             deps=deps,
             model_settings=model_settings,

pydantic_ai/direct.py

@@ -172,6 +172,12 @@ def model_request_stream(
                     index=0, delta=TextPartDelta(content_delta='a German-born theoretical ')
                 ),
                 PartDeltaEvent(index=0, delta=TextPartDelta(content_delta='physicist.')),
+                PartEndEvent(
+                    index=0,
+                    part=TextPart(
+                        content='Albert Einstein was a German-born theoretical physicist.'
+                    ),
+                ),
             ]
             '''
     ```
@@ -229,6 +235,12 @@ def model_request_stream_sync(
                 index=0, delta=TextPartDelta(content_delta='a German-born theoretical ')
             ),
             PartDeltaEvent(index=0, delta=TextPartDelta(content_delta='physicist.')),
+            PartEndEvent(
+                index=0,
+                part=TextPart(
+                    content='Albert Einstein was a German-born theoretical physicist.'
+                ),
+            ),
         ]
         '''
     ```

pydantic_ai/durable_exec/dbos/_agent.py

@@ -640,6 +640,9 @@ class DBOSAgent(WrapperAgent[AgentDepsT, OutputDataT], DBOSConfiguredInstance):
                 PartStartEvent(index=0, part=TextPart(content='The capital of ')),
                 FinalResultEvent(tool_name=None, tool_call_id=None),
                 PartDeltaEvent(index=0, delta=TextPartDelta(content_delta='France is Paris. ')),
+                PartEndEvent(
+                    index=0, part=TextPart(content='The capital of France is Paris. ')
+                ),
                 AgentRunResultEvent(
                     result=AgentRunResult(output='The capital of France is Paris. ')
                 ),

pydantic_ai/durable_exec/prefect/_agent.py

@@ -598,6 +598,9 @@ class PrefectAgent(WrapperAgent[AgentDepsT, OutputDataT]):
                 PartStartEvent(index=0, part=TextPart(content='The capital of ')),
                 FinalResultEvent(tool_name=None, tool_call_id=None),
                 PartDeltaEvent(index=0, delta=TextPartDelta(content_delta='France is Paris. ')),
+                PartEndEvent(
+                    index=0, part=TextPart(content='The capital of France is Paris. ')
+                ),
                 AgentRunResultEvent(
                     result=AgentRunResult(output='The capital of France is Paris. ')
                 ),

pydantic_ai/durable_exec/temporal/_agent.py

@@ -669,6 +669,9 @@ class TemporalAgent(WrapperAgent[AgentDepsT, OutputDataT]):
                 PartStartEvent(index=0, part=TextPart(content='The capital of ')),
                 FinalResultEvent(tool_name=None, tool_call_id=None),
                 PartDeltaEvent(index=0, delta=TextPartDelta(content_delta='France is Paris. ')),
+                PartEndEvent(
+                    index=0, part=TextPart(content='The capital of France is Paris. ')
+                ),
                 AgentRunResultEvent(
                     result=AgentRunResult(output='The capital of France is Paris. ')
                 ),

pydantic_ai/messages.py

@@ -13,7 +13,7 @@ import pydantic
 import pydantic_core
 from genai_prices import calc_price, types as genai_types
 from opentelemetry._events import Event  # pyright: ignore[reportPrivateImportUsage]
-from typing_extensions import Self, deprecated
+from typing_extensions import deprecated
 
 from . import _otel_messages, _utils
 from ._utils import generate_tool_call_id as _generate_tool_call_id, now_utc as _now_utc
@@ -514,16 +514,16 @@ class BinaryContent:
                 vendor_metadata=bc.vendor_metadata,
             )
         else:
-            return bc  # pragma: no cover
+            return bc
 
     @classmethod
-    def from_data_uri(cls, data_uri: str) -> Self:
+    def from_data_uri(cls, data_uri: str) -> BinaryContent:
         """Create a `BinaryContent` from a data URI."""
         prefix = 'data:'
         if not data_uri.startswith(prefix):
-            raise ValueError('Data URI must start with "data:"')  # pragma: no cover
+            raise ValueError('Data URI must start with "data:"')
         media_type, data = data_uri[len(prefix) :].split(';base64,', 1)
-        return cls(data=base64.b64decode(data), media_type=media_type)
+        return cls.narrow_type(cls(data=base64.b64decode(data), media_type=media_type))
 
     @pydantic.computed_field
     @property
@@ -1612,6 +1612,14 @@ class PartStartEvent:
     part: ModelResponsePart
     """The newly started `ModelResponsePart`."""
 
+    previous_part_kind: (
+        Literal['text', 'thinking', 'tool-call', 'builtin-tool-call', 'builtin-tool-return', 'file'] | None
+    ) = None
+    """The kind of the previous part, if any.
+
+    This is useful for UI event streams to know whether to group parts of the same kind together when emitting events.
+    """
+
     event_kind: Literal['part_start'] = 'part_start'
     """Event type identifier, used as a discriminator."""
 
@@ -1634,6 +1642,30 @@ class PartDeltaEvent:
     __repr__ = _utils.dataclasses_no_defaults_repr
 
 
+@dataclass(repr=False, kw_only=True)
+class PartEndEvent:
+    """An event indicating that a part is complete."""
+
+    index: int
+    """The index of the part within the overall response parts list."""
+
+    part: ModelResponsePart
+    """The complete `ModelResponsePart`."""
+
+    next_part_kind: (
+        Literal['text', 'thinking', 'tool-call', 'builtin-tool-call', 'builtin-tool-return', 'file'] | None
+    ) = None
+    """The kind of the next part, if any.
+
+    This is useful for UI event streams to know whether to group parts of the same kind together when emitting events.
+    """
+
+    event_kind: Literal['part_end'] = 'part_end'
+    """Event type identifier, used as a discriminator."""
+
+    __repr__ = _utils.dataclasses_no_defaults_repr
+
+
 @dataclass(repr=False, kw_only=True)
 class FinalResultEvent:
     """An event indicating the response to the current model request matches the output schema and will produce a result."""
@@ -1649,9 +1681,9 @@ class FinalResultEvent:
 
 
 ModelResponseStreamEvent = Annotated[
-    PartStartEvent | PartDeltaEvent | FinalResultEvent, pydantic.Discriminator('event_kind')
+    PartStartEvent | PartDeltaEvent | PartEndEvent | FinalResultEvent, pydantic.Discriminator('event_kind')
 ]
-"""An event in the model response stream, starting a new part, applying a delta to an existing one, or indicating the final result."""
+"""An event in the model response stream, starting a new part, applying a delta to an existing one, indicating a part is complete, or indicating the final result."""
 
 
 @dataclass(repr=False)

pydantic_ai/models/__init__.py

@@ -27,6 +27,7 @@ from .._run_context import RunContext
 from ..builtin_tools import AbstractBuiltinTool
 from ..exceptions import UserError
 from ..messages import (
+    BaseToolCallPart,
     BinaryImage,
     FilePart,
     FileUrl,
@@ -35,9 +36,12 @@ from ..messages import (
     ModelMessage,
     ModelRequest,
     ModelResponse,
+    ModelResponsePart,
     ModelResponseStreamEvent,
+    PartEndEvent,
     PartStartEvent,
     TextPart,
+    ThinkingPart,
     ToolCallPart,
     VideoUrl,
 )
@@ -543,7 +547,44 @@ class StreamedResponse(ABC):
                 async for event in iterator:
                     yield event
 
-            self._event_iterator = iterator_with_final_event(self._get_event_iterator())
+            async def iterator_with_part_end(
+                iterator: AsyncIterator[ModelResponseStreamEvent],
+            ) -> AsyncIterator[ModelResponseStreamEvent]:
+                last_start_event: PartStartEvent | None = None
+
+                def part_end_event(next_part: ModelResponsePart | None = None) -> PartEndEvent | None:
+                    if not last_start_event:
+                        return None
+
+                    index = last_start_event.index
+                    part = self._parts_manager.get_parts()[index]
+                    if not isinstance(part, TextPart | ThinkingPart | BaseToolCallPart):
+                        # Parts other than these 3 don't have deltas, so don't need an end part.
+                        return None
+
+                    return PartEndEvent(
+                        index=index,
+                        part=part,
+                        next_part_kind=next_part.part_kind if next_part else None,
+                    )
+
+                async for event in iterator:
+                    if isinstance(event, PartStartEvent):
+                        if last_start_event:
+                            end_event = part_end_event(event.part)
+                            if end_event:
+                                yield end_event
+
+                            event.previous_part_kind = last_start_event.part.part_kind
+                        last_start_event = event
+
+                    yield event
+
+                end_event = part_end_event()
+                if end_event:
+                    yield end_event
+
+            self._event_iterator = iterator_with_part_end(iterator_with_final_event(self._get_event_iterator()))
         return self._event_iterator
 
     @abstractmethod

pydantic_ai/models/google.py

@@ -471,11 +471,9 @@ class GoogleModel(Model):
                 raise UnexpectedModelBehavior(
                     f'Content filter {raw_finish_reason.value!r} triggered', response.model_dump_json()
                 )
-            else:
-                raise UnexpectedModelBehavior(
-                    'Content field missing from Gemini response', response.model_dump_json()
-                )  # pragma: no cover
-        parts = candidate.content.parts or []
+            parts = []  # pragma: no cover
+        else:
+            parts = candidate.content.parts or []
 
         usage = _metadata_as_usage(response)
         return _process_response_from_parts(
@@ -649,17 +647,12 @@ class GeminiStreamedResponse(StreamedResponse):
             #     )
 
             if candidate.content is None or candidate.content.parts is None:
-                if self.finish_reason == 'stop':  # pragma: no cover
-                    # Normal completion - skip this chunk
-                    continue
-                elif self.finish_reason == 'content_filter' and raw_finish_reason:  # pragma: no cover
+                if self.finish_reason == 'content_filter' and raw_finish_reason:  # pragma: no cover
                     raise UnexpectedModelBehavior(
                         f'Content filter {raw_finish_reason.value!r} triggered', chunk.model_dump_json()
                     )
                 else:  # pragma: no cover
-                    raise UnexpectedModelBehavior(
-                        'Content field missing from streaming Gemini response', chunk.model_dump_json()
-                    )
+                    continue
 
             parts = candidate.content.parts
             if not parts:

pydantic_ai/models/groq.py

@@ -524,6 +524,8 @@ class GroqStreamedResponse(StreamedResponse):
     async def _get_event_iterator(self) -> AsyncIterator[ModelResponseStreamEvent]:  # noqa: C901
         try:
             executed_tool_call_id: str | None = None
+            reasoning_index = 0
+            reasoning = False
             async for chunk in self._response:
                 self._usage += _map_usage(chunk)
 
@@ -540,10 +542,16 @@ class GroqStreamedResponse(StreamedResponse):
                     self.finish_reason = _FINISH_REASON_MAP.get(raw_finish_reason)
 
                 if choice.delta.reasoning is not None:
+                    if not reasoning:
+                        reasoning_index += 1
+                        reasoning = True
+
                     # NOTE: The `reasoning` field is only present if `groq_reasoning_format` is set to `parsed`.
                     yield self._parts_manager.handle_thinking_delta(
-                        vendor_part_id='reasoning', content=choice.delta.reasoning
+                        vendor_part_id=f'reasoning-{reasoning_index}', content=choice.delta.reasoning
                     )
+                else:
+                    reasoning = False
 
                 if choice.delta.executed_tools:
                     for tool in choice.delta.executed_tools:

pydantic_ai/providers/anthropic.py

@@ -12,7 +12,7 @@ from pydantic_ai.profiles.anthropic import anthropic_model_profile
 from pydantic_ai.providers import Provider
 
 try:
-    from anthropic import AsyncAnthropic, AsyncAnthropicBedrock
+    from anthropic import AsyncAnthropic, AsyncAnthropicBedrock, AsyncAnthropicVertex
 except ImportError as _import_error:
     raise ImportError(
         'Please install the `anthropic` package to use the Anthropic provider, '
@@ -20,7 +20,7 @@ except ImportError as _import_error:
     ) from _import_error
 
 
-AsyncAnthropicClient: TypeAlias = AsyncAnthropic | AsyncAnthropicBedrock
+AsyncAnthropicClient: TypeAlias = AsyncAnthropic | AsyncAnthropicBedrock | AsyncAnthropicVertex
 
 
 class AnthropicProvider(Provider[AsyncAnthropicClient]):

pydantic_ai/result.py

@@ -60,14 +60,26 @@ class AgentStream(Generic[AgentDepsT, OutputDataT]):
 
     async def stream_output(self, *, debounce_by: float | None = 0.1) -> AsyncIterator[OutputDataT]:
         """Asynchronously stream the (validated) agent outputs."""
+        last_response: _messages.ModelResponse | None = None
         async for response in self.stream_responses(debounce_by=debounce_by):
-            if self._raw_stream_response.final_result_event is not None:
-                try:
-                    yield await self.validate_response_output(response, allow_partial=True)
-                except ValidationError:
-                    pass
-        if self._raw_stream_response.final_result_event is not None:  # pragma: no branch
-            yield await self.validate_response_output(self.response)
+            if self._raw_stream_response.final_result_event is None or (
+                last_response and response.parts == last_response.parts
+            ):
+                continue
+            last_response = response
+
+            try:
+                yield await self.validate_response_output(response, allow_partial=True)
+            except ValidationError:
+                pass
+
+        response = self.response
+        if self._raw_stream_response.final_result_event is None or (
+            last_response and response.parts == last_response.parts
+        ):
+            return
+
+        yield await self.validate_response_output(response)
 
     async def stream_responses(self, *, debounce_by: float | None = 0.1) -> AsyncIterator[_messages.ModelResponse]:
         """Asynchronously stream the (unvalidated) model responses for the agent."""

pydantic_ai/ui/__init__.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from ._adapter import StateDeps, StateHandler, UIAdapter
+from ._event_stream import SSE_CONTENT_TYPE, NativeEvent, OnCompleteFunc, UIEventStream
+from ._messages_builder import MessagesBuilder
+
+__all__ = [
+    'UIAdapter',
+    'UIEventStream',
+    'SSE_CONTENT_TYPE',
+    'StateDeps',
+    'StateHandler',
+    'NativeEvent',
+    'OnCompleteFunc',
+    'MessagesBuilder',
+]