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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai
-Version: 1.10.0
+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.10.0
+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.10.0; extra == 'dbos'
+Requires-Dist: pydantic-ai-slim[dbos]==1.11.0; extra == 'dbos'
 Provides-Extra: examples
-Requires-Dist: pydantic-ai-examples==1.10.0; extra == 'examples'
+Requires-Dist: pydantic-ai-examples==1.11.0; extra == 'examples'
 Provides-Extra: outlines-llamacpp
-Requires-Dist: pydantic-ai-slim[outlines-llamacpp]==1.10.0; 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.10.0; 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.10.0; 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.10.0; 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.10.0; 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.10.0; extra == 'prefect'
+Requires-Dist: pydantic-ai-slim[prefect]==1.11.0; extra == 'prefect'
 Description-Content-Type: text/markdown
 
 <div align="center">

{pydantic_ai-1.10.0 → 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.10.0 → 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.10.0 → 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.10.0 → 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] = {