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

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

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

{pydantic_ai-1.9.1 → pydantic_ai-1.10.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.10.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.10.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',

{pydantic_ai-1.9.1 → pydantic_ai-1.10.0}/tests/test_streaming.py

@@ -135,6 +135,96 @@ async def test_streamed_text_response():
         )
 
 
+def test_streamed_text_sync_response():
+    m = TestModel()
+
+    test_agent = Agent(m)
+    assert test_agent.name is None
+
+    @test_agent.tool_plain
+    async def ret_a(x: str) -> str:
+        return f'{x}-apple'
+
+    result = test_agent.run_stream_sync('Hello')
+    assert test_agent.name == 'test_agent'
+    assert not result.is_complete
+    assert result.all_messages() == snapshot(
+        [
+            ModelRequest(parts=[UserPromptPart(content='Hello', timestamp=IsNow(tz=timezone.utc))]),
+            ModelResponse(
+                parts=[ToolCallPart(tool_name='ret_a', args={'x': 'a'}, tool_call_id=IsStr())],
+                usage=RequestUsage(input_tokens=51),
+                model_name='test',
+                timestamp=IsNow(tz=timezone.utc),
+                provider_name='test',
+            ),
+            ModelRequest(
+                parts=[
+                    ToolReturnPart(
+                        tool_name='ret_a', content='a-apple', timestamp=IsNow(tz=timezone.utc), tool_call_id=IsStr()
+                    )
+                ]
+            ),
+        ]
+    )
+    assert result.new_messages() == result.all_messages()
+    assert result.usage() == snapshot(
+        RunUsage(
+            requests=2,
+            input_tokens=103,
+            output_tokens=5,
+            tool_calls=1,
+        )
+    )
+    response = result.get_output()
+    assert response == snapshot('{"ret_a":"a-apple"}')
+    assert result.is_complete
+    assert result.timestamp() == IsNow(tz=timezone.utc)
+    assert result.response == snapshot(
+        ModelResponse(
+            parts=[TextPart(content='{"ret_a":"a-apple"}')],
+            usage=RequestUsage(input_tokens=52, output_tokens=11),
+            model_name='test',
+            timestamp=IsDatetime(),
+            provider_name='test',
+        )
+    )
+    assert result.all_messages() == snapshot(
+        [
+            ModelRequest(parts=[UserPromptPart(content='Hello', timestamp=IsNow(tz=timezone.utc))]),
+            ModelResponse(
+                parts=[ToolCallPart(tool_name='ret_a', args={'x': 'a'}, tool_call_id=IsStr())],
+                usage=RequestUsage(input_tokens=51),
+                model_name='test',
+                timestamp=IsNow(tz=timezone.utc),
+                provider_name='test',
+            ),
+            ModelRequest(
+                parts=[
+                    ToolReturnPart(
+                        tool_name='ret_a', content='a-apple', timestamp=IsNow(tz=timezone.utc), tool_call_id=IsStr()
+                    )
+                ]
+            ),
+            ModelResponse(
+                parts=[TextPart(content='{"ret_a":"a-apple"}')],
+                usage=RequestUsage(input_tokens=52, output_tokens=11),
+                model_name='test',
+                timestamp=IsNow(tz=timezone.utc),
+                provider_name='test',
+            ),
+        ]
+    )
+    assert result.usage() == snapshot(
+        RunUsage(
+            requests=2,
+            input_tokens=103,
+            output_tokens=11,
+            tool_calls=1,
+        )
+    )
+
+
 async def test_streamed_structured_response():
     m = TestModel()
 
@@ -302,6 +392,119 @@ async def test_streamed_text_stream():
         )
 
 
