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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai-slim
-Version: 1.0.8
+Version: 1.0.9
 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.8
+Requires-Dist: pydantic-graph==1.0.9
 Requires-Dist: pydantic>=2.10
 Requires-Dist: typing-inspection>=0.4.0
 Provides-Extra: a2a
@@ -53,11 +53,11 @@ Requires-Dist: rich>=13; extra == 'cli'
 Provides-Extra: cohere
 Requires-Dist: cohere>=5.18.0; (platform_system != 'Emscripten') and extra == 'cohere'
 Provides-Extra: dbos
-Requires-Dist: dbos>=1.13.0; extra == 'dbos'
+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.0.8; extra == 'evals'
+Requires-Dist: pydantic-evals==1.0.9; extra == 'evals'
 Provides-Extra: google
 Requires-Dist: google-genai>=1.31.0; extra == 'google'
 Provides-Extra: groq
@@ -71,7 +71,7 @@ Requires-Dist: mcp>=1.12.3; extra == 'mcp'
 Provides-Extra: mistral
 Requires-Dist: mistralai>=1.9.10; extra == 'mistral'
 Provides-Extra: openai
-Requires-Dist: openai>=1.99.9; extra == 'openai'
+Requires-Dist: openai>=1.107.2; extra == 'openai'
 Provides-Extra: retries
 Requires-Dist: tenacity>=8.2.3; extra == 'retries'
 Provides-Extra: tavily

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

@@ -545,21 +545,22 @@ class CallToolsNode(AgentNode[DepsT, NodeRunEndT]):
             # Ensure that the stream is only run once
 
             async def _run_stream() -> AsyncIterator[_messages.HandleResponseEvent]:  # noqa: C901
-                texts: list[str] = []
+                text = ''
                 tool_calls: list[_messages.ToolCallPart] = []
                 thinking_parts: list[_messages.ThinkingPart] = []
 
                 for part in self.model_response.parts:
                     if isinstance(part, _messages.TextPart):
-                        # ignore empty content for text parts, see #437
-                        if part.content:
-                            texts.append(part.content)
+                        text += part.content
                     elif isinstance(part, _messages.ToolCallPart):
                         tool_calls.append(part)
                     elif isinstance(part, _messages.BuiltinToolCallPart):
-                        yield _messages.BuiltinToolCallEvent(part)
+                        # Text parts before a built-in tool call are essentially thoughts,
+                        # not part of the final result output, so we reset the accumulated text
+                        text = ''
+                        yield _messages.BuiltinToolCallEvent(part)  # pyright: ignore[reportDeprecated]
                     elif isinstance(part, _messages.BuiltinToolReturnPart):
-                        yield _messages.BuiltinToolResultEvent(part)
+                        yield _messages.BuiltinToolResultEvent(part)  # pyright: ignore[reportDeprecated]
                     elif isinstance(part, _messages.ThinkingPart):
                         thinking_parts.append(part)
                     else:
@@ -572,9 +573,9 @@ class CallToolsNode(AgentNode[DepsT, NodeRunEndT]):
                 if tool_calls:
                     async for event in self._handle_tool_calls(ctx, tool_calls):
                         yield event
-                elif texts:
+                elif text:
                     # No events are emitted during the handling of text responses, so we don't need to yield anything
-                    self._next_node = await self._handle_text_response(ctx, texts)
+                    self._next_node = await self._handle_text_response(ctx, text)
                 elif thinking_parts:
                     # handle thinking-only responses (responses that contain only ThinkingPart instances)
                     # this can happen with models that support thinking mode when they don't provide
@@ -593,9 +594,16 @@ class CallToolsNode(AgentNode[DepsT, NodeRunEndT]):
                     if isinstance(ctx.deps.output_schema, _output.TextOutputSchema):
                         for message in reversed(ctx.state.message_history):
                             if isinstance(message, _messages.ModelResponse):
