pydantic-ai-slim 0.0.39__tar.gz → 0.0.41__tar.gz

{pydantic_ai_slim-0.0.39 → pydantic_ai_slim-0.0.41}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai-slim
-Version: 0.0.39
+Version: 0.0.41
 Summary: Agent Framework / shim to use Pydantic with LLMs, slim package
 Author-email: Samuel Colvin <samuel@pydantic.dev>
 License-Expression: MIT
@@ -29,7 +29,7 @@ Requires-Dist: exceptiongroup; python_version < '3.11'
 Requires-Dist: griffe>=1.3.2
 Requires-Dist: httpx>=0.27
 Requires-Dist: opentelemetry-api>=1.28.0
-Requires-Dist: pydantic-graph==0.0.39
+Requires-Dist: pydantic-graph==0.0.41
 Requires-Dist: pydantic>=2.10
 Requires-Dist: typing-inspection>=0.4.0
 Provides-Extra: anthropic

{pydantic_ai_slim-0.0.39 → pydantic_ai_slim-0.0.41}/pydantic_ai/models/__init__.py

@@ -262,8 +262,14 @@ class Model(ABC):
 
     @property
     @abstractmethod
-    def system(self) -> str | None:
-        """The system / model provider, ex: openai."""
+    def system(self) -> str:
+        """The system / model provider, ex: openai.
+
+        Use to populate the `gen_ai.system` OpenTelemetry semantic convention attribute,
+        so should use well-known values listed in
+        https://opentelemetry.io/docs/specs/semconv/attributes-registry/gen-ai/#gen-ai-system
+        when applicable.
+        """
         raise NotImplementedError()
 
     @property

{pydantic_ai_slim-0.0.39 → pydantic_ai_slim-0.0.41}/pydantic_ai/models/anthropic.py

@@ -11,7 +11,7 @@ from typing import Any, Literal, Union, cast, overload
 
 from anthropic.types import DocumentBlockParam
 from httpx import AsyncClient as AsyncHTTPClient
-from typing_extensions import assert_never
+from typing_extensions import assert_never, deprecated
 
 from .. import ModelHTTPError, UnexpectedModelBehavior, _utils, usage
 from .._utils import guard_tool_call_id as _guard_tool_call_id
@@ -31,15 +31,10 @@ from ..messages import (
     ToolReturnPart,
     UserPromptPart,
 )
+from ..providers import Provider, infer_provider
 from ..settings import ModelSettings
 from ..tools import ToolDefinition
-from . import (
-    Model,
-    ModelRequestParameters,
-    StreamedResponse,
-    cached_async_http_client,
-    check_allow_model_requests,
-)
+from . import Model, ModelRequestParameters, StreamedResponse, cached_async_http_client, check_allow_model_requests
 
 try:
     from anthropic import NOT_GIVEN, APIStatusError, AsyncAnthropic, AsyncStream
@@ -115,12 +110,33 @@ class AnthropicModel(Model):
     client: AsyncAnthropic = field(repr=False)
 
     _model_name: AnthropicModelName = field(repr=False)
-    _system: str | None = field(default='anthropic', repr=False)
+    _system: str = field(default='anthropic', repr=False)
+
+    @overload
+    def __init__(
+        self,
+        model_name: AnthropicModelName,
+        *,
+        provider: Literal['anthropic'] | Provider[AsyncAnthropic] = 'anthropic',
+    ) -> None: ...
 
