pydantic-ai 0.2.11__tar.gz → 0.2.12__tar.gz

{pydantic_ai-0.2.11 → pydantic_ai-0.2.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai
-Version: 0.2.11
+Version: 0.2.12
 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
@@ -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[a2a,anthropic,bedrock,cli,cohere,evals,google,groq,mcp,mistral,openai,vertexai]==0.2.11
+Requires-Dist: pydantic-ai-slim[a2a,anthropic,bedrock,cli,cohere,evals,google,groq,mcp,mistral,openai,vertexai]==0.2.12
 Provides-Extra: examples
-Requires-Dist: pydantic-ai-examples==0.2.11; extra == 'examples'
+Requires-Dist: pydantic-ai-examples==0.2.12; extra == 'examples'
 Provides-Extra: logfire
 Requires-Dist: logfire>=3.11.0; extra == 'logfire'
 Description-Content-Type: text/markdown

{pydantic_ai-0.2.11 → pydantic_ai-0.2.12}/tests/models/test_bedrock.py

@@ -31,6 +31,8 @@ from pydantic_ai.messages import (
     UserPromptPart,
     VideoUrl,
 )
+from pydantic_ai.models import ModelRequestParameters
+from pydantic_ai.tools import ToolDefinition
 from pydantic_ai.usage import Usage
 
 from ..conftest import IsDatetime, try_import
@@ -631,3 +633,96 @@ async def test_bedrock_group_consecutive_tool_return_parts(bedrock_provider: Bed
             },
         ]
     )
+
+
+async def test_bedrock_mistral_tool_result_format(bedrock_provider: BedrockProvider):
+    now = datetime.datetime.now()
+    req = [
+        ModelRequest(
+            parts=[
+                ToolReturnPart(tool_name='tool1', content={'foo': 'bar'}, tool_call_id='id1', timestamp=now),
+            ]
+        ),
+    ]
+
+    # Models other than Mistral support toolResult.content with text, not json
+    model = BedrockConverseModel('us.amazon.nova-micro-v1:0', provider=bedrock_provider)
+    # Call the mapping function directly
+    _, bedrock_messages = await model._map_messages(req)  # type: ignore[reportPrivateUsage]
+
+    assert bedrock_messages == snapshot(
+        [
+            {
+                'role': 'user',
+                'content': [
+                    {'toolResult': {'toolUseId': 'id1', 'content': [{'text': '{"foo":"bar"}'}], 'status': 'success'}},
+                ],
+            },
+        ]
+    )
+
+    # Mistral requires toolResult.content to hold json, not text
+    model = BedrockConverseModel('mistral.mistral-7b-instruct-v0:2', provider=bedrock_provider)
+    # Call the mapping function directly
+    _, bedrock_messages = await model._map_messages(req)  # type: ignore[reportPrivateUsage]
+
+    assert bedrock_messages == snapshot(
+        [
+            {
+                'role': 'user',
+                'content': [
+                    {'toolResult': {'toolUseId': 'id1', 'content': [{'json': {'foo': 'bar'}}], 'status': 'success'}},
+                ],
+            },
+        ]
+    )
+
+
+async def test_bedrock_anthropic_no_tool_choice(bedrock_provider: BedrockProvider):
+    my_tool = ToolDefinition(
+        'my_tool',
+        'This is my tool',
+        {'type': 'object', 'title': 'Result', 'properties': {'spam': {'type': 'number'}}},
+    )
+    mrp = ModelRequestParameters(function_tools=[my_tool], allow_text_output=False, output_tools=[])
+
+    # Models other than Anthropic support tool_choice
+    model = BedrockConverseModel('us.amazon.nova-micro-v1:0', provider=bedrock_provider)
+    tool_config = model._map_tool_config(mrp)  # type: ignore[reportPrivateUsage]
+
+    assert tool_config == snapshot(
+        {
+            'tools': [
+                {
+                    'toolSpec': {
+                        'name': 'my_tool',
+                        'description': 'This is my tool',
+                        'inputSchema': {
+                            'json': {'type': 'object', 'title': 'Result', 'properties': {'spam': {'type': 'number'}}}
+                        },
+                    }
+                }
+            ],
+            'toolChoice': {'any': {}},
+        }
+    )
+
+    # Anthropic models don't support tool_choice
+    model = BedrockConverseModel('us.anthropic.claude-3-7-sonnet-20250219-v1:0', provider=bedrock_provider)
+    tool_config = model._map_tool_config(mrp)  # type: ignore[reportPrivateUsage]
+
+    assert tool_config == snapshot(
+        {
+            'tools': [
+                {
+                    'toolSpec': {
+                        'name': 'my_tool',
+                        'description': 'This is my tool',
+                        'inputSchema': {
+                            'json': {'type': 'object', 'title': 'Result', 'properties': {'spam': {'type': 'number'}}}
+                        },
+                    }
+                }
+            ]
+        }
+    )

