pydantic-ai 0.0.21__tar.gz → 0.0.23__tar.gz

{pydantic_ai-0.0.21 → pydantic_ai-0.0.23}/.gitignore

@@ -3,7 +3,8 @@ site
 .venv
 dist
 __pycache__
-*.env
+.env
+.dev.vars
 /scratch/
 /.coverage
 env*/
@@ -14,3 +15,4 @@ examples/pydantic_ai_examples/.chat_app_messages.sqlite
 .cache/
 .vscode/
 /question_graph_history.json
+/docs-site/.wrangler/

{pydantic_ai-0.0.21 → pydantic_ai-0.0.23}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai
-Version: 0.0.21
+Version: 0.0.23
 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
@@ -32,9 +32,9 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Internet
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.9
-Requires-Dist: pydantic-ai-slim[anthropic,cohere,graph,groq,mistral,openai,vertexai]==0.0.21
+Requires-Dist: pydantic-ai-slim[anthropic,cohere,groq,mistral,openai,vertexai]==0.0.23
 Provides-Extra: examples
-Requires-Dist: pydantic-ai-examples==0.0.21; extra == 'examples'
+Requires-Dist: pydantic-ai-examples==0.0.23; extra == 'examples'
 Provides-Extra: logfire
 Requires-Dist: logfire>=2.3; extra == 'logfire'
 Description-Content-Type: text/markdown

