pydantic-ai 0.0.40__tar.gz → 0.0.41__tar.gz

{pydantic_ai-0.0.40 → pydantic_ai-0.0.41}/PKG-INFO

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

{pydantic_ai-0.0.40 → pydantic_ai-0.0.41}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "pydantic-ai"
-version = "0.0.40"
+version = "0.0.41"
 description = "Agent Framework / shim to use Pydantic with LLMs"
 authors = [
     { name = "Samuel Colvin", email = "samuel@pydantic.dev" },
@@ -36,7 +36,7 @@ classifiers = [
 ]
 requires-python = ">=3.9"
 dependencies = [
-    "pydantic-ai-slim[openai,vertexai,groq,anthropic,mistral,cohere,bedrock,cli]==0.0.40",
+    "pydantic-ai-slim[openai,vertexai,groq,anthropic,mistral,cohere,bedrock,cli]==0.0.41",
 ]
 
 [project.urls]
@@ -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.40"]
+examples = ["pydantic-ai-examples==0.0.41"]
 logfire = ["logfire>=2.3"]
 
 [tool.uv.sources]

{pydantic_ai-0.0.40 → pydantic_ai-0.0.41}/tests/models/test_anthropic.py

@@ -7,6 +7,7 @@ from dataclasses import dataclass, field
 from datetime import timezone
 from functools import cached_property
 from typing import Any, TypeVar, Union, cast
+from unittest.mock import patch
 
 import httpx
 import pytest
@@ -53,6 +54,7 @@ with try_import() as imports_successful:
     from anthropic.types.raw_message_delta_event import Delta
 
     from pydantic_ai.models.anthropic import AnthropicModel, AnthropicModelSettings
+    from pydantic_ai.providers.anthropic import AnthropicProvider
 
     # note: we use Union here so that casting works with Python 3.9
     MockAnthropicMessage = Union[AnthropicMessage, Exception]
@@ -68,7 +70,7 @@ T = TypeVar('T')
 
 
 def test_init():
-    m = AnthropicModel('claude-3-5-haiku-latest', api_key='foobar')
+    m = AnthropicModel('claude-3-5-haiku-latest', provider=AnthropicProvider(api_key='foobar'))
     assert m.client.api_key == 'foobar'
     assert m.model_name == 'claude-3-5-haiku-latest'
     assert m.system == 'anthropic'
@@ -81,6 +83,7 @@ class MockAnthropic:
     stream: Sequence[MockRawMessageStreamEvent] | Sequence[Sequence[MockRawMessageStreamEvent]] | None = None
     index = 0
     chat_completion_kwargs: list[dict[str, Any]] = field(default_factory=list)
+    base_url: str | None = None
 
     @cached_property
     def messages(self) -> Any:
@@ -134,7 +137,7 @@ def completion_message(content: list[ContentBlock], usage: AnthropicUsage) -> An
 async def test_sync_request_text_response(allow_model_requests: None):
     c = completion_message([TextBlock(text='world', type='text')], AnthropicUsage(input_tokens=5, output_tokens=10))
     mock_client = MockAnthropic.create_mock(c)
-    m = AnthropicModel('claude-3-5-haiku-latest', anthropic_client=mock_client)
+    m = AnthropicModel('claude-3-5-haiku-latest', provider=AnthropicProvider(anthropic_client=mock_client))
     agent = Agent(m)
 
     result = await agent.run('hello')
@@ -171,7 +174,7 @@ async def test_async_request_text_response(allow_model_requests: None):
         usage=AnthropicUsage(input_tokens=3, output_tokens=5),
     )
     mock_client = MockAnthropic.create_mock(c)
-    m = AnthropicModel('claude-3-5-haiku-latest', anthropic_client=mock_client)
+    m = AnthropicModel('claude-3-5-haiku-latest', provider=AnthropicProvider(anthropic_client=mock_client))
     agent = Agent(m)
 
     result = await agent.run('hello')
@@ -185,7 +188,7 @@ async def test_request_structured_response(allow_model_requests: None):
         usage=AnthropicUsage(input_tokens=3, output_tokens=5),
     )
     mock_client = MockAnthropic.create_mock(c)
-    m = AnthropicModel('claude-3-5-haiku-latest', anthropic_client=mock_client)
+    m = AnthropicModel('claude-3-5-haiku-latest', provider=AnthropicProvider(anthropic_client=mock_client))
     agent = Agent(m, result_type=list[int])
 
     result = await agent.run('hello')
@@ -235,7 +238,7 @@ async def test_request_tool_call(allow_model_requests: None):
     ]
 
     mock_client = MockAnthropic.create_mock(responses)