{pydantic_ai-0.2.11 → pydantic_ai-0.2.12}/tests/models/test_gemini.py

@@ -540,6 +540,7 @@ async def test_text_success(get_gemini_client: GetGeminiClient):
                 usage=Usage(requests=1, request_tokens=1, response_tokens=2, total_tokens=3, details={}),
                 model_name='gemini-1.5-flash-123',
                 timestamp=IsNow(tz=timezone.utc),
+                vendor_details={'finish_reason': 'STOP'},
             ),
         ]
     )
@@ -555,6 +556,7 @@ async def test_text_success(get_gemini_client: GetGeminiClient):
                 usage=Usage(requests=1, request_tokens=1, response_tokens=2, total_tokens=3, details={}),
                 model_name='gemini-1.5-flash-123',
                 timestamp=IsNow(tz=timezone.utc),
+                vendor_details={'finish_reason': 'STOP'},
             ),
             ModelRequest(parts=[UserPromptPart(content='Hello', timestamp=IsNow(tz=timezone.utc))]),
             ModelResponse(
@@ -562,6 +564,7 @@ async def test_text_success(get_gemini_client: GetGeminiClient):
                 usage=Usage(requests=1, request_tokens=1, response_tokens=2, total_tokens=3, details={}),
                 model_name='gemini-1.5-flash-123',
                 timestamp=IsNow(tz=timezone.utc),
+                vendor_details={'finish_reason': 'STOP'},
             ),
         ]
     )
@@ -585,6 +588,7 @@ async def test_request_structured_response(get_gemini_client: GetGeminiClient):
                 usage=Usage(requests=1, request_tokens=1, response_tokens=2, total_tokens=3, details={}),
                 model_name='gemini-1.5-flash-123',
                 timestamp=IsNow(tz=timezone.utc),
+                vendor_details={'finish_reason': 'STOP'},
             ),
             ModelRequest(
                 parts=[
@@ -647,6 +651,7 @@ async def test_request_tool_call(get_gemini_client: GetGeminiClient):
                 usage=Usage(requests=1, request_tokens=1, response_tokens=2, total_tokens=3, details={}),
                 model_name='gemini-1.5-flash-123',
                 timestamp=IsNow(tz=timezone.utc),
+                vendor_details={'finish_reason': 'STOP'},
             ),
             ModelRequest(
                 parts=[
@@ -666,6 +671,7 @@ async def test_request_tool_call(get_gemini_client: GetGeminiClient):
                 usage=Usage(requests=1, request_tokens=1, response_tokens=2, total_tokens=3, details={}),
                 model_name='gemini-1.5-flash-123',
                 timestamp=IsNow(tz=timezone.utc),
+                vendor_details={'finish_reason': 'STOP'},
             ),
             ModelRequest(
                 parts=[
@@ -688,6 +694,7 @@ async def test_request_tool_call(get_gemini_client: GetGeminiClient):
                 usage=Usage(requests=1, request_tokens=1, response_tokens=2, total_tokens=3, details={}),
                 model_name='gemini-1.5-flash-123',
                 timestamp=IsNow(tz=timezone.utc),
+                vendor_details={'finish_reason': 'STOP'},
             ),
         ]
     )
@@ -732,12 +739,12 @@ async def test_stream_text(get_gemini_client: GetGeminiClient):
                 'Hello world',
             ]
         )
-    assert result.usage() == snapshot(Usage(requests=1, request_tokens=2, response_tokens=4, total_tokens=6))
+    assert result.usage() == snapshot(Usage(requests=1, request_tokens=1, response_tokens=2, total_tokens=3))
 
     async with agent.run_stream('Hello') as result:
         chunks = [chunk async for chunk in result.stream_text(delta=True, debounce_by=None)]
         assert chunks == snapshot(['Hello ', 'world'])
-    assert result.usage() == snapshot(Usage(requests=1, request_tokens=2, response_tokens=4, total_tokens=6))
+    assert result.usage() == snapshot(Usage(requests=1, request_tokens=1, response_tokens=2, total_tokens=3))
 
 
 async def test_stream_invalid_unicode_text(get_gemini_client: GetGeminiClient):
@@ -769,7 +776,7 @@ async def test_stream_invalid_unicode_text(get_gemini_client: GetGeminiClient):
     async with agent.run_stream('Hello') as result:
         chunks = [chunk async for chunk in result.stream(debounce_by=None)]
         assert chunks == snapshot(['abc', 'abc€def', 'abc€def'])
-    assert result.usage() == snapshot(Usage(requests=1, request_tokens=2, response_tokens=4, total_tokens=6))
+    assert result.usage() == snapshot(Usage(requests=1, request_tokens=1, response_tokens=2, total_tokens=3))
 
 
 async def test_stream_text_no_data(get_gemini_client: GetGeminiClient):
@@ -840,7 +847,7 @@ async def test_stream_structured_tool_calls(get_gemini_client: GetGeminiClient):
     async with agent.run_stream('Hello') as result:
         response = await result.get_output()
         assert response == snapshot((1, 2))
-    assert result.usage() == snapshot(Usage(requests=2, request_tokens=3, response_tokens=6, total_tokens=9))
+    assert result.usage() == snapshot(Usage(requests=2, request_tokens=2, response_tokens=4, total_tokens=6))
     assert result.all_messages() == snapshot(
         [
             ModelRequest(parts=[UserPromptPart(content='Hello', timestamp=IsNow(tz=timezone.utc))]),
@@ -849,7 +856,7 @@ async def test_stream_structured_tool_calls(get_gemini_client: GetGeminiClient):
                     ToolCallPart(tool_name='foo', args={'x': 'a'}, tool_call_id=IsStr()),
                     ToolCallPart(tool_name='bar', args={'y': 'b'}, tool_call_id=IsStr()),
                 ],
-                usage=Usage(request_tokens=2, response_tokens=4, total_tokens=6),
+                usage=Usage(request_tokens=1, response_tokens=2, total_tokens=3, details={}),
                 model_name='gemini-1.5-flash',
                 timestamp=IsNow(tz=timezone.utc),
             ),
@@ -865,7 +872,7 @@ async def test_stream_structured_tool_calls(get_gemini_client: GetGeminiClient):
             ),
             ModelResponse(
                 parts=[ToolCallPart(tool_name='final_result', args={'response': [1, 2]}, tool_call_id=IsStr())],
-                usage=Usage(request_tokens=1, response_tokens=2, total_tokens=3),
+                usage=Usage(request_tokens=1, response_tokens=2, total_tokens=3, details={}),
                 model_name='gemini-1.5-flash',
                 timestamp=IsNow(tz=timezone.utc),
             ),