-                                last_texts = [p.content for p in message.parts if isinstance(p, _messages.TextPart)]
-                                if last_texts:
-                                    self._next_node = await self._handle_text_response(ctx, last_texts)
+                                text = ''
+                                for part in message.parts:
+                                    if isinstance(part, _messages.TextPart):
+                                        text += part.content
+                                    elif isinstance(part, _messages.BuiltinToolCallPart):
+                                        # Text parts before a built-in tool call are essentially thoughts,
+                                        # not part of the final result output, so we reset the accumulated text
+                                        text = ''  # pragma: no cover
+                                if text:
+                                    self._next_node = await self._handle_text_response(ctx, text)
                                     return
 
                     raise exceptions.UnexpectedModelBehavior('Received empty model response')
@@ -655,11 +663,9 @@ class CallToolsNode(AgentNode[DepsT, NodeRunEndT]):
     async def _handle_text_response(
         self,
         ctx: GraphRunContext[GraphAgentState, GraphAgentDeps[DepsT, NodeRunEndT]],
-        texts: list[str],
+        text: str,
     ) -> ModelRequestNode[DepsT, NodeRunEndT] | End[result.FinalResult[NodeRunEndT]]:
         output_schema = ctx.deps.output_schema
-
-        text = '\n\n'.join(texts)
         try:
             run_context = build_run_context(ctx)
             if isinstance(output_schema, _output.TextOutputSchema):

{pydantic_ai_slim-1.0.8 → pydantic_ai_slim-1.0.9}/pydantic_ai/_cli.py