{pydantic_ai-0.0.21 → pydantic_ai-0.0.23}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "pydantic-ai"
-version = "0.0.21"
+version = "0.0.23"
 description = "Agent Framework / shim to use Pydantic with LLMs"
 authors = [
     { name = "Samuel Colvin", email = "samuel@pydantic.dev" },
@@ -37,7 +37,7 @@ classifiers = [
 ]
 requires-python = ">=3.9"
 
-dependencies = ["pydantic-ai-slim[graph,openai,vertexai,groq,anthropic,mistral,cohere]==0.0.21"]
+dependencies = ["pydantic-ai-slim[openai,vertexai,groq,anthropic,mistral,cohere]==0.0.23"]
 
 [project.urls]
 Homepage = "https://ai.pydantic.dev"
@@ -46,7 +46,7 @@ Documentation = "https://ai.pydantic.dev"
 Changelog = "https://github.com/pydantic/pydantic-ai/releases"
 
 [project.optional-dependencies]
-examples = ["pydantic-ai-examples==0.0.21"]
+examples = ["pydantic-ai-examples==0.0.23"]
 logfire = ["logfire>=2.3"]
 
 [tool.uv.sources]
@@ -65,7 +65,6 @@ lint = [
     "ruff>=0.6.9",
 ]
 docs = [
-    "algoliasearch>=4.12.0",
     "black>=24.10.0",
     "bs4>=0.0.2",
     "markdownify>=0.14.1",
@@ -74,6 +73,10 @@ docs = [
     "mkdocs-material[imaging]>=9.5.45",
     "mkdocstrings-python>=1.12.2",
 ]
+docs-upload = [
+    "algoliasearch>=4.12.0",
+    "pydantic>=2.10.1",
+]
 
 [tool.hatch.build.targets.wheel]
 only-include = ["/README.md"]

{pydantic_ai-0.0.21 → pydantic_ai-0.0.23}/tests/models/test_anthropic.py

@@ -60,7 +60,8 @@ T = TypeVar('T')
 def test_init():
     m = AnthropicModel('claude-3-5-haiku-latest', api_key='foobar')
     assert m.client.api_key == 'foobar'
-    assert m.name() == 'anthropic:claude-3-5-haiku-latest'
+    assert m.model_name == 'claude-3-5-haiku-latest'
+    assert m.system == 'anthropic'
 
 
 @dataclass

{pydantic_ai-0.0.21 → pydantic_ai-0.0.23}/tests/models/test_cohere.py

@@ -44,7 +44,8 @@ pytestmark = [
 
 def test_init():
     m = CohereModel('command-r7b-12-2024', api_key='foobar')
-    assert m.name() == 'cohere:command-r7b-12-2024'
+    assert m.model_name == 'command-r7b-12-2024'
+    assert m.system == 'cohere'
 
 
 @dataclass

{pydantic_ai-0.0.21 → pydantic_ai-0.0.23}/tests/models/test_gemini.py

@@ -24,9 +24,11 @@ from pydantic_ai.messages import (
     ToolReturnPart,
     UserPromptPart,
 )
+from pydantic_ai.models import ModelRequestParameters
 from pydantic_ai.models.gemini import (
     ApiKeyAuth,
     GeminiModel,
+    GeminiModelSettings,
     _content_model_response,
     _function_call_part_from_call,
     _gemini_response_ta,
@@ -36,6 +38,7 @@ from pydantic_ai.models.gemini import (
     _GeminiFunction,
     _GeminiFunctionCallingConfig,
     _GeminiResponse,
+    _GeminiSafetyRating,
     _GeminiTextPart,
     _GeminiToolConfig,
     _GeminiTools,
@@ -75,18 +78,21 @@ def test_api_key_empty(env: TestEnv):
         GeminiModel('gemini-1.5-flash')
 
 
-async def test_agent_model_simple(allow_model_requests: None):
+async def test_model_simple(allow_model_requests: None):
     m = GeminiModel('gemini-1.5-flash', api_key='via-arg')
-    agent_model = await m.agent_model(function_tools=[], allow_text_result=True, result_tools=[])
-    assert isinstance(agent_model.http_client, httpx.AsyncClient)
-    assert agent_model.model_name == 'gemini-1.5-flash'
-    assert isinstance(agent_model.auth, ApiKeyAuth)
-    assert agent_model.auth.api_key == 'via-arg'
-    assert agent_model.tools is None
-    assert agent_model.tool_config is None
+    assert isinstance(m.http_client, httpx.AsyncClient)
+    assert m.model_name == 'gemini-1.5-flash'
+    assert isinstance(m.auth, ApiKeyAuth)
+    assert m.auth.api_key == 'via-arg'
 
+    arc = ModelRequestParameters(function_tools=[], allow_text_result=True, result_tools=[])
+    tools = m._get_tools(arc)
+    tool_config = m._get_tool_config(arc, tools)
+    assert tools is None
+    assert tool_config is None
 
-async def test_agent_model_tools(allow_model_requests: None):
+
+async def test_model_tools(allow_model_requests: None):
     m = GeminiModel('gemini-1.5-flash', api_key='via-arg')
     tools = [
         ToolDefinition(
@@ -110,8 +116,11 @@ async def test_agent_model_tools(allow_model_requests: None):
         'This is the tool for the final Result',
         {'type': 'object', 'title': 'Result', 'properties': {'spam': {'type': 'number'}}, 'required': ['spam']},
     )
-    agent_model = await m.agent_model(function_tools=tools, allow_text_result=True, result_tools=[result_tool])
-    assert agent_model.tools == snapshot(
+
+    arc = ModelRequestParameters(function_tools=tools, allow_text_result=True, result_tools=[result_tool])
+    tools = m._get_tools(arc)
+    tool_config = m._get_tool_config(arc, tools)
+    assert tools == snapshot(
         _GeminiTools(
             function_declarations=[
                 _GeminiFunction(
@@ -139,7 +148,7 @@ async def test_agent_model_tools(allow_model_requests: None):
             ]
         )
     )
-    assert agent_model.tool_config is None
+    assert tool_config is None
 
 
 async def test_require_response_tool(allow_model_requests: None):
@@ -149,8 +158,10 @@ async def test_require_response_tool(allow_model_requests: None):
         'This is the tool for the final Result',
         {'type': 'object', 'title': 'Result', 'properties': {'spam': {'type': 'number'}}},
     )
-    agent_model = await m.agent_model(function_tools=[], allow_text_result=False, result_tools=[result_tool])
-    assert agent_model.tools == snapshot(
+    arc = ModelRequestParameters(function_tools=[], allow_text_result=False, result_tools=[result_tool])
+    tools = m._get_tools(arc)
+    tool_config = m._get_tool_config(arc, tools)
+    assert tools == snapshot(
         _GeminiTools(
             function_declarations=[
                 _GeminiFunction(
@@ -164,7 +175,7 @@ async def test_require_response_tool(allow_model_requests: None):
             ]
         )
     )
-    assert agent_model.tool_config == snapshot(
+    assert tool_config == snapshot(
         _GeminiToolConfig(
             function_calling_config=_GeminiFunctionCallingConfig(mode='ANY', allowed_function_names=['result'])
         )
@@ -206,8 +217,9 @@ async def test_json_def_replaced(allow_model_requests: None):
         'This is the tool for the final Result',
         json_schema,
     )
-    agent_model = await m.agent_model(function_tools=[], allow_text_result=True, result_tools=[result_tool])
-    assert agent_model.tools == snapshot(
+    assert m._get_tools(
+        ModelRequestParameters(function_tools=[], allow_text_result=True, result_tools=[result_tool])
+    ) == snapshot(
         _GeminiTools(
             function_declarations=[
                 _GeminiFunction(
@@ -252,8 +264,9 @@ async def test_json_def_replaced_any_of(allow_model_requests: None):
         'This is the tool for the final Result',
         json_schema,
     )
-    agent_model = await m.agent_model(function_tools=[], allow_text_result=True, result_tools=[result_tool])
-    assert agent_model.tools == snapshot(
+    assert m._get_tools(
+        ModelRequestParameters(function_tools=[], allow_text_result=True, result_tools=[result_tool])
+    ) == snapshot(
         _GeminiTools(
             function_declarations=[
                 _GeminiFunction(
@@ -315,7 +328,7 @@ async def test_json_def_recursive(allow_model_requests: None):
         json_schema,
     )
     with pytest.raises(UserError, match=r'Recursive `\$ref`s in JSON Schema are not supported by Gemini'):
-        await m.agent_model(function_tools=[], allow_text_result=True, result_tools=[result_tool])
+        m._get_tools(ModelRequestParameters(function_tools=[], allow_text_result=True, result_tools=[result_tool]))
 
 
 async def test_json_def_date(allow_model_requests: None):
@@ -346,8 +359,9 @@ async def test_json_def_date(allow_model_requests: None):
         'This is the tool for the final Result',
         json_schema,
     )
-    agent_model = await m.agent_model(function_tools=[], allow_text_result=True, result_tools=[result_tool])
-    assert agent_model.tools == snapshot(
+    assert m._get_tools(
+        ModelRequestParameters(function_tools=[], allow_text_result=True, result_tools=[result_tool])
+    ) == snapshot(
         _GeminiTools(
             function_declarations=[
                 _GeminiFunction(
@@ -853,3 +867,90 @@ async def test_model_settings(client_with_handler: ClientWithHandler, env: TestE
         },
     )
     assert result.data == 'world'
+
+
+def gemini_no_content_response(
+    safety_ratings: list[_GeminiSafetyRating], finish_reason: Literal['SAFETY'] | None = 'SAFETY'
+) -> _GeminiResponse:
+    candidate = _GeminiCandidates(safety_ratings=safety_ratings)
+    if finish_reason:
+        candidate['finish_reason'] = finish_reason
+    return _GeminiResponse(candidates=[candidate], usage_metadata=example_usage())
+
+
+async def test_safety_settings_unsafe(
+    client_with_handler: ClientWithHandler, env: TestEnv, allow_model_requests: None
+) -> None:
+    try:
+
+        def handler(request: httpx.Request) -> httpx.Response:
+            safety_settings = json.loads(request.content)['safety_settings']
+            assert safety_settings == [
+                {'category': 'HARM_CATEGORY_CIVIC_INTEGRITY', 'threshold': 'BLOCK_LOW_AND_ABOVE'},
+                {'category': 'HARM_CATEGORY_DANGEROUS_CONTENT', 'threshold': 'BLOCK_LOW_AND_ABOVE'},
+            ]
+
+            return httpx.Response(
+                200,
+                content=_gemini_response_ta.dump_json(
+                    gemini_no_content_response(
+                        finish_reason='SAFETY',
+                        safety_ratings=[
+                            {'category': 'HARM_CATEGORY_HARASSMENT', 'probability': 'MEDIUM', 'blocked': True}
+                        ],
+                    ),
+                    by_alias=True,
+                ),
+                headers={'Content-Type': 'application/json'},
+            )
+
+        gemini_client = client_with_handler(handler)
+        m = GeminiModel('gemini-1.5-flash', http_client=gemini_client, api_key='mock')
+        agent = Agent(m)
+
+        await agent.run(
+            'a request for something rude',
+            model_settings=GeminiModelSettings(
+                gemini_safety_settings=[
+                    {'category': 'HARM_CATEGORY_CIVIC_INTEGRITY', 'threshold': 'BLOCK_LOW_AND_ABOVE'},
+                    {'category': 'HARM_CATEGORY_DANGEROUS_CONTENT', 'threshold': 'BLOCK_LOW_AND_ABOVE'},
+                ]
+            ),
+        )
+    except UnexpectedModelBehavior as e:
+        assert repr(e) == "UnexpectedModelBehavior('Safety settings triggered')"
+
+
+async def test_safety_settings_safe(
+    client_with_handler: ClientWithHandler, env: TestEnv, allow_model_requests: None
+) -> None:
+    def handler(request: httpx.Request) -> httpx.Response:
+        safety_settings = json.loads(request.content)['safety_settings']
+        assert safety_settings == [
+            {'category': 'HARM_CATEGORY_CIVIC_INTEGRITY', 'threshold': 'BLOCK_LOW_AND_ABOVE'},
+            {'category': 'HARM_CATEGORY_DANGEROUS_CONTENT', 'threshold': 'BLOCK_LOW_AND_ABOVE'},
+        ]
+
+        return httpx.Response(
+            200,
+            content=_gemini_response_ta.dump_json(
+                gemini_response(_content_model_response(ModelResponse(parts=[TextPart('world')]))),
+                by_alias=True,
+            ),
+            headers={'Content-Type': 'application/json'},
+        )
+
+    gemini_client = client_with_handler(handler)
+    m = GeminiModel('gemini-1.5-flash', http_client=gemini_client, api_key='mock')
+    agent = Agent(m)
+
+    result = await agent.run(
+        'hello',
+        model_settings=GeminiModelSettings(
+            gemini_safety_settings=[
+                {'category': 'HARM_CATEGORY_CIVIC_INTEGRITY', 'threshold': 'BLOCK_LOW_AND_ABOVE'},
+                {'category': 'HARM_CATEGORY_DANGEROUS_CONTENT', 'threshold': 'BLOCK_LOW_AND_ABOVE'},
+            ]
+        ),
+    )
+    assert result.data == 'world'

{pydantic_ai-0.0.21 → pydantic_ai-0.0.23}/tests/models/test_groq.py

@@ -52,7 +52,8 @@ pytestmark = [
 def test_init():
     m = GroqModel('llama-3.3-70b-versatile', api_key='foobar')
     assert m.client.api_key == 'foobar'
-    assert m.name() == 'groq:llama-3.3-70b-versatile'
+    assert m.model_name == 'llama-3.3-70b-versatile'
+    assert m.system == 'groq'
 
 
 @dataclass

{pydantic_ai-0.0.21 → pydantic_ai-0.0.23}/tests/models/test_mistral.py

@@ -48,7 +48,6 @@ with try_import() as imports_successful:
     from mistralai.types.basemodel import Unset as MistralUnset
 
     from pydantic_ai.models.mistral import (
-        MistralAgentModel,
         MistralModel,
         MistralStreamedResponse,
     )
@@ -1668,8 +1667,8 @@ def test_generate_user_output_format_complex():
             'prop_unrecognized_type': {'type': 'customSomething'},
         }
     }
-    mam = MistralAgentModel(Mistral(api_key=''), '', False, [], [], '{schema}')
-    result = mam._generate_user_output_format([schema])  # pyright: ignore[reportPrivateUsage]
+    m = MistralModel('', json_mode_schema_prompt='{schema}')
+    result = m._generate_user_output_format([schema])  # pyright: ignore[reportPrivateUsage]
     assert result.content == (
         "{'prop_anyOf': 'Optional[str]', "
         "'prop_no_type': 'Any', "
@@ -1685,8 +1684,8 @@ def test_generate_user_output_format_complex():
 
 def test_generate_user_output_format_multiple():
     schema = {'properties': {'prop_anyOf': {'anyOf': [{'type': 'string'}, {'type': 'integer'}]}}}
-    mam = MistralAgentModel(Mistral(api_key=''), '', False, [], [], '{schema}')
-    result = mam._generate_user_output_format([schema, schema])  # pyright: ignore[reportPrivateUsage]
+    m = MistralModel('', json_mode_schema_prompt='{schema}')
+    result = m._generate_user_output_format([schema, schema])  # pyright: ignore[reportPrivateUsage]
     assert result.content == "[{'prop_anyOf': 'Optional[str]'}, {'prop_anyOf': 'Optional[str]'}]"
 
 

{pydantic_ai-0.0.21 → pydantic_ai-0.0.23}/tests/models/test_model.py

@@ -8,66 +8,81 @@ from pydantic_ai.models import infer_model
 from ..conftest import TestEnv
 
 TEST_CASES = [
-    ('OPENAI_API_KEY', 'openai:gpt-3.5-turbo', 'openai:gpt-3.5-turbo', 'openai', 'OpenAIModel'),
-    ('OPENAI_API_KEY', 'gpt-3.5-turbo', 'openai:gpt-3.5-turbo', 'openai', 'OpenAIModel'),
-    ('OPENAI_API_KEY', 'o1', 'openai:o1', 'openai', 'OpenAIModel'),
-    ('GEMINI_API_KEY', 'google-gla:gemini-1.5-flash', 'google-gla:gemini-1.5-flash', 'gemini', 'GeminiModel'),
-    ('GEMINI_API_KEY', 'gemini-1.5-flash', 'google-gla:gemini-1.5-flash', 'gemini', 'GeminiModel'),
+    ('OPENAI_API_KEY', 'openai:gpt-3.5-turbo', 'gpt-3.5-turbo', 'openai', 'openai', 'OpenAIModel'),
+    ('OPENAI_API_KEY', 'gpt-3.5-turbo', 'gpt-3.5-turbo', 'openai', 'openai', 'OpenAIModel'),
+    ('OPENAI_API_KEY', 'o1', 'o1', 'openai', 'openai', 'OpenAIModel'),
+    ('GEMINI_API_KEY', 'google-gla:gemini-1.5-flash', 'gemini-1.5-flash', 'google-gla', 'gemini', 'GeminiModel'),
+    ('GEMINI_API_KEY', 'gemini-1.5-flash', 'gemini-1.5-flash', 'google-gla', 'gemini', 'GeminiModel'),
     (
         'GEMINI_API_KEY',
         'google-vertex:gemini-1.5-flash',
-        'google-vertex:gemini-1.5-flash',
+        'gemini-1.5-flash',
+        'google-vertex',
         'vertexai',
         'VertexAIModel',
     ),
     (
         'GEMINI_API_KEY',
         'vertexai:gemini-1.5-flash',
-        'google-vertex:gemini-1.5-flash',
+        'gemini-1.5-flash',
+        'google-vertex',
         'vertexai',
         'VertexAIModel',
     ),
     (
         'ANTHROPIC_API_KEY',
         'anthropic:claude-3-5-haiku-latest',
-        'anthropic:claude-3-5-haiku-latest',
+        'claude-3-5-haiku-latest',
+        'anthropic',
         'anthropic',
         'AnthropicModel',
     ),
     (
         'ANTHROPIC_API_KEY',
         'claude-3-5-haiku-latest',
-        'anthropic:claude-3-5-haiku-latest',
+        'claude-3-5-haiku-latest',
+        'anthropic',
         'anthropic',
         'AnthropicModel',
     ),
     (
         'GROQ_API_KEY',
         'groq:llama-3.3-70b-versatile',
-        'groq:llama-3.3-70b-versatile',
+        'llama-3.3-70b-versatile',
+        'groq',
         'groq',
         'GroqModel',
     ),
     (
         'MISTRAL_API_KEY',
         'mistral:mistral-small-latest',
-        'mistral:mistral-small-latest',
+        'mistral-small-latest',
+        'mistral',
         'mistral',
         'MistralModel',
     ),
     (
         'CO_API_KEY',
         'cohere:command',
-        'cohere:command',
+        'command',
+        'cohere',
         'cohere',
         'CohereModel',
     ),
 ]
 
 
-@pytest.mark.parametrize('mock_api_key, model_name, expected_model_name, module_name, model_class_name', TEST_CASES)
+@pytest.mark.parametrize(
+    'mock_api_key, model_name, expected_model_name, expected_system, module_name, model_class_name', TEST_CASES
+)
 def test_infer_model(
-    env: TestEnv, mock_api_key: str, model_name: str, expected_model_name: str, module_name: str, model_class_name: str
+    env: TestEnv,
+    mock_api_key: str,
+    model_name: str,
+    expected_model_name: str,
+    expected_system: str,
+    module_name: str,
+    model_class_name: str,
 ):
     try:
         model_module = import_module(f'pydantic_ai.models.{module_name}')
@@ -79,7 +94,8 @@ def test_infer_model(
 
     m = infer_model(model_name)  # pyright: ignore[reportArgumentType]
     assert isinstance(m, expected_model)
-    assert m.name() == expected_model_name
+    assert m.model_name == expected_model_name
+    assert m.system == expected_system
 
     m2 = infer_model(m)
     assert m2 is m

{pydantic_ai-0.0.21 → pydantic_ai-0.0.23}/tests/models/test_model_function.py

@@ -41,13 +41,13 @@ async def stream_hello(_messages: list[ModelMessage], _agent_info: AgentInfo) ->
 
 def test_init() -> None:
     m = FunctionModel(function=hello)
-    assert m.name() == 'function:hello:'
+    assert m.model_name == 'function:hello:'
 
     m1 = FunctionModel(stream_function=stream_hello)
-    assert m1.name() == 'function::stream_hello'
+    assert m1.model_name == 'function::stream_hello'
 
     m2 = FunctionModel(function=hello, stream_function=stream_hello)
-    assert m2.name() == 'function:hello:stream_hello'
+    assert m2.model_name == 'function:hello:stream_hello'
 
 
 async def return_last(messages: list[ModelMessage], _: AgentInfo) -> ModelResponse:

{pydantic_ai-0.0.21 → pydantic_ai-0.0.23}/tests/models/test_model_names.py

@@ -38,7 +38,7 @@ def test_known_model_names():
     groq_names = [f'groq:{n}' for n in get_model_names(GroqModelName)]
     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')
+        n for n in get_model_names(OpenAIModelName) if n.startswith('o1') or n.startswith('gpt') or n.startswith('o3')
     ]
     extra_names = ['test']
 

{pydantic_ai-0.0.21 → pydantic_ai-0.0.23}/tests/models/test_openai.py

@@ -25,11 +25,11 @@ from pydantic_ai.messages import (
 from pydantic_ai.result import Usage
 from pydantic_ai.settings import ModelSettings
 
-from ..conftest import IsNow, try_import
+from ..conftest import IsNow, TestEnv, try_import
 from .mock_async_stream import MockAsyncStream
 
 with try_import() as imports_successful:
-    from openai import NOT_GIVEN, AsyncOpenAI
+    from openai import NOT_GIVEN, AsyncOpenAI, OpenAIError
     from openai.types import chat
     from openai.types.chat.chat_completion import Choice
     from openai.types.chat.chat_completion_chunk import (
@@ -65,6 +65,20 @@ def test_init_with_base_url():
     m.name()
 
 
+def test_init_with_non_openai_model():
+    m = OpenAIModel('llama3.2-vision:latest', base_url='https://example.com/v1/')
+    m.name()
+
+
+def test_init_of_openai_without_api_key_raises_error(env: TestEnv):
+    env.remove('OPENAI_API_KEY')
+    with pytest.raises(
+        OpenAIError,
+        match='^The api_key client option must be set either by passing api_key to the client or by setting the OPENAI_API_KEY environment variable$',
+    ):
+        OpenAIModel('gpt-4o')
+
+
 @dataclass
 class MockOpenAI:
     completions: chat.ChatCompletion | list[chat.ChatCompletion] | None = None

{pydantic_ai-0.0.21 → pydantic_ai-0.0.23}/tests/models/test_vertexai.py

@@ -30,17 +30,18 @@ async def test_init_service_account(tmp_path: Path, allow_model_requests: None):
     save_service_account(service_account_path, 'my-project-id')
 
     model = VertexAIModel('gemini-1.5-flash', service_account_file=service_account_path)
-    assert model.url is None
-    assert model.auth is None
+    assert model._url is None
+    assert model._auth is None
 
-    await model.agent_model(function_tools=[], allow_text_result=True, result_tools=[])
+    await model.ainit()
 
     assert model.url == snapshot(
         'https://us-central1-aiplatform.googleapis.com/v1/projects/my-project-id/locations/us-central1/'
         'publishers/google/models/gemini-1.5-flash:'
     )
     assert model.auth is not None
-    assert model.name() == snapshot('google-vertex:gemini-1.5-flash')
+    assert model.model_name == snapshot('gemini-1.5-flash')
+    assert model.system == snapshot('google-vertex')
 
 
 class NoOpCredentials:
@@ -53,12 +54,12 @@ async def test_init_env(mocker: MockerFixture, allow_model_requests: None):
         return_value=(NoOpCredentials(), 'my-project-id'),
     )
     model = VertexAIModel('gemini-1.5-flash')
-    assert model.url is None
-    assert model.auth is None
+    assert model._url is None
+    assert model._auth is None
 
     assert patch.call_count == 0
 
-    await model.agent_model(function_tools=[], allow_text_result=True, result_tools=[])
+    await model.ainit()
 
     assert patch.call_count == 1
 
@@ -67,9 +68,10 @@ async def test_init_env(mocker: MockerFixture, allow_model_requests: None):
         'publishers/google/models/gemini-1.5-flash:'
     )
     assert model.auth is not None
-    assert model.name() == snapshot('google-vertex:gemini-1.5-flash')
+    assert model.model_name == snapshot('gemini-1.5-flash')
+    assert model.system == snapshot('google-vertex')
 
-    await model.agent_model(function_tools=[], allow_text_result=True, result_tools=[])
+    await model.ainit()
     assert model.url is not None
     assert model.auth is not None
     assert patch.call_count == 1
@@ -80,10 +82,10 @@ async def test_init_right_project_id(tmp_path: Path, allow_model_requests: None)
     save_service_account(service_account_path, 'my-project-id')
 
     model = VertexAIModel('gemini-1.5-flash', service_account_file=service_account_path, project_id='my-project-id')
-    assert model.url is None
-    assert model.auth is None
+    assert model._url is None
+    assert model._auth is None
 
-    await model.agent_model(function_tools=[], allow_text_result=True, result_tools=[])
+    await model.ainit()
 
     assert model.url == snapshot(
         'https://us-central1-aiplatform.googleapis.com/v1/projects/my-project-id/locations/us-central1/'
@@ -92,30 +94,6 @@ async def test_init_right_project_id(tmp_path: Path, allow_model_requests: None)
     assert model.auth is not None
 
 
-async def test_init_service_account_wrong_project_id(tmp_path: Path, allow_model_requests: None):
-    service_account_path = tmp_path / 'service_account.json'
-    save_service_account(service_account_path, 'my-project-id')
-
-    model = VertexAIModel('gemini-1.5-flash', service_account_file=service_account_path, project_id='different')
-
-    with pytest.raises(UserError) as exc_info:
-        await model.agent_model(function_tools=[], allow_text_result=True, result_tools=[])
-    assert str(exc_info.value) == snapshot(
-        "The project_id you provided does not match the one from service account file: 'different' != 'my-project-id'"
-    )
-
-
-async def test_init_env_wrong_project_id(mocker: MockerFixture, allow_model_requests: None):
-    mocker.patch('pydantic_ai.models.vertexai.google.auth.default', return_value=(NoOpCredentials(), 'my-project-id'))
-    model = VertexAIModel('gemini-1.5-flash', project_id='different')
-
-    with pytest.raises(UserError) as exc_info:
-        await model.agent_model(function_tools=[], allow_text_result=True, result_tools=[])
-    assert str(exc_info.value) == snapshot(
-        "The project_id you provided does not match the one from `google.auth.default()`: 'different' != 'my-project-id'"
-    )
-
-
 async def test_init_env_no_project_id(mocker: MockerFixture, allow_model_requests: None):
     mocker.patch(
         'pydantic_ai.models.vertexai.google.auth.default',
@@ -124,7 +102,7 @@ async def test_init_env_no_project_id(mocker: MockerFixture, allow_model_request
     model = VertexAIModel('gemini-1.5-flash')
 
     with pytest.raises(UserError) as exc_info:
-        await model.agent_model(function_tools=[], allow_text_result=True, result_tools=[])
+        await model.ainit()
     assert str(exc_info.value) == snapshot('No project_id provided and none found in `google.auth.default()`')
 
 

{pydantic_ai-0.0.21 → pydantic_ai-0.0.23}/tests/test_agent.py

@@ -326,13 +326,13 @@ def test_response_tuple():
     result = agent.run_sync('Hello')
     assert result.data == snapshot(('a', 'a'))
 
-    assert m.agent_model_function_tools == snapshot([])
-    assert m.agent_model_allow_text_result is False
+    assert m.last_model_request_parameters is not None
+    assert m.last_model_request_parameters.function_tools == snapshot([])
+    assert m.last_model_request_parameters.allow_text_result is False
 
-    assert m.agent_model_result_tools is not None
-    assert len(m.agent_model_result_tools) == 1
-
-    assert m.agent_model_result_tools == snapshot(
+    assert m.last_model_request_parameters.result_tools is not None
+    assert len(m.last_model_request_parameters.result_tools) == 1
+    assert m.last_model_request_parameters.result_tools == snapshot(
         [
             ToolDefinition(
                 name='final_result',
@@ -384,13 +384,14 @@ def test_response_union_allow_str(input_union_callable: Callable[[], Any]):
     assert result.data == snapshot('success (no tool calls)')
     assert got_tool_call_name == snapshot(None)
 
-    assert m.agent_model_function_tools == snapshot([])
-    assert m.agent_model_allow_text_result is True
+    assert m.last_model_request_parameters is not None
+    assert m.last_model_request_parameters.function_tools == snapshot([])
+    assert m.last_model_request_parameters.allow_text_result is True
 
-    assert m.agent_model_result_tools is not None
-    assert len(m.agent_model_result_tools) == 1
+    assert m.last_model_request_parameters.result_tools is not None
+    assert len(m.last_model_request_parameters.result_tools) == 1
 
-    assert m.agent_model_result_tools == snapshot(
+    assert m.last_model_request_parameters.result_tools == snapshot(
         [
             ToolDefinition(
                 name='final_result',
@@ -459,13 +460,14 @@ class Bar(BaseModel):
     assert result.data == mod.Foo(a=0, b='a')
     assert got_tool_call_name == snapshot('final_result_Foo')
 
-    assert m.agent_model_function_tools == snapshot([])
-    assert m.agent_model_allow_text_result is False
+    assert m.last_model_request_parameters is not None
+    assert m.last_model_request_parameters.function_tools == snapshot([])
+    assert m.last_model_request_parameters.allow_text_result is False
 
-    assert m.agent_model_result_tools is not None
-    assert len(m.agent_model_result_tools) == 2
+    assert m.last_model_request_parameters.result_tools is not None
+    assert len(m.last_model_request_parameters.result_tools) == 2
 
-    assert m.agent_model_result_tools == snapshot(
+    assert m.last_model_request_parameters.result_tools == snapshot(
         [
             ToolDefinition(
                 name='final_result_Foo',

{pydantic_ai-0.0.21 → pydantic_ai-0.0.23}/tests/test_examples.py

@@ -17,6 +17,7 @@ from pytest_examples import CodeExample, EvalExample, find_examples
 from pytest_mock import MockerFixture
 
 from pydantic_ai._utils import group_by_temporal
+from pydantic_ai.exceptions import UnexpectedModelBehavior
 from pydantic_ai.messages import (
     ModelMessage,
     ModelResponse,
@@ -179,7 +180,7 @@ text_responses: dict[str, str | ToolCallPart] = {
         'The weather in West London is raining, while in Wiltshire it is sunny.'
     ),
     'Tell me a joke.': 'Did you hear about the toothpaste scandal? They called it Colgate.',
-    'Explain?': 'This is an excellent joke invent by Samuel Colvin, it needs no explanation.',
+    'Explain?': 'This is an excellent joke invented by Samuel Colvin, it needs no explanation.',
     'What is the capital of France?': 'Paris',
     'What is the capital of Italy?': 'Rome',
     'What is the capital of the UK?': 'London',
@@ -288,6 +289,8 @@ async def model_logic(messages: list[ModelMessage], info: AgentInfo) -> ModelRes
                     )
                 ]
             )
+        elif m.content.startswith('Write a list of 5 very rude things that I might say'):
+            raise UnexpectedModelBehavior('Safety settings triggered', body='<safety settings details>')
         elif m.content.startswith('<examples>\n  <user>'):
             return ModelResponse(parts=[ToolCallPart(tool_name='final_result_EmailOk', args={})])
         elif m.content == 'Ask a simple question with a single correct answer.' and len(messages) > 2:

{pydantic_ai-0.0.21 → pydantic_ai-0.0.23}/tests/test_logfire.py

@@ -75,14 +75,14 @@ def test_logfire(get_logfire_summary: Callable[[], LogfireSummary]) -> None:
                 'id': 0,
                 'message': 'my_agent run prompt=Hello',
                 'children': [
-                    {'id': 1, 'message': 'preparing model and tools run_step=1'},
+                    {'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 and tools run_step=2'},
+                    {'id': 5, 'message': 'preparing model request params run_step=2'},
                     {'id': 6, 'message': 'model request'},
                     {'id': 7, 'message': 'handle model response -> final result'},
                 ],
@@ -102,16 +102,14 @@ def test_logfire(get_logfire_summary: Callable[[], LogfireSummary]) -> None:
                         'custom_result_text': None,
                         'custom_result_args': None,
                         'seed': 0,
-                        'agent_model_function_tools': None,
-                        'agent_model_allow_text_result': None,
-                        'agent_model_result_tools': None,
+                        'last_model_request_parameters': None,
                     },
                     'name': 'my_agent',
                     'end_strategy': 'early',
                     'model_settings': None,
                 }
             ),
-            'model_name': 'test-model',
+            'model_name': 'test',
             'agent_name': 'my_agent',
             'logfire.msg_template': '{agent_name} run {prompt=}',
             'logfire.msg': 'my_agent run prompt=Hello',
@@ -255,9 +253,9 @@ def test_logfire(get_logfire_summary: Callable[[], LogfireSummary]) -> None:
             'code.function': 'test_logfire',
             'code.lineno': IsInt(),
             'run_step': 1,
-            'logfire.msg_template': 'preparing model and tools {run_step=}',
+            'logfire.msg_template': 'preparing model request params {run_step=}',
             'logfire.span_type': 'span',
-            'logfire.msg': 'preparing model and tools run_step=1',
+            'logfire.msg': 'preparing model request params run_step=1',
             'logfire.json_schema': '{"type":"object","properties":{"run_step":{}}}',
         }
     )