pydantic-ai 1.0.10__tar.gz → 1.0.11__tar.gz

{pydantic_ai-1.0.10 → pydantic_ai-1.0.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai
-Version: 1.0.10
+Version: 1.0.11
 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
@@ -14,7 +14,6 @@ Classifier: Framework :: Pydantic
 Classifier: Framework :: Pydantic :: 2
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Information Technology
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
@@ -27,13 +26,13 @@ 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,google,groq,huggingface,logfire,mcp,mistral,openai,retries,temporal,vertexai]==1.0.10
+Requires-Dist: pydantic-ai-slim[ag-ui,anthropic,bedrock,cli,cohere,evals,google,groq,huggingface,logfire,mcp,mistral,openai,retries,temporal,vertexai]==1.0.11
 Provides-Extra: a2a
 Requires-Dist: fasta2a>=0.4.1; extra == 'a2a'
 Provides-Extra: dbos
-Requires-Dist: pydantic-ai-slim[dbos]==1.0.10; extra == 'dbos'
+Requires-Dist: pydantic-ai-slim[dbos]==1.0.11; extra == 'dbos'
 Provides-Extra: examples
-Requires-Dist: pydantic-ai-examples==1.0.10; extra == 'examples'
+Requires-Dist: pydantic-ai-examples==1.0.11; extra == 'examples'
 Description-Content-Type: text/markdown
 
 <div align="center">