@@ -356,7 +356,7 @@ def handle_slash_command(
         except IndexError:
             console.print('[dim]No output available to copy.[/dim]')
         else:
-            text_to_copy = '\n\n'.join(part.content for part in parts if isinstance(part, TextPart))
+            text_to_copy = ''.join(part.content for part in parts if isinstance(part, TextPart))
             text_to_copy = text_to_copy.strip()
             if text_to_copy:
                 pyperclip.copy(text_to_copy)

{pydantic_ai_slim-1.0.8 → pydantic_ai_slim-1.0.9}/pydantic_ai/_otel_messages.py

@@ -21,6 +21,7 @@ class ToolCallPart(TypedDict):
     id: str
     name: str
     arguments: NotRequired[JsonValue]
+    builtin: NotRequired[bool]  # Not (currently?) part of the spec, used by Logfire
 
 
 class ToolCallResponsePart(TypedDict):
@@ -28,6 +29,7 @@ class ToolCallResponsePart(TypedDict):
     id: str
     name: str
     result: NotRequired[JsonValue]
+    builtin: NotRequired[bool]  # Not (currently?) part of the spec, used by Logfire
 
 
 class MediaUrlPart(TypedDict):

{pydantic_ai_slim-1.0.8 → pydantic_ai_slim-1.0.9}/pydantic_ai/_parts_manager.py

@@ -19,6 +19,8 @@ from typing import Any
 
 from pydantic_ai.exceptions import UnexpectedModelBehavior
 from pydantic_ai.messages import (
+    BuiltinToolCallPart,
+    BuiltinToolReturnPart,
     ModelResponsePart,
     ModelResponseStreamEvent,
     PartDeltaEvent,
@@ -226,11 +228,11 @@ class ModelResponsePartsManager:
         self,
         *,
         vendor_part_id: Hashable | None,
-        tool_name: str | None,
-        args: str | dict[str, Any] | None,
-        tool_call_id: str | None,
+        tool_name: str | None = None,
+        args: str | dict[str, Any] | None = None,
+        tool_call_id: str | None = None,
     ) -> ModelResponseStreamEvent | None:
-        """Handle or update a tool call, creating or updating a `ToolCallPart` or `ToolCallPartDelta`.
+        """Handle or update a tool call, creating or updating a `ToolCallPart`, `BuiltinToolCallPart`, or `ToolCallPartDelta`.
 
         Managed items remain as `ToolCallPartDelta`s until they have at least a tool_name, at which
         point they are upgraded to `ToolCallPart`s.
@@ -247,15 +249,17 @@ class ModelResponsePartsManager:
             tool_call_id: An optional string representing an identifier for this tool call.
 
         Returns:
-            - A `PartStartEvent` if a new ToolCallPart is created.
+            - A `PartStartEvent` if a new ToolCallPart or BuiltinToolCallPart is created.
             - A `PartDeltaEvent` if an existing part is updated.
             - `None` if no new event is emitted (e.g., the part is still incomplete).
 
         Raises:
             UnexpectedModelBehavior: If attempting to apply a tool call delta to a part that is not
-                a ToolCallPart or ToolCallPartDelta.
+                a ToolCallPart, BuiltinToolCallPart, or ToolCallPartDelta.
         """
-        existing_matching_part_and_index: tuple[ToolCallPartDelta | ToolCallPart, int] | None = None
+        existing_matching_part_and_index: tuple[ToolCallPartDelta | ToolCallPart | BuiltinToolCallPart, int] | None = (
+            None
+        )
 
         if vendor_part_id is None:
             # vendor_part_id is None, so check if the latest part is a matching tool call or delta to update
@@ -264,14 +268,14 @@ class ModelResponsePartsManager:
             if tool_name is None and self._parts:
                 part_index = len(self._parts) - 1
                 latest_part = self._parts[part_index]
-                if isinstance(latest_part, ToolCallPart | ToolCallPartDelta):  # pragma: no branch
+                if isinstance(latest_part, ToolCallPart | BuiltinToolCallPart | ToolCallPartDelta):  # pragma: no branch
                     existing_matching_part_and_index = latest_part, part_index
         else:
             # vendor_part_id is provided, so look up the corresponding part or delta
             part_index = self._vendor_id_to_part_index.get(vendor_part_id)
             if part_index is not None:
                 existing_part = self._parts[part_index]
-                if not isinstance(existing_part, ToolCallPartDelta | ToolCallPart):
+                if not isinstance(existing_part, ToolCallPartDelta | ToolCallPart | BuiltinToolCallPart):
                     raise UnexpectedModelBehavior(f'Cannot apply a tool call delta to {existing_part=}')
                 existing_matching_part_and_index = existing_part, part_index
 
@@ -284,7 +288,7 @@ class ModelResponsePartsManager:
             new_part_index = len(self._parts)
             self._parts.append(part)
             # Only emit a PartStartEvent if we have enough information to produce a full ToolCallPart
-            if isinstance(part, ToolCallPart):
+            if isinstance(part, ToolCallPart | BuiltinToolCallPart):
                 return PartStartEvent(index=new_part_index, part=part)
         else:
             # Update the existing part or delta with the new information
@@ -292,7 +296,7 @@ class ModelResponsePartsManager:
             delta = ToolCallPartDelta(tool_name_delta=tool_name, args_delta=args, tool_call_id=tool_call_id)
             updated_part = delta.apply(existing_part)
             self._parts[part_index] = updated_part
-            if isinstance(updated_part, ToolCallPart):
+            if isinstance(updated_part, ToolCallPart | BuiltinToolCallPart):
                 if isinstance(existing_part, ToolCallPartDelta):
                     # We just upgraded a delta to a full part, so emit a PartStartEvent
                     return PartStartEvent(index=part_index, part=updated_part)
@@ -337,7 +341,7 @@ class ModelResponsePartsManager:
         else:
             # vendor_part_id is provided, so find and overwrite or create a new ToolCallPart.
             maybe_part_index = self._vendor_id_to_part_index.get(vendor_part_id)
-            if maybe_part_index is not None:
+            if maybe_part_index is not None and isinstance(self._parts[maybe_part_index], ToolCallPart):
                 new_part_index = maybe_part_index
                 self._parts[new_part_index] = new_part
             else:
@@ -345,3 +349,69 @@ class ModelResponsePartsManager:
                 self._parts.append(new_part)
             self._vendor_id_to_part_index[vendor_part_id] = new_part_index
         return PartStartEvent(index=new_part_index, part=new_part)
+
+    def handle_builtin_tool_call_part(
+        self,
+        *,
+        vendor_part_id: Hashable | None,
+        part: BuiltinToolCallPart,
+    ) -> ModelResponseStreamEvent:
+        """Create or overwrite a BuiltinToolCallPart.
+
+        Args:
+            vendor_part_id: The vendor's ID for this tool call part. If not
+                None and an existing part is found, that part is overwritten.
+            part: The BuiltinToolCallPart.
+
+        Returns:
+            ModelResponseStreamEvent: A `PartStartEvent` indicating that a new tool call part
+            has been added to the manager, or replaced an existing part.
+        """
+        if vendor_part_id is None:
+            # vendor_part_id is None, so we unconditionally append a new BuiltinToolCallPart to the end of the list
+            new_part_index = len(self._parts)
+            self._parts.append(part)
+        else:
+            # vendor_part_id is provided, so find and overwrite or create a new BuiltinToolCallPart.
+            maybe_part_index = self._vendor_id_to_part_index.get(vendor_part_id)
+            if maybe_part_index is not None and isinstance(self._parts[maybe_part_index], BuiltinToolCallPart):
+                new_part_index = maybe_part_index
+                self._parts[new_part_index] = part
+            else:
+                new_part_index = len(self._parts)
+                self._parts.append(part)
+            self._vendor_id_to_part_index[vendor_part_id] = new_part_index
+        return PartStartEvent(index=new_part_index, part=part)
+
+    def handle_builtin_tool_return_part(
+        self,
+        *,
+        vendor_part_id: Hashable | None,
+        part: BuiltinToolReturnPart,
+    ) -> ModelResponseStreamEvent:
+        """Create or overwrite a BuiltinToolReturnPart.
+
+        Args:
+            vendor_part_id: The vendor's ID for this tool call part. If not
+                None and an existing part is found, that part is overwritten.
+            part: The BuiltinToolReturnPart.
+
+        Returns:
+            ModelResponseStreamEvent: A `PartStartEvent` indicating that a new tool call part
+            has been added to the manager, or replaced an existing part.
+        """
+        if vendor_part_id is None:
+            # vendor_part_id is None, so we unconditionally append a new BuiltinToolReturnPart to the end of the list
+            new_part_index = len(self._parts)
+            self._parts.append(part)
+        else:
+            # vendor_part_id is provided, so find and overwrite or create a new BuiltinToolReturnPart.
+            maybe_part_index = self._vendor_id_to_part_index.get(vendor_part_id)
+            if maybe_part_index is not None and isinstance(self._parts[maybe_part_index], BuiltinToolReturnPart):
+                new_part_index = maybe_part_index
+                self._parts[new_part_index] = part
+            else:
+                new_part_index = len(self._parts)
+                self._parts.append(part)
+            self._vendor_id_to_part_index[vendor_part_id] = new_part_index
+        return PartStartEvent(index=new_part_index, part=part)

{pydantic_ai_slim-1.0.8 → pydantic_ai_slim-1.0.9}/pydantic_ai/_run_context.py

@@ -43,10 +43,17 @@ class RunContext(Generic[AgentDepsT]):
     tool_name: str | None = None
     """Name of the tool being called."""
     retry: int = 0
-    """Number of retries so far."""
+    """Number of retries of this tool so far."""
+    max_retries: int = 0
+    """The maximum number of retries of this tool."""
     run_step: int = 0
     """The current step in the run."""
     tool_call_approved: bool = False
     """Whether a tool call that required approval has now been approved."""
 
+    @property
+    def last_attempt(self) -> bool:
+        """Whether this is the last attempt at running this tool before an error is raised."""
+        return self.retry == self.max_retries
+
     __repr__ = _utils.dataclasses_no_defaults_repr

{pydantic_ai_slim-1.0.8 → pydantic_ai_slim-1.0.9}/pydantic_ai/_tool_manager.py

@@ -147,6 +147,7 @@ class ToolManager(Generic[AgentDepsT]):
                 tool_name=name,
                 tool_call_id=call.tool_call_id,
                 retry=self.ctx.retries.get(name, 0),
+                max_retries=tool.max_retries,
             )
 
             pyd_allow_partial = 'trailing-strings' if allow_partial else 'off'

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

@@ -9,7 +9,7 @@ from __future__ import annotations
 import json
 import uuid
 from collections.abc import AsyncIterator, Awaitable, Callable, Iterable, Mapping, Sequence
-from dataclasses import Field, dataclass, replace
+from dataclasses import Field, dataclass, field, replace
 from http import HTTPStatus
 from typing import (
     Any,
@@ -23,13 +23,15 @@ from typing import (
 )
 
 from pydantic import BaseModel, ValidationError
-from typing_extensions import assert_never
 
 from . import _utils
 from ._agent_graph import CallToolsNode, ModelRequestNode
 from .agent import AbstractAgent, AgentRun, AgentRunResult
 from .exceptions import UserError
 from .messages import (
+    BaseToolCallPart,
+    BuiltinToolCallPart,
+    BuiltinToolReturnPart,
     FunctionToolResultEvent,
     ModelMessage,
     ModelRequest,
@@ -123,6 +125,8 @@ SSE_CONTENT_TYPE: Final[str] = 'text/event-stream'
 OnCompleteFunc: TypeAlias = Callable[[AgentRunResult[Any]], None] | Callable[[AgentRunResult[Any]], Awaitable[None]]
 """Callback function type that receives the `AgentRunResult` of the completed run. Can be sync or async."""
 
+_BUILTIN_TOOL_CALL_ID_PREFIX: Final[str] = 'pyd_ai_builtin'
+
 
 class AGUIApp(Generic[AgentDepsT, OutputDataT], Starlette):
     """ASGI application for running Pydantic AI agents with AG-UI protocol support."""
@@ -487,20 +491,37 @@ async def _handle_model_request_event(  # noqa: C901
                 stream_ctx.part_end = TextMessageEndEvent(
                     message_id=message_id,
                 )
-            elif isinstance(part, ToolCallPart):  # pragma: no branch
+            elif isinstance(part, BaseToolCallPart):
+                tool_call_id = part.tool_call_id
+                if isinstance(part, BuiltinToolCallPart):
+                    builtin_tool_call_id = '|'.join(
+                        [_BUILTIN_TOOL_CALL_ID_PREFIX, part.provider_name or '', tool_call_id]
+                    )
+                    stream_ctx.builtin_tool_call_ids[tool_call_id] = builtin_tool_call_id
+                    tool_call_id = builtin_tool_call_id
+
                 message_id = stream_ctx.message_id or stream_ctx.new_message_id()
                 yield ToolCallStartEvent(
-                    tool_call_id=part.tool_call_id,
+                    tool_call_id=tool_call_id,
                     tool_call_name=part.tool_name,
                     parent_message_id=message_id,
                 )
                 if part.args:
                     yield ToolCallArgsEvent(
-                        tool_call_id=part.tool_call_id,
-                        delta=part.args if isinstance(part.args, str) else json.dumps(part.args),
+                        tool_call_id=tool_call_id,
+                        delta=part.args_as_json_str(),
                     )
                 stream_ctx.part_end = ToolCallEndEvent(
-                    tool_call_id=part.tool_call_id,
+                    tool_call_id=tool_call_id,
+                )
+            elif isinstance(part, BuiltinToolReturnPart):  # pragma: no branch
+                tool_call_id = stream_ctx.builtin_tool_call_ids[part.tool_call_id]
+                yield ToolCallResultEvent(
+                    message_id=stream_ctx.new_message_id(),
+                    type=EventType.TOOL_CALL_RESULT,
+                    role='tool',
+                    tool_call_id=tool_call_id,
+                    content=part.model_response_str(),
                 )
 
     elif isinstance(agent_event, PartDeltaEvent):
@@ -512,9 +533,12 @@ async def _handle_model_request_event(  # noqa: C901
                     delta=delta.content_delta,
                 )
         elif isinstance(delta, ToolCallPartDelta):  # pragma: no branch
-            assert delta.tool_call_id, '`ToolCallPartDelta.tool_call_id` must be set'
+            tool_call_id = delta.tool_call_id
+            assert tool_call_id, '`ToolCallPartDelta.tool_call_id` must be set'
+            if tool_call_id in stream_ctx.builtin_tool_call_ids:
+                tool_call_id = stream_ctx.builtin_tool_call_ids[tool_call_id]
             yield ToolCallArgsEvent(
-                tool_call_id=delta.tool_call_id,
+                tool_call_id=tool_call_id,
                 delta=delta.args_delta if isinstance(delta.args_delta, str) else json.dumps(delta.args_delta),
             )
         elif isinstance(delta, ThinkingPartDelta):  # pragma: no branch
@@ -550,9 +574,8 @@ async def _handle_tool_result_event(
     if not isinstance(result, ToolReturnPart):
         return
 
-    message_id = stream_ctx.new_message_id()
     yield ToolCallResultEvent(
-        message_id=message_id,
+        message_id=stream_ctx.new_message_id(),
         type=EventType.TOOL_CALL_RESULT,
         role='tool',
         tool_call_id=result.tool_call_id,
@@ -579,7 +602,9 @@ def _messages_from_ag_ui(messages: list[Message]) -> list[ModelMessage]:
     request_parts: list[ModelRequestPart] | None = None
     response_parts: list[ModelResponsePart] | None = None
     for msg in messages:
-        if isinstance(msg, UserMessage | SystemMessage | DeveloperMessage | ToolMessage):
+        if isinstance(msg, UserMessage | SystemMessage | DeveloperMessage) or (
+            isinstance(msg, ToolMessage) and not msg.tool_call_id.startswith(_BUILTIN_TOOL_CALL_ID_PREFIX)
+        ):
             if request_parts is None:
                 request_parts = []
                 result.append(ModelRequest(parts=request_parts))
@@ -589,44 +614,71 @@ def _messages_from_ag_ui(messages: list[Message]) -> list[ModelMessage]:
                 request_parts.append(UserPromptPart(content=msg.content))
             elif isinstance(msg, SystemMessage | DeveloperMessage):
                 request_parts.append(SystemPromptPart(content=msg.content))
-            elif isinstance(msg, ToolMessage):
-                tool_name = tool_calls.get(msg.tool_call_id)
+            else:
+                tool_call_id = msg.tool_call_id
+                tool_name = tool_calls.get(tool_call_id)
                 if tool_name is None:  # pragma: no cover
-                    raise _ToolCallNotFoundError(tool_call_id=msg.tool_call_id)
+                    raise _ToolCallNotFoundError(tool_call_id=tool_call_id)
 
                 request_parts.append(
                     ToolReturnPart(
                         tool_name=tool_name,
                         content=msg.content,
-                        tool_call_id=msg.tool_call_id,
+                        tool_call_id=tool_call_id,
                     )
                 )
-            else:
-                assert_never(msg)
 
-        elif isinstance(msg, AssistantMessage):
+        elif isinstance(msg, AssistantMessage) or (  # pragma: no branch
+            isinstance(msg, ToolMessage) and msg.tool_call_id.startswith(_BUILTIN_TOOL_CALL_ID_PREFIX)
+        ):
             if response_parts is None:
                 response_parts = []
                 result.append(ModelResponse(parts=response_parts))
                 request_parts = None
 
-            if msg.content:
-                response_parts.append(TextPart(content=msg.content))
-
-            if msg.tool_calls:
-                for tool_call in msg.tool_calls:
-                    tool_calls[tool_call.id] = tool_call.function.name
+            if isinstance(msg, AssistantMessage):
+                if msg.content:
+                    response_parts.append(TextPart(content=msg.content))
+
+                if msg.tool_calls:
+                    for tool_call in msg.tool_calls:
+                        tool_call_id = tool_call.id
+                        tool_name = tool_call.function.name
+                        tool_calls[tool_call_id] = tool_name
+
+                        if tool_call_id.startswith(_BUILTIN_TOOL_CALL_ID_PREFIX):
+                            _, provider_name, tool_call_id = tool_call_id.split('|', 2)
+                            response_parts.append(
+                                BuiltinToolCallPart(
+                                    tool_name=tool_name,
+                                    args=tool_call.function.arguments,
+                                    tool_call_id=tool_call_id,
+                                    provider_name=provider_name,
+                                )
+                            )
+                        else:
+                            response_parts.append(
+                                ToolCallPart(
+                                    tool_name=tool_name,
+                                    tool_call_id=tool_call_id,
+                                    args=tool_call.function.arguments,
+                                )
+                            )
+            else:
+                tool_call_id = msg.tool_call_id
+                tool_name = tool_calls.get(tool_call_id)
+                if tool_name is None:  # pragma: no cover
+                    raise _ToolCallNotFoundError(tool_call_id=tool_call_id)
+                _, provider_name, tool_call_id = tool_call_id.split('|', 2)
 
-                response_parts.extend(
-                    ToolCallPart(
-                        tool_name=tool_call.function.name,
-                        tool_call_id=tool_call.id,
-                        args=tool_call.function.arguments,
+                response_parts.append(
+                    BuiltinToolReturnPart(
+                        tool_name=tool_name,
+                        content=msg.content,
+                        tool_call_id=tool_call_id,
+                        provider_name=provider_name,
                     )
-                    for tool_call in msg.tool_calls
                 )
-        else:
-            assert_never(msg)
 
     return result
 
@@ -687,6 +739,7 @@ class _RequestStreamContext:
     message_id: str = ''
     part_end: BaseEvent | None = None
     thinking: bool = False
+    builtin_tool_call_ids: dict[str, str] = field(default_factory=dict)
 
     def new_message_id(self) -> str:
         """Generate a new message ID for the request stream.

{pydantic_ai_slim-1.0.8 → pydantic_ai_slim-1.0.9}/pydantic_ai/builtin_tools.py

@@ -18,6 +18,9 @@ class AbstractBuiltinTool(ABC):
     The builtin tools are passed to the model as part of the `ModelRequestParameters`.
     """
 
+    kind: str = 'unknown_builtin_tool'
+    """Built-in tool identifier, this should be available on all built-in tools as a discriminator."""
+
 
 @dataclass(kw_only=True)
 class WebSearchTool(AbstractBuiltinTool):
@@ -80,6 +83,9 @@ class WebSearchTool(AbstractBuiltinTool):
     * Anthropic
     """
 
+    kind: str = 'web_search'
+    """The kind of tool."""
+
 
 class WebSearchUserLocation(TypedDict, total=False):
     """Allows you to localize search results based on a user's location.
@@ -113,6 +119,9 @@ class CodeExecutionTool(AbstractBuiltinTool):
     * Google
     """
 
+    kind: str = 'code_execution'
+    """The kind of tool."""
+
 
 class UrlContextTool(AbstractBuiltinTool):
     """Allows your agent to access contents from URLs.
@@ -121,3 +130,6 @@ class UrlContextTool(AbstractBuiltinTool):
 
     * Google
     """
+
+    kind: str = 'url_context'
+    """The kind of tool."""

{pydantic_ai_slim-1.0.8 → pydantic_ai_slim-1.0.9}/pydantic_ai/durable_exec/temporal/_model.py

@@ -4,7 +4,7 @@ from collections.abc import AsyncIterator, Callable
 from contextlib import asynccontextmanager
 from dataclasses import dataclass
 from datetime import datetime
-from typing import Any
+from typing import Any, cast
 
 from pydantic import ConfigDict, with_config
 from temporalio import activity, workflow
@@ -30,7 +30,8 @@ from ._run_context import TemporalRunContext
 @with_config(ConfigDict(arbitrary_types_allowed=True))
 class _RequestParams:
     messages: list[ModelMessage]
-    model_settings: ModelSettings | None
+    # `model_settings` can't be a `ModelSettings` because Temporal would end up dropping fields only defined on its subclasses.
+    model_settings: dict[str, Any] | None
     model_request_parameters: ModelRequestParameters
     serialized_run_context: Any
 
@@ -82,7 +83,11 @@ class TemporalModel(WrapperModel):
 
         @activity.defn(name=f'{activity_name_prefix}__model_request')
         async def request_activity(params: _RequestParams) -> ModelResponse:
-            return await self.wrapped.request(params.messages, params.model_settings, params.model_request_parameters)
+            return await self.wrapped.request(
+                params.messages,
+                cast(ModelSettings | None, params.model_settings),
+                params.model_request_parameters,
+            )
 
         self.request_activity = request_activity
 
@@ -92,7 +97,10 @@ class TemporalModel(WrapperModel):
 
             run_context = self.run_context_type.deserialize_run_context(params.serialized_run_context, deps=deps)
             async with self.wrapped.request_stream(
-                params.messages, params.model_settings, params.model_request_parameters, run_context
+                params.messages,
+                cast(ModelSettings | None, params.model_settings),
+                params.model_request_parameters,
+                run_context,
             ) as streamed_response:
                 await self.event_stream_handler(run_context, streamed_response)
 
@@ -124,7 +132,7 @@ class TemporalModel(WrapperModel):
             activity=self.request_activity,
             arg=_RequestParams(
                 messages=messages,
-                model_settings=model_settings,
+                model_settings=cast(dict[str, Any] | None, model_settings),
                 model_request_parameters=model_request_parameters,
                 serialized_run_context=None,
             ),
@@ -161,7 +169,7 @@ class TemporalModel(WrapperModel):
             args=[
                 _RequestParams(
                     messages=messages,
-                    model_settings=model_settings,
+                    model_settings=cast(dict[str, Any] | None, model_settings),
                     model_request_parameters=model_request_parameters,
                     serialized_run_context=serialized_run_context,
                 ),

{pydantic_ai_slim-1.0.8 → pydantic_ai_slim-1.0.9}/pydantic_ai/durable_exec/temporal/_run_context.py

@@ -9,7 +9,7 @@ from pydantic_ai.tools import AgentDepsT, RunContext
 class TemporalRunContext(RunContext[AgentDepsT]):
     """The [`RunContext`][pydantic_ai.tools.RunContext] subclass to use to serialize and deserialize the run context for use inside a Temporal activity.
 
-    By default, only the `deps`, `retries`, `tool_call_id`, `tool_name`, `tool_call_approved`, `retry` and `run_step` attributes will be available.
+    By default, only the `deps`, `retries`, `tool_call_id`, `tool_name`, `tool_call_approved`, `retry`, `max_retries` and `run_step` attributes will be available.
     To make another attribute available, create a `TemporalRunContext` subclass with a custom `serialize_run_context` class method that returns a dictionary that includes the attribute and pass it to [`TemporalAgent`][pydantic_ai.durable_exec.temporal.TemporalAgent].
     """
 
@@ -42,6 +42,7 @@ class TemporalRunContext(RunContext[AgentDepsT]):
             'tool_name': ctx.tool_name,
             'tool_call_approved': ctx.tool_call_approved,
             'retry': ctx.retry,
+            'max_retries': ctx.max_retries,
             'run_step': ctx.run_step,
         }