pydantic-ai-slim 0.0.55__tar.gz → 0.1.1__tar.gz

{pydantic_ai_slim-0.0.55 → pydantic_ai_slim-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai-slim
-Version: 0.0.55
+Version: 0.1.1
 Summary: Agent Framework / shim to use Pydantic with LLMs, slim package
 Author-email: Samuel Colvin <samuel@pydantic.dev>
 License-Expression: MIT
@@ -29,13 +29,13 @@ Requires-Dist: exceptiongroup; python_version < '3.11'
 Requires-Dist: griffe>=1.3.2
 Requires-Dist: httpx>=0.27
 Requires-Dist: opentelemetry-api>=1.28.0
-Requires-Dist: pydantic-graph==0.0.55
+Requires-Dist: pydantic-graph==0.1.1
 Requires-Dist: pydantic>=2.10
 Requires-Dist: typing-inspection>=0.4.0
 Provides-Extra: anthropic
 Requires-Dist: anthropic>=0.49.0; extra == 'anthropic'
 Provides-Extra: bedrock
-Requires-Dist: boto3>=1.34.116; extra == 'bedrock'
+Requires-Dist: boto3>=1.35.74; extra == 'bedrock'
 Provides-Extra: cli
 Requires-Dist: argcomplete>=3.5.0; extra == 'cli'
 Requires-Dist: prompt-toolkit>=3; extra == 'cli'
@@ -45,7 +45,7 @@ Requires-Dist: cohere>=5.13.11; (platform_system != 'Emscripten') and extra == '
 Provides-Extra: duckduckgo
 Requires-Dist: duckduckgo-search>=7.0.0; extra == 'duckduckgo'
 Provides-Extra: evals
-Requires-Dist: pydantic-evals==0.0.55; extra == 'evals'
+Requires-Dist: pydantic-evals==0.1.1; extra == 'evals'
 Provides-Extra: groq
 Requires-Dist: groq>=0.15.0; extra == 'groq'
 Provides-Extra: logfire
@@ -55,7 +55,7 @@ Requires-Dist: mcp>=1.4.1; (python_version >= '3.10') and extra == 'mcp'
 Provides-Extra: mistral
 Requires-Dist: mistralai>=1.2.5; extra == 'mistral'
 Provides-Extra: openai
-Requires-Dist: openai>=1.67.0; extra == 'openai'
+Requires-Dist: openai>=1.74.0; extra == 'openai'
 Provides-Extra: tavily
 Requires-Dist: tavily-python>=0.5.0; extra == 'tavily'
 Provides-Extra: vertexai

{pydantic_ai_slim-0.0.55 → pydantic_ai_slim-0.1.1}/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_slim-0.0.55 → pydantic_ai_slim-0.1.1}/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_slim-0.0.55 → pydantic_ai_slim-0.1.1}/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: