pydantic-ai 0.0.30__tar.gz → 0.0.32__tar.gz

{pydantic_ai-0.0.30 → pydantic_ai-0.0.32}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: pydantic-ai
-Version: 0.0.30
+Version: 0.0.32
 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
 Project-URL: Documentation, https://ai.pydantic.dev
 Project-URL: Changelog, https://github.com/pydantic/pydantic-ai/releases
-Author-email: Samuel Colvin <samuel@pydantic.dev>
+Author-email: Samuel Colvin <samuel@pydantic.dev>, Marcelo Trylesinski <marcelotryle@gmail.com>, David Montague <david@pydantic.dev>, Alex Hall <alex@pydantic.dev>
 License-Expression: MIT
 License-File: LICENSE
 Classifier: Development Status :: 4 - Beta
@@ -28,9 +28,9 @@ Classifier: Topic :: Internet
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.9
-Requires-Dist: pydantic-ai-slim[anthropic,cohere,groq,mistral,openai,vertexai]==0.0.30
+Requires-Dist: pydantic-ai-slim[anthropic,cohere,groq,mistral,openai,vertexai]==0.0.32
 Provides-Extra: examples
-Requires-Dist: pydantic-ai-examples==0.0.30; extra == 'examples'
+Requires-Dist: pydantic-ai-examples==0.0.32; extra == 'examples'
 Provides-Extra: logfire
 Requires-Dist: logfire>=2.3; extra == 'logfire'
 Description-Content-Type: text/markdown

{pydantic_ai-0.0.30 → pydantic_ai-0.0.32}/pyproject.toml

@@ -4,9 +4,14 @@ build-backend = "hatchling.build"
 
 [project]
 name = "pydantic-ai"
-version = "0.0.30"
+version = "0.0.32"
 description = "Agent Framework / shim to use Pydantic with LLMs"