-    m = AnthropicModel('claude-3-5-haiku-latest', anthropic_client=mock_client)
+    m = AnthropicModel('claude-3-5-haiku-latest', provider=AnthropicProvider(anthropic_client=mock_client))
     agent = Agent(m, system_prompt='this is the system prompt')
 
     @agent.tool_plain
@@ -327,7 +330,7 @@ async def test_parallel_tool_calls(allow_model_requests: None, parallel_tool_cal
     ]
 
     mock_client = MockAnthropic.create_mock(responses)
-    m = AnthropicModel('claude-3-5-haiku-latest', anthropic_client=mock_client)
+    m = AnthropicModel('claude-3-5-haiku-latest', provider=AnthropicProvider(anthropic_client=mock_client))
     agent = Agent(m, model_settings=ModelSettings(parallel_tool_calls=parallel_tool_calls))
 
     @agent.tool_plain
@@ -366,7 +369,7 @@ async def test_multiple_parallel_tool_calls(allow_model_requests: None):
     # However, we do want to use the environment variable if present when rewriting VCR cassettes.
     api_key = os.environ.get('ANTHROPIC_API_KEY', 'mock-value')
     agent = Agent(
-        AnthropicModel('claude-3-5-haiku-latest', api_key=api_key),
+        AnthropicModel('claude-3-5-haiku-latest', provider=AnthropicProvider(api_key=api_key)),
         system_prompt=system_prompt,
         tools=[retrieve_entity_info],
     )
@@ -436,7 +439,7 @@ async def test_multiple_parallel_tool_calls(allow_model_requests: None):
 async def test_anthropic_specific_metadata(allow_model_requests: None) -> None:
     c = completion_message([TextBlock(text='world', type='text')], AnthropicUsage(input_tokens=5, output_tokens=10))
     mock_client = MockAnthropic.create_mock(c)
-    m = AnthropicModel('claude-3-5-haiku-latest', anthropic_client=mock_client)
+    m = AnthropicModel('claude-3-5-haiku-latest', provider=AnthropicProvider(anthropic_client=mock_client))
     agent = Agent(m)
 
     result = await agent.run('hello', model_settings=AnthropicModelSettings(anthropic_metadata={'user_id': '123'}))
@@ -525,7 +528,7 @@ async def test_stream_structured(allow_model_requests: None):
     ]
 
     mock_client = MockAnthropic.create_stream_mock([stream, done_stream])
-    m = AnthropicModel('claude-3-5-haiku-latest', anthropic_client=mock_client)
+    m = AnthropicModel('claude-3-5-haiku-latest', provider=AnthropicProvider(anthropic_client=mock_client))
     agent = Agent(m)
 
     tool_called = False
@@ -555,7 +558,7 @@ async def test_stream_structured(allow_model_requests: None):
 
 @pytest.mark.vcr()
 async def test_image_url_input(allow_model_requests: None, anthropic_api_key: str):
