pydantic-ai-slim 0.0.55__py3-none-any.whl → 0.1.1__py3-none-any.whl

pydantic_ai/__init__.py

@@ -1,4 +1,4 @@
-from importlib.metadata import version
+from importlib.metadata import version as _metadata_version
 
 from .agent import Agent, CallToolsNode, EndStrategy, ModelRequestNode, UserPromptNode, capture_run_messages
 from .exceptions import (
@@ -10,7 +10,9 @@ from .exceptions import (
     UsageLimitExceeded,
     UserError,
 )
-from .messages import AudioUrl, BinaryContent, DocumentUrl, ImageUrl
+from .format_prompt import format_as_xml
+from .messages import AudioUrl, BinaryContent, DocumentUrl, ImageUrl, VideoUrl
+from .result import ToolOutput
 from .tools import RunContext, Tool
 
 __all__ = (
@@ -33,10 +35,15 @@ __all__ = (
     # messages
     'ImageUrl',
     'AudioUrl',
+    'VideoUrl',
     'DocumentUrl',
     'BinaryContent',
     # tools
     'Tool',
     'RunContext',
+    # result
+    'ToolOutput',
+    # format_prompt
+    'format_as_xml',
 )
-__version__ = version('pydantic_ai_slim')
+__version__ = _metadata_version('pydantic_ai_slim')

pydantic_ai/_agent_graph.py

@@ -3,11 +3,11 @@ from __future__ import annotations as _annotations
 import asyncio
 import dataclasses
 import json
-from collections.abc import AsyncIterator, Iterator, Sequence
+from collections.abc import AsyncIterator, Awaitable, Iterator, Sequence
 from contextlib import asynccontextmanager, contextmanager
 from contextvars import ContextVar
 from dataclasses import field
-from typing import TYPE_CHECKING, Any, Generic, Literal, Union, cast
+from typing import TYPE_CHECKING, Any, Callable, Generic, Literal, Union, cast
 
 from opentelemetry.trace import Span, Tracer
 from typing_extensions import TypeGuard, TypeVar, assert_never
@@ -16,7 +16,7 @@ from pydantic_graph import BaseNode, Graph, GraphRunContext
 from pydantic_graph.nodes import End, NodeRunEndT
 
 from . import (
-    _result,
+    _output,
     _system_prompt,
     exceptions,
     messages as _messages,
@@ -25,7 +25,7 @@ from . import (
     usage as _usage,
 )
 from .models.instrumented import InstrumentedModel
-from .result import ResultDataT
+from .result import OutputDataT, ToolOutput
 from .settings import ModelSettings, merge_model_settings
 from .tools import RunContext, Tool, ToolDefinition
 
@@ -53,7 +53,7 @@ EndStrategy = Literal['early', 'exhaustive']
 - `'exhaustive'`: Process all tool calls even after finding a final result
 """
 DepsT = TypeVar('DepsT')
-ResultT = TypeVar('ResultT')
+OutputT = TypeVar('OutputT')
 
 
 @dataclasses.dataclass
@@ -74,7 +74,7 @@ class GraphAgentState:
 
 
 @dataclasses.dataclass
-class GraphAgentDeps(Generic[DepsT, ResultDataT]):
+class GraphAgentDeps(Generic[DepsT, OutputDataT]):
     """Dependencies/config passed to the agent graph."""
 
     user_deps: DepsT
@@ -87,10 +87,10 @@ class GraphAgentDeps(Generic[DepsT, ResultDataT]):
     usage_limits: _usage.UsageLimits
     max_result_retries: int
     end_strategy: EndStrategy
+    get_instructions: Callable[[RunContext[DepsT]], Awaitable[str | None]]
 
-    result_schema: _result.ResultSchema[ResultDataT] | None
-    result_tools: list[ToolDefinition]
-    result_validators: list[_result.ResultValidator[DepsT, ResultDataT]]
+    output_schema: _output.OutputSchema[OutputDataT] | None
+    output_validators: list[_output.OutputValidator[DepsT, OutputDataT]]
 
     function_tools: dict[str, Tool[DepsT]] = dataclasses.field(repr=False)
     mcp_servers: Sequence[MCPServer] = dataclasses.field(repr=False)
@@ -126,6 +126,9 @@ def is_agent_node(
 class UserPromptNode(AgentNode[DepsT, NodeRunEndT]):
     user_prompt: str | Sequence[_messages.UserContent] | None
 
+    instructions: str | None
+    instructions_functions: list[_system_prompt.SystemPromptRunner[DepsT]]
+
     system_prompts: tuple[str, ...]
     system_prompt_functions: list[_system_prompt.SystemPromptRunner[DepsT]]
     system_prompt_dynamic_functions: dict[str, _system_prompt.SystemPromptRunner[DepsT]]
@@ -139,7 +142,9 @@ class UserPromptNode(AgentNode[DepsT, NodeRunEndT]):
         self, ctx: GraphRunContext[GraphAgentState, GraphAgentDeps[DepsT, NodeRunEndT]]
     ) -> _messages.ModelRequest:
         run_context = build_run_context(ctx)
-        history, next_message = await self._prepare_messages(self.user_prompt, ctx.state.message_history, run_context)
+        history, next_message = await self._prepare_messages(
+            self.user_prompt, ctx.state.message_history, ctx.deps.get_instructions, run_context
+        )
         ctx.state.message_history = history
         run_context.messages = history
 
@@ -153,6 +158,7 @@ class UserPromptNode(AgentNode[DepsT, NodeRunEndT]):
         self,
         user_prompt: str | Sequence[_messages.UserContent] | None,
         message_history: list[_messages.ModelMessage] | None,
+        get_instructions: Callable[[RunContext[DepsT]], Awaitable[str | None]],
         run_context: RunContext[DepsT],
     ) -> tuple[list[_messages.ModelMessage], _messages.ModelRequest]:
         try:
@@ -167,6 +173,7 @@ class UserPromptNode(AgentNode[DepsT, NodeRunEndT]):
                 ctx_messages.used = True
 
         parts: list[_messages.ModelRequestPart] = []
+        instructions = await get_instructions(run_context)
         if message_history:
             # Shallow copy messages
             messages.extend(message_history)
@@ -177,7 +184,7 @@ class UserPromptNode(AgentNode[DepsT, NodeRunEndT]):
 
         if user_prompt is not None:
             parts.append(_messages.UserPromptPart(user_prompt))
-        return messages, _messages.ModelRequest(parts)
+        return messages, _messages.ModelRequest(parts, instructions=instructions)
 
     async def _reevaluate_dynamic_prompts(
         self, messages: list[_messages.ModelMessage], run_context: RunContext[DepsT]
@@ -233,11 +240,11 @@ async def _prepare_request_parameters(
         *map(add_mcp_server_tools, ctx.deps.mcp_servers),
     )
 
-    result_schema = ctx.deps.result_schema
+    output_schema = ctx.deps.output_schema
     return models.ModelRequestParameters(
         function_tools=function_tool_defs,
-        allow_text_result=allow_text_result(result_schema),
-        result_tools=result_schema.tool_defs() if result_schema is not None else [],
+        allow_text_output=allow_text_output(output_schema),
+        output_tools=output_schema.tool_defs() if output_schema is not None else [],
     )
 
 
@@ -271,8 +278,8 @@ class ModelRequestNode(AgentNode[DepsT, NodeRunEndT]):
         async with self._stream(ctx) as streamed_response:
             agent_stream = result.AgentStream[DepsT, T](
                 streamed_response,
-                ctx.deps.result_schema,
-                ctx.deps.result_validators,
+                ctx.deps.output_schema,
+                ctx.deps.output_validators,
                 build_run_context(ctx),
                 ctx.deps.usage_limits,
             )
@@ -290,6 +297,7 @@ class ModelRequestNode(AgentNode[DepsT, NodeRunEndT]):
         assert not self._did_stream, 'stream() should only be called once per node'
 
         model_settings, model_request_parameters = await self._prepare_request(ctx)
+        model_request_parameters = ctx.deps.model.customize_request_parameters(model_request_parameters)
         async with ctx.deps.model.request_stream(
             ctx.state.message_history, model_settings, model_request_parameters
         ) as streamed_response:
@@ -431,17 +439,17 @@ class CallToolsNode(AgentNode[DepsT, NodeRunEndT]):
         ctx: GraphRunContext[GraphAgentState, GraphAgentDeps[DepsT, NodeRunEndT]],
         tool_calls: list[_messages.ToolCallPart],
     ) -> AsyncIterator[_messages.HandleResponseEvent]:
-        result_schema = ctx.deps.result_schema
+        output_schema = ctx.deps.output_schema
 
-        # first look for the result tool call
+        # first, look for the output tool call
         final_result: result.FinalResult[NodeRunEndT] | None = None
         parts: list[_messages.ModelRequestPart] = []
-        if result_schema is not None:
-            for call, result_tool in result_schema.find_tool(tool_calls):
+        if output_schema is not None:
+            for call, output_tool in output_schema.find_tool(tool_calls):
                 try:
-                    result_data = result_tool.validate(call)
-                    result_data = await _validate_result(result_data, ctx, call)
-                except _result.ToolRetryError as e:
+                    result_data = output_tool.validate(call)
+                    result_data = await _validate_output(result_data, ctx, call)
+                except _output.ToolRetryError as e:
                     # TODO: Should only increment retry stuff once per node execution, not for each tool call
                     #   Also, should increment the tool-specific retry count rather than the run retry count
                     ctx.state.increment_retries(ctx.deps.max_result_retries)
@@ -466,7 +474,11 @@ class CallToolsNode(AgentNode[DepsT, NodeRunEndT]):
         else:
             if tool_responses:
                 parts.extend(tool_responses)
-            self._next_node = ModelRequestNode[DepsT, NodeRunEndT](_messages.ModelRequest(parts=parts))
+            run_context = build_run_context(ctx)
+            instructions = await ctx.deps.get_instructions(run_context)
+            self._next_node = ModelRequestNode[DepsT, NodeRunEndT](
+                _messages.ModelRequest(parts=parts, instructions=instructions)
+            )
 
     def _handle_final_result(
         self,
@@ -488,9 +500,9 @@ class CallToolsNode(AgentNode[DepsT, NodeRunEndT]):
                 'all_messages_events': json.dumps(
                     [InstrumentedModel.event_to_dict(e) for e in InstrumentedModel.messages_to_otel_events(messages)]
                 ),
-                'final_result': final_result.data
-                if isinstance(final_result.data, str)
-                else json.dumps(InstrumentedModel.serialize_any(final_result.data)),
+                'final_result': final_result.output
+                if isinstance(final_result.output, str)
+                else json.dumps(InstrumentedModel.serialize_any(final_result.output)),
             }
         )
         run_span.set_attributes(
@@ -507,7 +519,6 @@ class CallToolsNode(AgentNode[DepsT, NodeRunEndT]):
             }
         )
 
-        # End the run with self.data
         return End(final_result)
 
     async def _handle_text_response(
@@ -515,14 +526,14 @@ class CallToolsNode(AgentNode[DepsT, NodeRunEndT]):
         ctx: GraphRunContext[GraphAgentState, GraphAgentDeps[DepsT, NodeRunEndT]],
         texts: list[str],
     ) -> ModelRequestNode[DepsT, NodeRunEndT] | End[result.FinalResult[NodeRunEndT]]:
-        result_schema = ctx.deps.result_schema
+        output_schema = ctx.deps.output_schema
 
         text = '\n\n'.join(texts)
-        if allow_text_result(result_schema):
+        if allow_text_output(output_schema):
             result_data_input = cast(NodeRunEndT, text)
             try:
-                result_data = await _validate_result(result_data_input, ctx, None)
-            except _result.ToolRetryError as e:
+                result_data = await _validate_output(result_data_input, ctx, None)
+            except _output.ToolRetryError as e:
                 ctx.state.increment_retries(ctx.deps.max_result_retries)
                 return ModelRequestNode[DepsT, NodeRunEndT](_messages.ModelRequest(parts=[e.tool_retry]))
             else:
@@ -534,7 +545,7 @@ class CallToolsNode(AgentNode[DepsT, NodeRunEndT]):
                 _messages.ModelRequest(
                     parts=[
                         _messages.RetryPromptPart(
-                            content='Plain text responses are not permitted, please call one of the functions instead.',
+                            content='Plain text responses are not permitted, please include your response in a tool call',
                         )
                     ]
                 )
@@ -555,8 +566,8 @@ def build_run_context(ctx: GraphRunContext[GraphAgentState, GraphAgentDeps[DepsT
 
 async def process_function_tools(
     tool_calls: list[_messages.ToolCallPart],
-    result_tool_name: str | None,
-    result_tool_call_id: str | None,
+    output_tool_name: str | None,
+    output_tool_call_id: str | None,
     ctx: GraphRunContext[GraphAgentState, GraphAgentDeps[DepsT, NodeRunEndT]],
     output_parts: list[_messages.ModelRequestPart],
 ) -> AsyncIterator[_messages.HandleResponseEvent]:
@@ -566,22 +577,22 @@ async def process_function_tools(
 
     Because async iterators can't have return values, we use `output_parts` as an output argument.
     """
-    stub_function_tools = bool(result_tool_name) and ctx.deps.end_strategy == 'early'
-    result_schema = ctx.deps.result_schema
+    stub_function_tools = bool(output_tool_name) and ctx.deps.end_strategy == 'early'
+    output_schema = ctx.deps.output_schema
 
-    # we rely on the fact that if we found a result, it's the first result tool in the last
-    found_used_result_tool = False
+    # we rely on the fact that if we found a result, it's the first output tool in the last
+    found_used_output_tool = False
     run_context = build_run_context(ctx)
 
     calls_to_run: list[tuple[Tool[DepsT], _messages.ToolCallPart]] = []
     call_index_to_event_id: dict[int, str] = {}
     for call in tool_calls:
         if (
-            call.tool_name == result_tool_name
-            and call.tool_call_id == result_tool_call_id
-            and not found_used_result_tool
+            call.tool_name == output_tool_name
+            and call.tool_call_id == output_tool_call_id
+            and not found_used_output_tool
         ):
-            found_used_result_tool = True
+            found_used_output_tool = True
             output_parts.append(
                 _messages.ToolReturnPart(
                     tool_name=call.tool_name,
@@ -618,15 +629,15 @@ async def process_function_tools(
                 yield event
                 call_index_to_event_id[len(calls_to_run)] = event.call_id
                 calls_to_run.append((mcp_tool, call))
-        elif result_schema is not None and call.tool_name in result_schema.tools:
-            # if tool_name is in _result_schema, it means we found a result tool but an error occurred in
+        elif output_schema is not None and call.tool_name in output_schema.tools:
+            # if tool_name is in output_schema, it means we found a output tool but an error occurred in
             # validation, we don't add another part here
-            if result_tool_name is not None:
-                if found_used_result_tool:
-                    content = 'Result tool not used - a final result was already processed.'
+            if output_tool_name is not None:
+                if found_used_output_tool:
+                    content = 'Output tool not used - a final result was already processed.'
                 else:
                     # TODO: Include information about the validation failure, and/or merge this with the ModelRetry part
-                    content = 'Result tool not used - result failed validation.'
+                    content = 'Output tool not used - result failed validation.'
                 part = _messages.ToolReturnPart(
                     tool_name=call.tool_name,
                     content=content,
@@ -706,8 +717,8 @@ def _unknown_tool(
 ) -> _messages.RetryPromptPart:
     ctx.state.increment_retries(ctx.deps.max_result_retries)
     tool_names = list(ctx.deps.function_tools.keys())
-    if result_schema := ctx.deps.result_schema:
-        tool_names.extend(result_schema.tool_names())
+    if output_schema := ctx.deps.output_schema:
+        tool_names.extend(output_schema.tool_names())
 
     if tool_names:
         msg = f'Available tools: {", ".join(tool_names)}'
@@ -721,20 +732,20 @@ def _unknown_tool(
     )
 
 
-async def _validate_result(
+async def _validate_output(
     result_data: T,
     ctx: GraphRunContext[GraphAgentState, GraphAgentDeps[DepsT, T]],
     tool_call: _messages.ToolCallPart | None,
 ) -> T:
-    for validator in ctx.deps.result_validators:
+    for validator in ctx.deps.output_validators:
         run_context = build_run_context(ctx)
         result_data = await validator.validate(result_data, tool_call, run_context)
     return result_data
 
 
-def allow_text_result(result_schema: _result.ResultSchema[Any] | None) -> bool:
+def allow_text_output(output_schema: _output.OutputSchema[Any] | None) -> bool:
     """Check if the result schema allows text results."""
-    return result_schema is None or result_schema.allow_text_result
+    return output_schema is None or output_schema.allow_text_output
 
 
 @dataclasses.dataclass
@@ -786,19 +797,19 @@ def get_captured_run_messages() -> _RunMessages:
 
 
 def build_agent_graph(
-    name: str | None, deps_type: type[DepsT], result_type: type[ResultT]
-) -> Graph[GraphAgentState, GraphAgentDeps[DepsT, result.FinalResult[ResultT]], result.FinalResult[ResultT]]:
+    name: str | None, deps_type: type[DepsT], output_type: type[OutputT] | ToolOutput[OutputT]
+) -> Graph[GraphAgentState, GraphAgentDeps[DepsT, result.FinalResult[OutputT]], result.FinalResult[OutputT]]:
     """Build the execution [Graph][pydantic_graph.Graph] for a given agent."""
     nodes = (
         UserPromptNode[DepsT],
         ModelRequestNode[DepsT],
         CallToolsNode[DepsT],
     )
-    graph = Graph[GraphAgentState, GraphAgentDeps[DepsT, Any], result.FinalResult[ResultT]](
+    graph = Graph[GraphAgentState, GraphAgentDeps[DepsT, Any], result.FinalResult[OutputT]](
         nodes=nodes,
         name=name or 'Agent',
         state_type=GraphAgentState,
-        run_end_type=result.FinalResult[result_type],
+        run_end_type=result.FinalResult[OutputT],
         auto_instrument=False,
     )
     return graph

pydantic_ai/_cli.py

@@ -208,14 +208,13 @@ async def ask_agent(
     if not stream:
         with status:
             result = await agent.run(prompt, message_history=messages)
-        content = result.data
+        content = result.output
         console.print(Markdown(content, code_theme=code_theme))
         return result.all_messages()
 
     with status, ExitStack() as stack:
         async with agent.iter(prompt, message_history=messages) as agent_run:
             live = Live('', refresh_per_second=15, console=console, vertical_overflow='visible')
-            content: str = ''
             async for node in agent_run:
                 if Agent.is_model_request_node(node):
                     async with node.stream(agent_run.ctx) as handle_stream:

pydantic_ai/{_result.py → _output.py}

@@ -12,7 +12,7 @@ from typing_inspection.introspection import is_union_origin
 
 from . import _utils, messages as _messages
 from .exceptions import ModelRetry
-from .result import ResultDataT, ResultDataT_inv, ResultValidatorFunc
+from .result import DEFAULT_OUTPUT_TOOL_NAME, OutputDataT, OutputDataT_inv, OutputValidatorFunc, ToolOutput
 from .tools import AgentDepsT, GenerateToolJsonSchema, RunContext, ToolDefinition
 
 T = TypeVar('T')
@@ -20,8 +20,8 @@ T = TypeVar('T')
 
 
 @dataclass
-class ResultValidator(Generic[AgentDepsT, ResultDataT_inv]):
-    function: ResultValidatorFunc[AgentDepsT, ResultDataT_inv]
+class OutputValidator(Generic[AgentDepsT, OutputDataT_inv]):
+    function: OutputValidatorFunc[AgentDepsT, OutputDataT_inv]
     _takes_ctx: bool = field(init=False)
     _is_async: bool = field(init=False)
 
@@ -77,47 +77,68 @@ class ToolRetryError(Exception):
 
 
 @dataclass
-class ResultSchema(Generic[ResultDataT]):
+class OutputSchema(Generic[OutputDataT]):
     """Model the final response from an agent run.
 
-    Similar to `Tool` but for the final result of running an agent.
+    Similar to `Tool` but for the final output of running an agent.
     """
 
-    tools: dict[str, ResultTool[ResultDataT]]
-    allow_text_result: bool
+    tools: dict[str, OutputSchemaTool[OutputDataT]]
+    allow_text_output: bool
 
     @classmethod
     def build(
-        cls: type[ResultSchema[T]], response_type: type[T], name: str, description: str | None
-    ) -> ResultSchema[T] | None:
-        """Build a ResultSchema dataclass from a response type."""
-        if response_type is str:
+        cls: type[OutputSchema[T]],
+        output_type: type[T] | ToolOutput[T],
+        name: str | None = None,
+        description: str | None = None,
+        strict: bool | None = None,
+    ) -> OutputSchema[T] | None:
+        """Build an OutputSchema dataclass from a response type."""
+        if output_type is str:
             return None
 
-        if response_type_option := extract_str_from_union(response_type):
-            response_type = response_type_option.value
-            allow_text_result = True
+        if isinstance(output_type, ToolOutput):
+            # do we need to error on conflicts here? (DavidM): If this is internal maybe doesn't matter, if public, use overloads
+            name = output_type.name
+            description = output_type.description
+            output_type_ = output_type.output_type
+            strict = output_type.strict
         else:
-            allow_text_result = False
+            output_type_ = output_type
 
-        def _build_tool(a: Any, tool_name_: str, multiple: bool) -> ResultTool[T]:
-            return cast(ResultTool[T], ResultTool(a, tool_name_, description, multiple))
+        if output_type_option := extract_str_from_union(output_type):
+            output_type_ = output_type_option.value
+            allow_text_output = True
+        else:
+            allow_text_output = False
 
-        tools: dict[str, ResultTool[T]] = {}
-        if args := get_union_args(response_type):
+        tools: dict[str, OutputSchemaTool[T]] = {}
+        if args := get_union_args(output_type_):
             for i, arg in enumerate(args, start=1):
-                tool_name = union_tool_name(name, arg)
+                tool_name = raw_tool_name = union_tool_name(name, arg)
                 while tool_name in tools:
-                    tool_name = f'{tool_name}_{i}'
-                tools[tool_name] = _build_tool(arg, tool_name, True)
+                    tool_name = f'{raw_tool_name}_{i}'
+                tools[tool_name] = cast(
+                    OutputSchemaTool[T],
+                    OutputSchemaTool(
+                        output_type=arg, name=tool_name, description=description, multiple=True, strict=strict
+                    ),
+                )
         else:
-            tools[name] = _build_tool(response_type, name, False)
+            name = name or DEFAULT_OUTPUT_TOOL_NAME
+            tools[name] = cast(
+                OutputSchemaTool[T],
+                OutputSchemaTool(
+                    output_type=output_type_, name=name, description=description, multiple=False, strict=strict
+                ),
+            )
 
-        return cls(tools=tools, allow_text_result=allow_text_result)
+        return cls(tools=tools, allow_text_output=allow_text_output)
 
     def find_named_tool(
         self, parts: Iterable[_messages.ModelResponsePart], tool_name: str
-    ) -> tuple[_messages.ToolCallPart, ResultTool[ResultDataT]] | None:
+    ) -> tuple[_messages.ToolCallPart, OutputSchemaTool[OutputDataT]] | None:
         """Find a tool that matches one of the calls, with a specific name."""
         for part in parts:
             if isinstance(part, _messages.ToolCallPart):
@@ -127,7 +148,7 @@ class ResultSchema(Generic[ResultDataT]):
     def find_tool(
         self,
         parts: Iterable[_messages.ModelResponsePart],
-    ) -> Iterator[tuple[_messages.ToolCallPart, ResultTool[ResultDataT]]]:
+    ) -> Iterator[tuple[_messages.ToolCallPart, OutputSchemaTool[OutputDataT]]]:
         """Find a tool that matches one of the calls."""
         for part in parts:
             if isinstance(part, _messages.ToolCallPart):
@@ -147,16 +168,16 @@ DEFAULT_DESCRIPTION = 'The final response which ends this conversation'
 
 
 @dataclass(init=False)
-class ResultTool(Generic[ResultDataT]):
+class OutputSchemaTool(Generic[OutputDataT]):
     tool_def: ToolDefinition
     type_adapter: TypeAdapter[Any]
 
-    def __init__(self, response_type: type[ResultDataT], name: str, description: str | None, multiple: bool):
-        """Build a ResultTool dataclass from a response type."""
-        assert response_type is not str, 'ResultTool does not support str as a response type'
-
-        if _utils.is_model_like(response_type):
-            self.type_adapter = TypeAdapter(response_type)
+    def __init__(
+        self, *, output_type: type[OutputDataT], name: str, description: str | None, multiple: bool, strict: bool | None
+    ):
+        """Build a OutputSchemaTool from a response type."""
+        if _utils.is_model_like(output_type):
+            self.type_adapter = TypeAdapter(output_type)
             outer_typed_dict_key: str | None = None
             # noinspection PyArgumentList
             parameters_json_schema = _utils.check_object_json_schema(
@@ -165,7 +186,7 @@ class ResultTool(Generic[ResultDataT]):
         else:
             response_data_typed_dict = TypedDict(  # noqa: UP013
                 'response_data_typed_dict',
-                {'response': response_type},  # pyright: ignore[reportInvalidTypeForm]
+                {'response': output_type},  # pyright: ignore[reportInvalidTypeForm]
             )
             self.type_adapter = TypeAdapter(response_data_typed_dict)
             outer_typed_dict_key = 'response'
@@ -184,19 +205,20 @@ class ResultTool(Generic[ResultDataT]):
         else:
             tool_description = description or DEFAULT_DESCRIPTION
             if multiple:
-                tool_description = f'{union_arg_name(response_type)}: {tool_description}'
+                tool_description = f'{union_arg_name(output_type)}: {tool_description}'
 
         self.tool_def = ToolDefinition(
             name=name,
             description=tool_description,
             parameters_json_schema=parameters_json_schema,
             outer_typed_dict_key=outer_typed_dict_key,
+            strict=strict,
         )
 
     def validate(
         self, tool_call: _messages.ToolCallPart, allow_partial: bool = False, wrap_validation_errors: bool = True
-    ) -> ResultDataT:
-        """Validate a result message.
+    ) -> OutputDataT:
+        """Validate an output message.
 
         Args:
             tool_call: The tool call from the LLM to validate.
@@ -204,14 +226,14 @@ class ResultTool(Generic[ResultDataT]):
             wrap_validation_errors: If true, wrap the validation errors in a retry message.
 
         Returns:
-            Either the validated result data (left) or a retry message (right).
+            Either the validated output data (left) or a retry message (right).
         """
         try:
             pyd_allow_partial: Literal['off', 'trailing-strings'] = 'trailing-strings' if allow_partial else 'off'
             if isinstance(tool_call.args, str):
-                result = self.type_adapter.validate_json(tool_call.args, experimental_allow_partial=pyd_allow_partial)
+                output = self.type_adapter.validate_json(tool_call.args, experimental_allow_partial=pyd_allow_partial)
             else:
-                result = self.type_adapter.validate_python(tool_call.args, experimental_allow_partial=pyd_allow_partial)
+                output = self.type_adapter.validate_python(tool_call.args, experimental_allow_partial=pyd_allow_partial)
         except ValidationError as e:
             if wrap_validation_errors:
                 m = _messages.RetryPromptPart(
@@ -224,21 +246,21 @@ class ResultTool(Generic[ResultDataT]):
                 raise
         else:
             if k := self.tool_def.outer_typed_dict_key:
-                result = result[k]
-            return result
+                output = output[k]
+            return output
 
 
-def union_tool_name(base_name: str, union_arg: Any) -> str:
-    return f'{base_name}_{union_arg_name(union_arg)}'
+def union_tool_name(base_name: str | None, union_arg: Any) -> str:
+    return f'{base_name or DEFAULT_OUTPUT_TOOL_NAME}_{union_arg_name(union_arg)}'
 
 
 def union_arg_name(union_arg: Any) -> str:
     return union_arg.__name__
 
 
-def extract_str_from_union(response_type: Any) -> _utils.Option[Any]:
+def extract_str_from_union(output_type: Any) -> _utils.Option[Any]:
     """Extract the string type from a Union, return the remaining union or remaining type."""
-    union_args = get_union_args(response_type)
+    union_args = get_union_args(output_type)
     if any(t is str for t in union_args):
         remain_args: list[Any] = []
         includes_str = False
@@ -255,7 +277,7 @@ def extract_str_from_union(response_type: Any) -> _utils.Option[Any]:
 
 
 def get_union_args(tp: Any) -> tuple[Any, ...]:
-    """Extract the arguments of a Union type if `response_type` is a union, otherwise return an empty tuple."""
+    """Extract the arguments of a Union type if `output_type` is a union, otherwise return an empty tuple."""
     if typing_objects.is_typealiastype(tp):
         tp = tp.__value__
 

pydantic_ai/_utils.py

@@ -15,7 +15,14 @@ from pydantic import BaseModel
 from pydantic.json_schema import JsonSchemaValue
 from typing_extensions import ParamSpec, TypeAlias, TypeGuard, is_typeddict
 
+from pydantic_graph._utils import AbstractSpan
+
+AbstractSpan = AbstractSpan
+
 if TYPE_CHECKING:
+    from pydantic_ai.agent import AgentRun, AgentRunResult
+    from pydantic_graph import GraphRun, GraphRunResult
+
     from . import messages as _messages
     from .tools import ObjectJsonSchema
 
@@ -281,3 +288,16 @@ class PeekableAsyncStream(Generic[T]):
         except StopAsyncIteration:
             self._exhausted = True
             raise
+
+
+def get_traceparent(x: AgentRun | AgentRunResult | GraphRun | GraphRunResult) -> str:
+    import logfire
+    import logfire_api
+    from logfire.experimental.annotations import get_traceparent
+
+    span: AbstractSpan | None = x._span(required=False)  # type: ignore[reportPrivateUsage]
+    if not span:  # pragma: no cover
+        return ''
+    if isinstance(span, logfire_api.LogfireSpan):  # pragma: no cover
+        assert isinstance(span, logfire.LogfireSpan)
+    return get_traceparent(span)