pydantic-ai-slim 1.0.0b1__py3-none-any.whl → 1.0.1__py3-none-any.whl

pydantic_ai/_a2a.py

@@ -272,7 +272,7 @@ class AgentWorker(Worker[list[ModelMessage]], Generic[WorkerOutputT, AgentDepsT]
                 assert_never(part)
         return model_parts
 
-    def _response_parts_to_a2a(self, parts: list[ModelResponsePart]) -> list[Part]:
+    def _response_parts_to_a2a(self, parts: Sequence[ModelResponsePart]) -> list[Part]:
         """Convert pydantic-ai ModelResponsePart objects to A2A Part objects.
 
         This handles the conversion from pydantic-ai's internal response parts to

pydantic_ai/_agent_graph.py

@@ -2,7 +2,6 @@ from __future__ import annotations as _annotations
 
 import asyncio
 import dataclasses
-import hashlib
 from collections import defaultdict, deque
 from collections.abc import AsyncIterator, Awaitable, Callable, Iterator, Sequence
 from contextlib import asynccontextmanager, contextmanager
@@ -302,16 +301,21 @@ class UserPromptNode(AgentNode[DepsT, NodeRunEndT]):
         if self.system_prompt_dynamic_functions:
             for msg in messages:
                 if isinstance(msg, _messages.ModelRequest):
-                    for i, part in enumerate(msg.parts):
+                    reevaluated_message_parts: list[_messages.ModelRequestPart] = []
+                    for part in msg.parts:
                         if isinstance(part, _messages.SystemPromptPart) and part.dynamic_ref:
                             # Look up the runner by its ref
                             if runner := self.system_prompt_dynamic_functions.get(  # pragma: lax no cover
                                 part.dynamic_ref
                             ):
                                 updated_part_content = await runner.run(run_context)
-                                msg.parts[i] = _messages.SystemPromptPart(
-                                    updated_part_content, dynamic_ref=part.dynamic_ref
-                                )
+                                part = _messages.SystemPromptPart(updated_part_content, dynamic_ref=part.dynamic_ref)
+
+                        reevaluated_message_parts.append(part)
+
+                    # Replace message parts with reevaluated ones to prevent mutating parts list
+                    if reevaluated_message_parts != msg.parts:
+                        msg.parts = reevaluated_message_parts
 
     async def _sys_parts(self, run_context: RunContext[DepsT]) -> list[_messages.ModelRequestPart]:
         """Build the initial messages for the conversation."""
@@ -650,13 +654,6 @@ def build_run_context(ctx: GraphRunContext[GraphAgentState, GraphAgentDeps[DepsT
     )
 
 
-def multi_modal_content_identifier(identifier: str | bytes) -> str:
-    """Generate stable identifier for multi-modal content to help LLM in finding a specific file in tool call responses."""
-    if isinstance(identifier, str):
-        identifier = identifier.encode('utf-8')
-    return hashlib.sha1(identifier).hexdigest()[:6]
-
-
 async def process_function_tools(  # noqa: C901
     tool_manager: ToolManager[DepsT],
     tool_calls: list[_messages.ToolCallPart],
@@ -764,6 +761,7 @@ async def process_function_tools(  # noqa: C901
             calls_to_run,
             deferred_tool_results,
             ctx.deps.tracer,
+            ctx.deps.usage_limits,
             output_parts,
             deferred_calls,
         ):
@@ -810,6 +808,7 @@ async def _call_tools(
     tool_calls: list[_messages.ToolCallPart],
     deferred_tool_results: dict[str, DeferredToolResult],
     tracer: Tracer,
+    usage_limits: _usage.UsageLimits | None,
     output_parts: list[_messages.ModelRequestPart],
     output_deferred_calls: dict[Literal['external', 'unapproved'], list[_messages.ToolCallPart]],
 ) -> AsyncIterator[_messages.HandleResponseEvent]:
@@ -830,7 +829,7 @@ async def _call_tools(
     ):
         tasks = [
             asyncio.create_task(
-                _call_tool(tool_manager, call, deferred_tool_results.get(call.tool_call_id)),
+                _call_tool(tool_manager, call, deferred_tool_results.get(call.tool_call_id), usage_limits),
                 name=call.tool_name,
             )
             for call in tool_calls
@@ -870,14 +869,15 @@ async def _call_tool(
     tool_manager: ToolManager[DepsT],
     tool_call: _messages.ToolCallPart,
     tool_call_result: DeferredToolResult | None,
+    usage_limits: _usage.UsageLimits | None,
 ) -> tuple[_messages.ToolReturnPart | _messages.RetryPromptPart, _messages.UserPromptPart | None]:
     try:
         if tool_call_result is None:
-            tool_result = await tool_manager.handle_call(tool_call)
+            tool_result = await tool_manager.handle_call(tool_call, usage_limits=usage_limits)
         elif isinstance(tool_call_result, ToolApproved):
             if tool_call_result.override_args is not None:
                 tool_call = dataclasses.replace(tool_call, args=tool_call_result.override_args)
-            tool_result = await tool_manager.handle_call(tool_call)
+            tool_result = await tool_manager.handle_call(tool_call, usage_limits=usage_limits)
         elif isinstance(tool_call_result, ToolDenied):
             return _messages.ToolReturnPart(
                 tool_name=tool_call.tool_name,
@@ -915,10 +915,7 @@ async def _call_tool(
                     f'`ToolReturn` should be used directly.'
                 )
             elif isinstance(content, _messages.MultiModalContent):
-                if isinstance(content, _messages.BinaryContent):
-                    identifier = content.identifier or multi_modal_content_identifier(content.data)
-                else:
-                    identifier = multi_modal_content_identifier(content.url)
+                identifier = content.identifier
 
                 return_values.append(f'See file {identifier}')
                 user_contents.extend([f'This is file {identifier}:', content])

pydantic_ai/_parts_manager.py

@@ -154,6 +154,7 @@ class ModelResponsePartsManager:
         *,
         vendor_part_id: Hashable | None,
         content: str | None = None,
+        id: str | None = None,
         signature: str | None = None,
     ) -> ModelResponseStreamEvent:
         """Handle incoming thinking content, creating or updating a ThinkingPart in the manager as appropriate.
@@ -167,6 +168,7 @@ class ModelResponsePartsManager:
                 of thinking. If None, a new part will be created unless the latest part is already
                 a ThinkingPart.
             content: The thinking content to append to the appropriate ThinkingPart.
+            id: An optional id for the thinking part.
             signature: An optional signature for the thinking content.
 
         Returns:
@@ -197,7 +199,7 @@ class ModelResponsePartsManager:
             if content is not None:
                 # There is no existing thinking part that should be updated, so create a new one
                 new_part_index = len(self._parts)
-                part = ThinkingPart(content=content, signature=signature)
+                part = ThinkingPart(content=content, id=id, signature=signature)
                 if vendor_part_id is not None:  # pragma: no branch
                     self._vendor_id_to_part_index[vendor_part_id] = new_part_index
                 self._parts.append(part)

pydantic_ai/_tool_manager.py

@@ -14,6 +14,7 @@ from .exceptions import ModelRetry, ToolRetryError, UnexpectedModelBehavior
 from .messages import ToolCallPart
 from .tools import ToolDefinition
 from .toolsets.abstract import AbstractToolset, ToolsetTool
+from .usage import UsageLimits
 
 
 @dataclass
@@ -66,7 +67,11 @@ class ToolManager(Generic[AgentDepsT]):
             return None
 
     async def handle_call(
-        self, call: ToolCallPart, allow_partial: bool = False, wrap_validation_errors: bool = True
+        self,
+        call: ToolCallPart,
+        allow_partial: bool = False,
+        wrap_validation_errors: bool = True,
+        usage_limits: UsageLimits | None = None,
     ) -> Any:
         """Handle a tool call by validating the arguments, calling the tool, and handling retries.
 
@@ -74,13 +79,14 @@ class ToolManager(Generic[AgentDepsT]):
             call: The tool call part to handle.
             allow_partial: Whether to allow partial validation of the tool arguments.
             wrap_validation_errors: Whether to wrap validation errors in a retry prompt part.
+            usage_limits: Optional usage limits to check before executing tools.
         """
         if self.tools is None or self.ctx is None:
             raise ValueError('ToolManager has not been prepared for a run step yet')  # pragma: no cover
 
         if (tool := self.tools.get(call.tool_name)) and tool.tool_def.kind == 'output':
-            # Output tool calls are not traced
-            return await self._call_tool(call, allow_partial, wrap_validation_errors)
+            # Output tool calls are not traced and not counted
+            return await self._call_tool(call, allow_partial, wrap_validation_errors, count_tool_usage=False)
         else:
             return await self._call_tool_traced(
                 call,
@@ -88,9 +94,17 @@ class ToolManager(Generic[AgentDepsT]):
                 wrap_validation_errors,
                 self.ctx.tracer,
                 self.ctx.trace_include_content,
+                usage_limits,
             )
 
-    async def _call_tool(self, call: ToolCallPart, allow_partial: bool, wrap_validation_errors: bool) -> Any:
+    async def _call_tool(
+        self,
+        call: ToolCallPart,
+        allow_partial: bool,
+        wrap_validation_errors: bool,
+        usage_limits: UsageLimits | None = None,
+        count_tool_usage: bool = True,
+    ) -> Any:
         if self.tools is None or self.ctx is None:
             raise ValueError('ToolManager has not been prepared for a run step yet')  # pragma: no cover
 
@@ -121,7 +135,15 @@ class ToolManager(Generic[AgentDepsT]):
             else:
                 args_dict = validator.validate_python(call.args or {}, allow_partial=pyd_allow_partial)
 
-            return await self.toolset.call_tool(name, args_dict, ctx, tool)
+            if usage_limits is not None and count_tool_usage:
+                usage_limits.check_before_tool_call(self.ctx.usage)
+
+            result = await self.toolset.call_tool(name, args_dict, ctx, tool)
+
+            if count_tool_usage:
+                self.ctx.usage.tool_calls += 1
+
+            return result
         except (ValidationError, ModelRetry) as e:
             max_retries = tool.max_retries if tool is not None else 1
             current_retry = self.ctx.retries.get(name, 0)
@@ -160,6 +182,7 @@ class ToolManager(Generic[AgentDepsT]):
         wrap_validation_errors: bool,
         tracer: Tracer,
         include_content: bool = False,
+        usage_limits: UsageLimits | None = None,
     ) -> Any:
         """See <https://opentelemetry.io/docs/specs/semconv/gen-ai/gen-ai-spans/#execute-tool-span>."""
         span_attributes = {
@@ -189,7 +212,7 @@ class ToolManager(Generic[AgentDepsT]):
         }
         with tracer.start_as_current_span('running tool', attributes=span_attributes) as span:
             try:
-                tool_result = await self._call_tool(call, allow_partial, wrap_validation_errors)
+                tool_result = await self._call_tool(call, allow_partial, wrap_validation_errors, usage_limits)
             except ToolRetryError as e:
                 part = e.tool_retry
                 if include_content and span.is_recording():

pydantic_ai/ag_ui.py

@@ -68,6 +68,9 @@ try:
         TextMessageContentEvent,
         TextMessageEndEvent,
         TextMessageStartEvent,
+        # TODO: Enable once https://github.com/ag-ui-protocol/ag-ui/issues/289 is resolved.
+        # ThinkingEndEvent,
+        # ThinkingStartEvent,
         ThinkingTextMessageContentEvent,
         ThinkingTextMessageEndEvent,
         ThinkingTextMessageStartEvent,
@@ -392,6 +395,12 @@ async def _agent_stream(run: AgentRun[AgentDepsT, Any]) -> AsyncIterator[BaseEve
                 if stream_ctx.part_end:  # pragma: no branch
                     yield stream_ctx.part_end
                     stream_ctx.part_end = None
+                if stream_ctx.thinking:
+                    # TODO: Enable once https://github.com/ag-ui-protocol/ag-ui/issues/289 is resolved.
+                    # yield ThinkingEndEvent(
+                    #     type=EventType.THINKING_END,
+                    # )
+                    stream_ctx.thinking = False
         elif isinstance(node, CallToolsNode):
             async with node.stream(run.ctx) as handle_stream:
                 async for event in handle_stream:
@@ -400,7 +409,7 @@ async def _agent_stream(run: AgentRun[AgentDepsT, Any]) -> AsyncIterator[BaseEve
                             yield msg
 
 
-async def _handle_model_request_event(
+async def _handle_model_request_event(  # noqa: C901
     stream_ctx: _RequestStreamContext,
     agent_event: ModelResponseStreamEvent,
 ) -> AsyncIterator[BaseEvent]:
@@ -420,56 +429,70 @@ async def _handle_model_request_event(
             stream_ctx.part_end = None
 
         part = agent_event.part
-        if isinstance(part, TextPart):
-            message_id = stream_ctx.new_message_id()
-            yield TextMessageStartEvent(
-                message_id=message_id,
-            )
-            if part.content:  # pragma: no branch
-                yield TextMessageContentEvent(
-                    message_id=message_id,
+        if isinstance(part, ThinkingPart):  # pragma: no branch
+            if not stream_ctx.thinking:
+                # TODO: Enable once https://github.com/ag-ui-protocol/ag-ui/issues/289 is resolved.
+                # yield ThinkingStartEvent(
+                #     type=EventType.THINKING_START,
+                # )
+                stream_ctx.thinking = True
+
+            if part.content:
+                yield ThinkingTextMessageStartEvent(
+                    type=EventType.THINKING_TEXT_MESSAGE_START,
+                )
+                yield ThinkingTextMessageContentEvent(
+                    type=EventType.THINKING_TEXT_MESSAGE_CONTENT,
                     delta=part.content,
                 )
-            stream_ctx.part_end = TextMessageEndEvent(
-                message_id=message_id,
-            )
-        elif isinstance(part, ToolCallPart):  # pragma: no branch
-            message_id = stream_ctx.message_id or stream_ctx.new_message_id()
-            yield ToolCallStartEvent(
-                tool_call_id=part.tool_call_id,
-                tool_call_name=part.tool_name,
-                parent_message_id=message_id,
-            )
-            if part.args:
-                yield ToolCallArgsEvent(
+                stream_ctx.part_end = ThinkingTextMessageEndEvent(
+                    type=EventType.THINKING_TEXT_MESSAGE_END,
+                )
+        else:
+            if stream_ctx.thinking:
+                # TODO: Enable once https://github.com/ag-ui-protocol/ag-ui/issues/289 is resolved.
+                # yield ThinkingEndEvent(
+                #     type=EventType.THINKING_END,
+                # )
+                stream_ctx.thinking = False
+
+            if isinstance(part, TextPart):
+                message_id = stream_ctx.new_message_id()
+                yield TextMessageStartEvent(
+                    message_id=message_id,
+                )
+                if part.content:  # pragma: no branch
+                    yield TextMessageContentEvent(
+                        message_id=message_id,
+                        delta=part.content,
+                    )
+                stream_ctx.part_end = TextMessageEndEvent(
+                    message_id=message_id,
+                )
+            elif isinstance(part, ToolCallPart):  # pragma: no branch
+                message_id = stream_ctx.message_id or stream_ctx.new_message_id()
+                yield ToolCallStartEvent(
+                    tool_call_id=part.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),
+                    )
+                stream_ctx.part_end = ToolCallEndEvent(
                     tool_call_id=part.tool_call_id,
-                    delta=part.args if isinstance(part.args, str) else json.dumps(part.args),
                 )
-            stream_ctx.part_end = ToolCallEndEvent(
-                tool_call_id=part.tool_call_id,
-            )
-
-        elif isinstance(part, ThinkingPart):  # pragma: no branch
-            yield ThinkingTextMessageStartEvent(
-                type=EventType.THINKING_TEXT_MESSAGE_START,
-            )
-            # Always send the content even if it's empty, as it may be
-            # used to indicate the start of thinking.
-            yield ThinkingTextMessageContentEvent(
-                type=EventType.THINKING_TEXT_MESSAGE_CONTENT,
-                delta=part.content,
-            )
-            stream_ctx.part_end = ThinkingTextMessageEndEvent(
-                type=EventType.THINKING_TEXT_MESSAGE_END,
-            )
 
     elif isinstance(agent_event, PartDeltaEvent):
         delta = agent_event.delta
         if isinstance(delta, TextPartDelta):
-            yield TextMessageContentEvent(
-                message_id=stream_ctx.message_id,
-                delta=delta.content_delta,
-            )
+            if delta.content_delta:  # pragma: no branch
+                yield TextMessageContentEvent(
+                    message_id=stream_ctx.message_id,
+                    delta=delta.content_delta,
+                )
         elif isinstance(delta, ToolCallPartDelta):  # pragma: no branch
             assert delta.tool_call_id, '`ToolCallPartDelta.tool_call_id` must be set'
             yield ToolCallArgsEvent(
@@ -478,6 +501,14 @@ async def _handle_model_request_event(
             )
         elif isinstance(delta, ThinkingPartDelta):  # pragma: no branch
             if delta.content_delta:  # pragma: no branch
+                if not isinstance(stream_ctx.part_end, ThinkingTextMessageEndEvent):
+                    yield ThinkingTextMessageStartEvent(
+                        type=EventType.THINKING_TEXT_MESSAGE_START,
+                    )
+                    stream_ctx.part_end = ThinkingTextMessageEndEvent(
+                        type=EventType.THINKING_TEXT_MESSAGE_END,
+                    )
+
                 yield ThinkingTextMessageContentEvent(
                     type=EventType.THINKING_TEXT_MESSAGE_CONTENT,
                     delta=delta.content_delta,
@@ -629,6 +660,7 @@ class _RequestStreamContext:
 
     message_id: str = ''
     part_end: BaseEvent | None = None
+    thinking: bool = False
 
     def new_message_id(self) -> str:
         """Generate a new message ID for the request stream.

pydantic_ai/agent/__init__.py

@@ -4,15 +4,15 @@ import dataclasses
 import inspect
 import json
 import warnings
+from asyncio import Lock
 from collections.abc import AsyncIterator, Awaitable, Callable, Iterator, Sequence
 from contextlib import AbstractAsyncContextManager, AsyncExitStack, asynccontextmanager, contextmanager
 from contextvars import ContextVar
 from typing import TYPE_CHECKING, Any, ClassVar, cast, overload
 
-import anyio
 from opentelemetry.trace import NoOpTracer, use_span
 from pydantic.json_schema import GenerateJsonSchema
-from typing_extensions import TypeVar, deprecated
+from typing_extensions import Self, TypeVar, deprecated
 
 from pydantic_graph import Graph
 
@@ -157,7 +157,7 @@ class Agent(AbstractAgent[AgentDepsT, OutputDataT]):
 
     _event_stream_handler: EventStreamHandler[AgentDepsT] | None = dataclasses.field(repr=False)
 
-    _enter_lock: anyio.Lock = dataclasses.field(repr=False)
+    _enter_lock: Lock = dataclasses.field(repr=False)
     _entered_count: int = dataclasses.field(repr=False)
     _exit_stack: AsyncExitStack | None = dataclasses.field(repr=False)
 
@@ -374,7 +374,7 @@ class Agent(AbstractAgent[AgentDepsT, OutputDataT]):
             _utils.Option[Sequence[Tool[AgentDepsT] | ToolFuncEither[AgentDepsT, ...]]]
         ] = ContextVar('_override_tools', default=None)
 
-        self._enter_lock = anyio.Lock()
+        self._enter_lock = Lock()
         self._entered_count = 0
         self._exit_stack = None
 
@@ -1066,7 +1066,7 @@ class Agent(AbstractAgent[AgentDepsT, OutputDataT]):
             strict: Whether to enforce JSON schema compliance (only affects OpenAI).
                 See [`ToolDefinition`][pydantic_ai.tools.ToolDefinition] for more info.
             requires_approval: Whether this tool requires human-in-the-loop approval. Defaults to False.
-                See the [tools documentation](../tools.md#human-in-the-loop-tool-approval) for more info.
+                See the [tools documentation](../deferred-tools.md#human-in-the-loop-tool-approval) for more info.
         """
 
         def tool_decorator(
@@ -1165,7 +1165,7 @@ class Agent(AbstractAgent[AgentDepsT, OutputDataT]):
             strict: Whether to enforce JSON schema compliance (only affects OpenAI).
                 See [`ToolDefinition`][pydantic_ai.tools.ToolDefinition] for more info.
             requires_approval: Whether this tool requires human-in-the-loop approval. Defaults to False.
-                See the [tools documentation](../tools.md#human-in-the-loop-tool-approval) for more info.
+                See the [tools documentation](../deferred-tools.md#human-in-the-loop-tool-approval) for more info.
         """
 
         def tool_decorator(func_: ToolFuncPlain[ToolParams]) -> ToolFuncPlain[ToolParams]:
@@ -1355,7 +1355,7 @@ class Agent(AbstractAgent[AgentDepsT, OutputDataT]):
 
         return schema  # pyright: ignore[reportReturnType]
 
-    async def __aenter__(self) -> AbstractAgent[AgentDepsT, OutputDataT]:
+    async def __aenter__(self) -> Self:
         """Enter the agent context.
 
         This will start all [`MCPServerStdio`s][pydantic_ai.mcp.MCPServerStdio] registered as `toolsets` so they are ready to be used.

pydantic_ai/durable_exec/temporal/_agent.py

@@ -1,14 +1,16 @@
 from __future__ import annotations
 
-from collections.abc import AsyncIterator, Callable, Iterator, Sequence
+from collections.abc import AsyncIterable, AsyncIterator, Callable, Iterator, Sequence
 from contextlib import AbstractAsyncContextManager, asynccontextmanager, contextmanager
 from contextvars import ContextVar
+from dataclasses import dataclass
 from datetime import timedelta
 from typing import Any, Literal, overload
 
+from pydantic import ConfigDict, with_config
 from pydantic.errors import PydanticUserError
 from pydantic_core import PydanticSerializationError
-from temporalio import workflow
+from temporalio import activity, workflow
 from temporalio.common import RetryPolicy
 from temporalio.workflow import ActivityConfig
 from typing_extensions import Never
@@ -21,7 +23,6 @@ from pydantic_ai import (
 )
 from pydantic_ai._run_context import AgentDepsT
 from pydantic_ai.agent import AbstractAgent, AgentRun, AgentRunResult, EventStreamHandler, RunOutputDataT, WrapperAgent
-from pydantic_ai.durable_exec.temporal._run_context import TemporalRunContext
 from pydantic_ai.exceptions import UserError
 from pydantic_ai.models import Model
 from pydantic_ai.output import OutputDataT, OutputSpec
@@ -29,15 +30,24 @@ from pydantic_ai.result import StreamedRunResult
 from pydantic_ai.settings import ModelSettings
 from pydantic_ai.tools import (
     DeferredToolResults,
+    RunContext,
     Tool,
     ToolFuncEither,
 )
 from pydantic_ai.toolsets import AbstractToolset
 
 from ._model import TemporalModel
+from ._run_context import TemporalRunContext
 from ._toolset import TemporalWrapperToolset, temporalize_toolset
 
 
+@dataclass
+@with_config(ConfigDict(arbitrary_types_allowed=True))
+class _EventStreamHandlerParams:
+    event: _messages.AgentStreamEvent
+    serialized_run_context: Any
+
+
 class TemporalAgent(WrapperAgent[AgentDepsT, OutputDataT]):
     def __init__(
         self,
@@ -86,6 +96,10 @@ class TemporalAgent(WrapperAgent[AgentDepsT, OutputDataT]):
         """
         super().__init__(wrapped)
 
+        self._name = name
+        self._event_stream_handler = event_stream_handler
+        self.run_context_type = run_context_type
+
         # start_to_close_timeout is required
         activity_config = activity_config or ActivityConfig(start_to_close_timeout=timedelta(seconds=60))
 
@@ -97,13 +111,13 @@ class TemporalAgent(WrapperAgent[AgentDepsT, OutputDataT]):
             PydanticUserError.__name__,
         ]
         activity_config['retry_policy'] = retry_policy
+        self.activity_config = activity_config
 
         model_activity_config = model_activity_config or {}
         toolset_activity_config = toolset_activity_config or {}
         tool_activity_config = tool_activity_config or {}
 
-        self._name = name or wrapped.name
-        if self._name is None:
+        if self.name is None:
             raise UserError(
                 "An agent needs to have a unique `name` in order to be used with Temporal. The name will be used to identify the agent's activities within the workflow."
             )
@@ -116,13 +130,33 @@ class TemporalAgent(WrapperAgent[AgentDepsT, OutputDataT]):
                 'An agent needs to have a `model` in order to be used with Temporal, it cannot be set at agent run time.'
             )
 
+        async def event_stream_handler_activity(params: _EventStreamHandlerParams, deps: AgentDepsT) -> None:
+            # We can never get here without an `event_stream_handler`, as `TemporalAgent.run_stream` and `TemporalAgent.iter` raise an error saying to use `TemporalAgent.run` instead,
+            # and that only ends up calling `event_stream_handler` if it is set.
+            assert self.event_stream_handler is not None
+
+            run_context = self.run_context_type.deserialize_run_context(params.serialized_run_context, deps=deps)
+
+            async def streamed_response():
+                yield params.event
+
+            await self.event_stream_handler(run_context, streamed_response())
+
+        # Set type hint explicitly so that Temporal can take care of serialization and deserialization
+        event_stream_handler_activity.__annotations__['deps'] = self.deps_type
+
+        self.event_stream_handler_activity = activity.defn(name=f'{activity_name_prefix}__event_stream_handler')(
+            event_stream_handler_activity
+        )
+        activities.append(self.event_stream_handler_activity)
+
         temporal_model = TemporalModel(
             wrapped.model,
             activity_name_prefix=activity_name_prefix,
             activity_config=activity_config | model_activity_config,
             deps_type=self.deps_type,
-            run_context_type=run_context_type,
-            event_stream_handler=event_stream_handler or wrapped.event_stream_handler,
+            run_context_type=self.run_context_type,
+            event_stream_handler=self.event_stream_handler,
         )
         activities.extend(temporal_model.temporal_activities)
 
@@ -139,7 +173,7 @@ class TemporalAgent(WrapperAgent[AgentDepsT, OutputDataT]):
                 activity_config | toolset_activity_config.get(id, {}),
                 tool_activity_config.get(id, {}),
                 self.deps_type,
-                run_context_type,
+                self.run_context_type,
             )
             if isinstance(toolset, TemporalWrapperToolset):
                 activities.extend(toolset.temporal_activities)
@@ -155,7 +189,7 @@ class TemporalAgent(WrapperAgent[AgentDepsT, OutputDataT]):
 
     @property
     def name(self) -> str | None:
-        return self._name
+        return self._name or super().name
 
     @name.setter
     def name(self, value: str | None) -> None:  # pragma: no cover
@@ -167,6 +201,33 @@ class TemporalAgent(WrapperAgent[AgentDepsT, OutputDataT]):
     def model(self) -> Model:
         return self._model
 
+    @property
+    def event_stream_handler(self) -> EventStreamHandler[AgentDepsT] | None:
+        handler = self._event_stream_handler or super().event_stream_handler
+        if handler is None:
+            return None
+        elif workflow.in_workflow():
+            return self._call_event_stream_handler_activity
+        else:
+            return handler
+
+    async def _call_event_stream_handler_activity(
+        self, ctx: RunContext[AgentDepsT], stream: AsyncIterable[_messages.AgentStreamEvent]
+    ) -> None:
+        serialized_run_context = self.run_context_type.serialize_run_context(ctx)
+        async for event in stream:
+            await workflow.execute_activity(  # pyright: ignore[reportUnknownMemberType]
+                activity=self.event_stream_handler_activity,
+                args=[
+                    _EventStreamHandlerParams(
+                        event=event,
+                        serialized_run_context=serialized_run_context,
+                    ),
+                    ctx.deps,
+                ],
+                **self.activity_config,
+            )
+
     @property
     def toolsets(self) -> Sequence[AbstractToolset[AgentDepsT]]:
         with self._temporal_overrides():
@@ -296,7 +357,7 @@ class TemporalAgent(WrapperAgent[AgentDepsT, OutputDataT]):
                 usage=usage,
                 infer_name=infer_name,
                 toolsets=toolsets,
-                event_stream_handler=event_stream_handler,
+                event_stream_handler=event_stream_handler or self.event_stream_handler,
                 **_deprecated_kwargs,
             )
 

pydantic_ai/exceptions.py

@@ -65,7 +65,7 @@ class ModelRetry(Exception):
 class CallDeferred(Exception):
     """Exception to raise when a tool call should be deferred.
 
-    See [tools docs](../tools.md#deferred-tools) for more information.
+    See [tools docs](../deferred-tools.md#deferred-tools) for more information.
     """
 
     pass
@@ -74,7 +74,7 @@ class CallDeferred(Exception):
 class ApprovalRequired(Exception):
     """Exception to raise when a tool call requires human-in-the-loop approval.
 
-    See [tools docs](../tools.md#human-in-the-loop-tool-approval) for more information.
+    See [tools docs](../deferred-tools.md#human-in-the-loop-tool-approval) for more information.
     """
 
     pass