@@ -1096,9 +1103,16 @@ I need to use the `get_image` tool to see the image first.
                     ),
                     ToolCallPart(tool_name='get_image', args={}, tool_call_id=IsStr()),
                 ],
-                usage=Usage(requests=1, request_tokens=38, response_tokens=28, total_tokens=427, details={}),
+                usage=Usage(
+                    requests=1,
+                    request_tokens=38,
+                    response_tokens=28,
+                    total_tokens=427,
+                    details={'thoughts_tokens': 361, 'text_prompt_tokens': 38},
+                ),
                 model_name='gemini-2.5-pro-preview-03-25',
                 timestamp=IsDatetime(),
+                vendor_details={'finish_reason': 'STOP'},
             ),
             ModelRequest(
                 parts=[
@@ -1119,9 +1133,16 @@ I need to use the `get_image` tool to see the image first.
             ),
             ModelResponse(
                 parts=[TextPart(content='The image shows a kiwi fruit, sliced in half.')],
-                usage=Usage(requests=1, request_tokens=360, response_tokens=11, total_tokens=572, details={}),
+                usage=Usage(
+                    requests=1,
+                    request_tokens=360,
+                    response_tokens=11,
+                    total_tokens=572,
+                    details={'thoughts_tokens': 201, 'text_prompt_tokens': 102, 'image_prompt_tokens': 258},
+                ),
                 model_name='gemini-2.5-pro-preview-03-25',
                 timestamp=IsDatetime(),
+                vendor_details={'finish_reason': 'STOP'},
             ),
         ]
     )
@@ -1241,9 +1262,16 @@ async def test_gemini_model_instructions(allow_model_requests: None, gemini_api_
             ),
             ModelResponse(
                 parts=[TextPart(content='The capital of France is Paris.\n')],
-                usage=Usage(requests=1, request_tokens=13, response_tokens=8, total_tokens=21, details={}),
+                usage=Usage(
+                    requests=1,
+                    request_tokens=13,
+                    response_tokens=8,
+                    total_tokens=21,
+                    details={'text_prompt_tokens': 13, 'text_candidates_tokens': 8},
+                ),
                 model_name='gemini-1.5-flash',
                 timestamp=IsDatetime(),
+                vendor_details={'finish_reason': 'STOP'},
             ),
         ]
     )
@@ -1284,3 +1312,18 @@ async def test_gemini_additional_properties_is_true(allow_model_requests: None,
         assert result.output == snapshot(
             'I need a location dictionary to use the `get_temperature` function.  I cannot provide the temperature in Tokyo without more information.\n'
         )
+
+
+async def test_gemini_no_finish_reason(get_gemini_client: GetGeminiClient):
+    response = gemini_response(
+        _content_model_response(ModelResponse(parts=[TextPart('Hello world')])), finish_reason=None
+    )
+    gemini_client = get_gemini_client(response)
+    m = GeminiModel('gemini-1.5-flash', provider=GoogleGLAProvider(http_client=gemini_client))
+    agent = Agent(m)
+
+    result = await agent.run('Hello World')
+
+    for message in result.all_messages():
+        if isinstance(message, ModelResponse):
+            assert message.vendor_details is None

{pydantic_ai-0.2.11 → pydantic_ai-0.2.12}/tests/models/test_google.py

@@ -65,7 +65,15 @@ async def test_google_model(allow_model_requests: None, google_provider: GoogleP
 
     result = await agent.run('Hello!')
     assert result.output == snapshot('Hello there! How can I help you today?\n')
-    assert result.usage() == snapshot(Usage(requests=1, request_tokens=7, response_tokens=11, total_tokens=18))
+    assert result.usage() == snapshot(
+        Usage(
+            requests=1,
+            request_tokens=7,
+            response_tokens=11,
+            total_tokens=18,
+            details={'text_prompt_tokens': 7, 'text_candidates_tokens': 11},
+        )
+    )
     assert result.all_messages() == snapshot(
         [
             ModelRequest(
@@ -82,9 +90,16 @@ async def test_google_model(allow_model_requests: None, google_provider: GoogleP
             ),
             ModelResponse(
                 parts=[TextPart(content='Hello there! How can I help you today?\n')],
-                usage=Usage(requests=1, request_tokens=7, response_tokens=11, total_tokens=18, details={}),
+                usage=Usage(
+                    requests=1,
+                    request_tokens=7,
+                    response_tokens=11,
+                    total_tokens=18,
+                    details={'text_prompt_tokens': 7, 'text_candidates_tokens': 11},
+                ),
                 model_name='gemini-1.5-flash',
                 timestamp=IsDatetime(),
+                vendor_details={'finish_reason': 'STOP'},
             ),
         ]
     )
@@ -114,7 +129,15 @@ async def test_google_model_structured_response(allow_model_requests: None, goog
 
     result = await agent.run('What was the temperature in London 1st January 2022?', output_type=Response)
     assert result.output == snapshot({'temperature': '30°C', 'date': datetime.date(2022, 1, 1), 'city': 'London'})
-    assert result.usage() == snapshot(Usage(requests=2, request_tokens=224, response_tokens=35, total_tokens=259))
+    assert result.usage() == snapshot(
+        Usage(
+            requests=2,
+            request_tokens=224,
+            response_tokens=35,
+            total_tokens=259,
+            details={'text_prompt_tokens': 224, 'text_candidates_tokens': 35},
+        )
+    )
     assert result.all_messages() == snapshot(
         [
             ModelRequest(
@@ -135,9 +158,16 @@ async def test_google_model_structured_response(allow_model_requests: None, goog
                         tool_name='temperature', args={'date': '2022-01-01', 'city': 'London'}, tool_call_id=IsStr()
                     )
                 ],
-                usage=Usage(requests=1, request_tokens=101, response_tokens=14, total_tokens=115, details={}),
+                usage=Usage(
+                    requests=1,
+                    request_tokens=101,
+                    response_tokens=14,
+                    total_tokens=115,
+                    details={'text_prompt_tokens': 101, 'text_candidates_tokens': 14},
+                ),
                 model_name='gemini-1.5-flash',
                 timestamp=IsDatetime(),
+                vendor_details={'finish_reason': 'STOP'},
             ),
             ModelRequest(
                 parts=[
@@ -154,9 +184,16 @@ async def test_google_model_structured_response(allow_model_requests: None, goog
                         tool_call_id=IsStr(),
                     )
                 ],
-                usage=Usage(requests=1, request_tokens=123, response_tokens=21, total_tokens=144, details={}),
+                usage=Usage(
+                    requests=1,
+                    request_tokens=123,
+                    response_tokens=21,
+                    total_tokens=144,
+                    details={'text_prompt_tokens': 123, 'text_candidates_tokens': 21},
+                ),
                 model_name='gemini-1.5-flash',
                 timestamp=IsDatetime(),
+                vendor_details={'finish_reason': 'STOP'},
             ),
             ModelRequest(
                 parts=[
@@ -211,10 +248,11 @@ async def test_google_model_retry(allow_model_requests: None, google_provider: G
                     request_tokens=57,
                     response_tokens=15,
                     total_tokens=173,
-                    details={'thoughts_token_count': 101},
+                    details={'thoughts_tokens': 101, 'text_prompt_tokens': 57},
                 ),
                 model_name='models/gemini-2.5-pro-preview-05-06',
                 timestamp=IsDatetime(),
+                vendor_details={'finish_reason': 'STOP'},
             ),
             ModelRequest(
                 parts=[
@@ -232,9 +270,16 @@ async def test_google_model_retry(allow_model_requests: None, google_provider: G
                         content='I am sorry, I cannot fulfill this request. The country you provided is not supported.'
                     )
                 ],
-                usage=Usage(requests=1, request_tokens=104, response_tokens=18, total_tokens=122, details={}),
+                usage=Usage(
+                    requests=1,
+                    request_tokens=104,
+                    response_tokens=18,
+                    total_tokens=122,
+                    details={'text_prompt_tokens': 104},
+                ),
                 model_name='models/gemini-2.5-pro-preview-05-06',
                 timestamp=IsDatetime(),
+                vendor_details={'finish_reason': 'STOP'},
             ),
         ]
     )
@@ -488,9 +533,16 @@ async def test_google_model_instructions(allow_model_requests: None, google_prov
             ),
             ModelResponse(
                 parts=[TextPart(content='The capital of France is Paris.\n')],
-                usage=Usage(requests=1, request_tokens=13, response_tokens=8, total_tokens=21, details={}),
+                usage=Usage(
+                    requests=1,
+                    request_tokens=13,
+                    response_tokens=8,
+                    total_tokens=21,
+                    details={'text_prompt_tokens': 13, 'text_candidates_tokens': 8},
+                ),
                 model_name='gemini-2.0-flash',
                 timestamp=IsDatetime(),
+                vendor_details={'finish_reason': 'STOP'},
             ),
         ]
     )

{pydantic_ai-0.2.11 → pydantic_ai-0.2.12}/tests/models/test_openai.py

@@ -30,9 +30,13 @@ from pydantic_ai.messages import (
     UserPromptPart,
 )
 from pydantic_ai.models.gemini import GeminiModel
+from pydantic_ai.profiles import ModelProfile
+from pydantic_ai.profiles._json_schema import InlineDefsJsonSchemaTransformer
+from pydantic_ai.profiles.openai import OpenAIModelProfile, openai_model_profile
 from pydantic_ai.providers.google_gla import GoogleGLAProvider
 from pydantic_ai.result import Usage
 from pydantic_ai.settings import ModelSettings
+from pydantic_ai.tools import ToolDefinition
 
 from ..conftest import IsDatetime, IsNow, IsStr, raise_if_exception, try_import
 from .mock_async_stream import MockAsyncStream
@@ -56,8 +60,8 @@ with try_import() as imports_successful:
         OpenAIModel,
         OpenAIModelSettings,
         OpenAISystemPromptRole,
-        _OpenAIJsonSchema,  # pyright: ignore[reportPrivateUsage]
     )
+    from pydantic_ai.profiles.openai import OpenAIJsonSchemaTransformer
     from pydantic_ai.providers.openai import OpenAIProvider
 
     # note: we use Union here so that casting works with Python 3.9
@@ -1356,23 +1360,33 @@ async def test_strict_mode_cannot_infer_strict(
     # Create a mock completion for testing
     c = completion_message(ChatCompletionMessage(content='world', role='assistant'))
 
-    # Test 1: Default behavior (strict setting not explicitly specified; function is strict-mode-compatible)
-    mock_client = MockOpenAI.create_mock(c)
-    m = OpenAIModel('gpt-4o', provider=OpenAIProvider(openai_client=mock_client))
-    agent = Agent(m)
+    async def assert_strict(expected_strict: bool | None, profile: ModelProfile | None = None):
+        mock_client = MockOpenAI.create_mock(c)
+        m = OpenAIModel('gpt-4o', provider=OpenAIProvider(openai_client=mock_client), profile=profile)
+        agent = Agent(m)
 
-    agent.tool_plain(strict=tool_strict)(tool)
+        agent.tool_plain(strict=tool_strict)(tool)
 
-    await agent.run('hello')
-    kwargs = get_mock_chat_completion_kwargs(mock_client)[0]
-    assert 'tools' in kwargs, kwargs
+        await agent.run('hello')
+        kwargs = get_mock_chat_completion_kwargs(mock_client)[0]
+        assert 'tools' in kwargs, kwargs
+
+        assert kwargs['tools'][0]['function']['parameters'] == expected_params
+        actual_strict = kwargs['tools'][0]['function'].get('strict')
+        assert actual_strict == expected_strict
+        if actual_strict is None:
+            # If strict is included, it should be non-None
+            assert 'strict' not in kwargs['tools'][0]['function']
+
+    await assert_strict(expected_strict)
 
-    assert kwargs['tools'][0]['function']['parameters'] == expected_params
-    actual_strict = kwargs['tools'][0]['function'].get('strict')
-    assert actual_strict == expected_strict
-    if actual_strict is None:
-        # If strict is included, it should be non-None
-        assert 'strict' not in kwargs['tools'][0]['function']
+    # If the model profile says strict is not supported, we never pass strict
+    await assert_strict(
+        None,
+        profile=OpenAIModelProfile(openai_supports_strict_tool_definition=False).update(
+            openai_model_profile('test-model')
+        ),
+    )
 
 
 def test_strict_schema():
@@ -1390,7 +1404,7 @@ def test_strict_schema():
         my_list: list[float]
         my_discriminated_union: Annotated[Apple | Banana, Discriminator('kind')]
 
-    assert _OpenAIJsonSchema(MyModel.model_json_schema(), strict=True).walk() == snapshot(
+    assert OpenAIJsonSchemaTransformer(MyModel.model_json_schema(), strict=True).walk() == snapshot(
         {
             '$defs': {
                 'Apple': {
@@ -1601,3 +1615,98 @@ async def test_openai_instructions_with_logprobs(allow_model_requests: None):
             'top_logprobs': [],
         }
     ]
+
+
+def test_openai_model_profile():
+    m = OpenAIModel('gpt-4o', provider=OpenAIProvider(api_key='foobar'))
+    assert isinstance(m.profile, OpenAIModelProfile)
+
+
+def test_openai_model_profile_custom():
+    m = OpenAIModel(
+        'gpt-4o',
+        provider=OpenAIProvider(api_key='foobar'),
+        profile=ModelProfile(json_schema_transformer=InlineDefsJsonSchemaTransformer),
+    )
+    assert isinstance(m.profile, ModelProfile)
+    assert m.profile.json_schema_transformer is InlineDefsJsonSchemaTransformer
+
+    m = OpenAIModel(
+        'gpt-4o',
+        provider=OpenAIProvider(api_key='foobar'),
+        profile=OpenAIModelProfile(openai_supports_strict_tool_definition=False),
+    )
+    assert isinstance(m.profile, OpenAIModelProfile)
+    assert m.profile.openai_supports_strict_tool_definition is False
+
+
+def test_openai_model_profile_function():
+    def model_profile(model_name: str) -> ModelProfile:
+        return ModelProfile(json_schema_transformer=InlineDefsJsonSchemaTransformer if model_name == 'gpt-4o' else None)
+
+    m = OpenAIModel('gpt-4o', provider=OpenAIProvider(api_key='foobar'), profile=model_profile)
+    assert isinstance(m.profile, ModelProfile)
+    assert m.profile.json_schema_transformer is InlineDefsJsonSchemaTransformer
+
+    m = OpenAIModel('gpt-4o-mini', provider=OpenAIProvider(api_key='foobar'), profile=model_profile)
+    assert isinstance(m.profile, ModelProfile)
+    assert m.profile.json_schema_transformer is None
+
+
+def test_openai_model_profile_from_provider():
+    class CustomProvider(OpenAIProvider):
+        def model_profile(self, model_name: str) -> ModelProfile:
+            return ModelProfile(
+                json_schema_transformer=InlineDefsJsonSchemaTransformer if model_name == 'gpt-4o' else None
+            )
+
+    m = OpenAIModel('gpt-4o', provider=CustomProvider(api_key='foobar'))
+    assert isinstance(m.profile, ModelProfile)
+    assert m.profile.json_schema_transformer is InlineDefsJsonSchemaTransformer
+
+    m = OpenAIModel('gpt-4o-mini', provider=CustomProvider(api_key='foobar'))
+    assert isinstance(m.profile, ModelProfile)
+    assert m.profile.json_schema_transformer is None
+
+
+def test_model_profile_strict_not_supported():
+    my_tool = ToolDefinition(
+        'my_tool',
+        'This is my tool',
+        {'type': 'object', 'title': 'Result', 'properties': {'spam': {'type': 'number'}}},
+        strict=True,
+    )
+
+    m = OpenAIModel('gpt-4o', provider=OpenAIProvider(api_key='foobar'))
+    tool_param = m._map_tool_definition(my_tool)  # type: ignore[reportPrivateUsage]
+
+    assert tool_param == snapshot(
+        {
+            'type': 'function',
+            'function': {
+                'name': 'my_tool',
+                'description': 'This is my tool',
+                'parameters': {'type': 'object', 'title': 'Result', 'properties': {'spam': {'type': 'number'}}},
+                'strict': True,
+            },
+        }
+    )
+
+    # Some models don't support strict tool definitions
+    m = OpenAIModel(
+        'gpt-4o',
+        provider=OpenAIProvider(api_key='foobar'),
+        profile=OpenAIModelProfile(openai_supports_strict_tool_definition=False).update(openai_model_profile('gpt-4o')),
+    )
+    tool_param = m._map_tool_definition(my_tool)  # type: ignore[reportPrivateUsage]
+
+    assert tool_param == snapshot(
+        {
+            'type': 'function',
+            'function': {
+                'name': 'my_tool',
+                'description': 'This is my tool',
+                'parameters': {'type': 'object', 'title': 'Result', 'properties': {'spam': {'type': 'number'}}},
+            },
+        }
+    )

{pydantic_ai-0.2.11 → pydantic_ai-0.2.12}/tests/models/test_openai_responses.py

@@ -1,4 +1,5 @@
 import json
+from dataclasses import replace
 
 import pytest
 from inline_snapshot import snapshot
@@ -18,6 +19,8 @@ from pydantic_ai.messages import (
     ToolReturnPart,
     UserPromptPart,
 )
+from pydantic_ai.profiles.openai import openai_model_profile
+from pydantic_ai.tools import ToolDefinition
 from pydantic_ai.usage import Usage
 
 from ..conftest import IsDatetime, IsStr, TestEnv, try_import
@@ -462,3 +465,43 @@ async def test_openai_responses_model_instructions(allow_model_requests: None, o
             ),
         ]
     )
+
+
+def test_model_profile_strict_not_supported():
+    my_tool = ToolDefinition(
+        'my_tool',
+        'This is my tool',
+        {'type': 'object', 'title': 'Result', 'properties': {'spam': {'type': 'number'}}},
+        strict=True,
+    )
+
+    m = OpenAIResponsesModel('gpt-4o', provider=OpenAIProvider(api_key='foobar'))
+    tool_param = m._map_tool_definition(my_tool)  # type: ignore[reportPrivateUsage]
+
+    assert tool_param == snapshot(
+        {
+            'name': 'my_tool',
+            'parameters': {'type': 'object', 'title': 'Result', 'properties': {'spam': {'type': 'number'}}},
+            'type': 'function',
+            'description': 'This is my tool',
+            'strict': True,
+        }
+    )
+
+    # Some models don't support strict tool definitions
+    m = OpenAIResponsesModel(
+        'gpt-4o',
+        provider=OpenAIProvider(api_key='foobar'),
+        profile=replace(openai_model_profile('gpt-4o'), openai_supports_strict_tool_definition=False),
+    )
+    tool_param = m._map_tool_definition(my_tool)  # type: ignore[reportPrivateUsage]
+
+    assert tool_param == snapshot(
+        {
+            'name': 'my_tool',
+            'parameters': {'type': 'object', 'title': 'Result', 'properties': {'spam': {'type': 'number'}}},
+            'type': 'function',
+            'description': 'This is my tool',
+            'strict': False,
+        }
+    )