@@ -95,7 +94,7 @@ Integrates the [Model Context Protocol](https://ai.pydantic.dev/mcp/client), [Ag
 Easily lets you flag that certain tool calls [require approval](https://ai.pydantic.dev/deferred-tools#human-in-the-loop-tool-approval) before they can proceed, possibly depending on tool call arguments, conversation history, or user preferences.
 
 8. **Durable Execution**:
-Enables you to build [durable agents](https://ai.pydantic.dev/temporal) that can preserve their progress across transient API failures and application errors or restarts, and handle long-running, asynchronous, and human-in-the-loop workflows with production-grade reliability.
+Enables you to build [durable agents](https://ai.pydantic.dev/durable_execution/overview/) that can preserve their progress across transient API failures and application errors or restarts, and handle long-running, asynchronous, and human-in-the-loop workflows with production-grade reliability.
 
 9. **Streamed Outputs**:
 Provides the ability to [stream](https://ai.pydantic.dev/output#streamed-results) structured output continuously, with immediate validation, ensuring real time access to generated data.

{pydantic_ai-1.0.10 → pydantic_ai-1.0.11}/README.md

@@ -57,7 +57,7 @@ Integrates the [Model Context Protocol](https://ai.pydantic.dev/mcp/client), [Ag
 Easily lets you flag that certain tool calls [require approval](https://ai.pydantic.dev/deferred-tools#human-in-the-loop-tool-approval) before they can proceed, possibly depending on tool call arguments, conversation history, or user preferences.
 
 8. **Durable Execution**:
-Enables you to build [durable agents](https://ai.pydantic.dev/temporal) that can preserve their progress across transient API failures and application errors or restarts, and handle long-running, asynchronous, and human-in-the-loop workflows with production-grade reliability.
+Enables you to build [durable agents](https://ai.pydantic.dev/durable_execution/overview/) that can preserve their progress across transient API failures and application errors or restarts, and handle long-running, asynchronous, and human-in-the-loop workflows with production-grade reliability.
 
 9. **Streamed Outputs**:
 Provides the ability to [stream](https://ai.pydantic.dev/output#streamed-results) structured output continuously, with immediate validation, ensuring real time access to generated data.

{pydantic_ai-1.0.10 → pydantic_ai-1.0.11}/pyproject.toml

@@ -22,6 +22,7 @@ authors = [
     { name = "Douwe Maan", email = "douwe@pydantic.dev" },
 ]
 license = "MIT"
+license-files = ["LICENSE"]
 readme = "README.md"
 classifiers = [
     "Development Status :: 5 - Production/Stable",
@@ -34,7 +35,6 @@ classifiers = [
     "Programming Language :: Python :: 3.13",
     "Intended Audience :: Developers",
     "Intended Audience :: Information Technology",
-    "License :: OSI Approved :: MIT License",
     "Operating System :: OS Independent",
     "Topic :: Internet",
     "Topic :: Scientific/Engineering :: Artificial Intelligence",
@@ -102,7 +102,7 @@ dev = [
     "pytest-xdist>=3.6.1",
     # Needed for PyCharm users
     "pip>=25.2",
-    "genai-prices>=0.0.22",
+    "genai-prices>=0.0.28",
     "mcp-run-python>=0.0.20",
 ]
 lint = ["mypy>=1.11.2", "pyright>=1.1.390", "ruff>=0.6.9"]

pydantic_ai-1.0.11/tests/models/cassettes/test_anthropic/test_anthropic_output_tool_with_thinking.yaml

@@ -0,0 +1,74 @@
+interactions:
+- request:
+    headers:
+      accept:
+      - application/json
+      accept-encoding:
+      - gzip, deflate
+      connection:
+      - keep-alive
+      content-length:
+      - '471'
+      content-type:
+      - application/json
+      host:
+      - api.anthropic.com
+    method: POST
+    parsed_body:
+      max_tokens: 4096
+      messages:
+      - content:
+        - text: What is 3 + 3?
+          type: text
+        role: user
+      model: claude-sonnet-4-0
+      stream: false
+      system: |-
+        Always respond with a JSON object that's compatible with this schema:
+
+        {"properties": {"response": {"type": "integer"}}, "required": ["response"], "type": "object", "title": "int"}
+
+        Don't include any text or Markdown fencing before or after.
+      thinking:
+        budget_tokens: 3000
+        type: enabled
+    uri: https://api.anthropic.com/v1/messages?beta=true
+  response:
+    headers:
+      connection:
+      - keep-alive
+      content-length:
+      - '1032'
+      content-type:
+      - application/json
+      strict-transport-security:
+      - max-age=31536000; includeSubDomains; preload
+      transfer-encoding:
+      - chunked
+    parsed_body:
+      content:
+      - signature: ErQCCkYICBgCKkDId3yuTWB+RmnrHX1N/m+Q+uvt6TTyU6tRWGzFYK1UmQo+lkK5PFjgRvLK6eXA/q8sbVIC6mO3/1eq5aTkSX7+EgzYnRzfZdWJZ1X+410aDC5zyOhlAbOmBiBUmiIwPC3/mI3lVg3woo5Q2jwuZ/u+Pl8LMzrFxG0YbK2F5YDVuCjhrJsOq5e1V36GWJjqKpsBsKiPfPZQ6wizN25g64pwJb+Wjm55hDeGpK8xJeVFuren6PNKKkruBtlK1PIVpjSXBGkdTJCC69xlhwaXF20zah/A8HDm/2QEqid8Gz8+7zu+b7OGa22WdW0uZEwQgJtydTscZFqWzyAm8CZtsCh8STbRNPggOaCNg9vX5ipu2D+jXnAaL6MIOOQ3FUO+CdljS0mvfoyeCabS8TUYAQ==
+        thinking: The user is asking for 3 + 3, which equals 6. I need to respond with a JSON object that has a "response"
+          field containing an integer value.
+        type: thinking
+      - text: '{"response": 6}'
+        type: text
+      id: msg_01Fo4JKsQzJMTQBgLSAeCJDG
+      model: claude-sonnet-4-20250514
+      role: assistant
+      stop_reason: end_turn
+      stop_sequence: null
+      type: message
+      usage:
+        cache_creation:
+          ephemeral_1h_input_tokens: 0
+          ephemeral_5m_input_tokens: 0
+        cache_creation_input_tokens: 0
+        cache_read_input_tokens: 0
+        input_tokens: 105
+        output_tokens: 55
+        service_tier: standard
+    status:
+      code: 200
+      message: OK
+version: 1

{pydantic_ai-1.0.10 → pydantic_ai-1.0.11}/tests/models/test_anthropic.py

@@ -2,6 +2,7 @@ from __future__ import annotations as _annotations
 
 import json
 import os
+import re
 from collections.abc import Callable, Sequence
 from dataclasses import dataclass, field
 from datetime import timezone
@@ -4182,6 +4183,29 @@ async def test_anthropic_native_output(allow_model_requests: None, anthropic_api
         await agent.run('What is the largest city in the user country?')
 
 
+async def test_anthropic_output_tool_with_thinking(allow_model_requests: None, anthropic_api_key: str):
+    m = AnthropicModel(
+        'claude-sonnet-4-0',
+        provider=AnthropicProvider(api_key=anthropic_api_key),
+        settings=AnthropicModelSettings(anthropic_thinking={'type': 'enabled', 'budget_tokens': 3000}),
+    )
+
+    agent = Agent(m, output_type=int)
+
+    with pytest.raises(
+        UserError,
+        match=re.escape(
+            'Anthropic does not support thinking and output tools at the same time. Use `output_type=PromptedOutput(...)` instead.'
+        ),
+    ):
+        await agent.run('What is 3 + 3?')
+
+    agent = Agent(m, output_type=PromptedOutput(int))
+
+    result = await agent.run('What is 3 + 3?')
+    assert result.output == snapshot(6)
+
+
 async def test_anthropic_tool_with_thinking(allow_model_requests: None, anthropic_api_key: str):
     """When using thinking with tool calls in Anthropic, we need to send the thinking part back to the provider.
 

{pydantic_ai-1.0.10 → pydantic_ai-1.0.11}/tests/models/test_instrumented.py

@@ -42,7 +42,7 @@ from pydantic_ai.models.instrumented import InstrumentationSettings, Instrumente
 from pydantic_ai.settings import ModelSettings
 from pydantic_ai.usage import RequestUsage
 
-from ..conftest import IsStr, try_import
+from ..conftest import IsInt, IsStr, try_import
 
 with try_import() as imports_successful:
     from logfire.testing import CaptureLogfire
@@ -831,6 +831,115 @@ Fix the errors and try again.\
             ]
         )
 
+    assert capfire.get_collected_metrics() == snapshot(
+        [
+            {
+                'name': 'gen_ai.client.token.usage',
+                'description': 'Measures number of input and output tokens used',
+                'unit': '{token}',
+                'data': {
+                    'data_points': [
+                        {
+                            'attributes': {
+                                'gen_ai.system': 'openai',
+                                'gen_ai.operation.name': 'chat',
+                                'gen_ai.request.model': 'gpt-4o',
+                                'gen_ai.response.model': 'gpt-4o-2024-11-20',
+                                'gen_ai.token.type': 'input',
+                            },
+                            'start_time_unix_nano': IsInt(),
+                            'time_unix_nano': IsInt(),
+                            'count': 1,
+                            'sum': 100,
+                            'scale': 20,
+                            'zero_count': 0,
+                            'positive': {'offset': 6966588, 'bucket_counts': [1]},
+                            'negative': {'offset': 0, 'bucket_counts': [0]},
+                            'flags': 0,
+                            'min': 100,
+                            'max': 100,
+                            'exemplars': [],
+                        },
+                        {
+                            'attributes': {
+                                'gen_ai.system': 'openai',
+                                'gen_ai.operation.name': 'chat',
+                                'gen_ai.request.model': 'gpt-4o',
+                                'gen_ai.response.model': 'gpt-4o-2024-11-20',
+                                'gen_ai.token.type': 'output',
+                            },
+                            'start_time_unix_nano': IsInt(),
+                            'time_unix_nano': IsInt(),
+                            'count': 1,
+                            'sum': 200,
+                            'scale': 20,
+                            'zero_count': 0,
+                            'positive': {'offset': 8015164, 'bucket_counts': [1]},
+                            'negative': {'offset': 0, 'bucket_counts': [0]},
+                            'flags': 0,
+                            'min': 200,
+                            'max': 200,
+                            'exemplars': [],
+                        },
+                    ],
+                    'aggregation_temporality': 1,
+                },
+            },
+            {
+                'name': 'operation.cost',
+                'description': 'Monetary cost',
+                'unit': '{USD}',
+                'data': {
+                    'data_points': [
+                        {
+                            'attributes': {
+                                'gen_ai.system': 'openai',
+                                'gen_ai.operation.name': 'chat',
+                                'gen_ai.request.model': 'gpt-4o',
+                                'gen_ai.response.model': 'gpt-4o-2024-11-20',
+                                'gen_ai.token.type': 'input',
+                            },
+                            'start_time_unix_nano': IsInt(),
+                            'time_unix_nano': IsInt(),
+                            'count': 1,
+                            'sum': 0.00025,
+                            'scale': 20,
+                            'zero_count': 0,
+                            'positive': {'offset': -12547035, 'bucket_counts': [1]},
+                            'negative': {'offset': 0, 'bucket_counts': [0]},
+                            'flags': 0,
+                            'min': 0.00025,
+                            'max': 0.00025,
+                            'exemplars': [],
+                        },
+                        {
+                            'attributes': {
+                                'gen_ai.system': 'openai',
+                                'gen_ai.operation.name': 'chat',
+                                'gen_ai.request.model': 'gpt-4o',
+                                'gen_ai.response.model': 'gpt-4o-2024-11-20',
+                                'gen_ai.token.type': 'output',
+                            },
+                            'start_time_unix_nano': IsInt(),
+                            'time_unix_nano': IsInt(),
+                            'count': 1,
+                            'sum': 0.002,
+                            'scale': 20,
+                            'zero_count': 0,
+                            'positive': {'offset': -9401307, 'bucket_counts': [1]},
+                            'negative': {'offset': 0, 'bucket_counts': [0]},
+                            'flags': 0,
+                            'min': 0.002,
+                            'max': 0.002,
+                            'exemplars': [],
+                        },
+                    ],
+                    'aggregation_temporality': 1,
+                },
+            },
+        ]
+    )
+
 
 def test_messages_to_otel_events_serialization_errors():
     class Foo:

{pydantic_ai-1.0.10 → pydantic_ai-1.0.11}/tests/models/test_model_names.py

@@ -58,9 +58,7 @@ def test_known_model_names():  # pragma: lax no cover
             else:
                 yield from get_model_names(arg)
 
-    anthropic_names = [f'anthropic:{n}' for n in get_model_names(AnthropicModelName)] + [
-        n for n in get_model_names(AnthropicModelName) if n.startswith('claude')
-    ]
+    anthropic_names = [f'anthropic:{n}' for n in get_model_names(AnthropicModelName)]
     cohere_names = [f'cohere:{n}' for n in get_model_names(CohereModelName)]
     google_names = [f'google-gla:{n}' for n in get_model_names(GeminiModelName)] + [
         f'google-vertex:{n}' for n in get_model_names(GeminiModelName)
@@ -69,9 +67,7 @@ def test_known_model_names():  # pragma: lax no cover
     groq_names = [f'groq:{n}' for n in get_model_names(GroqModelName)]
     moonshotai_names = [f'moonshotai:{n}' for n in get_model_names(MoonshotAIModelName)]
     mistral_names = [f'mistral:{n}' for n in get_model_names(MistralModelName)]
-    openai_names = [f'openai:{n}' for n in get_model_names(OpenAIModelName)] + [
-        n for n in get_model_names(OpenAIModelName) if n.startswith('o1') or n.startswith('gpt') or n.startswith('o3')
-    ]
+    openai_names = [f'openai:{n}' for n in get_model_names(OpenAIModelName)]
     bedrock_names = [f'bedrock:{n}' for n in get_model_names(BedrockModelName)]
     deepseek_names = ['deepseek:deepseek-chat', 'deepseek:deepseek-reasoner']
     huggingface_names = [f'huggingface:{n}' for n in get_model_names(HuggingFaceModelName)]

{pydantic_ai-1.0.10 → pydantic_ai-1.0.11}/tests/models/test_openai.py

@@ -172,6 +172,27 @@ async def test_request_simple_usage(allow_model_requests: None):
     )
 
 
+async def test_openai_chat_image_detail_vendor_metadata(allow_model_requests: None):
+    c = completion_message(
+        ChatCompletionMessage(content='done', role='assistant'),
+    )
+    mock_client = MockOpenAI.create_mock(c)
+    model = OpenAIChatModel('gpt-4o', provider=OpenAIProvider(openai_client=mock_client))
+    agent = Agent(model)
+
+    image_url = ImageUrl('https://example.com/image.png', vendor_metadata={'detail': 'high'})
+    binary_image = BinaryContent(b'\x89PNG', media_type='image/png', vendor_metadata={'detail': 'high'})
+
+    await agent.run(['Describe these inputs.', image_url, binary_image])
+
+    request_kwargs = get_mock_chat_completion_kwargs(mock_client)
+    image_parts = [
+        item['image_url'] for item in request_kwargs[0]['messages'][0]['content'] if item['type'] == 'image_url'
+    ]
+    assert image_parts
+    assert all(part['detail'] == 'high' for part in image_parts)
+
+
 async def test_request_structured_response(allow_model_requests: None):
     c = completion_message(
         ChatCompletionMessage(

{pydantic_ai-1.0.10 → pydantic_ai-1.0.11}/tests/models/test_openai_responses.py

@@ -39,7 +39,7 @@ from pydantic_ai.tools import ToolDefinition
 from pydantic_ai.usage import RequestUsage, RunUsage
 
 from ..conftest import IsDatetime, IsStr, TestEnv, try_import
-from .mock_openai import MockOpenAIResponses, response_message
+from .mock_openai import MockOpenAIResponses, get_mock_responses_kwargs, response_message
 
 with try_import() as imports_successful:
     from openai.types.responses.response_output_message import Content, ResponseOutputMessage, ResponseOutputText
@@ -78,6 +78,40 @@ async def test_openai_responses_model_simple_response(allow_model_requests: None
     assert result.output == snapshot('The capital of France is Paris.')
 
 
+async def test_openai_responses_image_detail_vendor_metadata(allow_model_requests: None):
+    c = response_message(
+        [
+            ResponseOutputMessage(
+                id='output-1',
+                content=cast(list[Content], [ResponseOutputText(text='done', type='output_text', annotations=[])]),
+                role='assistant',
+                status='completed',
+                type='message',
+            )
+        ]
+    )
+    mock_client = MockOpenAIResponses.create_mock(c)
+    model = OpenAIResponsesModel('gpt-4o', provider=OpenAIProvider(openai_client=mock_client))
+    agent = Agent(model=model)
+
+    image_url = ImageUrl('https://example.com/image.png', vendor_metadata={'detail': 'high'})
+    binary_image = BinaryContent(b'\x89PNG', media_type='image/png', vendor_metadata={'detail': 'high'})
+
+    result = await agent.run(['Describe these inputs.', image_url, binary_image])
+    assert result.output == 'done'
+
+    response_kwargs = get_mock_responses_kwargs(mock_client)
+    image_parts = [
+        item
+        for message in response_kwargs[0]['input']
+        if message.get('role') == 'user'
+        for item in message['content']
+        if item['type'] == 'input_image'
+    ]
+    assert image_parts
+    assert all(part['detail'] == 'high' for part in image_parts)
+
+
 async def test_openai_responses_model_simple_response_with_tool_call(allow_model_requests: None, openai_api_key: str):
     model = OpenAIResponsesModel('gpt-4o', provider=OpenAIProvider(api_key=openai_api_key))
 

{pydantic_ai-1.0.10 → pydantic_ai-1.0.11}/tests/providers/test_ollama.py

@@ -9,6 +9,7 @@ from pydantic_ai.profiles._json_schema import InlineDefsJsonSchemaTransformer
 from pydantic_ai.profiles.cohere import cohere_model_profile
 from pydantic_ai.profiles.deepseek import deepseek_model_profile
 from pydantic_ai.profiles.google import GoogleJsonSchemaTransformer, google_model_profile
+from pydantic_ai.profiles.harmony import harmony_model_profile
 from pydantic_ai.profiles.meta import meta_model_profile
 from pydantic_ai.profiles.mistral import mistral_model_profile
 from pydantic_ai.profiles.openai import OpenAIJsonSchemaTransformer
@@ -77,6 +78,7 @@ def test_ollama_provider_model_profile(mocker: MockerFixture):
     mistral_model_profile_mock = mocker.patch(f'{ns}.mistral_model_profile', wraps=mistral_model_profile)
     qwen_model_profile_mock = mocker.patch(f'{ns}.qwen_model_profile', wraps=qwen_model_profile)
     cohere_model_profile_mock = mocker.patch(f'{ns}.cohere_model_profile', wraps=cohere_model_profile)
+    harmony_model_profile_mock = mocker.patch(f'{ns}.harmony_model_profile', wraps=harmony_model_profile)
 
     meta_profile = provider.model_profile('llama3.2')
     meta_model_profile_mock.assert_called_with('llama3.2')
@@ -115,6 +117,12 @@ def test_ollama_provider_model_profile(mocker: MockerFixture):
     assert cohere_profile is not None
     assert cohere_profile.json_schema_transformer == OpenAIJsonSchemaTransformer
 
+    harmony_profile = provider.model_profile('gpt-oss')
+    harmony_model_profile_mock.assert_called_with('gpt-oss')
+    assert harmony_profile is not None
+    assert harmony_profile.json_schema_transformer == OpenAIJsonSchemaTransformer
+    assert harmony_profile.ignore_streamed_leading_whitespace is True
+
     unknown_profile = provider.model_profile('unknown-model')
     assert unknown_profile is not None
     assert unknown_profile.json_schema_transformer == OpenAIJsonSchemaTransformer

{pydantic_ai-1.0.10 → pydantic_ai-1.0.11}/tests/test_dbos.py

@@ -43,9 +43,14 @@ from pydantic_ai.usage import RequestUsage
 from .conftest import IsDatetime, IsStr
 
 try:
+    import importlib.metadata
+
     from dbos import DBOS, DBOSConfig, SetWorkflowID
+    from packaging.version import Version
 
     from pydantic_ai.durable_exec.dbos import DBOSAgent, DBOSMCPServer, DBOSModel
+
+    dbos_version = Version(importlib.metadata.version('dbos'))
 except ImportError:  # pragma: lax no cover
     pytest.skip('DBOS is not installed', allow_module_level=True)
 
@@ -110,9 +115,10 @@ def workflow_raises(exc_type: type[Exception], exc_message: str) -> Iterator[Non
 DBOS_SQLITE_FILE = 'dbostest.sqlite'
 DBOS_CONFIG: DBOSConfig = {
     'name': 'pydantic_dbos_tests',
-    'database_url': f'sqlite:///{DBOS_SQLITE_FILE}',
     'system_database_url': f'sqlite:///{DBOS_SQLITE_FILE}',
     'run_admin_server': False,
+    # enable_otlp requires dbos>1.14
+    'enable_otlp': True,
 }
 
 
@@ -1042,9 +1048,19 @@ async def test_dbos_agent_run_in_workflow_with_event_stream_handler(allow_model_
     ):
         pass
 
-    with workflow_raises(TypeError, snapshot('Serialized function should be defined at the top level of a module')):
+    with pytest.raises(Exception) as exc_info:
         await simple_dbos_agent.run('What is the capital of Mexico?', event_stream_handler=simple_event_stream_handler)
 
+    if dbos_version <= Version('1.14'):  # pragma: lax no cover
+        # Older DBOS versions used jsonpickle
+        assert str(exc_info.value) == snapshot('Serialized function should be defined at the top level of a module')
+    else:
+        # Newer DBOS versions use pickle
+        assert (
+            "local object 'test_dbos_agent_run_in_workflow_with_event_stream_handler.<locals>.simple_event_stream_handler'"
+            in str(exc_info.value)
+        )
+
 
 async def test_dbos_agent_run_in_workflow_with_model(allow_model_requests: None, dbos: DBOS):
     # A non-DBOS model is not wrapped as steps so it's not deterministic and cannot be used in a DBOS workflow.
@@ -1142,15 +1158,19 @@ async def get_model_name(ctx: RunContext[UnserializableDeps]) -> int:
 async def test_dbos_agent_with_unserializable_deps_type(allow_model_requests: None, dbos: DBOS):
     unserializable_deps_dbos_agent = DBOSAgent(unserializable_deps_agent)
     # Test this raises a serialization error because httpx.AsyncClient is not serializable.
-    with pytest.raises(
-        Exception,
-        match='object proxy must define __reduce_ex__()',
-    ):
+    with pytest.raises(Exception) as exc_info:
         async with AsyncClient() as client:
             # This will trigger the client to be unserializable
             logfire.instrument_httpx(client, capture_all=True)
             await unserializable_deps_dbos_agent.run('What is the model name?', deps=UnserializableDeps(client=client))
 
+    if dbos_version <= Version('1.14'):  # pragma: lax no cover
+        # Older DBOS versions used jsonpickle
+        assert str(exc_info.value) == snapshot('object proxy must define __reduce_ex__()')
+    else:
+        # Newer DBOS versions use pickle
+        assert str(exc_info.value) == snapshot("cannot pickle '_thread.RLock' object")
+
 
 # Test dynamic toolsets in an agent with DBOS