+def test_streamed_text_stream_sync():
+    m = TestModel(custom_output_text='The cat sat on the mat.')
+
+    agent = Agent(m)
+
+    result = agent.run_stream_sync('Hello')
+    # typehint to test (via static typing) that the stream type is correctly inferred
+    chunks: list[str] = [c for c in result.stream_text()]
+    # one chunk with `stream_text()` due to group_by_temporal
+    assert chunks == snapshot(['The cat sat on the mat.'])
+    assert result.is_complete
+
+    result = agent.run_stream_sync('Hello')
+    # typehint to test (via static typing) that the stream type is correctly inferred
+    chunks: list[str] = [c for c in result.stream_output()]
+    # two chunks with `stream()` due to not-final vs. final
+    assert chunks == snapshot(['The cat sat on the mat.'])
+    assert result.is_complete
+
+    result = agent.run_stream_sync('Hello')
+    assert [c for c in result.stream_text(debounce_by=None)] == snapshot(
+        [
+            'The ',
+            'The cat ',
+            'The cat sat ',
+            'The cat sat on ',
+            'The cat sat on the ',
+            'The cat sat on the mat.',
+        ]
+    )
+
+    result = agent.run_stream_sync('Hello')
+    # with stream_text, there is no need to do partial validation, so we only get the final message once:
+    assert [c for c in result.stream_text(delta=False, debounce_by=None)] == snapshot(
+        ['The ', 'The cat ', 'The cat sat ', 'The cat sat on ', 'The cat sat on the ', 'The cat sat on the mat.']
+    )
+
+    result = agent.run_stream_sync('Hello')
+    assert [c for c in result.stream_text(delta=True, debounce_by=None)] == snapshot(
+        ['The ', 'cat ', 'sat ', 'on ', 'the ', 'mat.']
+    )
+
+    def upcase(text: str) -> str:
+        return text.upper()
+
+    result = agent.run_stream_sync('Hello', output_type=TextOutput(upcase))
+    assert [c for c in result.stream_output(debounce_by=None)] == snapshot(
+        ['THE ', 'THE CAT ', 'THE CAT SAT ', 'THE CAT SAT ON ', 'THE CAT SAT ON THE ', 'THE CAT SAT ON THE MAT.']
+    )
+
+    result = agent.run_stream_sync('Hello')
+    assert [c for c, _is_last in result.stream_responses(debounce_by=None)] == snapshot(
+        [
+            ModelResponse(
+                parts=[TextPart(content='The ')],
+                usage=RequestUsage(input_tokens=51, output_tokens=1),
+                model_name='test',
+                timestamp=IsNow(tz=timezone.utc),
+                provider_name='test',
+            ),
+            ModelResponse(
+                parts=[TextPart(content='The cat ')],
+                usage=RequestUsage(input_tokens=51, output_tokens=2),
+                model_name='test',
+                timestamp=IsNow(tz=timezone.utc),
+                provider_name='test',
+            ),
+            ModelResponse(
+                parts=[TextPart(content='The cat sat ')],
+                usage=RequestUsage(input_tokens=51, output_tokens=3),
+                model_name='test',
+                timestamp=IsNow(tz=timezone.utc),
+                provider_name='test',
+            ),
+            ModelResponse(
+                parts=[TextPart(content='The cat sat on ')],
+                usage=RequestUsage(input_tokens=51, output_tokens=4),
+                model_name='test',
+                timestamp=IsNow(tz=timezone.utc),
+                provider_name='test',
+            ),
+            ModelResponse(
+                parts=[TextPart(content='The cat sat on the ')],
+                usage=RequestUsage(input_tokens=51, output_tokens=5),
+                model_name='test',
+                timestamp=IsNow(tz=timezone.utc),
+                provider_name='test',
+            ),
+            ModelResponse(
+                parts=[TextPart(content='The cat sat on the mat.')],
+                usage=RequestUsage(input_tokens=51, output_tokens=7),
+                model_name='test',
+                timestamp=IsNow(tz=timezone.utc),
+                provider_name='test',
+            ),
+            ModelResponse(
+                parts=[TextPart(content='The cat sat on the mat.')],
+                usage=RequestUsage(input_tokens=51, output_tokens=7),
+                model_name='test',
+                timestamp=IsNow(tz=timezone.utc),
+                provider_name='test',
+            ),
+            ModelResponse(
+                parts=[TextPart(content='The cat sat on the mat.')],
+                usage=RequestUsage(input_tokens=51, output_tokens=7),
+                model_name='test',
+                timestamp=IsDatetime(),
+                provider_name='test',
+            ),
+        ]
+    )
+
+
 async def test_plain_response():
     call_index = 0
 
@@ -1892,3 +2095,24 @@ async def test_run_stream_events():
             AgentRunResultEvent(result=AgentRunResult(output='{"ret_a":"a-apple"}')),
         ]
     )
