pydantic-ai 1.9.1__tar.gz → 1.11.0__tar.gz

{pydantic_ai-1.9.1 → pydantic_ai-1.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai
-Version: 1.9.1
+Version: 1.11.0
 Summary: Agent Framework / shim to use Pydantic with LLMs
 Project-URL: Homepage, https://ai.pydantic.dev
 Project-URL: Source, https://github.com/pydantic/pydantic-ai
@@ -26,25 +26,25 @@ Classifier: Topic :: Internet
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.10
-Requires-Dist: pydantic-ai-slim[ag-ui,anthropic,bedrock,cli,cohere,evals,fastmcp,google,groq,huggingface,logfire,mcp,mistral,openai,retries,temporal,ui,vertexai]==1.9.1
+Requires-Dist: pydantic-ai-slim[ag-ui,anthropic,bedrock,cli,cohere,evals,fastmcp,google,groq,huggingface,logfire,mcp,mistral,openai,retries,temporal,ui,vertexai]==1.11.0
 Provides-Extra: a2a
 Requires-Dist: fasta2a>=0.4.1; extra == 'a2a'
 Provides-Extra: dbos
-Requires-Dist: pydantic-ai-slim[dbos]==1.9.1; extra == 'dbos'
+Requires-Dist: pydantic-ai-slim[dbos]==1.11.0; extra == 'dbos'
 Provides-Extra: examples
-Requires-Dist: pydantic-ai-examples==1.9.1; extra == 'examples'
+Requires-Dist: pydantic-ai-examples==1.11.0; extra == 'examples'
 Provides-Extra: outlines-llamacpp
-Requires-Dist: pydantic-ai-slim[outlines-llamacpp]==1.9.1; extra == 'outlines-llamacpp'
+Requires-Dist: pydantic-ai-slim[outlines-llamacpp]==1.11.0; extra == 'outlines-llamacpp'
 Provides-Extra: outlines-mlxlm
-Requires-Dist: pydantic-ai-slim[outlines-mlxlm]==1.9.1; extra == 'outlines-mlxlm'
+Requires-Dist: pydantic-ai-slim[outlines-mlxlm]==1.11.0; extra == 'outlines-mlxlm'
 Provides-Extra: outlines-sglang
-Requires-Dist: pydantic-ai-slim[outlines-sglang]==1.9.1; extra == 'outlines-sglang'
+Requires-Dist: pydantic-ai-slim[outlines-sglang]==1.11.0; extra == 'outlines-sglang'
 Provides-Extra: outlines-transformers
-Requires-Dist: pydantic-ai-slim[outlines-transformers]==1.9.1; extra == 'outlines-transformers'
+Requires-Dist: pydantic-ai-slim[outlines-transformers]==1.11.0; extra == 'outlines-transformers'
 Provides-Extra: outlines-vllm-offline
-Requires-Dist: pydantic-ai-slim[outlines-vllm-offline]==1.9.1; extra == 'outlines-vllm-offline'
+Requires-Dist: pydantic-ai-slim[outlines-vllm-offline]==1.11.0; extra == 'outlines-vllm-offline'
 Provides-Extra: prefect
-Requires-Dist: pydantic-ai-slim[prefect]==1.9.1; extra == 'prefect'
+Requires-Dist: pydantic-ai-slim[prefect]==1.11.0; extra == 'prefect'
 Description-Content-Type: text/markdown
 
 <div align="center">

{pydantic_ai-1.9.1 → pydantic_ai-1.11.0}/tests/graph/beta/test_graph_execution.py

@@ -7,7 +7,7 @@ from dataclasses import dataclass, field
 import pytest
 
 from pydantic_graph.beta import GraphBuilder, StepContext
-from pydantic_graph.beta.join import ReduceFirstValue, reduce_list_append
+from pydantic_graph.beta.join import ReduceFirstValue, reduce_list_append, reduce_list_extend
 
 pytestmark = pytest.mark.anyio
 
@@ -343,3 +343,40 @@ async def test_mixed_sequential_and_parallel_execution():
     assert 'parallel-100' in state.log
     assert 'step3' in state.log
     assert result == 'Result: 152'  # (50+1) + (100+1) = 152
+
+
+async def test_multiple_sequential_joins():
+    g = GraphBuilder(output_type=list[int])
+
+    @g.step
+    async def source(ctx: StepContext[None, None, None]) -> int:
+        return 10
+
+    @g.step
+    async def add_one(ctx: StepContext[None, None, int]) -> list[int]:
+        return [ctx.inputs + 1]
+
+    @g.step
+    async def add_two(ctx: StepContext[None, None, int]) -> list[int]:
+        return [ctx.inputs + 2]
+
+    @g.step
+    async def add_three(ctx: StepContext[None, None, int]) -> list[int]:
+        return [ctx.inputs + 3]
+
+    collect = g.join(reduce_list_extend, initial_factory=list[int], parent_fork_id='source_fork', node_id='collect')
+    mediator = g.join(reduce_list_extend, initial_factory=list[int], node_id='mediator')
+
+    # Broadcasting: send the value from source to all three steps
+    g.add(
+        g.edge_from(g.start_node).to(source),
+        g.edge_from(source).to(add_one, add_two, add_three, fork_id='source_fork'),
+        g.edge_from(add_one, add_two).to(mediator),
+        g.edge_from(mediator).to(collect),
+        g.edge_from(add_three).to(collect),
+        g.edge_from(collect).to(g.end_node),
+    )
+
+    graph = g.build()
+    result = await graph.run()
+    assert sorted(result) == [11, 12, 13]

{pydantic_ai-1.9.1 → pydantic_ai-1.11.0}/tests/models/cassettes/test_gemini/test_gemini_drop_exclusive_maximum.yaml

@@ -259,7 +259,7 @@ interactions:
             name: get_chinese_zodiac
             response:
               call_error: |-
-                1 validation errors: [
+                1 validation error: [
                   {
                     "type": "greater_than",
                     "loc": [

{pydantic_ai-1.9.1 → pydantic_ai-1.11.0}/tests/models/test_openai_responses.py

@@ -78,6 +78,8 @@ def test_openai_responses_model(env: TestEnv):
     model = OpenAIResponsesModel('gpt-4o')
     assert model.model_name == 'gpt-4o'
     assert model.system == 'openai'
+    assert model.base_url == 'https://api.openai.com/v1/'
+    assert model.client.api_key == 'test'
 
 
 async def test_openai_responses_model_simple_response(allow_model_requests: None, openai_api_key: str):

{pydantic_ai-1.9.1 → pydantic_ai-1.11.0}/tests/test_ag_ui.py

@@ -19,6 +19,8 @@ from pydantic import BaseModel
 from pydantic_ai import (
     BuiltinToolCallPart,
     BuiltinToolReturnPart,
+    FunctionToolCallEvent,
+    FunctionToolResultEvent,
     ModelMessage,
     ModelRequest,
     ModelResponse,
@@ -29,6 +31,7 @@ from pydantic_ai import (
     TextPart,
     TextPartDelta,
     ToolCallPart,
+    ToolCallPartDelta,
     ToolReturn,
     ToolReturnPart,
     UserPromptPart,
@@ -1661,6 +1664,194 @@ async def test_event_stream_back_to_back_text():
     )
 
 
+async def test_event_stream_multiple_responses_with_tool_calls():
+    async def event_generator():
+        yield PartStartEvent(index=0, part=TextPart(content='Hello'))
+        yield PartDeltaEvent(index=0, delta=TextPartDelta(content_delta=' world'))
+        yield PartEndEvent(index=0, part=TextPart(content='Hello world'), next_part_kind='tool-call')
+
+        yield PartStartEvent(
+            index=1,
+            part=ToolCallPart(tool_name='tool_call_1', args='{}', tool_call_id='tool_call_1'),
+            previous_part_kind='text',
+        )
+        yield PartDeltaEvent(
+            index=1, delta=ToolCallPartDelta(args_delta='{"query": "Hello world"}', tool_call_id='tool_call_1')
+        )
+        yield PartEndEvent(
+            index=1,
+            part=ToolCallPart(tool_name='tool_call_1', args='{"query": "Hello world"}', tool_call_id='tool_call_1'),
+            next_part_kind='tool-call',
+        )
+
+        yield PartStartEvent(
+            index=2,
+            part=ToolCallPart(tool_name='tool_call_2', args='{}', tool_call_id='tool_call_2'),
+            previous_part_kind='tool-call',
+        )
+        yield PartDeltaEvent(
+            index=2, delta=ToolCallPartDelta(args_delta='{"query": "Goodbye world"}', tool_call_id='tool_call_2')
+        )
+        yield PartEndEvent(
+            index=2,
+            part=ToolCallPart(tool_name='tool_call_2', args='{"query": "Hello world"}', tool_call_id='tool_call_2'),
+            next_part_kind=None,
+        )
+
+        yield FunctionToolCallEvent(
+            part=ToolCallPart(tool_name='tool_call_1', args='{"query": "Hello world"}', tool_call_id='tool_call_1')
+        )
+        yield FunctionToolCallEvent(
+            part=ToolCallPart(tool_name='tool_call_2', args='{"query": "Goodbye world"}', tool_call_id='tool_call_2')
+        )
+
+        yield FunctionToolResultEvent(
+            result=ToolReturnPart(tool_name='tool_call_1', content='Hi!', tool_call_id='tool_call_1')
+        )
+        yield FunctionToolResultEvent(
+            result=ToolReturnPart(tool_name='tool_call_2', content='Bye!', tool_call_id='tool_call_2')
+        )
+
+        yield PartStartEvent(
+            index=0,
+            part=ToolCallPart(tool_name='tool_call_3', args='{}', tool_call_id='tool_call_3'),
+            previous_part_kind=None,
+        )
+        yield PartDeltaEvent(
+            index=0, delta=ToolCallPartDelta(args_delta='{"query": "Hello world"}', tool_call_id='tool_call_3')
+        )
+        yield PartEndEvent(
+            index=0,
+            part=ToolCallPart(tool_name='tool_call_3', args='{"query": "Hello world"}', tool_call_id='tool_call_3'),
+            next_part_kind='tool-call',
+        )
+
+        yield PartStartEvent(
+            index=1,
+            part=ToolCallPart(tool_name='tool_call_4', args='{}', tool_call_id='tool_call_4'),
+            previous_part_kind='tool-call',
+        )
+        yield PartDeltaEvent(
+            index=1, delta=ToolCallPartDelta(args_delta='{"query": "Goodbye world"}', tool_call_id='tool_call_4')
+        )
+        yield PartEndEvent(
+            index=1,
+            part=ToolCallPart(tool_name='tool_call_4', args='{"query": "Goodbye world"}', tool_call_id='tool_call_4'),
+            next_part_kind=None,
+        )
+
+        yield FunctionToolCallEvent(
+            part=ToolCallPart(tool_name='tool_call_3', args='{"query": "Hello world"}', tool_call_id='tool_call_3')
+        )
+        yield FunctionToolCallEvent(
+            part=ToolCallPart(tool_name='tool_call_4', args='{"query": "Goodbye world"}', tool_call_id='tool_call_4')
+        )
+
+        yield FunctionToolResultEvent(
+            result=ToolReturnPart(tool_name='tool_call_3', content='Hi!', tool_call_id='tool_call_3')
+        )
+        yield FunctionToolResultEvent(
+            result=ToolReturnPart(tool_name='tool_call_4', content='Bye!', tool_call_id='tool_call_4')
+        )
+
+    run_input = create_input(
+        UserMessage(
+            id='msg_1',
+            content='Tell me about Hello World',
+        ),
+    )
+    event_stream = AGUIEventStream(run_input=run_input)
+    events = [
+        json.loads(event.removeprefix('data: '))
+        async for event in event_stream.encode_stream(event_stream.transform_stream(event_generator()))
+    ]
+
+    assert events == snapshot(
+        [
+            {
+                'type': 'RUN_STARTED',
+                'threadId': (thread_id := IsSameStr()),
+                'runId': (run_id := IsSameStr()),
+            },
+            {'type': 'TEXT_MESSAGE_START', 'messageId': (message_id := IsSameStr()), 'role': 'assistant'},
+            {'type': 'TEXT_MESSAGE_CONTENT', 'messageId': message_id, 'delta': 'Hello'},
+            {'type': 'TEXT_MESSAGE_CONTENT', 'messageId': message_id, 'delta': ' world'},
+            {'type': 'TEXT_MESSAGE_END', 'messageId': message_id},
+            {
+                'type': 'TOOL_CALL_START',
+                'toolCallId': 'tool_call_1',
+                'toolCallName': 'tool_call_1',
+                'parentMessageId': message_id,
+            },
+            {'type': 'TOOL_CALL_ARGS', 'toolCallId': 'tool_call_1', 'delta': '{}'},
+            {'type': 'TOOL_CALL_ARGS', 'toolCallId': 'tool_call_1', 'delta': '{"query": "Hello world"}'},
+            {'type': 'TOOL_CALL_END', 'toolCallId': 'tool_call_1'},
+            {
+                'type': 'TOOL_CALL_START',
+                'toolCallId': 'tool_call_2',
+                'toolCallName': 'tool_call_2',
+                'parentMessageId': message_id,
+            },
+            {'type': 'TOOL_CALL_ARGS', 'toolCallId': 'tool_call_2', 'delta': '{}'},
+            {'type': 'TOOL_CALL_ARGS', 'toolCallId': 'tool_call_2', 'delta': '{"query": "Goodbye world"}'},
+            {'type': 'TOOL_CALL_END', 'toolCallId': 'tool_call_2'},
+            {
+                'type': 'TOOL_CALL_RESULT',
+                'messageId': IsStr(),
+                'toolCallId': 'tool_call_1',
+                'content': 'Hi!',
+                'role': 'tool',
+            },
+            {
+                'type': 'TOOL_CALL_RESULT',
+                'messageId': (result_message_id := IsSameStr()),
+                'toolCallId': 'tool_call_2',
+                'content': 'Bye!',
+                'role': 'tool',
+            },
+            {
+                'type': 'TOOL_CALL_START',
+                'toolCallId': 'tool_call_3',
+                'toolCallName': 'tool_call_3',
+                'parentMessageId': (new_message_id := IsSameStr()),
+            },
+            {'type': 'TOOL_CALL_ARGS', 'toolCallId': 'tool_call_3', 'delta': '{}'},
+            {'type': 'TOOL_CALL_ARGS', 'toolCallId': 'tool_call_3', 'delta': '{"query": "Hello world"}'},
+            {'type': 'TOOL_CALL_END', 'toolCallId': 'tool_call_3'},
+            {
+                'type': 'TOOL_CALL_START',
+                'toolCallId': 'tool_call_4',
+                'toolCallName': 'tool_call_4',
+                'parentMessageId': new_message_id,
+            },
+            {'type': 'TOOL_CALL_ARGS', 'toolCallId': 'tool_call_4', 'delta': '{}'},
+            {'type': 'TOOL_CALL_ARGS', 'toolCallId': 'tool_call_4', 'delta': '{"query": "Goodbye world"}'},
+            {'type': 'TOOL_CALL_END', 'toolCallId': 'tool_call_4'},
+            {
+                'type': 'TOOL_CALL_RESULT',
+                'messageId': IsStr(),
+                'toolCallId': 'tool_call_3',
+                'content': 'Hi!',
+                'role': 'tool',
+            },
+            {
+                'type': 'TOOL_CALL_RESULT',
+                'messageId': IsStr(),
+                'toolCallId': 'tool_call_4',
+                'content': 'Bye!',
+                'role': 'tool',
+            },
+            {
+                'type': 'RUN_FINISHED',
+                'threadId': thread_id,
+                'runId': run_id,
+            },
+        ]
+    )
+
+    assert result_message_id != new_message_id
+
+
 async def test_handle_ag_ui_request():
     agent = Agent(model=TestModel())
     run_input = create_input(

{pydantic_ai-1.9.1 → pydantic_ai-1.11.0}/tests/test_agent.py

@@ -3,7 +3,7 @@ import json
 import re
 import sys
 from collections import defaultdict
-from collections.abc import AsyncIterable, Callable
+from collections.abc import AsyncIterable, AsyncIterator, Callable
 from dataclasses import dataclass, replace
 from datetime import timezone
 from typing import Any, Generic, Literal, TypeVar, Union
@@ -59,7 +59,7 @@ from pydantic_ai._output import (
 )
 from pydantic_ai.agent import AgentRunResult, WrapperAgent
 from pydantic_ai.builtin_tools import CodeExecutionTool, MCPServerTool, WebSearchTool
-from pydantic_ai.models.function import AgentInfo, FunctionModel
+from pydantic_ai.models.function import AgentInfo, DeltaToolCall, DeltaToolCalls, FunctionModel
 from pydantic_ai.models.test import TestModel
 from pydantic_ai.output import StructuredDict, ToolOutput
 from pydantic_ai.result import RunUsage
@@ -201,7 +201,7 @@ def test_result_pydantic_model_retry():
             ),
             ModelResponse(
                 parts=[ToolCallPart(tool_name='final_result', args='{"a": 42, "b": "foo"}', tool_call_id=IsStr())],
-                usage=RequestUsage(input_tokens=87, output_tokens=14),
+                usage=RequestUsage(input_tokens=89, output_tokens=14),
                 model_name='function:return_model:',
                 timestamp=IsNow(tz=timezone.utc),
             ),
@@ -260,7 +260,9 @@ def test_result_pydantic_model_validation_error():
     retry_prompt = user_retry.parts[0]
     assert isinstance(retry_prompt, RetryPromptPart)
     assert retry_prompt.model_response() == snapshot("""\
-1 validation errors: [
+1 validation error:
+```json
+[
   {
     "type": "value_error",
     "loc": [
@@ -270,6 +272,7 @@ def test_result_pydantic_model_validation_error():
     "input": "foo"
   }
 ]
+```
 
 Fix the errors and try again.""")
 
@@ -335,6 +338,85 @@ def test_output_validator():
     )
 
 
+def test_output_validator_partial_sync():
+    """Test that output validators receive correct value for `partial_output` in sync mode."""
+    call_log: list[tuple[str, bool]] = []
+
+    agent = Agent[None, str](TestModel(custom_output_text='test output'))
+
+    @agent.output_validator
+    def validate_output(ctx: RunContext[None], output: str) -> str:
+        call_log.append((output, ctx.partial_output))
+        return output
+
+    result = agent.run_sync('Hello')
+    assert result.output == 'test output'
+
+    assert call_log == snapshot([('test output', False)])
+
+
+async def test_output_validator_partial_stream_text():
+    """Test that output validators receive correct value for `partial_output` when using stream_text()."""
+    call_log: list[tuple[str, bool]] = []
+
+    async def stream_text(messages: list[ModelMessage], info: AgentInfo) -> AsyncIterator[str]:
+        for chunk in ['Hello', ' ', 'world', '!']:
+            yield chunk
+
+    agent = Agent(FunctionModel(stream_function=stream_text))
+
+    @agent.output_validator
+    def validate_output(ctx: RunContext[None], output: str) -> str:
+        call_log.append((output, ctx.partial_output))
+        return output
+
+    async with agent.run_stream('Hello') as result:
+        text_parts = []
+        async for chunk in result.stream_text(debounce_by=None):
+            text_parts.append(chunk)
+
+    assert text_parts[-1] == 'Hello world!'
+    assert call_log == snapshot(
+        [
+            ('Hello', True),
+            ('Hello ', True),
+            ('Hello world', True),
+            ('Hello world!', True),
+            ('Hello world!', False),
+        ]
+    )
+
+
+async def test_output_validator_partial_stream_output():
+    """Test that output validators receive correct value for `partial_output` when using stream_output()."""
+    call_log: list[tuple[Foo, bool]] = []
+
+    async def stream_model(messages: list[ModelMessage], info: AgentInfo) -> AsyncIterator[DeltaToolCalls]:
+        assert info.output_tools is not None
+        yield {0: DeltaToolCall(name=info.output_tools[0].name, json_args='{"a": 42')}
+        yield {0: DeltaToolCall(json_args=', "b": "f')}
+        yield {0: DeltaToolCall(json_args='oo"}')}
+
+    agent = Agent(FunctionModel(stream_function=stream_model), output_type=Foo)
+
+    @agent.output_validator
+    def validate_output(ctx: RunContext[None], output: Foo) -> Foo:
+        call_log.append((output, ctx.partial_output))
+        return output
+
+    async with agent.run_stream('Hello') as result:
+        outputs = [output async for output in result.stream_output(debounce_by=None)]
+
+    assert outputs[-1] == Foo(a=42, b='foo')
+    assert call_log == snapshot(
+        [
+            (Foo(a=42, b='f'), True),
+            (Foo(a=42, b='foo'), True),
+            (Foo(a=42, b='foo'), False),
+        ]
+    )
+
+
 def test_plain_response_then_tuple():
     call_index = 0
 
@@ -1796,7 +1878,7 @@ def test_native_output():
             ),
             ModelResponse(
                 parts=[TextPart(content='{"city": "Mexico City", "country": "Mexico"}')],
-                usage=RequestUsage(input_tokens=85, output_tokens=12),
+                usage=RequestUsage(input_tokens=87, output_tokens=12),
                 model_name='function:return_city_location:',
                 timestamp=IsDatetime(),
             ),
@@ -3894,6 +3976,30 @@ You are a potato.\
     )
 
 
+def test_instructions_during_run():
+    agent = Agent('test', instructions='You are a helpful assistant.')
+    result = agent.run_sync('Hello', instructions='Your task is to greet people.')
+    assert result.all_messages()[0] == snapshot(
+        ModelRequest(
+            parts=[UserPromptPart(content='Hello', timestamp=IsDatetime())],
+            instructions="""\
+You are a helpful assistant.
+Your task is to greet people.\
+""",
+        )
+    )
+
+    result2 = agent.run_sync('Hello again!')
+    assert result2.all_messages()[0] == snapshot(
+        ModelRequest(
+            parts=[UserPromptPart(content='Hello again!', timestamp=IsDatetime())],
+            instructions="""\
+You are a helpful assistant.\
+""",
+        )
+    )
+
+
 def test_multi_agent_instructions_with_structured_output():
     """Test that Agent2 uses its own instructions when called with Agent1's history.
 

{pydantic_ai-1.9.1 → pydantic_ai-1.11.0}/tests/test_examples.py

@@ -522,6 +522,7 @@ text_responses: dict[str, str | ToolCallPart | Sequence[ToolCallPart]] = {
     'Where do I live?': 'You live in Mexico City.',
     'Tell me about the pydantic/pydantic-ai repo.': 'The pydantic/pydantic-ai repo is a Python agent framework for building Generative AI applications.',
     'What do I have on my calendar today?': "You're going to spend all day playing with Pydantic AI.",
+    'Write a long story about a cat': 'Once upon a time, there was a curious cat named Whiskers who loved to explore the world around him...',
 }
 
 tool_responses: dict[tuple[str, str], str] = {

{pydantic_ai-1.9.1 → pydantic_ai-1.11.0}/tests/test_messages.py

@@ -147,6 +147,7 @@ def test_binary_content_video(media_type: str, format: str):
         ('application/pdf', 'pdf'),
         ('text/plain', 'txt'),
         ('text/csv', 'csv'),
+        ('application/msword', 'doc'),
         ('application/vnd.openxmlformats-officedocument.wordprocessingml.document', 'docx'),
         ('application/vnd.openxmlformats-officedocument.spreadsheetml.sheet', 'xlsx'),
         ('text/html', 'html'),
@@ -209,6 +210,7 @@ _url_formats = [
     pytest.param(DocumentUrl('foobar.pdf'), 'application/pdf', 'pdf', id='pdf'),
     pytest.param(DocumentUrl('foobar.txt'), 'text/plain', 'txt', id='txt'),
     pytest.param(DocumentUrl('foobar.csv'), 'text/csv', 'csv', id='csv'),
+    pytest.param(DocumentUrl('foobar.doc'), 'application/msword', 'doc', id='doc'),
     pytest.param(
         DocumentUrl('foobar.docx'),
         'application/vnd.openxmlformats-officedocument.wordprocessingml.document',