-authors = [{ name = "Samuel Colvin", email = "samuel@pydantic.dev" }]
+authors = [
+    { name = "Samuel Colvin", email = "samuel@pydantic.dev" },
+    { name = "Marcelo Trylesinski", email = "marcelotryle@gmail.com" },
+    { name = "David Montague", email = "david@pydantic.dev" },
+    { name = "Alex Hall", email = "alex@pydantic.dev" },
+]
 license = "MIT"
 readme = "README.md"
 classifiers = [
@@ -32,7 +37,7 @@ classifiers = [
 requires-python = ">=3.9"
 
 dependencies = [
-    "pydantic-ai-slim[openai,vertexai,groq,anthropic,mistral,cohere]==0.0.30",
+    "pydantic-ai-slim[openai,vertexai,groq,anthropic,mistral,cohere]==0.0.32",
 ]
 
 [project.urls]
@@ -42,7 +47,7 @@ Documentation = "https://ai.pydantic.dev"
 Changelog = "https://github.com/pydantic/pydantic-ai/releases"
 
 [project.optional-dependencies]
-examples = ["pydantic-ai-examples==0.0.30"]
+examples = ["pydantic-ai-examples==0.0.32"]
 logfire = ["logfire>=2.3"]
 
 [tool.uv.sources]
@@ -165,6 +170,9 @@ exclude_lines = [
 [tool.logfire]
 ignore_no_config = true
 
+[tool.inline-snapshot]
+format-command="ruff format --stdin-filename {filename}"
+
 [tool.inline-snapshot.shortcuts]
 snap-fix = ["create", "fix"]
 snap = ["create"]

{pydantic_ai-0.0.30 → pydantic_ai-0.0.32}/tests/models/test_instrumented.py

@@ -106,7 +106,7 @@ class MyResponseStream(StreamedResponse):
 @pytest.mark.anyio
 @requires_logfire_events
 async def test_instrumented_model(capfire: CaptureLogfire):
-    model = InstrumentedModel.from_logfire(MyModel(), event_mode='logs')
+    model = InstrumentedModel(MyModel(), event_mode='logs')
     assert model.system == 'my_system'
     assert model.model_name == 'my_model'
 
@@ -168,6 +168,7 @@ async def test_instrumented_model(capfire: CaptureLogfire):
                 'severity_text': None,
                 'attributes': {
                     'gen_ai.system': 'my_system',
+                    'gen_ai.message.index': 0,
                     'event.name': 'gen_ai.system.message',
                 },
                 'timestamp': 2000000000,
@@ -182,6 +183,7 @@ async def test_instrumented_model(capfire: CaptureLogfire):
                 'severity_text': None,
                 'attributes': {
                     'gen_ai.system': 'my_system',
+                    'gen_ai.message.index': 0,
                     'event.name': 'gen_ai.user.message',
                 },
                 'timestamp': 4000000000,
@@ -196,6 +198,7 @@ async def test_instrumented_model(capfire: CaptureLogfire):
                 'severity_text': None,
                 'attributes': {
                     'gen_ai.system': 'my_system',
+                    'gen_ai.message.index': 0,
                     'event.name': 'gen_ai.tool.message',
                 },
                 'timestamp': 6000000000,
@@ -218,6 +221,7 @@ Fix the errors and try again.\
                 'severity_text': None,
                 'attributes': {
                     'gen_ai.system': 'my_system',
+                    'gen_ai.message.index': 0,
                     'event.name': 'gen_ai.tool.message',
                 },
                 'timestamp': 8000000000,
@@ -239,6 +243,7 @@ Fix the errors and try again.\
                 'severity_text': None,
                 'attributes': {
                     'gen_ai.system': 'my_system',
+                    'gen_ai.message.index': 0,
                     'event.name': 'gen_ai.user.message',
                 },
                 'timestamp': 10000000000,
@@ -253,6 +258,7 @@ Fix the errors and try again.\
                 'severity_text': None,
                 'attributes': {
                     'gen_ai.system': 'my_system',
+                    'gen_ai.message.index': 1,
                     'event.name': 'gen_ai.assistant.message',
                 },
                 'timestamp': 12000000000,
@@ -324,7 +330,7 @@ async def test_instrumented_model_not_recording():
 @pytest.mark.anyio
 @requires_logfire_events
 async def test_instrumented_model_stream(capfire: CaptureLogfire):
-    model = InstrumentedModel.from_logfire(MyModel(), event_mode='logs')
+    model = InstrumentedModel(MyModel(), event_mode='logs')
 
     messages: list[ModelMessage] = [
         ModelRequest(
@@ -380,6 +386,7 @@ async def test_instrumented_model_stream(capfire: CaptureLogfire):
                 'severity_text': None,
                 'attributes': {
                     'gen_ai.system': 'my_system',
+                    'gen_ai.message.index': 0,
                     'event.name': 'gen_ai.user.message',
                 },
                 'timestamp': 2000000000,
@@ -406,7 +413,7 @@ async def test_instrumented_model_stream(capfire: CaptureLogfire):
 @pytest.mark.anyio
 @requires_logfire_events
 async def test_instrumented_model_stream_break(capfire: CaptureLogfire):
-    model = InstrumentedModel.from_logfire(MyModel(), event_mode='logs')
+    model = InstrumentedModel(MyModel(), event_mode='logs')
 
     messages: list[ModelMessage] = [
         ModelRequest(
@@ -474,6 +481,7 @@ async def test_instrumented_model_stream_break(capfire: CaptureLogfire):
                 'severity_text': None,
                 'attributes': {
                     'gen_ai.system': 'my_system',
+                    'gen_ai.message.index': 0,
                     'event.name': 'gen_ai.user.message',
                 },
                 'timestamp': 2000000000,
@@ -555,12 +563,14 @@ async def test_instrumented_model_attributes_mode(capfire: CaptureLogfire):
                                     'event.name': 'gen_ai.system.message',
                                     'content': 'system_prompt',
                                     'role': 'system',
+                                    'gen_ai.message.index': 0,
                                     'gen_ai.system': 'my_system',
                                 },
                                 {
                                     'event.name': 'gen_ai.user.message',
                                     'content': 'user_prompt',
                                     'role': 'user',
+                                    'gen_ai.message.index': 0,
                                     'gen_ai.system': 'my_system',
                                 },
                                 {
@@ -568,6 +578,7 @@ async def test_instrumented_model_attributes_mode(capfire: CaptureLogfire):
                                     'content': 'tool_return_content',
                                     'role': 'tool',
                                     'id': 'tool_call_3',
+                                    'gen_ai.message.index': 0,
                                     'gen_ai.system': 'my_system',
                                 },
                                 {
@@ -579,6 +590,7 @@ Fix the errors and try again.\
 """,
                                     'role': 'tool',
                                     'id': 'tool_call_4',
+                                    'gen_ai.message.index': 0,
                                     'gen_ai.system': 'my_system',
                                 },
                                 {
@@ -589,12 +601,14 @@ retry_prompt2
 Fix the errors and try again.\
 """,
                                     'role': 'user',
+                                    'gen_ai.message.index': 0,
                                     'gen_ai.system': 'my_system',
                                 },
                                 {
                                     'event.name': 'gen_ai.assistant.message',
                                     'role': 'assistant',
                                     'content': 'text3',
+                                    'gen_ai.message.index': 1,
                                     'gen_ai.system': 'my_system',
                                 },
                                 {
@@ -632,3 +646,35 @@ Fix the errors and try again.\
             },
         ]
     )
+
+
+def test_messages_to_otel_events_serialization_errors():
+    class Foo:
+        def __repr__(self):
+            return 'Foo()'
+
+    class Bar:
+        def __repr__(self):
+            raise ValueError('error!')
+
+    messages = [
+        ModelResponse(parts=[ToolCallPart('tool', {'arg': Foo()})]),
+        ModelRequest(parts=[ToolReturnPart('tool', Bar())]),
+    ]
+
+    assert [
+        InstrumentedModel.event_to_dict(e) for e in InstrumentedModel.messages_to_otel_events(messages)
+    ] == snapshot(
+        [
+            {
+                'body': "{'role': 'assistant', 'tool_calls': [{'id': None, 'type': 'function', 'function': {'name': 'tool', 'arguments': {'arg': Foo()}}}]}",
+                'gen_ai.message.index': 0,
+                'event.name': 'gen_ai.assistant.message',
+            },
+            {
+                'body': 'Unable to serialize: error!',
+                'gen_ai.message.index': 1,
+                'event.name': 'gen_ai.tool.message',
+            },
+        ]
+    )

{pydantic_ai-0.0.30 → pydantic_ai-0.0.32}/tests/test_agent.py

@@ -1183,6 +1183,42 @@ class TestMultipleToolCalls:
         tool_returns = [m for m in result.all_messages() if isinstance(m, ToolReturnPart)]
         assert tool_returns == snapshot([])
 
+    def test_multiple_final_result_are_validated_correctly(self):
+        """Tests that if multiple final results are returned, but one fails validation, the other is used."""
+
+        def return_model(_: list[ModelMessage], info: AgentInfo) -> ModelResponse:
+            assert info.result_tools is not None
+            return ModelResponse(
+                parts=[
+                    ToolCallPart('final_result', {'bad_value': 'first'}, tool_call_id='first'),
+                    ToolCallPart('final_result', {'value': 'second'}, tool_call_id='second'),
+                ]
+            )
+
+        agent = Agent(FunctionModel(return_model), result_type=self.ResultType, end_strategy='early')
+        result = agent.run_sync('test multiple final results')
+
+        # Verify the result came from the second final tool
+        assert result.data.value == 'second'
+
+        # Verify we got appropriate tool returns
+        assert result.new_messages()[-1].parts == snapshot(
+            [
+                ToolReturnPart(
+                    tool_name='final_result',
+                    tool_call_id='first',
+                    content='Result tool not used - result failed validation.',
+                    timestamp=IsNow(tz=timezone.utc),
+                ),
+                ToolReturnPart(
+                    tool_name='final_result',
+                    content='Final result processed.',
+                    timestamp=IsNow(tz=timezone.utc),
+                    tool_call_id='second',
+                ),
+            ]
+        )
+
 
 async def test_model_settings_override() -> None:
     def return_settings(_: list[ModelMessage], info: AgentInfo) -> ModelResponse:

pydantic_ai-0.0.32/tests/test_logfire.py

@@ -0,0 +1,193 @@
+from __future__ import annotations as _annotations
+
+from dataclasses import dataclass
+from typing import Any, Callable
+
+import pytest
+from dirty_equals import IsJson
+from inline_snapshot import snapshot
+from typing_extensions import NotRequired, TypedDict
+
+from pydantic_ai import Agent
+from pydantic_ai.models.test import TestModel
+
+try:
+    from logfire.testing import CaptureLogfire
+except ImportError:
+    logfire_installed = False
+else:
+    logfire_installed = True
+
+
+class SpanSummary(TypedDict):
+    id: int
+    message: str
+    children: NotRequired[list[SpanSummary]]
+
+
+@dataclass(init=False)
+class LogfireSummary:
+    traces: list[SpanSummary]
+    attributes: dict[int, dict[str, Any]]
+
+    def __init__(self, capfire: CaptureLogfire):
+        spans = capfire.exporter.exported_spans_as_dict()
+        spans.sort(key=lambda s: s['start_time'])
+        self.traces = []
+        span_lookup: dict[tuple[str, str], SpanSummary] = {}
+        self.attributes = {}
+        id_counter = 0
+        for span in spans:
+            tid = span['context']['trace_id'], span['context']['span_id']
+            span_lookup[tid] = span_summary = SpanSummary(id=id_counter, message=span['attributes']['logfire.msg'])
+            self.attributes[id_counter] = span['attributes']
+            id_counter += 1
+            if parent := span['parent']:
+                parent_span = span_lookup[(parent['trace_id'], parent['span_id'])]
+                parent_span.setdefault('children', []).append(span_summary)
+            else:
+                self.traces.append(span_summary)
+
+
+@pytest.fixture
+def get_logfire_summary(capfire: CaptureLogfire) -> Callable[[], LogfireSummary]:
+    def get_summary() -> LogfireSummary:
+        return LogfireSummary(capfire)
+
+    return get_summary
+
+
+@pytest.mark.skipif(not logfire_installed, reason='logfire not installed')
+def test_logfire(get_logfire_summary: Callable[[], LogfireSummary]) -> None:
+    my_agent = Agent(model=TestModel(), instrument=True)
+
+    @my_agent.tool_plain
+    async def my_ret(x: int) -> str:
+        return str(x + 1)
+
+    result = my_agent.run_sync('Hello')
+    assert result.data == snapshot('{"my_ret":"1"}')
+
+    summary = get_logfire_summary()
+    assert summary.traces == snapshot(
+        [
+            {
+                'id': 0,
+                'message': 'my_agent run',
+                'children': [
+                    {'id': 1, 'message': 'preparing model request params'},
+                    {'id': 2, 'message': 'chat test'},
+                    {'id': 3, 'message': 'running tools: my_ret'},
+                    {'id': 4, 'message': 'preparing model request params'},
+                    {'id': 5, 'message': 'chat test'},
+                ],
+            }
+        ]
+    )
+    assert summary.attributes[0] == snapshot(
+        {
+            'model_name': 'test',
+            'agent_name': 'my_agent',
+            'logfire.msg': 'my_agent run',
+            'logfire.span_type': 'span',
+            'gen_ai.usage.input_tokens': 103,
+            'gen_ai.usage.output_tokens': 12,
+            'all_messages_events': IsJson(
+                snapshot(
+                    [
+                        {
+                            'content': 'Hello',
+                            'role': 'user',
+                            'gen_ai.message.index': 0,
+                            'event.name': 'gen_ai.user.message',
+                        },
+                        {
+                            'role': 'assistant',
+                            'tool_calls': [
+                                {
+                                    'id': None,
+                                    'type': 'function',
+                                    'function': {
+                                        'name': 'my_ret',
+                                        'arguments': {'x': 0},
+                                    },
+                                }
+                            ],
+                            'gen_ai.message.index': 1,
+                            'event.name': 'gen_ai.assistant.message',
+                        },
+                        {
+                            'content': '1',
+                            'role': 'tool',
+                            'id': None,
+                            'gen_ai.message.index': 2,
+                            'event.name': 'gen_ai.tool.message',
+                        },
+                        {
+                            'role': 'assistant',
+                            'content': '{"my_ret":"1"}',
+                            'gen_ai.message.index': 3,
+                            'event.name': 'gen_ai.assistant.message',
+                        },
+                    ]
+                )
+            ),
+            'final_result': '{"my_ret":"1"}',
+            'logfire.json_schema': IsJson(
+                snapshot(
+                    {
+                        'type': 'object',
+                        'properties': {'all_messages_events': {'type': 'array'}, 'final_result': {'type': 'object'}},
+                    }
+                )
+            ),
+        }
+    )
+    assert summary.attributes[1] == snapshot(
+        {
+            'run_step': 1,
+            'logfire.span_type': 'span',
+            'logfire.msg': 'preparing model request params',
+        }
+    )
+    assert summary.attributes[2] == snapshot(
+        {
+            'gen_ai.operation.name': 'chat',
+            'gen_ai.system': 'test',
+            'gen_ai.request.model': 'test',
+            'logfire.span_type': 'span',
+            'logfire.msg': 'chat test',
+            'gen_ai.response.model': 'test',
+            'gen_ai.usage.input_tokens': 51,
+            'gen_ai.usage.output_tokens': 4,
+            'events': IsJson(
+                snapshot(
+                    [
+                        {
+                            'event.name': 'gen_ai.user.message',
+                            'content': 'Hello',
+                            'role': 'user',
+                            'gen_ai.message.index': 0,
+                            'gen_ai.system': 'test',
+                        },
+                        {
+                            'event.name': 'gen_ai.choice',
+                            'index': 0,
+                            'message': {
+                                'role': 'assistant',
+                                'tool_calls': [
+                                    {
+                                        'id': None,
+                                        'type': 'function',
+                                        'function': {'name': 'my_ret', 'arguments': {'x': 0}},
+                                    }
+                                ],
+                            },
+                            'gen_ai.system': 'test',
+                        },
+                    ]
+                )
+            ),
+            'logfire.json_schema': '{"type": "object", "properties": {"events": {"type": "array"}}}',
+        }
+    )

{pydantic_ai-0.0.30 → pydantic_ai-0.0.32}/tests/test_streaming.py

@@ -761,14 +761,14 @@ async def test_iter_stream_output():
     messages: list[str] = []
 
     stream_usage: Usage | None = None
-    with agent.iter('Hello') as run:
+    async with agent.iter('Hello') as run:
         async for node in run:
             if agent.is_model_request_node(node):
                 async with node.stream(run.ctx) as stream:
                     async for chunk in stream.stream_output(debounce_by=None):
                         messages.append(chunk)
                 stream_usage = deepcopy(stream.usage())
-    assert run.next_node == End(data=FinalResult(data='The bat sat on the mat.', tool_name=None))
+    assert run.next_node == End(data=FinalResult(data='The bat sat on the mat.', tool_name=None, tool_call_id=None))
     assert (
         run.usage()
         == stream_usage
@@ -800,7 +800,7 @@ async def test_iter_stream_responses():
     run: AgentRun
     stream: AgentStream
     messages: list[ModelResponse] = []
-    with agent.iter('Hello') as run:
+    async with agent.iter('Hello') as run:
         async for node in run:
             if agent.is_model_request_node(node):
                 async with node.stream(run.ctx) as stream:
@@ -843,7 +843,7 @@ async def test_stream_iter_structured_validator() -> None:
         return ResultType(value=data.value + ' (validated)')
 
     outputs: list[ResultType] = []
-    with agent.iter('test') as run:
+    async with agent.iter('test') as run:
         async for node in run:
             if agent.is_model_request_node(node):
                 async with node.stream(run.ctx) as stream:

{pydantic_ai-0.0.30 → pydantic_ai-0.0.32}/tests/test_utils.py

@@ -44,6 +44,30 @@ def test_check_object_json_schema():
     object_schema = {'type': 'object', 'properties': {'a': {'type': 'string'}}}
     assert check_object_json_schema(object_schema) == object_schema
 
+    ref_schema = {
+        '$defs': {
+            'JsonModel': {
+                'properties': {
+                    'type': {'title': 'Type', 'type': 'string'},
+                    'items': {'anyOf': [{'$ref': '#/$defs/JsonModel'}, {'type': 'null'}]},
+                },
+                'required': ['type', 'items'],
+                'title': 'JsonModel',
+                'type': 'object',
+            }
+        },
+        '$ref': '#/$defs/JsonModel',
+    }
+    assert check_object_json_schema(ref_schema) == {
+        'properties': {
+            'type': {'title': 'Type', 'type': 'string'},
+            'items': {'anyOf': [{'$ref': '#/$defs/JsonModel'}, {'type': 'null'}]},
+        },
+        'required': ['type', 'items'],
+        'title': 'JsonModel',
+        'type': 'object',
+    }
+
     array_schema = {'type': 'array', 'items': {'type': 'string'}}
     with pytest.raises(UserError, match='^Schema must be an object$'):
         check_object_json_schema(array_schema)

pydantic_ai-0.0.30/tests/test_logfire.py

@@ -1,261 +0,0 @@
-from __future__ import annotations as _annotations
-
-from dataclasses import dataclass
-from typing import Any, Callable
-
-import pytest
-from dirty_equals import IsInt, IsJson, IsStr
-from inline_snapshot import snapshot
-from typing_extensions import NotRequired, TypedDict
-
-from pydantic_ai import Agent
-from pydantic_ai.models.test import TestModel
-
-try:
-    from logfire.testing import CaptureLogfire
-except ImportError:
-    logfire_installed = False
-else:
-    logfire_installed = True
-
-
-class SpanSummary(TypedDict):
-    id: int
-    message: str
-    children: NotRequired[list[SpanSummary]]
-
-
-@dataclass(init=False)
-class LogfireSummary:
-    traces: list[SpanSummary]
-    attributes: dict[int, dict[str, Any]]
-
-    def __init__(self, capfire: CaptureLogfire):
-        spans = capfire.exporter.exported_spans_as_dict()
-        spans.sort(key=lambda s: s['start_time'])
-        self.traces = []
-        span_lookup: dict[tuple[str, str], SpanSummary] = {}
-        self.attributes = {}
-        id_counter = 0
-        for span in spans:
-            tid = span['context']['trace_id'], span['context']['span_id']
-            span_lookup[tid] = span_summary = SpanSummary(id=id_counter, message=span['attributes']['logfire.msg'])
-            self.attributes[id_counter] = span['attributes']
-            id_counter += 1
-            if parent := span['parent']:
-                parent_span = span_lookup[(parent['trace_id'], parent['span_id'])]
-                parent_span.setdefault('children', []).append(span_summary)
-            else:
-                self.traces.append(span_summary)
-
-
-@pytest.fixture
-def get_logfire_summary(capfire: CaptureLogfire) -> Callable[[], LogfireSummary]:
-    def get_summary() -> LogfireSummary:
-        return LogfireSummary(capfire)
-
-    return get_summary
-
-
-@pytest.mark.skipif(not logfire_installed, reason='logfire not installed')
-def test_logfire(get_logfire_summary: Callable[[], LogfireSummary]) -> None:
-    my_agent = Agent(model=TestModel())
-
-    @my_agent.tool_plain
-    async def my_ret(x: int) -> str:
-        return str(x + 1)
-
-    result = my_agent.run_sync('Hello')
-    assert result.data == snapshot('{"my_ret":"1"}')
-
-    summary = get_logfire_summary()
-    assert summary.traces == snapshot(
-        [
-            {
-                'id': 0,
-                'message': 'my_agent run prompt=Hello',
-                'children': [
-                    {'id': 1, 'message': 'preparing model request params run_step=1'},
-                    {'id': 2, 'message': 'model request'},
-                    {
-                        'id': 3,
-                        'message': 'handle model response -> tool-return',
-                        'children': [{'id': 4, 'message': "running tools=['my_ret']"}],
-                    },
-                    {'id': 5, 'message': 'preparing model request params run_step=2'},
-                    {'id': 6, 'message': 'model request'},
-                    {'id': 7, 'message': 'handle model response -> final result'},
-                ],
-            }
-        ]
-    )
-    assert summary.attributes[0] == snapshot(
-        {
-            'code.filepath': 'test_logfire.py',
-            'code.function': 'test_logfire',
-            'code.lineno': 123,
-            'prompt': 'Hello',
-            'agent': IsJson(
-                {
-                    'model': {
-                        'call_tools': 'all',
-                        'custom_result_text': None,
-                        'custom_result_args': None,
-                        'seed': 0,
-                        'last_model_request_parameters': None,
-                    },
-                    'name': 'my_agent',
-                    'end_strategy': 'early',
-                    'model_settings': None,
-                }
-            ),
-            'model_name': 'test',
-            'agent_name': 'my_agent',
-            'logfire.msg_template': '{agent_name} run {prompt=}',
-            'logfire.msg': 'my_agent run prompt=Hello',
-            'logfire.span_type': 'span',
-            'all_messages': IsJson(
-                [
-                    {
-                        'parts': [
-                            {
-                                'content': 'Hello',
-                                'timestamp': IsStr(regex=r'\d{4}-\d{2}-.+'),
-                                'part_kind': 'user-prompt',
-                            },
-                        ],
-                        'kind': 'request',
-                    },
-                    {
-                        'parts': [
-                            {'tool_name': 'my_ret', 'args': {'x': 0}, 'tool_call_id': None, 'part_kind': 'tool-call'}
-                        ],
-                        'model_name': 'test',
-                        'timestamp': IsStr(regex=r'\d{4}-\d{2}-.+'),
-                        'kind': 'response',
-                    },
-                    {
-                        'parts': [
-                            {
-                                'tool_name': 'my_ret',
-                                'content': '1',
-                                'tool_call_id': None,
-                                'timestamp': IsStr(regex=r'\d{4}-\d{2}-.+'),
-                                'part_kind': 'tool-return',
-                            },
-                        ],
-                        'kind': 'request',
-                    },
-                    {
-                        'parts': [{'content': '{"my_ret":"1"}', 'part_kind': 'text'}],
-                        'model_name': 'test',
-                        'timestamp': IsStr(regex=r'\d{4}-\d{2}-.+'),
-                        'kind': 'response',
-                    },
-                ]
-            ),
-            'usage': IsJson(
-                {'requests': 2, 'request_tokens': 103, 'response_tokens': 12, 'total_tokens': 115, 'details': None}
-            ),
-            'logfire.json_schema': IsJson(
-                {
-                    'type': 'object',
-                    'properties': {
-                        'prompt': {},
-                        'agent': {
-                            'type': 'object',
-                            'title': 'Agent',
-                            'x-python-datatype': 'dataclass',
-                            'properties': {
-                                'model': {'type': 'object', 'title': 'TestModel', 'x-python-datatype': 'dataclass'}
-                            },
-                        },
-                        'model_name': {},
-                        'agent_name': {},
-                        'all_messages': {
-                            'type': 'array',
-                            'prefixItems': [
-                                {
-                                    'type': 'object',
-                                    'title': 'ModelRequest',
-                                    'x-python-datatype': 'dataclass',
-                                    'properties': {
-                                        'parts': {
-                                            'type': 'array',
-                                            'items': {
-                                                'type': 'object',
-                                                'title': 'UserPromptPart',
-                                                'x-python-datatype': 'dataclass',
-                                                'properties': {'timestamp': {'type': 'string', 'format': 'date-time'}},
-                                            },
-                                        }
-                                    },
-                                },
-                                {
-                                    'type': 'object',
-                                    'title': 'ModelResponse',
-                                    'x-python-datatype': 'dataclass',
-                                    'properties': {
-                                        'parts': {
-                                            'type': 'array',
-                                            'items': {
-                                                'type': 'object',
-                                                'title': 'ToolCallPart',
-                                                'x-python-datatype': 'dataclass',
-                                            },
-                                        },
-                                        'timestamp': {'type': 'string', 'format': 'date-time'},
-                                    },
-                                },
-                                {
-                                    'type': 'object',
-                                    'title': 'ModelRequest',
-                                    'x-python-datatype': 'dataclass',
-                                    'properties': {
-                                        'parts': {
-                                            'type': 'array',
-                                            'items': {
-                                                'type': 'object',
-                                                'title': 'ToolReturnPart',
-                                                'x-python-datatype': 'dataclass',
-                                                'properties': {'timestamp': {'type': 'string', 'format': 'date-time'}},
-                                            },
-                                        }
-                                    },
-                                },
-                                {
-                                    'type': 'object',
-                                    'title': 'ModelResponse',
-                                    'x-python-datatype': 'dataclass',
-                                    'properties': {
-                                        'parts': {
-                                            'type': 'array',
-                                            'items': {
-                                                'type': 'object',
-                                                'title': 'TextPart',
-                                                'x-python-datatype': 'dataclass',
-                                            },
-                                        },
-                                        'timestamp': {'type': 'string', 'format': 'date-time'},
-                                    },
-                                },
-                            ],
-                        },
-                        'usage': {'type': 'object', 'title': 'Usage', 'x-python-datatype': 'dataclass'},
-                    },
-                }
-            ),
-        }
-    )
-    assert summary.attributes[1] == snapshot(
-        {
-            'code.filepath': 'test_logfire.py',
-            'code.function': 'test_logfire',
-            'code.lineno': IsInt(),
-            'run_step': 1,
-            'logfire.msg_template': 'preparing model request params {run_step=}',
-            'logfire.span_type': 'span',
-            'logfire.msg': 'preparing model request params run_step=1',
-            'logfire.json_schema': '{"type":"object","properties":{"run_step":{}}}',
-        }
-    )