pydantic-ai 0.5.0__tar.gz → 0.5.1__tar.gz

{pydantic_ai-0.5.0 → pydantic_ai-0.5.1}/Makefile

@@ -60,13 +60,10 @@ typecheck-both: typecheck-pyright typecheck-mypy
 
 .PHONY: test
 test: ## Run tests and collect coverage data
-	uv run coverage run -m pytest
+	COVERAGE_PROCESS_START=./pyproject.toml uv run coverage run -m pytest -n auto --dist=loadgroup
+	@uv run coverage combine
 	@uv run coverage report
 
-.PHONY: test-fast
-test-fast: ## Same as test except no coverage and 4x faster depending on hardware
-	uv run pytest -n auto --dist=loadgroup
-
 .PHONY: test-all-python
 test-all-python: ## Run tests on Python 3.9 to 3.13
 	UV_PROJECT_ENVIRONMENT=.venv39 uv run --python 3.9 --all-extras --all-packages coverage run -p -m pytest

{pydantic_ai-0.5.0 → pydantic_ai-0.5.1}/PKG-INFO

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

{pydantic_ai-0.5.0 → pydantic_ai-0.5.1}/pyproject.toml

@@ -215,6 +215,10 @@ filterwarnings = [
 
 # https://coverage.readthedocs.io/en/latest/config.html#run
 [tool.coverage.run]
+parallel = true
+concurrency = ["multiprocessing", "thread"]
+# We use a subdirectory for coverage data to avoid noisy coverage data files.
+data_file = ".coverage/.coverage"
 # required to avoid warnings about files created by create_module fixture
 include = [
     "pydantic_ai_slim/**/*.py",
@@ -245,6 +249,7 @@ source = [
 
 # https://coverage.readthedocs.io/en/latest/config.html#report
 [tool.coverage.report]
+fail_under = 100
 skip_covered = true
 show_missing = true
 ignore_errors = true

{pydantic_ai-0.5.0 → pydantic_ai-0.5.1}/tests/conftest.py

@@ -251,7 +251,7 @@ def pytest_recording_configure(config: Any, vcr: VCR):
 def mock_vcr_aiohttp_content(mocker: MockerFixture):
     try:
         from vcr.stubs import aiohttp_stubs
-    except ImportError:
+    except ImportError:  # pragma: lax no cover
         return
 
     # google-genai calls `self.response_stream.content.readline()` where `self.response_stream` is a `MockClientResponse`,
@@ -416,9 +416,9 @@ def vertex_provider_auth(mocker: MockerFixture) -> None:  # pragma: lax no cover
 
 
 @pytest.fixture()
-async def vertex_provider():
+async def vertex_provider():  # pragma: lax no cover
     # NOTE: You need to comment out this line to rewrite the cassettes locally.
-    if not os.getenv('CI', False):  # pragma: lax no cover
+    if not os.getenv('CI', False):
         pytest.skip('Requires properly configured local google vertex config to pass')
 
     try:
@@ -478,10 +478,10 @@ def model(
 
             return CohereModel('command-r-plus', provider=CohereProvider(api_key=co_api_key))
         elif request.param == 'gemini':
-            from pydantic_ai.models.gemini import GeminiModel
+            from pydantic_ai.models.gemini import GeminiModel  # type: ignore[reportDeprecated]
             from pydantic_ai.providers.google_gla import GoogleGLAProvider
 
-            return GeminiModel('gemini-1.5-flash', provider=GoogleGLAProvider(api_key=gemini_api_key))
+            return GeminiModel('gemini-1.5-flash', provider=GoogleGLAProvider(api_key=gemini_api_key))  # type: ignore[reportDeprecated]
         elif request.param == 'google':
             from pydantic_ai.models.google import GoogleModel
             from pydantic_ai.providers.google import GoogleProvider

{pydantic_ai-0.5.0 → pydantic_ai-0.5.1}/tests/evals/test_dataset.py

@@ -7,11 +7,11 @@ from pathlib import Path
 from typing import Any
 
 import pytest
-from dirty_equals import HasRepr, IsNumber
+from dirty_equals import HasRepr, IsNumber, IsPartialDict
 from inline_snapshot import snapshot
 from pydantic import BaseModel, TypeAdapter
 
-from ..conftest import IsStr, try_import
+from ..conftest import try_import
 from .utils import render_table
 
 with try_import() as imports_successful:
@@ -1159,7 +1159,7 @@ async def test_evaluate_async_logfire(
     example_dataset: Dataset[TaskInput, TaskOutput, TaskMetadata],
     simple_evaluator: type[Evaluator[TaskInput, TaskOutput, TaskMetadata]],
     capfire: CaptureLogfire,
-):
+):  # pragma: lax no cover
     """Test evaluating a dataset."""
     example_dataset.add_evaluator(simple_evaluator())
 
@@ -1197,90 +1197,90 @@ async def test_evaluate_async_logfire(
             'parent': None,
             'start_time': 1000000000,
         },
-        {
-            'attributes': {
-                'assertions': '{"correct":{"name":"correct","value":true,"reason":null,"source":{"name":"SimpleEvaluator","arguments":null}}}',
-                'attributes': '{}',
-                'case_name': 'case1',
-                'code.filepath': IsStr(),
-                'code.lineno': 123,
-                'expected_output': '{"answer":"4","confidence":1.0}',
-                'inputs': '{"query":"What is 2+2?"}',
-                'labels': '{}',
-                'logfire.json_schema': '{"type":"object","properties":{"task_name":{},"case_name":{},"inputs":{"type":"object","title":"TaskInput","x-python-datatype":"PydanticModel"},"metadata":{"type":"object","title":"TaskMetadata","x-python-datatype":"PydanticModel"},"expected_output":{"type":"object","title":"TaskOutput","x-python-datatype":"PydanticModel"},"output":{"type":"object","title":"TaskOutput","x-python-datatype":"PydanticModel"},"task_duration":{},"metrics":{"type":"object"},"attributes":{"type":"object"},"assertions":{"type":"object"},"scores":{"type":"object"},"labels":{"type":"object"}}}',
-                'logfire.msg': 'case: case1',
-                'logfire.msg_template': 'case: {case_name}',
-                'logfire.span_type': 'span',
-                'metadata': '{"difficulty":"easy","category":"general"}',
-                'metrics': '{}',
-                'output': '{"answer":"4","confidence":1.0}',
-                'scores': '{"confidence":{"name":"confidence","value":1.0,"reason":null,"source":{"name":"SimpleEvaluator","arguments":null}}}',
-                'task_duration': 1.0,
-                'task_name': 'mock_async_task',
-            },
-            'context': {'is_remote': False, 'span_id': 3, 'trace_id': 1},
-            'end_time': 8000000000,
-            'name': 'case: {case_name}',
-            'parent': {'is_remote': False, 'span_id': 1, 'trace_id': 1},
-            'start_time': 2000000000,
-        },
-        {
-            'attributes': {
-                'code.filepath': IsStr(),
-                'code.lineno': 123,
-                'logfire.json_schema': '{"type":"object","properties":{"task":{}}}',
-                'logfire.msg': 'execute mock_async_task',
-                'logfire.msg_template': 'execute {task}',
-                'logfire.span_type': 'span',
-                'task': 'mock_async_task',
-            },
-            'context': {'is_remote': False, 'span_id': 5, 'trace_id': 1},
-            'end_time': 4000000000,
-            'name': 'execute {task}',
-            'parent': {'is_remote': False, 'span_id': 3, 'trace_id': 1},
-            'start_time': 3000000000,
-        },
-        {
-            'attributes': {
-                'assertions': '{"correct":{"name":"correct","value":true,"reason":null,"source":{"name":"SimpleEvaluator","arguments":null}}}',
-                'attributes': '{}',
-                'case_name': 'case2',
-                'code.filepath': IsStr(),
-                'code.lineno': 123,
-                'expected_output': '{"answer":"Paris","confidence":1.0}',
-                'inputs': '{"query":"What is the capital of France?"}',
-                'labels': '{}',
-                'logfire.json_schema': '{"type":"object","properties":{"task_name":{},"case_name":{},"inputs":{"type":"object","title":"TaskInput","x-python-datatype":"PydanticModel"},"metadata":{"type":"object","title":"TaskMetadata","x-python-datatype":"PydanticModel"},"expected_output":{"type":"object","title":"TaskOutput","x-python-datatype":"PydanticModel"},"output":{"type":"object","title":"TaskOutput","x-python-datatype":"PydanticModel"},"task_duration":{},"metrics":{"type":"object"},"attributes":{"type":"object"},"assertions":{"type":"object"},"scores":{"type":"object"},"labels":{"type":"object"}}}',
-                'logfire.msg': 'case: case2',
-                'logfire.msg_template': 'case: {case_name}',
-                'logfire.span_type': 'span',
-                'metadata': '{"difficulty":"medium","category":"geography"}',
-                'metrics': '{}',
-                'output': '{"answer":"Paris","confidence":1.0}',
-                'scores': '{"confidence":{"name":"confidence","value":1.0,"reason":null,"source":{"name":"SimpleEvaluator","arguments":null}}}',
-                'task_duration': 1.0,
-                'task_name': 'mock_async_task',
-            },
-            'context': {'is_remote': False, 'span_id': 7, 'trace_id': 1},
-            'end_time': 9000000000,
-            'name': 'case: {case_name}',
-            'parent': {'is_remote': False, 'span_id': 1, 'trace_id': 1},
-            'start_time': 5000000000,
-        },
-        {
-            'attributes': {
-                'code.filepath': IsStr(),
-                'code.lineno': 123,
-                'logfire.json_schema': '{"type":"object","properties":{"task":{}}}',
-                'logfire.msg': 'execute mock_async_task',
-                'logfire.msg_template': 'execute {task}',
-                'logfire.span_type': 'span',
-                'task': 'mock_async_task',
-            },
-            'context': {'is_remote': False, 'span_id': 9, 'trace_id': 1},
-            'end_time': 7000000000,
-            'name': 'execute {task}',
-            'parent': {'is_remote': False, 'span_id': 7, 'trace_id': 1},
-            'start_time': 6000000000,
-        },
+        IsPartialDict(
+            {
+                'attributes': {
+                    'assertions': '{"correct":{"name":"correct","value":true,"reason":null,"source":{"name":"SimpleEvaluator","arguments":null}}}',
+                    'attributes': '{}',
+                    'case_name': 'case1',
+                    'expected_output': '{"answer":"4","confidence":1.0}',
+                    'inputs': '{"query":"What is 2+2?"}',
+                    'labels': '{}',
+                    'logfire.json_schema': '{"type":"object","properties":{"task_name":{},"case_name":{},"inputs":{"type":"object","title":"TaskInput","x-python-datatype":"PydanticModel"},"metadata":{"type":"object","title":"TaskMetadata","x-python-datatype":"PydanticModel"},"expected_output":{"type":"object","title":"TaskOutput","x-python-datatype":"PydanticModel"},"output":{"type":"object","title":"TaskOutput","x-python-datatype":"PydanticModel"},"task_duration":{},"metrics":{"type":"object"},"attributes":{"type":"object"},"assertions":{"type":"object"},"scores":{"type":"object"},"labels":{"type":"object"}}}',
+                    'logfire.msg': 'case: case1',
+                    'logfire.msg_template': 'case: {case_name}',
+                    'logfire.span_type': 'span',
+                    'metadata': '{"difficulty":"easy","category":"general"}',
+                    'metrics': '{}',
+                    'output': '{"answer":"4","confidence":1.0}',
+                    'scores': '{"confidence":{"name":"confidence","value":1.0,"reason":null,"source":{"name":"SimpleEvaluator","arguments":null}}}',
+                    'task_duration': 1.0,
+                    'task_name': 'mock_async_task',
+                },
+                'context': {'is_remote': False, 'span_id': 3, 'trace_id': 1},
+                'end_time': 8000000000,
+                'name': 'case: {case_name}',
+                'parent': {'is_remote': False, 'span_id': 1, 'trace_id': 1},
+                'start_time': 2000000000,
+            }
+        ),
+        IsPartialDict(
+            {
+                'attributes': {
+                    'logfire.json_schema': '{"type":"object","properties":{"task":{}}}',
+                    'logfire.msg': 'execute mock_async_task',
+                    'logfire.msg_template': 'execute {task}',
+                    'logfire.span_type': 'span',
+                    'task': 'mock_async_task',
+                },
+                'context': {'is_remote': False, 'span_id': 5, 'trace_id': 1},
+                'end_time': 4000000000,
+                'name': 'execute {task}',
+                'parent': {'is_remote': False, 'span_id': 3, 'trace_id': 1},
+                'start_time': 3000000000,
+            }
+        ),
+        IsPartialDict(
+            {
+                'attributes': {
+                    'assertions': '{"correct":{"name":"correct","value":true,"reason":null,"source":{"name":"SimpleEvaluator","arguments":null}}}',
+                    'attributes': '{}',
+                    'case_name': 'case2',
+                    'expected_output': '{"answer":"Paris","confidence":1.0}',
+                    'inputs': '{"query":"What is the capital of France?"}',
+                    'labels': '{}',
+                    'logfire.json_schema': '{"type":"object","properties":{"task_name":{},"case_name":{},"inputs":{"type":"object","title":"TaskInput","x-python-datatype":"PydanticModel"},"metadata":{"type":"object","title":"TaskMetadata","x-python-datatype":"PydanticModel"},"expected_output":{"type":"object","title":"TaskOutput","x-python-datatype":"PydanticModel"},"output":{"type":"object","title":"TaskOutput","x-python-datatype":"PydanticModel"},"task_duration":{},"metrics":{"type":"object"},"attributes":{"type":"object"},"assertions":{"type":"object"},"scores":{"type":"object"},"labels":{"type":"object"}}}',
+                    'logfire.msg': 'case: case2',
+                    'logfire.msg_template': 'case: {case_name}',
+                    'logfire.span_type': 'span',
+                    'metadata': '{"difficulty":"medium","category":"geography"}',
+                    'metrics': '{}',
+                    'output': '{"answer":"Paris","confidence":1.0}',
+                    'scores': '{"confidence":{"name":"confidence","value":1.0,"reason":null,"source":{"name":"SimpleEvaluator","arguments":null}}}',
+                    'task_duration': 1.0,
+                    'task_name': 'mock_async_task',
+                },
+                'context': {'is_remote': False, 'span_id': 7, 'trace_id': 1},
+                'end_time': 9000000000,
+                'name': 'case: {case_name}',
+                'parent': {'is_remote': False, 'span_id': 1, 'trace_id': 1},
+                'start_time': 5000000000,
+            }
+        ),
+        IsPartialDict(
+            {
+                'attributes': {
+                    'logfire.json_schema': '{"type":"object","properties":{"task":{}}}',
+                    'logfire.msg': 'execute mock_async_task',
+                    'logfire.msg_template': 'execute {task}',
+                    'logfire.span_type': 'span',
+                    'task': 'mock_async_task',
+                },
+                'context': {'is_remote': False, 'span_id': 9, 'trace_id': 1},
+                'end_time': 7000000000,
+                'name': 'execute {task}',
+                'parent': {'is_remote': False, 'span_id': 7, 'trace_id': 1},
+                'start_time': 6000000000,
+            }
+        ),
     ]

{pydantic_ai-0.5.0 → pydantic_ai-0.5.1}/tests/models/test_fallback.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import sys
 from collections.abc import AsyncIterator
 from datetime import timezone
+from typing import Any
 
 import pytest
 from inline_snapshot import snapshot
@@ -247,6 +248,14 @@ def test_all_failed() -> None:
     assert exceptions[0].body == {'error': 'test error'}
 
 
+def add_missing_response_model(spans: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    for span in spans:
+        attrs = span.setdefault('attributes', {})
+        if 'gen_ai.request.model' in attrs:
+            attrs.setdefault('gen_ai.response.model', attrs['gen_ai.request.model'])
+    return spans
+
+
 @pytest.mark.skipif(not logfire_imports_successful(), reason='logfire not installed')
 def test_all_failed_instrumented(capfire: CaptureLogfire) -> None:
     fallback_model = FallbackModel(failure_model, failure_model)
@@ -260,7 +269,7 @@ def test_all_failed_instrumented(capfire: CaptureLogfire) -> None:
     assert exceptions[0].status_code == 500
     assert exceptions[0].model_name == 'test-function-model'
     assert exceptions[0].body == {'error': 'test error'}
-    assert capfire.exporter.exported_spans_as_dict() == snapshot(
+    assert add_missing_response_model(capfire.exporter.exported_spans_as_dict()) == snapshot(
         [
             {
                 'name': 'chat fallback:function:failure_response:,function:failure_response:',
@@ -277,6 +286,7 @@ def test_all_failed_instrumented(capfire: CaptureLogfire) -> None:
                     'logfire.span_type': 'span',
                     'logfire.msg': 'chat fallback:function:failure_response:,function:failure_response:',
                     'logfire.level_num': 17,
+                    'gen_ai.response.model': 'fallback:function:failure_response:,function:failure_response:',
                 },
                 'events': [
                     {

{pydantic_ai-0.5.0 → pydantic_ai-0.5.1}/tests/models/test_gemini.py

@@ -1,4 +1,5 @@
 # pyright: reportPrivateUsage=false
+# pyright: reportDeprecated=false
 from __future__ import annotations as _annotations
 
 import datetime
@@ -60,7 +61,7 @@ from pydantic_ai.tools import ToolDefinition
 
 from ..conftest import ClientWithHandler, IsDatetime, IsInstance, IsNow, IsStr, TestEnv, try_import
 
-pytestmark = pytest.mark.anyio
+pytestmark = [pytest.mark.anyio, pytest.mark.filterwarnings('ignore:Use `GoogleModel` instead.:DeprecationWarning')]
 
 
 async def test_model_simple(allow_model_requests: None):
@@ -360,24 +361,25 @@ async def test_json_def_enum(allow_model_requests: None):
 
     # This tests that the enum values are properly converted to strings for Gemini
     assert m._get_tools(mrp) == snapshot(
-        _GeminiTools(
-            function_declarations=[
-                _GeminiFunction(
-                    name='result',
-                    description='This is the tool for the final Result',
-                    parameters={
+        {
+            'function_declarations': [
+                {
+                    'name': 'result',
+                    'description': 'This is the tool for the final Result',
+                    'parameters': {
                         'properties': {
                             'progress': {
                                 'items': {'enum': ['100', '80', '60', '40', '20'], 'type': 'string'},
                                 'type': 'array',
                                 'nullable': True,
+                                'default': None,
                             }
                         },
                         'type': 'object',
                     },
-                )
+                }
             ]
-        )
+        }
     )
 
 
@@ -406,12 +408,12 @@ async def test_json_def_replaced_any_of(allow_model_requests: None):
     )
     mrp = m.customize_request_parameters(mrp)
     assert m._get_tools(mrp) == snapshot(
-        _GeminiTools(
-            function_declarations=[
-                _GeminiFunction(
-                    name='result',
-                    description='This is the tool for the final Result',
-                    parameters={
+        {
+            'function_declarations': [
+                {
+                    'name': 'result',
+                    'description': 'This is the tool for the final Result',
+                    'parameters': {
                         'properties': {
                             'op_location': {
                                 'properties': {
@@ -421,13 +423,14 @@ async def test_json_def_replaced_any_of(allow_model_requests: None):
                                 'required': ['lat', 'lng'],
                                 'nullable': True,
                                 'type': 'object',
+                                'default': None,
                             }
                         },
                         'type': 'object',
                     },
-                )
+                }
             ]
-        )
+        }
     )
 
 

{pydantic_ai-0.5.0 → pydantic_ai-0.5.1}/tests/models/test_gemini_vertex.py

@@ -1,3 +1,4 @@
+# pyright: reportDeprecated=false
 import os
 from dataclasses import dataclass
 from typing import Union
@@ -32,6 +33,7 @@ with try_import() as imports_successful:
 pytestmark = [
     pytest.mark.skipif(not imports_successful(), reason='google-auth not installed'),
     pytest.mark.anyio,
+    pytest.mark.filterwarnings('ignore:Use `GoogleModel` instead.:DeprecationWarning'),
 ]
 
 

{pydantic_ai-0.5.0 → pydantic_ai-0.5.1}/tests/models/test_google.py

@@ -318,7 +318,9 @@ async def test_google_model_gla_labels_raises_value_error(allow_model_requests:
         await agent.run('What is the capital of France?')
 
 
-async def test_google_model_vertex_provider(allow_model_requests: None, vertex_provider: GoogleProvider):
+async def test_google_model_vertex_provider(
+    allow_model_requests: None, vertex_provider: GoogleProvider
+):  # pragma: lax no cover
     model = GoogleModel('gemini-2.0-flash', provider=vertex_provider)
     agent = Agent(model=model, system_prompt='You are a helpful chatbot.')
     result = await agent.run('What is the capital of France?')
@@ -774,7 +776,7 @@ async def test_google_url_input(
     expected_output: str,
     allow_model_requests: None,
     vertex_provider: GoogleProvider,
-) -> None:
+) -> None:  # pragma: lax no cover
     m = GoogleModel('gemini-2.0-flash', provider=vertex_provider)
     agent = Agent(m)
     result = await agent.run(['What is the main content of this URL?', url])
@@ -806,7 +808,7 @@ async def test_google_url_input(
     not os.getenv('CI', False), reason='Requires properly configured local google vertex config to pass'
 )
 @pytest.mark.vcr()
-async def test_google_url_input_force_download(allow_model_requests: None) -> None:
+async def test_google_url_input_force_download(allow_model_requests: None) -> None:  # pragma: lax no cover
     provider = GoogleProvider(project='pydantic-ai', location='us-central1')
     m = GoogleModel('gemini-2.0-flash', provider=provider)
     agent = Agent(m)

{pydantic_ai-0.5.0 → pydantic_ai-0.5.1}/tests/models/test_openai.py

@@ -37,12 +37,10 @@ from pydantic_ai.messages import (
     UserPromptPart,
 )
 from pydantic_ai.models import ModelRequestParameters
-from pydantic_ai.models.gemini import GeminiModel
 from pydantic_ai.output import NativeOutput, PromptedOutput, TextOutput, ToolOutput
 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
@@ -65,6 +63,7 @@ with try_import() as imports_successful:
     from openai.types.chat.chat_completion_token_logprob import ChatCompletionTokenLogprob
     from openai.types.completion_usage import CompletionUsage, PromptTokensDetails
 
+    from pydantic_ai.models.google import GoogleModel
     from pydantic_ai.models.openai import (
         OpenAIModel,
         OpenAIModelSettings,
@@ -73,6 +72,7 @@ with try_import() as imports_successful:
         OpenAISystemPromptRole,
     )
     from pydantic_ai.profiles.openai import OpenAIJsonSchemaTransformer
+    from pydantic_ai.providers.google import GoogleProvider
     from pydantic_ai.providers.openai import OpenAIProvider
 
     # note: we use Union here so that casting works with Python 3.9
@@ -1016,7 +1016,7 @@ async def test_max_completion_tokens(allow_model_requests: None, model_name: str
 
 
 async def test_multiple_agent_tool_calls(allow_model_requests: None, gemini_api_key: str, openai_api_key: str):
-    gemini_model = GeminiModel('gemini-2.0-flash-exp', provider=GoogleGLAProvider(api_key=gemini_api_key))
+    gemini_model = GoogleModel('gemini-2.0-flash-exp', provider=GoogleProvider(api_key=gemini_api_key))
     openai_model = OpenAIModel('gpt-4o-mini', provider=OpenAIProvider(api_key=openai_api_key))
 
     agent = Agent(model=gemini_model)

{pydantic_ai-0.5.0 → pydantic_ai-0.5.1}/tests/providers/test_google_vertex.py

@@ -2,6 +2,7 @@ from __future__ import annotations as _annotations
 
 import json
 import os
+import sys
 from dataclasses import dataclass
 from pathlib import Path
 from unittest.mock import patch
@@ -12,7 +13,7 @@ from inline_snapshot import snapshot
 from pytest_mock import MockerFixture
 
 from pydantic_ai.agent import Agent
-from pydantic_ai.models.gemini import GeminiModel
+from pydantic_ai.models.gemini import GeminiModel  # type: ignore[reportDeprecated]
 
 from ..conftest import try_import
 
@@ -24,6 +25,7 @@ with try_import() as imports_successful:
 pytestmark = [
     pytest.mark.skipif(not imports_successful(), reason='google-genai not installed'),
     pytest.mark.anyio(),
+    pytest.mark.filterwarnings('ignore:Use `GoogleModel` instead.:DeprecationWarning'),
 ]
 
 
@@ -68,6 +70,7 @@ async def mock_refresh_token():
     return 'my-token'
 
 
+@pytest.mark.skipif(sys.version_info < (3, 10), reason='Flaky test in 3.9')
 async def test_google_vertex_provider_service_account_file(
     monkeypatch: pytest.MonkeyPatch, tmp_path: Path, allow_model_requests: None
 ):
@@ -81,6 +84,7 @@ async def test_google_vertex_provider_service_account_file(
     assert getattr(provider.client.auth, 'project_id') == 'my-project-id'
 
 
+@pytest.mark.skipif(sys.version_info < (3, 10), reason='Flaky test in 3.9')
 async def test_google_vertex_provider_service_account_file_info(
     monkeypatch: pytest.MonkeyPatch, allow_model_requests: None
 ):
@@ -164,7 +168,7 @@ def vertex_provider_auth(mocker: MockerFixture) -> None:  # pragma: lax no cover
 )
 @pytest.mark.vcr()
 async def test_vertexai_provider(allow_model_requests: None):  # pragma: lax no cover
-    m = GeminiModel('gemini-2.0-flash', provider='google-vertex')
+    m = GeminiModel('gemini-2.0-flash', provider='google-vertex')  # type: ignore[reportDeprecated]
     agent = Agent(m)
 
     result = await agent.run('What is the capital of France?')

{pydantic_ai-0.5.0 → pydantic_ai-0.5.1}/tests/test_live.py

@@ -28,24 +28,28 @@ def openai(http_client: httpx.AsyncClient, _tmp_path: Path) -> Model:
     return OpenAIModel('gpt-4o-mini', provider=OpenAIProvider(http_client=http_client))
 
 
-def gemini(http_client: httpx.AsyncClient, _tmp_path: Path) -> Model:
-    from pydantic_ai.models.gemini import GeminiModel
-    from pydantic_ai.providers.google_gla import GoogleGLAProvider
+def gemini(_: httpx.AsyncClient, _tmp_path: Path) -> Model:
+    from pydantic_ai.models.google import GoogleModel
 
-    return GeminiModel('gemini-1.5-pro', provider=GoogleGLAProvider(http_client=http_client))
+    return GoogleModel('gemini-1.5-pro')
 
 
-def vertexai(http_client: httpx.AsyncClient, tmp_path: Path) -> Model:
-    from pydantic_ai.models.gemini import GeminiModel
-    from pydantic_ai.providers.google_vertex import GoogleVertexProvider
+def vertexai(_: httpx.AsyncClient, tmp_path: Path) -> Model:
+    from google.oauth2 import service_account
+
+    from pydantic_ai.models.google import GoogleModel
+    from pydantic_ai.providers.google import GoogleProvider
 
     service_account_content = os.environ['GOOGLE_SERVICE_ACCOUNT_CONTENT']
     service_account_path = tmp_path / 'service_account.json'
     service_account_path.write_text(service_account_content)
-    return GeminiModel(
-        'gemini-1.5-flash',
-        provider=GoogleVertexProvider(service_account_file=service_account_path, http_client=http_client),
+
+    credentials = service_account.Credentials.from_service_account_file(  # type: ignore[reportUnknownReturnType]
+        service_account_path,
+        scopes=['https://www.googleapis.com/auth/cloud-platform'],
     )
+    provider = GoogleProvider(credentials=credentials)
+    return GoogleModel('gemini-1.5-flash', provider=provider)
 
 
 def groq(http_client: httpx.AsyncClient, _tmp_path: Path) -> Model:
@@ -88,7 +92,9 @@ def cohere(http_client: httpx.AsyncClient, _tmp_path: Path) -> Model:
 params = [
     pytest.param(openai, id='openai'),
     pytest.param(gemini, marks=pytest.mark.skip(reason='API seems very flaky'), id='gemini'),
-    pytest.param(vertexai, id='vertexai'),
+    pytest.param(
+        vertexai, marks=pytest.mark.skip(reason='This needs to be fixed. It raises RuntimeError.'), id='vertexai'
+    ),
     pytest.param(groq, id='groq'),
     pytest.param(anthropic, id='anthropic'),
     pytest.param(ollama, id='ollama'),