+    @deprecated('Use the `provider` parameter instead of `api_key`, `anthropic_client`, and `http_client`.')
+    @overload
     def __init__(
         self,
         model_name: AnthropicModelName,
         *,
+        provider: None = None,
+        api_key: str | None = None,
+        anthropic_client: AsyncAnthropic | None = None,
+        http_client: AsyncHTTPClient | None = None,
+    ) -> None: ...
+
+    def __init__(
+        self,
+        model_name: AnthropicModelName,
+        *,
+        provider: Literal['anthropic'] | Provider[AsyncAnthropic] | None = None,
         api_key: str | None = None,
         anthropic_client: AsyncAnthropic | None = None,
         http_client: AsyncHTTPClient | None = None,
@@ -130,6 +146,8 @@ class AnthropicModel(Model):
         Args:
             model_name: The name of the Anthropic model to use. List of model names available
                 [here](https://docs.anthropic.com/en/docs/about-claude/models).
+            provider: The provider to use for the Anthropic API. Can be either the string 'anthropic' or an
+                instance of `Provider[AsyncAnthropic]`. If not provided, the other parameters will be used.
             api_key: The API key to use for authentication, if not provided, the `ANTHROPIC_API_KEY` environment variable
                 will be used if available.
             anthropic_client: An existing
@@ -138,7 +156,12 @@ class AnthropicModel(Model):
             http_client: An existing `httpx.AsyncClient` to use for making HTTP requests.
         """
         self._model_name = model_name
-        if anthropic_client is not None:
+
+        if provider is not None:
+            if isinstance(provider, str):
+                provider = infer_provider(provider)
+            self.client = provider.client
+        elif anthropic_client is not None:
             assert http_client is None, 'Cannot provide both `anthropic_client` and `http_client`'
             assert api_key is None, 'Cannot provide both `anthropic_client` and `api_key`'
             self.client = anthropic_client
@@ -183,7 +206,7 @@ class AnthropicModel(Model):
         return self._model_name
 
     @property
-    def system(self) -> str | None:
+    def system(self) -> str:
         """The system / model provider."""
         return self._system
 
@@ -355,8 +378,17 @@ class AnthropicModel(Model):
                             source={'data': io.BytesIO(item.data), 'media_type': item.media_type, 'type': 'base64'},  # type: ignore
                             type='image',
                         )
+                    elif item.media_type == 'application/pdf':
+                        yield DocumentBlockParam(
+                            source=Base64PDFSourceParam(
+                                data=io.BytesIO(item.data),
+                                media_type='application/pdf',
+                                type='base64',
+                            ),
+                            type='document',
+                        )
                     else:
-                        raise RuntimeError('Only images are supported for binary content')
+                        raise RuntimeError('Only images and PDFs are supported for binary content')
                 elif isinstance(item, ImageUrl):
                     try:
                         response = await cached_async_http_client().get(item.url)

{pydantic_ai_slim-0.0.39 → pydantic_ai_slim-0.0.41}/pydantic_ai/models/bedrock.py

@@ -119,7 +119,7 @@ class BedrockConverseModel(Model):
     client: BedrockRuntimeClient
 
     _model_name: BedrockModelName = field(repr=False)
-    _system: str | None = field(default='bedrock', repr=False)
+    _system: str = field(default='bedrock', repr=False)
 
     @property
     def model_name(self) -> str:
@@ -127,7 +127,7 @@ class BedrockConverseModel(Model):
         return self._model_name
 
     @property
-    def system(self) -> str | None:
+    def system(self) -> str:
         """The system / model provider, ex: openai."""
         return self._system
 

{pydantic_ai_slim-0.0.39 → pydantic_ai_slim-0.0.41}/pydantic_ai/models/cohere.py

@@ -98,7 +98,7 @@ class CohereModel(Model):
     client: AsyncClientV2 = field(repr=False)
 
     _model_name: CohereModelName = field(repr=False)
-    _system: str | None = field(default='cohere', repr=False)
+    _system: str = field(default='cohere', repr=False)
 
     def __init__(
         self,
@@ -148,7 +148,7 @@ class CohereModel(Model):
         return self._model_name
 
     @property
-    def system(self) -> str | None:
+    def system(self) -> str:
         """The system / model provider."""
         return self._system
 

{pydantic_ai_slim-0.0.39 → pydantic_ai_slim-0.0.41}/pydantic_ai/models/fallback.py

@@ -1,10 +1,14 @@
 from __future__ import annotations as _annotations
 
 from collections.abc import AsyncIterator
-from contextlib import AsyncExitStack, asynccontextmanager
+from contextlib import AsyncExitStack, asynccontextmanager, suppress
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Callable
 
+from opentelemetry.trace import get_current_span
+
+from pydantic_ai.models.instrumented import InstrumentedModel
+
 from ..exceptions import FallbackExceptionGroup, ModelHTTPError
 from . import KnownModelName, Model, ModelRequestParameters, StreamedResponse, infer_model
 
@@ -40,7 +44,6 @@ class FallbackModel(Model):
             fallback_on: A callable or tuple of exceptions that should trigger a fallback.
         """
         self.models = [infer_model(default_model), *[infer_model(m) for m in fallback_models]]
-        self._model_name = f'FallBackModel[{", ".join(model.model_name for model in self.models)}]'
 
         if isinstance(fallback_on, tuple):
             self._fallback_on = _default_fallback_condition_factory(fallback_on)
@@ -62,14 +65,15 @@ class FallbackModel(Model):
         for model in self.models:
             try:
                 response, usage = await model.request(messages, model_settings, model_request_parameters)
-                response.model_used = model  # type: ignore
-                return response, usage
             except Exception as exc:
                 if self._fallback_on(exc):
                     exceptions.append(exc)
                     continue
                 raise exc
 
+            self._set_span_attributes(model)
+            return response, usage
+
         raise FallbackExceptionGroup('All models from FallbackModel failed', exceptions)
 
     @asynccontextmanager
@@ -93,20 +97,29 @@ class FallbackModel(Model):
                         exceptions.append(exc)
                         continue
                     raise exc
+
+                self._set_span_attributes(model)
                 yield response
                 return
 
         raise FallbackExceptionGroup('All models from FallbackModel failed', exceptions)
 
+    def _set_span_attributes(self, model: Model):
+        with suppress(Exception):
+            span = get_current_span()
+            if span.is_recording():
+                attributes = getattr(span, 'attributes', {})
+                if attributes.get('gen_ai.request.model') == self.model_name:
+                    span.set_attributes(InstrumentedModel.model_attributes(model))
+
     @property
     def model_name(self) -> str:
         """The model name."""
-        return self._model_name
+        return f'fallback:{",".join(model.model_name for model in self.models)}'
 
     @property
-    def system(self) -> str | None:
-        """The system / model provider, n/a for fallback models."""
-        return None
+    def system(self) -> str:
+        return f'fallback:{",".join(model.system for model in self.models)}'
 
     @property
     def base_url(self) -> str | None:

{pydantic_ai_slim-0.0.39 → pydantic_ai_slim-0.0.41}/pydantic_ai/models/function.py

@@ -45,7 +45,7 @@ class FunctionModel(Model):
     stream_function: StreamFunctionDef | None = None
 
     _model_name: str = field(repr=False)
-    _system: str | None = field(default=None, repr=False)
+    _system: str = field(default='function', repr=False)
 
     @overload
     def __init__(self, function: FunctionDef, *, model_name: str | None = None) -> None: ...
@@ -140,7 +140,7 @@ class FunctionModel(Model):
         return self._model_name
 
     @property
-    def system(self) -> str | None:
+    def system(self) -> str:
         """The system / model provider."""
         return self._system
 

{pydantic_ai_slim-0.0.39 → pydantic_ai_slim-0.0.41}/pydantic_ai/models/gemini.py

@@ -91,7 +91,7 @@ class GeminiModel(Model):
     _provider: Literal['google-gla', 'google-vertex'] | Provider[AsyncHTTPClient] | None = field(repr=False)
     _auth: AuthProtocol | None = field(repr=False)
     _url: str | None = field(repr=False)
-    _system: str | None = field(default='google-gla', repr=False)
+    _system: str = field(default='gemini', repr=False)
 
     @overload
     def __init__(
@@ -139,11 +139,9 @@ class GeminiModel(Model):
 
         if provider is not None:
             if isinstance(provider, str):
-                self._system = provider
-                self.client = infer_provider(provider).client
-            else:
-                self._system = provider.name
-                self.client = provider.client
+                provider = infer_provider(provider)
+            self._system = provider.name
+            self.client = provider.client
             self._url = str(self.client.base_url)
         else:
             if api_key is None:
@@ -197,7 +195,7 @@ class GeminiModel(Model):
         return self._model_name
 
     @property
-    def system(self) -> str | None:
+    def system(self) -> str:
         """The system / model provider."""
         return self._system
 

{pydantic_ai_slim-0.0.39 → pydantic_ai_slim-0.0.41}/pydantic_ai/models/groq.py

@@ -88,7 +88,7 @@ class GroqModel(Model):
     client: AsyncGroq = field(repr=False)
 
     _model_name: GroqModelName = field(repr=False)
-    _system: str | None = field(default='groq', repr=False)
+    _system: str = field(default='groq', repr=False)
 
     @overload
     def __init__(
@@ -138,9 +138,8 @@ class GroqModel(Model):
 
         if provider is not None:
             if isinstance(provider, str):
-                self.client = infer_provider(provider).client
-            else:
-                self.client = provider.client
+                provider = infer_provider(provider)
+            self.client = provider.client
         elif groq_client is not None:
             assert http_client is None, 'Cannot provide both `groq_client` and `http_client`'
             assert api_key is None, 'Cannot provide both `groq_client` and `api_key`'
@@ -186,7 +185,7 @@ class GroqModel(Model):
         return self._model_name
 
     @property
-    def system(self) -> str | None:
+    def system(self) -> str:
         """The system / model provider."""
         return self._system
 

{pydantic_ai_slim-0.0.39 → pydantic_ai_slim-0.0.41}/pydantic_ai/models/instrumented.py

@@ -175,11 +175,7 @@ class InstrumentedModel(WrapperModel):
                         )
                     )
                 new_attributes: dict[str, AttributeValue] = usage.opentelemetry_attributes()  # type: ignore
-                if model_used := getattr(response, 'model_used', None):
-                    # FallbackModel sets model_used on the response so that we can report the attributes
-                    # of the model that was actually used.
-                    new_attributes.update(self.model_attributes(model_used))
-                    attributes.update(new_attributes)
+                attributes.update(getattr(span, 'attributes', {}))
                 request_model = attributes[GEN_AI_REQUEST_MODEL_ATTRIBUTE]
                 new_attributes['gen_ai.response.model'] = response.model_name or request_model
                 span.set_attributes(new_attributes)
@@ -213,10 +209,8 @@ class InstrumentedModel(WrapperModel):
 
     @staticmethod
     def model_attributes(model: Model):
-        system = getattr(model, 'system', '') or model.__class__.__name__.removesuffix('Model').lower()
-        system = {'google-gla': 'gemini', 'google-vertex': 'vertex_ai', 'mistral': 'mistral_ai'}.get(system, system)
         attributes: dict[str, AttributeValue] = {
-            GEN_AI_SYSTEM_ATTRIBUTE: system,
+            GEN_AI_SYSTEM_ATTRIBUTE: model.system,
             GEN_AI_REQUEST_MODEL_ATTRIBUTE: model.model_name,
         }
         if base_url := model.base_url:

{pydantic_ai_slim-0.0.39 → pydantic_ai_slim-0.0.41}/pydantic_ai/models/mistral.py

@@ -7,11 +7,11 @@ from contextlib import asynccontextmanager
 from dataclasses import dataclass, field
 from datetime import datetime, timezone
 from itertools import chain
-from typing import Any, Callable, Literal, Union, cast
+from typing import Any, Callable, Literal, Union, cast, overload
 
 import pydantic_core
 from httpx import AsyncClient as AsyncHTTPClient, Timeout
-from typing_extensions import assert_never
+from typing_extensions import assert_never, deprecated
 
 from .. import ModelHTTPError, UnexpectedModelBehavior, _utils
 from .._utils import now_utc as _now_utc
@@ -31,6 +31,7 @@ from ..messages import (
     ToolReturnPart,
     UserPromptPart,
 )
+from ..providers import Provider, infer_provider
 from ..result import Usage
 from ..settings import ModelSettings
 from ..tools import ToolDefinition
@@ -110,12 +111,35 @@ class MistralModel(Model):
     json_mode_schema_prompt: str = """Answer in JSON Object, respect the format:\n```\n{schema}\n```\n"""
 
     _model_name: MistralModelName = field(repr=False)
-    _system: str | None = field(default='mistral', repr=False)
+    _system: str = field(default='mistral_ai', repr=False)
 
+    @overload
     def __init__(
         self,
         model_name: MistralModelName,
         *,
+        provider: Literal['mistral'] | Provider[Mistral] = 'mistral',
+        json_mode_schema_prompt: str = """Answer in JSON Object, respect the format:\n```\n{schema}\n```\n""",
+    ) -> None: ...
+
+    @overload
+    @deprecated('Use the `provider` parameter instead of `api_key`, `client` and `http_client`.')
+    def __init__(
+        self,
+        model_name: MistralModelName,
+        *,
+        provider: None = None,
+        api_key: str | Callable[[], str | None] | None = None,
+        client: Mistral | None = None,
+        http_client: AsyncHTTPClient | None = None,
+        json_mode_schema_prompt: str = """Answer in JSON Object, respect the format:\n```\n{schema}\n```\n""",
+    ) -> None: ...
+
+    def __init__(
+        self,
+        model_name: MistralModelName,
+        *,
+        provider: Literal['mistral'] | Provider[Mistral] | None = None,
         api_key: str | Callable[[], str | None] | None = None,
         client: Mistral | None = None,
         http_client: AsyncHTTPClient | None = None,
@@ -124,6 +148,9 @@ class MistralModel(Model):
         """Initialize a Mistral model.
 
         Args:
+            provider: The provider to use for authentication and API access. Can be either the string
+                'mistral' or an instance of `Provider[Mistral]`. If not provided, a new provider will be
+                created using the other parameters.
             model_name: The name of the model to use.
             api_key: The API key to use for authentication, if unset uses `MISTRAL_API_KEY` environment variable.
             client: An existing `Mistral` client to use, if provided, `api_key` and `http_client` must be `None`.
@@ -133,17 +160,22 @@ class MistralModel(Model):
         self._model_name = model_name
         self.json_mode_schema_prompt = json_mode_schema_prompt
 
-        if client is not None:
+        if provider is not None:
+            if isinstance(provider, str):
+                # TODO(Marcelo): We should add an integration test with VCR when I get the API key.
+                provider = infer_provider(provider)  # pragma: no cover
+            self.client = provider.client
+        elif client is not None:
             assert http_client is None, 'Cannot provide both `mistral_client` and `http_client`'
             assert api_key is None, 'Cannot provide both `mistral_client` and `api_key`'
             self.client = client
         else:
-            api_key = os.getenv('MISTRAL_API_KEY') if api_key is None else api_key
+            api_key = api_key or os.getenv('MISTRAL_API_KEY')
             self.client = Mistral(api_key=api_key, async_client=http_client or cached_async_http_client())
 
     @property
     def base_url(self) -> str:
-        return str(self.client.sdk_configuration.get_server_details()[0])
+        return self.client.sdk_configuration.get_server_details()[0]
 
     async def request(
         self,
@@ -179,7 +211,7 @@ class MistralModel(Model):
         return self._model_name
 
     @property
-    def system(self) -> str | None:
+    def system(self) -> str:
         """The system / model provider."""
         return self._system
 

{pydantic_ai_slim-0.0.39 → pydantic_ai_slim-0.0.41}/pydantic_ai/models/openai.py

@@ -99,16 +99,16 @@ class OpenAIModel(Model):
     system_prompt_role: OpenAISystemPromptRole | None = field(default=None)
 
     _model_name: OpenAIModelName = field(repr=False)
-    _system: str | None = field(repr=False)
+    _system: str = field(repr=False)
 
     @overload
     def __init__(
         self,
         model_name: OpenAIModelName,
         *,
-        provider: Literal['openai', 'deepseek'] | Provider[AsyncOpenAI] = 'openai',
+        provider: Literal['openai', 'deepseek', 'azure'] | Provider[AsyncOpenAI] = 'openai',
         system_prompt_role: OpenAISystemPromptRole | None = None,
-        system: str | None = 'openai',
+        system: str = 'openai',
     ) -> None: ...
 
     @deprecated('Use the `provider` parameter instead of `base_url`, `api_key`, `openai_client` and `http_client`.')
@@ -123,20 +123,20 @@ class OpenAIModel(Model):
         openai_client: AsyncOpenAI | None = None,
         http_client: AsyncHTTPClient | None = None,
         system_prompt_role: OpenAISystemPromptRole | None = None,
-        system: str | None = 'openai',
+        system: str = 'openai',
     ) -> None: ...
 
     def __init__(
         self,
         model_name: OpenAIModelName,
         *,
-        provider: Literal['openai', 'deepseek'] | Provider[AsyncOpenAI] | None = None,
+        provider: Literal['openai', 'deepseek', 'azure'] | Provider[AsyncOpenAI] | None = None,
         base_url: str | None = None,
         api_key: str | None = None,
         openai_client: AsyncOpenAI | None = None,
         http_client: AsyncHTTPClient | None = None,
         system_prompt_role: OpenAISystemPromptRole | None = None,
-        system: str | None = 'openai',
+        system: str = 'openai',
     ):
         """Initialize an OpenAI model.
 
@@ -162,9 +162,8 @@ class OpenAIModel(Model):
 
         if provider is not None:
             if isinstance(provider, str):
-                self.client = infer_provider(provider).client
-            else:
-                self.client = provider.client
+                provider = infer_provider(provider)
+            self.client = provider.client
         else:  # pragma: no cover
             # This is a workaround for the OpenAI client requiring an API key, whilst locally served,
             # openai compatible models do not always need an API key, but a placeholder (non-empty) key is required.
@@ -224,7 +223,7 @@ class OpenAIModel(Model):
         return self._model_name
 
     @property
-    def system(self) -> str | None:
+    def system(self) -> str:
         """The system / model provider."""
         return self._system
 

{pydantic_ai_slim-0.0.39 → pydantic_ai_slim-0.0.41}/pydantic_ai/models/test.py

@@ -79,7 +79,7 @@ class TestModel(Model):
     This is set when a request is made, so will reflect the function tools from the last step of the last run.
     """
     _model_name: str = field(default='test', repr=False)
-    _system: str | None = field(default=None, repr=False)
+    _system: str = field(default='test', repr=False)
 
     async def request(
         self,
@@ -113,7 +113,7 @@ class TestModel(Model):
         return self._model_name
 
     @property
-    def system(self) -> str | None:
+    def system(self) -> str:
         """The system / model provider."""
         return self._system
 

{pydantic_ai_slim-0.0.39 → pydantic_ai_slim-0.0.41}/pydantic_ai/models/vertexai.py

@@ -69,7 +69,7 @@ class VertexAIModel(GeminiModel):
     url_template: str
 
     _model_name: GeminiModelName = field(repr=False)
-    _system: str | None = field(default='google-vertex', repr=False)
+    _system: str = field(default='vertex_ai', repr=False)
 
     # TODO __init__ can be removed once we drop 3.9 and we can set kw_only correctly on the dataclass
     def __init__(
@@ -175,7 +175,7 @@ class VertexAIModel(GeminiModel):
         return self._model_name
 
     @property
-    def system(self) -> str | None:
+    def system(self) -> str:
         """The system / model provider."""
         return self._system
 

{pydantic_ai_slim-0.0.39 → pydantic_ai_slim-0.0.41}/pydantic_ai/models/wrapper.py

@@ -38,7 +38,7 @@ class WrapperModel(Model):
         return self.wrapped.model_name
 
     @property
-    def system(self) -> str | None:
+    def system(self) -> str:
         return self.wrapped.system
 
     def __getattr__(self, item: str):

{pydantic_ai_slim-0.0.39 → pydantic_ai_slim-0.0.41}/pydantic_ai/providers/__init__.py

@@ -69,5 +69,13 @@ def infer_provider(provider: str) -> Provider[Any]:
         from .groq import GroqProvider
 
         return GroqProvider()
+    elif provider == 'anthropic':
+        from .anthropic import AnthropicProvider
+
+        return AnthropicProvider()
+    elif provider == 'mistral':
+        from .mistral import MistralProvider
+
+        return MistralProvider()
     else:  # pragma: no cover
         raise ValueError(f'Unknown provider: {provider}')

pydantic_ai_slim-0.0.41/pydantic_ai/providers/anthropic.py

@@ -0,0 +1,74 @@
+from __future__ import annotations as _annotations
+
+import os
+from typing import overload
+
+import httpx
+
+from pydantic_ai.models import cached_async_http_client
+
+try:
+    from anthropic import AsyncAnthropic
+except ImportError as _import_error:  # pragma: no cover
+    raise ImportError(
+        'Please install the `anthropic` package to use the Anthropic provider, '
+        "you can use the `anthropic` optional group — `pip install 'pydantic-ai-slim[anthropic]'`"
+    ) from _import_error
+
+
+from . import Provider
+
+
+class AnthropicProvider(Provider[AsyncAnthropic]):
+    """Provider for Anthropic API."""
+
+    @property
+    def name(self) -> str:
+        return 'anthropic'
+
+    @property
+    def base_url(self) -> str:
+        return str(self._client.base_url)
+
+    @property
+    def client(self) -> AsyncAnthropic:
+        return self._client
+
+    @overload
+    def __init__(self, *, anthropic_client: AsyncAnthropic | None = None) -> None: ...
+
+    @overload
+    def __init__(self, *, api_key: str | None = None, http_client: httpx.AsyncClient | None = None) -> None: ...
+
+    def __init__(
+        self,
+        *,
+        api_key: str | None = None,
+        anthropic_client: AsyncAnthropic | None = None,
+        http_client: httpx.AsyncClient | None = None,
+    ) -> None:
+        """Create a new Anthropic provider.
+
+        Args:
+            api_key: The API key to use for authentication, if not provided, the `ANTHROPIC_API_KEY` environment variable
+                will be used if available.
+            anthropic_client: An existing [`AsyncAnthropic`](https://github.com/anthropics/anthropic-sdk-python)
+                client to use. If provided, the `api_key` and `http_client` arguments will be ignored.
+            http_client: An existing `httpx.AsyncClient` to use for making HTTP requests.
+        """
+        if anthropic_client is not None:
+            assert http_client is None, 'Cannot provide both `anthropic_client` and `http_client`'
+            assert api_key is None, 'Cannot provide both `anthropic_client` and `api_key`'
+            self._client = anthropic_client
+        else:
+            api_key = api_key or os.environ.get('ANTHROPIC_API_KEY')
+            if api_key is None:
+                raise ValueError(
+                    'Set the `ANTHROPIC_API_KEY` environment variable or pass it via `AnthropicProvider(api_key=...)`'
+                    'to use the Anthropic provider.'
+                )
+
+            if http_client is not None:
+                self._client = AsyncAnthropic(api_key=api_key, http_client=http_client)
+            else:
+                self._client = AsyncAnthropic(api_key=api_key, http_client=cached_async_http_client())

pydantic_ai_slim-0.0.41/pydantic_ai/providers/azure.py

@@ -0,0 +1,108 @@
+from __future__ import annotations as _annotations
+
+import os
+from typing import overload
+
+import httpx
+from openai import AsyncOpenAI
+
+from pydantic_ai.models import cached_async_http_client
+
+try:
+    from openai import AsyncAzureOpenAI
+except ImportError as _import_error:  # pragma: no cover
+    raise ImportError(
+        'Please install the `openai` package to use the Azure provider, '
+        "you can use the `openai` optional group — `pip install 'pydantic-ai-slim[openai]'`"
+    ) from _import_error
+
+
+from . import Provider
+
+
+class AzureProvider(Provider[AsyncOpenAI]):
+    """Provider for Azure OpenAI API.
+
+    See <https://azure.microsoft.com/en-us/products/ai-foundry> for more information.
+    """
+
+    @property
+    def name(self) -> str:
+        return 'azure'
+
+    @property
+    def base_url(self) -> str:
+        assert self._base_url is not None
+        return self._base_url
+
+    @property
+    def client(self) -> AsyncOpenAI:
+        return self._client
+
+    @overload
+    def __init__(self, *, openai_client: AsyncAzureOpenAI) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
+        azure_endpoint: str | None = None,
+        api_version: str | None = None,
+        api_key: str | None = None,
+        http_client: httpx.AsyncClient | None = None,
+    ) -> None: ...
+
+    def __init__(
+        self,
+        *,
+        azure_endpoint: str | None = None,
+        api_version: str | None = None,
+        api_key: str | None = None,
+        openai_client: AsyncAzureOpenAI | None = None,
+        http_client: httpx.AsyncClient | None = None,
+    ) -> None:
+        """Create a new Azure provider.
+
+        Args:
+            azure_endpoint: The Azure endpoint to use for authentication, if not provided, the `AZURE_OPENAI_ENDPOINT`
+                environment variable will be used if available.
+            api_version: The API version to use for authentication, if not provided, the `OPENAI_API_VERSION`
+                environment variable will be used if available.
+            api_key: The API key to use for authentication, if not provided, the `AZURE_OPENAI_API_KEY` environment variable
+                will be used if available.
+            openai_client: An existing
+                [`AsyncAzureOpenAI`](https://github.com/openai/openai-python#microsoft-azure-openai)
+                client to use. If provided, `base_url`, `api_key`, and `http_client` must be `None`.
+            http_client: An existing `httpx.AsyncClient` to use for making HTTP requests.
+        """
+        if openai_client is not None:
+            assert azure_endpoint is None, 'Cannot provide both `openai_client` and `azure_endpoint`'
+            assert http_client is None, 'Cannot provide both `openai_client` and `http_client`'
+            assert api_key is None, 'Cannot provide both `openai_client` and `api_key`'
+            self._base_url = str(openai_client.base_url)
+            self._client = openai_client
+        else:
+            azure_endpoint = azure_endpoint or os.getenv('AZURE_OPENAI_ENDPOINT')
+            if azure_endpoint is None:  # pragma: no cover
+                raise ValueError(
+                    'Must provide one of the `azure_endpoint` argument or the `AZURE_OPENAI_ENDPOINT` environment variable'
+                )
+
+            if api_key is None and 'OPENAI_API_KEY' not in os.environ:  # pragma: no cover
+                raise ValueError(
+                    'Must provide one of the `api_key` argument or the `OPENAI_API_KEY` environment variable'
+                )
+
+            if api_version is None and 'OPENAI_API_VERSION' not in os.environ:  # pragma: no cover
+                raise ValueError(
+                    'Must provide one of the `api_version` argument or the `OPENAI_API_VERSION` environment variable'
+                )
+
+            http_client = http_client or cached_async_http_client()
+            self._client = AsyncAzureOpenAI(
+                azure_endpoint=azure_endpoint,
+                api_key=api_key,
+                api_version=api_version,
+                http_client=http_client,
+            )
+            self._base_url = str(self._client.base_url)

{pydantic_ai_slim-0.0.39 → pydantic_ai_slim-0.0.41}/pydantic_ai/providers/bedrock.py

@@ -10,7 +10,7 @@ try:
     from botocore.exceptions import NoRegionError
 except ImportError as _import_error:
     raise ImportError(
-        'Please install `boto3` to use the Bedrock provider, '
+        'Please install the `boto3` package to use the Bedrock provider, '
         "you can use the `bedrock` optional group — `pip install 'pydantic-ai-slim[bedrock]'`"
     ) from _import_error
 

{pydantic_ai_slim-0.0.39 → pydantic_ai_slim-0.0.41}/pydantic_ai/providers/deepseek.py

@@ -12,7 +12,7 @@ try:
     from openai import AsyncOpenAI
 except ImportError as _import_error:  # pragma: no cover
     raise ImportError(
-        'Please install `openai` to use the DeepSeek provider, '
+        'Please install the `openai` package to use the DeepSeek provider, '
         "you can use the `openai` optional group — `pip install 'pydantic-ai-slim[openai]'`"
     ) from _import_error
 

{pydantic_ai_slim-0.0.39 → pydantic_ai_slim-0.0.41}/pydantic_ai/providers/google_vertex.py

@@ -21,7 +21,7 @@ try:
     from google.oauth2.service_account import Credentials as ServiceAccountCredentials
 except ImportError as _import_error:
     raise ImportError(
-        'Please install `google-auth` to use the Google Vertex AI provider, '
+        'Please install the `google-auth` package to use the Google Vertex AI provider, '
         "you can use the `vertexai` optional group — `pip install 'pydantic-ai-slim[vertexai]'`"
     ) from _import_error
 

{pydantic_ai_slim-0.0.39 → pydantic_ai_slim-0.0.41}/pydantic_ai/providers/groq.py

@@ -11,7 +11,7 @@ try:
     from groq import AsyncGroq
 except ImportError as _import_error:  # pragma: no cover
     raise ImportError(
-        'Please install `groq` to use the Groq provider, '
+        'Please install the `groq` package to use the Groq provider, '
         "you can use the `groq` optional group — `pip install 'pydantic-ai-slim[groq]'`"
     ) from _import_error
 
@@ -66,8 +66,6 @@ class GroqProvider(Provider[AsyncGroq]):
             )
 
         if groq_client is not None:
-            assert http_client is None, 'Cannot provide both `groq_client` and `http_client`'
-            assert api_key is None, 'Cannot provide both `groq_client` and `api_key`'
             self._client = groq_client
         elif http_client is not None:
             self._client = AsyncGroq(base_url=self.base_url, api_key=api_key, http_client=http_client)

pydantic_ai_slim-0.0.41/pydantic_ai/providers/mistral.py

@@ -0,0 +1,73 @@
+from __future__ import annotations as _annotations
+
+import os
+from typing import overload
+
+from httpx import AsyncClient as AsyncHTTPClient
+
+from pydantic_ai.models import cached_async_http_client
+
+try:
+    from mistralai import Mistral
+except ImportError as e:  # pragma: no cover
+    raise ImportError(
+        'Please install the `mistral` package to use the Mistral provider, '
+        "you can use the `mistral` optional group — `pip install 'pydantic-ai-slim[mistral]'`"
+    ) from e
+
+
+from . import Provider
+
+
+class MistralProvider(Provider[Mistral]):
+    """Provider for Mistral API."""
+
+    @property
+    def name(self) -> str:
+        return 'mistral'
+
+    @property
+    def base_url(self) -> str:
+        return self.client.sdk_configuration.get_server_details()[0]
+
+    @property
+    def client(self) -> Mistral:
+        return self._client
+
+    @overload
+    def __init__(self, *, mistral_client: Mistral | None = None) -> None: ...
+
+    @overload
+    def __init__(self, *, api_key: str | None = None, http_client: AsyncHTTPClient | None = None) -> None: ...
+
+    def __init__(
+        self,
+        *,
+        api_key: str | None = None,
+        mistral_client: Mistral | None = None,
+        http_client: AsyncHTTPClient | None = None,
+    ) -> None:
+        """Create a new Mistral provider.
+
+        Args:
+            api_key: The API key to use for authentication, if not provided, the `MISTRAL_API_KEY` environment variable
+                will be used if available.
+            mistral_client: An existing `Mistral` client to use, if provided, `api_key` and `http_client` must be `None`.
+            http_client: An existing async client to use for making HTTP requests.
+        """
+        api_key = api_key or os.environ.get('MISTRAL_API_KEY')
+
+        if api_key is None and mistral_client is None:
+            raise ValueError(
+                'Set the `MISTRAL_API_KEY` environment variable or pass it via `MistralProvider(api_key=...)`'
+                'to use the Mistral provider.'
+            )
+
+        if mistral_client is not None:
+            assert http_client is None, 'Cannot provide both `mistral_client` and `http_client`'
+            assert api_key is None, 'Cannot provide both `mistral_client` and `api_key`'
+            self._client = mistral_client
+        elif http_client is not None:
+            self._client = Mistral(api_key=api_key, async_client=http_client)
+        else:
+            self._client = Mistral(api_key=api_key, async_client=cached_async_http_client())

{pydantic_ai_slim-0.0.39 → pydantic_ai_slim-0.0.41}/pydantic_ai/providers/openai.py

@@ -1,7 +1,6 @@
 from __future__ import annotations as _annotations
 
 import os
-from typing import TypeVar
 
 import httpx
 
@@ -11,15 +10,13 @@ try:
     from openai import AsyncOpenAI
 except ImportError as _import_error:  # pragma: no cover
     raise ImportError(
-        'Please install `openai` to use the OpenAI provider, '
+        'Please install the `openai` package to use the OpenAI provider, '
         "you can use the `openai` optional group — `pip install 'pydantic-ai-slim[openai]'`"
     ) from _import_error
 
 
 from . import Provider
 
-InterfaceClient = TypeVar('InterfaceClient')
-
 
 class OpenAIProvider(Provider[AsyncOpenAI]):
     """Provider for OpenAI API."""
@@ -55,7 +52,7 @@ class OpenAIProvider(Provider[AsyncOpenAI]):
                 client to use. If provided, `base_url`, `api_key`, and `http_client` must be `None`.
             http_client: An existing `httpx.AsyncClient` to use for making HTTP requests.
         """
-        self._base_url = base_url or 'https://api.openai.com/v1'
+        self._base_url = base_url or os.getenv('OPENAI_BASE_URL', 'https://api.openai.com/v1')
         # This is a workaround for the OpenAI client requiring an API key, whilst locally served,
         # openai compatible models do not always need an API key, but a placeholder (non-empty) key is required.
         if api_key is None and 'OPENAI_API_KEY' not in os.environ and openai_client is None:

{pydantic_ai_slim-0.0.39 → pydantic_ai_slim-0.0.41}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "pydantic-ai-slim"
-version = "0.0.39"
+version = "0.0.41"
 description = "Agent Framework / shim to use Pydantic with LLMs, slim package"
 authors = [{ name = "Samuel Colvin", email = "samuel@pydantic.dev" }]
 license = "MIT"
@@ -36,7 +36,7 @@ dependencies = [
     "griffe>=1.3.2",
     "httpx>=0.27",
     "pydantic>=2.10",
-    "pydantic-graph==0.0.39",
+    "pydantic-graph==0.0.41",
     "exceptiongroup; python_version < '3.11'",
     "opentelemetry-api>=1.28.0",
     "typing-inspection>=0.4.0",

{pydantic_ai_slim-0.0.39 → pydantic_ai_slim-0.0.41}/pydantic_ai/agent.py

@@ -475,8 +475,8 @@ class Agent(Generic[AgentDepsT, ResultDataT]):
             start_node,
             state=state,
             deps=graph_deps,
-            infer_name=False,
             span=use_span(run_span, end_on_exit=True),
+            infer_name=False,
         ) as graph_run:
             yield AgentRun(graph_run)