-    m = AnthropicModel('claude-3-5-haiku-latest', api_key=anthropic_api_key)
+    m = AnthropicModel('claude-3-5-haiku-latest', provider=AnthropicProvider(api_key=anthropic_api_key))
     agent = Agent(m)
 
     result = await agent.run(
@@ -573,7 +576,7 @@ Potatoes are root vegetables that are staple foods in many cuisines around the w
 
 @pytest.mark.vcr()
 async def test_image_url_input_invalid_mime_type(allow_model_requests: None, anthropic_api_key: str):
-    m = AnthropicModel('claude-3-5-haiku-latest', api_key=anthropic_api_key)
+    m = AnthropicModel('claude-3-5-haiku-latest', provider=AnthropicProvider(api_key=anthropic_api_key))
     agent = Agent(m)
 
     result = await agent.run(
@@ -593,7 +596,7 @@ async def test_image_url_input_invalid_mime_type(allow_model_requests: None, ant
 async def test_audio_as_binary_content_input(allow_model_requests: None, media_type: str):
     c = completion_message([TextBlock(text='world', type='text')], AnthropicUsage(input_tokens=5, output_tokens=10))
     mock_client = MockAnthropic.create_mock(c)
-    m = AnthropicModel('claude-3-5-haiku-latest', anthropic_client=mock_client)
+    m = AnthropicModel('claude-3-5-haiku-latest', provider=AnthropicProvider(anthropic_client=mock_client))
     agent = Agent(m)
 
     base64_content = b'//uQZ'
@@ -610,7 +613,7 @@ def test_model_status_error(allow_model_requests: None) -> None:
             body={'error': 'test error'},
         )
     )
-    m = AnthropicModel('claude-3-5-sonnet-latest', anthropic_client=mock_client)
+    m = AnthropicModel('claude-3-5-sonnet-latest', provider=AnthropicProvider(anthropic_client=mock_client))
     agent = Agent(m)
     with pytest.raises(ModelHTTPError) as exc_info:
         agent.run_sync('hello')
@@ -623,7 +626,7 @@ def test_model_status_error(allow_model_requests: None) -> None:
 async def test_document_binary_content_input(
     allow_model_requests: None, anthropic_api_key: str, document_content: BinaryContent
 ):
-    m = AnthropicModel('claude-3-5-sonnet-latest', api_key=anthropic_api_key)
+    m = AnthropicModel('claude-3-5-sonnet-latest', provider=AnthropicProvider(api_key=anthropic_api_key))
     agent = Agent(m)
 
     result = await agent.run(['What is the main content on this document?', document_content])
@@ -634,7 +637,7 @@ async def test_document_binary_content_input(
 
 @pytest.mark.vcr()
 async def test_document_url_input(allow_model_requests: None, anthropic_api_key: str):
-    m = AnthropicModel('claude-3-5-sonnet-latest', api_key=anthropic_api_key)
+    m = AnthropicModel('claude-3-5-sonnet-latest', provider=AnthropicProvider(api_key=anthropic_api_key))
     agent = Agent(m)
 
     document_url = DocumentUrl(url='https://www.w3.org/WAI/ER/tests/xhtml/testfiles/resources/pdf/dummy.pdf')
@@ -647,7 +650,7 @@ async def test_document_url_input(allow_model_requests: None, anthropic_api_key:
 
 @pytest.mark.vcr()
 async def test_text_document_url_input(allow_model_requests: None, anthropic_api_key: str):
-    m = AnthropicModel('claude-3-5-sonnet-latest', api_key=anthropic_api_key)
+    m = AnthropicModel('claude-3-5-sonnet-latest', provider=AnthropicProvider(api_key=anthropic_api_key))
     agent = Agent(m)
 
     text_document_url = DocumentUrl(url='https://example-files.online-convert.com/document/txt/example.txt')
@@ -668,3 +671,17 @@ This document is a TXT test file that primarily contains information about the u
 
 The document is formatted as a test file with metadata including its purpose, file type, and version. It also includes attribution information indicating the content is from Wikipedia and is licensed under Attribution-ShareAlike 4.0.\
 """)
+
+
+def test_init_with_provider():
+    provider = AnthropicProvider(api_key='api-key')
+    model = AnthropicModel('claude-3-opus-latest', provider=provider)
+    assert model.model_name == 'claude-3-opus-latest'
+    assert model.client == provider.client
+
+
+def test_init_with_provider_string():
+    with patch.dict(os.environ, {'ANTHROPIC_API_KEY': 'env-api-key'}, clear=False):
+        model = AnthropicModel('claude-3-opus-latest', provider='anthropic')
+        assert model.model_name == 'claude-3-opus-latest'
+        assert model.client is not None

{pydantic_ai-0.0.40 → pydantic_ai-0.0.41}/tests/models/test_fallback.py

@@ -185,6 +185,82 @@ def test_first_failed_instrumented(capfire: CaptureLogfire) -> None:
     )
 
 
+@pytest.mark.skipif(not logfire_imports_successful(), reason='logfire not installed')
+async def test_first_failed_instrumented_stream(capfire: CaptureLogfire) -> None:
+    fallback_model = FallbackModel(failure_model_stream, success_model_stream)
+    agent = Agent(model=fallback_model, instrument=True)
+    async with agent.run_stream('input') as result:
+        assert [c async for c, _is_last in result.stream_structured(debounce_by=None)] == snapshot(
+            [
+                ModelResponse(
+                    parts=[TextPart(content='hello ')],
+                    model_name='function::success_response_stream',
+                    timestamp=IsNow(tz=timezone.utc),
+                ),
+                ModelResponse(
+                    parts=[TextPart(content='hello world')],
+                    model_name='function::success_response_stream',
+                    timestamp=IsNow(tz=timezone.utc),
+                ),
+                ModelResponse(
+                    parts=[TextPart(content='hello world')],
+                    model_name='function::success_response_stream',
+                    timestamp=IsNow(tz=timezone.utc),
+                ),
+            ]
+        )
+        assert result.is_complete
+
+    assert capfire.exporter.exported_spans_as_dict() == snapshot(
+        [
+            {
+                'name': 'preparing model request params',
+                'context': {'trace_id': 1, 'span_id': 3, 'is_remote': False},
+                'parent': {'trace_id': 1, 'span_id': 1, 'is_remote': False},
+                'start_time': 2000000000,
+                'end_time': 3000000000,
+                'attributes': {
+                    'run_step': 1,
+                    'logfire.span_type': 'span',
+                    'logfire.msg': 'preparing model request params',
+                },
+            },
+            {
+                'name': 'chat function::success_response_stream',
+                'context': {'trace_id': 1, 'span_id': 5, 'is_remote': False},
+                'parent': {'trace_id': 1, 'span_id': 1, 'is_remote': False},
+                'start_time': 4000000000,
+                'end_time': 5000000000,
+                'attributes': {
+                    'gen_ai.operation.name': 'chat',
+                    'logfire.span_type': 'span',
+                    'logfire.msg': 'chat fallback:function::failure_response_stream,function::success_response_stream',
+                    'gen_ai.system': 'function',
+                    'gen_ai.request.model': 'function::success_response_stream',
+                    'gen_ai.usage.input_tokens': 50,
+                    'gen_ai.usage.output_tokens': 2,
+                    'gen_ai.response.model': 'function::success_response_stream',
+                    'events': '[{"content": "input", "role": "user", "gen_ai.system": "function", "gen_ai.message.index": 0, "event.name": "gen_ai.user.message"}, {"index": 0, "message": {"role": "assistant", "content": "hello world"}, "gen_ai.system": "function", "event.name": "gen_ai.choice"}]',
+                    'logfire.json_schema': '{"type": "object", "properties": {"events": {"type": "array"}}}',
+                },
+            },
+            {
+                'name': 'agent run',
+                'context': {'trace_id': 1, 'span_id': 1, 'is_remote': False},
+                'parent': None,
+                'start_time': 1000000000,
+                'end_time': 6000000000,
+                'attributes': {
+                    'model_name': 'fallback:function::failure_response_stream,function::success_response_stream',
+                    'agent_name': 'agent',
+                    'logfire.msg': 'agent run',
+                    'logfire.span_type': 'span',
+                },
+            },
+        ]
+    )
+
+
 def test_all_failed() -> None:
     fallback_model = FallbackModel(failure_model, failure_model)
     agent = Agent(model=fallback_model)

{pydantic_ai-0.0.40 → pydantic_ai-0.0.41}/tests/models/test_mistral.py

@@ -56,6 +56,7 @@ with try_import() as imports_successful:
         MistralModel,
         MistralStreamedResponse,
     )
+    from pydantic_ai.providers.mistral import MistralProvider
 
     # note: we use Union here so that casting works with Python 3.9
     MockChatCompletion = Union[MistralChatCompletionResponse, Exception]
@@ -98,13 +99,13 @@ class MockMistralAI:
         self, *_args: Any, stream: bool = False, **_kwargs: Any
     ) -> MistralChatCompletionResponse | MockAsyncStream[MockCompletionEvent]:
         if stream or self.stream:
-            assert self.stream is not None, 'you can only used `stream=True` if `stream` is provided'
+            assert self.stream is not None, 'you can only use `stream=True` if `stream` is provided'
             if isinstance(self.stream[0], list):
                 response = MockAsyncStream(iter(cast(list[MockCompletionEvent], self.stream[self.index])))
             else:
                 response = MockAsyncStream(iter(cast(list[MockCompletionEvent], self.stream)))
         else:
-            assert self.completions is not None, 'you can only used `stream=False` if `completions` are provided'
+            assert self.completions is not None, 'you can only use `stream=False` if `completions` are provided'
             if isinstance(self.completions, Sequence):
                 raise_if_exception(self.completions[self.index])
                 response = cast(MistralChatCompletionResponse, self.completions[self.index])
@@ -173,8 +174,14 @@ def func_chunk(
 #####################
 
 
+def test_init_deprecated():
+    m = MistralModel('mistral-large-latest', api_key='foobar')  # pyright: ignore[reportDeprecated]
+    assert m.model_name == 'mistral-large-latest'
+    assert m.base_url == 'https://api.mistral.ai'
+
+
 def test_init():
-    m = MistralModel('mistral-large-latest', api_key='foobar')
+    m = MistralModel('mistral-large-latest', provider=MistralProvider(api_key='foobar'))
     assert m.model_name == 'mistral-large-latest'
     assert m.base_url == 'https://api.mistral.ai'
 
@@ -194,7 +201,7 @@ async def test_multiple_completions(allow_model_requests: None):
         completion_message(MistralAssistantMessage(content='hello again')),
     ]
     mock_client = MockMistralAI.create_mock(completions)
-    model = MistralModel('mistral-large-latest', client=mock_client)
+    model = MistralModel('mistral-large-latest', provider=MistralProvider(mistral_client=mock_client))
     agent = Agent(model=model)
 
     result = await agent.run('hello')
@@ -237,7 +244,7 @@ async def test_three_completions(allow_model_requests: None):
         completion_message(MistralAssistantMessage(content='final message')),
     ]
     mock_client = MockMistralAI.create_mock(completions)
-    model = MistralModel('mistral-large-latest', client=mock_client)
+    model = MistralModel('mistral-large-latest', provider=MistralProvider(mistral_client=mock_client))
     agent = Agent(model=model)
 
     result = await agent.run('hello')
@@ -296,7 +303,7 @@ async def test_stream_text(allow_model_requests: None):
         chunk([]),
     ]
     mock_client = MockMistralAI.create_stream_mock(stream)
-    model = MistralModel('mistral-large-latest', client=mock_client)
+    model = MistralModel('mistral-large-latest', provider=MistralProvider(mistral_client=mock_client))
     agent = Agent(model=model)
 
     async with agent.run_stream('') as result:
@@ -317,7 +324,7 @@ async def test_stream_text_finish_reason(allow_model_requests: None):
         text_chunk('.', finish_reason='stop'),
     ]
     mock_client = MockMistralAI.create_stream_mock(stream)
-    model = MistralModel('mistral-large-latest', client=mock_client)
+    model = MistralModel('mistral-large-latest', provider=MistralProvider(mistral_client=mock_client))
     agent = Agent(model=model)
 
     async with agent.run_stream('') as result:
@@ -335,7 +342,7 @@ async def test_no_delta(allow_model_requests: None):
         text_chunk('world'),
     ]
     mock_client = MockMistralAI.create_stream_mock(stream)
-    model = MistralModel('mistral-large-latest', client=mock_client)
+    model = MistralModel('mistral-large-latest', provider=MistralProvider(mistral_client=mock_client))
     agent = Agent(model=model)
 
     async with agent.run_stream('') as result:
@@ -372,7 +379,7 @@ async def test_request_model_structured_with_arguments_dict_response(allow_model
         usage=MistralUsageInfo(prompt_tokens=1, completion_tokens=2, total_tokens=3),
     )
     mock_client = MockMistralAI.create_mock(completion)
-    model = MistralModel('mistral-large-latest', client=mock_client)
+    model = MistralModel('mistral-large-latest', provider=MistralProvider(mistral_client=mock_client))
     agent = Agent(model=model, result_type=CityLocation)
 
     result = await agent.run('User prompt value')
@@ -430,7 +437,7 @@ async def test_request_model_structured_with_arguments_str_response(allow_model_
         )
     )
     mock_client = MockMistralAI.create_mock(completion)
-    model = MistralModel('mistral-large-latest', client=mock_client)
+    model = MistralModel('mistral-large-latest', provider=MistralProvider(mistral_client=mock_client))
     agent = Agent(model=model, result_type=CityLocation)
 
     result = await agent.run('User prompt value')
@@ -483,7 +490,7 @@ async def test_request_result_type_with_arguments_str_response(allow_model_reque
         )
     )
     mock_client = MockMistralAI.create_mock(completion)
-    model = MistralModel('mistral-large-latest', client=mock_client)
+    model = MistralModel('mistral-large-latest', provider=MistralProvider(mistral_client=mock_client))
     agent = Agent(model=model, result_type=int, system_prompt='System prompt value')
 
     result = await agent.run('User prompt value')
@@ -568,7 +575,7 @@ async def test_stream_structured_with_all_type(allow_model_requests: None):
     ]
 
     mock_client = MockMistralAI.create_stream_mock(stream)
-    model = MistralModel('mistral-large-latest', client=mock_client)
+    model = MistralModel('mistral-large-latest', provider=MistralProvider(mistral_client=mock_client))
     agent = Agent(model, result_type=MyTypedDict)
 
     async with agent.run_stream('User prompt value') as result:
@@ -678,7 +685,7 @@ async def test_stream_result_type_primitif_dict(allow_model_requests: None):
     ]
 
     mock_client = MockMistralAI.create_stream_mock(stream)
-    model = MistralModel('mistral-large-latest', client=mock_client)
+    model = MistralModel('mistral-large-latest', provider=MistralProvider(mistral_client=mock_client))
     agent = Agent(model=model, result_type=MyTypedDict)
 
     async with agent.run_stream('User prompt value') as result:
@@ -734,7 +741,7 @@ async def test_stream_result_type_primitif_int(allow_model_requests: None):
     ]
 
     mock_client = MockMistralAI.create_stream_mock(stream)
-    model = MistralModel('mistral-large-latest', client=mock_client)
+    model = MistralModel('mistral-large-latest', provider=MistralProvider(mistral_client=mock_client))
     agent = Agent(model=model, result_type=int)
 
     async with agent.run_stream('User prompt value') as result:
@@ -793,7 +800,7 @@ async def test_stream_result_type_primitif_array(allow_model_requests: None):
     ]
 
     mock_client = MockMistralAI.create_stream_mock(stream)
-    model = MistralModel('mistral-large-latest', client=mock_client)
+    model = MistralModel('mistral-large-latest', provider=MistralProvider(mistral_client=mock_client))
     agent = Agent(model, result_type=list[str])
 
     async with agent.run_stream('User prompt value') as result:
@@ -886,7 +893,7 @@ async def test_stream_result_type_basemodel_with_default_params(allow_model_requ
     ]
 
     mock_client = MockMistralAI.create_stream_mock(stream)
-    model = MistralModel('mistral-large-latest', client=mock_client)
+    model = MistralModel('mistral-large-latest', provider=MistralProvider(mistral_client=mock_client))
     agent = Agent(model=model, result_type=MyTypedBaseModel)
 
     async with agent.run_stream('User prompt value') as result:
@@ -971,7 +978,7 @@ async def test_stream_result_type_basemodel_with_required_params(allow_model_req
     ]
 
     mock_client = MockMistralAI.create_stream_mock(stream)
-    model = MistralModel('mistral-large-latest', client=mock_client)
+    model = MistralModel('mistral-large-latest', provider=MistralProvider(mistral_client=mock_client))
     agent = Agent(model=model, result_type=MyTypedBaseModel)
 
     async with agent.run_stream('User prompt value') as result:
@@ -1043,7 +1050,7 @@ async def test_request_tool_call(allow_model_requests: None):
         completion_message(MistralAssistantMessage(content='final response', role='assistant')),
     ]
     mock_client = MockMistralAI.create_mock(completion)
-    model = MistralModel('mistral-large-latest', client=mock_client)
+    model = MistralModel('mistral-large-latest', provider=MistralProvider(mistral_client=mock_client))
     agent = Agent(model, system_prompt='this is the system prompt')
 
     @agent.tool_plain
@@ -1180,7 +1187,7 @@ async def test_request_tool_call_with_result_type(allow_model_requests: None):
         ),
     ]
     mock_client = MockMistralAI.create_mock(completion)
-    model = MistralModel('mistral-large-latest', client=mock_client)
+    model = MistralModel('mistral-large-latest', provider=MistralProvider(mistral_client=mock_client))
     agent = Agent(model, system_prompt='this is the system prompt', result_type=MyTypedDict)
 
     @agent.tool_plain
@@ -1316,7 +1323,7 @@ async def test_stream_tool_call_with_return_type(allow_model_requests: None):
     ]
 
     mock_client = MockMistralAI.create_stream_mock(completion)
-    model = MistralModel('mistral-large-latest', client=mock_client)
+    model = MistralModel('mistral-large-latest', provider=MistralProvider(mistral_client=mock_client))
     agent = Agent(model, system_prompt='this is the system prompt', result_type=MyTypedDict)
 
     @agent.tool_plain
@@ -1416,7 +1423,7 @@ async def test_stream_tool_call(allow_model_requests: None):
     ]
 
     mock_client = MockMistralAI.create_stream_mock(completion)
-    model = MistralModel('mistral-large-latest', client=mock_client)
+    model = MistralModel('mistral-large-latest', provider=MistralProvider(mistral_client=mock_client))
     agent = Agent(model, system_prompt='this is the system prompt')
 
     @agent.tool_plain
@@ -1516,7 +1523,7 @@ async def test_stream_tool_call_with_retry(allow_model_requests: None):
     ]
 
     mock_client = MockMistralAI.create_stream_mock(completion)
-    model = MistralModel('mistral-large-latest', client=mock_client)
+    model = MistralModel('mistral-large-latest', provider=MistralProvider(mistral_client=mock_client))
     agent = Agent(model, system_prompt='this is the system prompt')
 
     @agent.tool_plain
@@ -1743,7 +1750,7 @@ def test_validate_required_json_schema(desc: str, schema: dict[str, Any], data:
 async def test_image_url_input(allow_model_requests: None):
     c = completion_message(MistralAssistantMessage(content='world', role='assistant'))
     mock_client = MockMistralAI.create_mock(c)
-    m = MistralModel('mistral-large-latest', client=mock_client)
+    m = MistralModel('mistral-large-latest', provider=MistralProvider(mistral_client=mock_client))
     agent = Agent(m)
 
     result = await agent.run(
@@ -1779,7 +1786,7 @@ async def test_image_url_input(allow_model_requests: None):
 async def test_image_as_binary_content_input(allow_model_requests: None):
     c = completion_message(MistralAssistantMessage(content='world', role='assistant'))
     mock_client = MockMistralAI.create_mock(c)
-    m = MistralModel('mistral-large-latest', client=mock_client)
+    m = MistralModel('mistral-large-latest', provider=MistralProvider(mistral_client=mock_client))
     agent = Agent(m)
 
     base64_content = (
@@ -1810,7 +1817,7 @@ async def test_image_as_binary_content_input(allow_model_requests: None):
 async def test_audio_as_binary_content_input(allow_model_requests: None):
     c = completion_message(MistralAssistantMessage(content='world', role='assistant'))
     mock_client = MockMistralAI.create_mock(c)
-    m = MistralModel('mistral-large-latest', client=mock_client)
+    m = MistralModel('mistral-large-latest', provider=MistralProvider(mistral_client=mock_client))
     agent = Agent(m)
 
     base64_content = b'//uQZ'
@@ -1827,7 +1834,7 @@ def test_model_status_error(allow_model_requests: None) -> None:
             body='test error',
         )
     )
-    m = MistralModel('mistral-large-latest', client=mock_client)
+    m = MistralModel('mistral-large-latest', provider=MistralProvider(mistral_client=mock_client))
     agent = Agent(m)
     with pytest.raises(ModelHTTPError) as exc_info:
         agent.run_sync('hello')

pydantic_ai-0.0.41/tests/providers/test_anthropic.py

@@ -0,0 +1,56 @@
+from __future__ import annotations as _annotations
+
+import os
+from unittest.mock import patch
+
+import httpx
+import pytest
+
+from ..conftest import try_import
+
+with try_import() as imports_successful:
+    from anthropic import AsyncAnthropic
+
+    from pydantic_ai.providers.anthropic import AnthropicProvider
+
+
+pytestmark = pytest.mark.skipif(not imports_successful(), reason='need to install anthropic')
+
+
+def test_anthropic_provider():
+    provider = AnthropicProvider(api_key='api-key')
+    assert provider.name == 'anthropic'
+    assert provider.base_url == 'https://api.anthropic.com'
+    assert isinstance(provider.client, AsyncAnthropic)
+    assert provider.client.api_key == 'api-key'
+
+
+def test_anthropic_provider_need_api_key() -> None:
+    with patch.dict(os.environ, {}, clear=True):
+        with pytest.raises(
+            ValueError,
+            match=r'.*ANTHROPIC_API_KEY.*',
+        ):
+            AnthropicProvider()
+
+
+def test_anthropic_provider_pass_http_client() -> None:
+    http_client = httpx.AsyncClient()
+    provider = AnthropicProvider(http_client=http_client, api_key='api-key')
+    assert isinstance(provider.client, AsyncAnthropic)
+    # Verify the http_client is being used by the AsyncAnthropic client
+    assert provider.client._client == http_client  # type: ignore[reportPrivateUsage]
+
+
+def test_anthropic_provider_pass_anthropic_client() -> None:
+    anthropic_client = AsyncAnthropic(api_key='api-key')
+    provider = AnthropicProvider(anthropic_client=anthropic_client)
+    assert provider.client == anthropic_client
+
+
+def test_anthropic_provider_with_env_base_url(monkeypatch: pytest.MonkeyPatch) -> None:
+    # Test with environment variable for base_url
+    custom_base_url = 'https://custom.anthropic.com/v1'
+    monkeypatch.setenv('ANTHROPIC_BASE_URL', custom_base_url)
+    provider = AnthropicProvider(api_key='api-key')
+    assert provider.base_url.rstrip('/') == custom_base_url.rstrip('/')

{pydantic_ai-0.0.40 → pydantic_ai-0.0.41}/tests/providers/test_groq.py

@@ -55,12 +55,3 @@ def test_groq_provider_with_env_base_url(monkeypatch: pytest.MonkeyPatch) -> Non
     monkeypatch.setenv('GROQ_BASE_URL', 'https://custom.groq.com/v1')
     provider = GroqProvider(api_key='api-key')
     assert provider.base_url == 'https://custom.groq.com/v1'
-
-
-def test_infer_groq_provider():
-    with patch.dict(os.environ, {'GROQ_API_KEY': 'test-api-key'}, clear=False):
-        from pydantic_ai.providers import infer_provider
-
-        provider = infer_provider('groq')
-        assert provider.name == 'groq'
-        assert isinstance(provider, GroqProvider)

pydantic_ai-0.0.41/tests/providers/test_mistral.py

@@ -0,0 +1,58 @@
+from __future__ import annotations as _annotations
+
+import os
+import re
+from unittest.mock import patch
+
+import httpx
+import pytest
+
+from ..conftest import try_import
+
+with try_import() as imports_successful:
+    from mistralai import Mistral
+
+    from pydantic_ai.providers.mistral import MistralProvider
+
+
+pytestmark = pytest.mark.skipif(not imports_successful(), reason='mistral not installed')
+
+
+def test_mistral_provider():
+    provider = MistralProvider(api_key='api-key')
+    assert provider.name == 'mistral'
+    assert provider.base_url == 'https://api.mistral.ai'
+    assert isinstance(provider.client, Mistral)
+    assert provider.client.sdk_configuration.security.api_key == 'api-key'  # pyright: ignore
+
+
+def test_mistral_provider_need_api_key() -> None:
+    with patch.dict(os.environ, {}, clear=True):
+        with pytest.raises(
+            ValueError,
+            match=re.escape(
+                'Set the `MISTRAL_API_KEY` environment variable or pass it via `MistralProvider(api_key=...)`'
+                'to use the Mistral provider.'
+            ),
+        ):
+            MistralProvider()
+
+
+def test_mistral_provider_pass_http_client() -> None:
+    http_client = httpx.AsyncClient()
+    provider = MistralProvider(http_client=http_client, api_key='api-key')
+    assert provider.client.sdk_configuration.async_client == http_client
+
+
+def test_mistral_provider_pass_groq_client() -> None:
+    mistral_client = Mistral(api_key='api-key')
+    provider = MistralProvider(mistral_client=mistral_client)
+    assert provider.client == mistral_client
+
+
+def test_mistral_provider_with_base_url() -> None:
+    # Test with environment variable for base_url
+    provider = MistralProvider(
+        mistral_client=Mistral(api_key='test-api-key', server_url='https://custom.mistral.com/v1'),
+    )
+    assert provider.base_url == 'https://custom.mistral.com/v1'

{pydantic_ai-0.0.40 → pydantic_ai-0.0.41}/tests/providers/test_provider_names.py

@@ -11,22 +11,26 @@ from pydantic_ai.providers import Provider, infer_provider
 from ..conftest import try_import
 
 with try_import() as imports_successful:
+    from pydantic_ai.providers.anthropic import AnthropicProvider
     from pydantic_ai.providers.deepseek import DeepSeekProvider
     from pydantic_ai.providers.google_gla import GoogleGLAProvider
     from pydantic_ai.providers.google_vertex import GoogleVertexProvider
     from pydantic_ai.providers.groq import GroqProvider
+    from pydantic_ai.providers.mistral import MistralProvider
     from pydantic_ai.providers.openai import OpenAIProvider
 
     test_infer_provider_params = [
+        ('anthropic', AnthropicProvider, 'ANTHROPIC_API_KEY'),
         ('deepseek', DeepSeekProvider, 'DEEPSEEK_API_KEY'),
         ('openai', OpenAIProvider, None),
         ('google-vertex', GoogleVertexProvider, None),
         ('google-gla', GoogleGLAProvider, 'GEMINI_API_KEY'),
         ('groq', GroqProvider, 'GROQ_API_KEY'),
+        ('mistral', MistralProvider, 'MISTRAL_API_KEY'),
     ]
 
 if not imports_successful():
-    test_infer_provider_params = []
+    test_infer_provider_params = []  # pragma: no cover
 
 pytestmark = pytest.mark.skipif(not imports_successful(), reason='need to install all extra packages')
 

{pydantic_ai-0.0.40 → pydantic_ai-0.0.41}/tests/test_live.py

@@ -57,8 +57,9 @@ def groq(http_client: httpx.AsyncClient, _tmp_path: Path) -> Model:
 
 def anthropic(http_client: httpx.AsyncClient, _tmp_path: Path) -> Model:
     from pydantic_ai.models.anthropic import AnthropicModel
+    from pydantic_ai.providers.anthropic import AnthropicProvider
 
-    return AnthropicModel('claude-3-5-sonnet-latest', http_client=http_client)
+    return AnthropicModel('claude-3-5-sonnet-latest', provider=AnthropicProvider(http_client=http_client))
 
 
 def ollama(http_client: httpx.AsyncClient, _tmp_path: Path) -> Model:
@@ -72,8 +73,9 @@ def ollama(http_client: httpx.AsyncClient, _tmp_path: Path) -> Model:
 
 def mistral(http_client: httpx.AsyncClient, _tmp_path: Path) -> Model:
     from pydantic_ai.models.mistral import MistralModel
+    from pydantic_ai.providers.mistral import MistralProvider
 
-    return MistralModel('mistral-small-latest', http_client=http_client)
+    return MistralModel('mistral-small-latest', provider=MistralProvider(http_client=http_client))
 
 
 # TODO(Marcelo): We've surpassed the limit of our API key on Cohere.