+
+
+def test_structured_response_sync_validation():
+    async def text_stream(_messages: list[ModelMessage], agent_info: AgentInfo) -> AsyncIterator[DeltaToolCalls]:
+        assert agent_info.output_tools is not None
+        assert len(agent_info.output_tools) == 1
+        name = agent_info.output_tools[0].name
+        json_data = json.dumps({'response': [1, 2, 3, 4]})
+        yield {0: DeltaToolCall(name=name)}
+        yield {0: DeltaToolCall(json_args=json_data[:15])}
+        yield {0: DeltaToolCall(json_args=json_data[15:])}
+
+    agent = Agent(FunctionModel(stream_function=text_stream), output_type=list[int])
+
+    chunks: list[list[int]] = []
+    result = agent.run_stream_sync('')
+    for structured_response, last in result.stream_responses(debounce_by=None):
+        response_data = result.validate_response_output(structured_response, allow_partial=not last)
+        chunks.append(response_data)
+
+    assert chunks == snapshot([[1], [1, 2, 3, 4], [1, 2, 3, 4], [1, 2, 3, 4]])

{pydantic_ai-1.9.1 → pydantic_ai-1.10.0}/tests/typed_agent.py

@@ -260,7 +260,7 @@ else:
 Tool(foobar_ctx, takes_ctx=True)
 Tool(foobar_ctx)
 Tool(foobar_plain, takes_ctx=False)
-assert_type(Tool(foobar_plain), Tool[None])
+assert_type(Tool(foobar_plain), Tool[object])
 assert_type(Tool(foobar_plain), Tool)
 
 # unfortunately we can't type check these cases, since from a typing perspect `foobar_ctx` is valid as a plain tool

pydantic_ai-1.10.0/tests/typed_deps.py

@@ -0,0 +1,86 @@
+from dataclasses import dataclass
+from typing import Any
+
+from typing_extensions import assert_type
+
+from pydantic_ai import Agent, RunContext, Tool, ToolDefinition
+
+
+@dataclass
+class DepsA:
+    a: int
+
+
+@dataclass
+class DepsB:
+    b: str
+
+
+@dataclass
+class AgentDeps(DepsA, DepsB):
+    pass
+
+
+agent = Agent(
+    instructions='...',
+    model='...',
+    deps_type=AgentDeps,
+)
+
+
+@agent.tool
+def tool_func_1(ctx: RunContext[DepsA]) -> int:
+    return ctx.deps.a
+
+
+@agent.tool
+def tool_func_2(ctx: RunContext[DepsB]) -> str:
+    return ctx.deps.b
+
+
+# Ensure that you can use tools with deps that are supertypes of the agent's deps
+agent.run_sync('...', deps=AgentDeps(a=0, b='test'))
+
+
+def my_plain_tool() -> str:
+    return 'abc'
+
+
+def my_context_tool(ctx: RunContext[int]) -> str:
+    return str(ctx.deps)
+
+
+async def my_prepare_none(ctx: RunContext, tool_defn: ToolDefinition) -> None:
+    pass
+
+
+async def my_prepare_object(ctx: RunContext[object], tool_defn: ToolDefinition) -> None:
+    pass
+
+
+async def my_prepare_any(ctx: RunContext[Any], tool_defn: ToolDefinition) -> None:
+    pass
+
+
+tool_1 = Tool(my_plain_tool)
+assert_type(tool_1, Tool[object])
+
+tool_2 = Tool(my_plain_tool, prepare=my_prepare_none)
+assert_type(tool_2, Tool[None])  # due to default parameter of RunContext being None and inferring from prepare
+
+tool_3 = Tool(my_plain_tool, prepare=my_prepare_object)
+assert_type(tool_3, Tool[object])
+
+tool_4 = Tool(my_plain_tool, prepare=my_prepare_any)
+assert_type(tool_4, Tool[Any])
+
+tool_5 = Tool(my_context_tool)
+assert_type(tool_5, Tool[int])
+
+tool_6 = Tool(my_context_tool, prepare=my_prepare_object)
+assert_type(tool_6, Tool[int])
+
+# Note: The following is not ideal behavior, but the workaround is to just not use Any as the argument to your prepare
+# function, as shown in the example immediately above
+tool_7 = Tool(my_context_tool, prepare=my_prepare_any)
+assert_type(tool_7, Tool[Any])