pydantic-ai-slim 0.0.38__tar.gz → 0.0.40__tar.gz

{pydantic_ai_slim-0.0.38 → pydantic_ai_slim-0.0.40}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai-slim
-Version: 0.0.38
+Version: 0.0.40
 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.38
+Requires-Dist: pydantic-graph==0.0.40
 Requires-Dist: pydantic>=2.10
 Requires-Dist: typing-inspection>=0.4.0
 Provides-Extra: anthropic

{pydantic_ai_slim-0.0.38 → pydantic_ai_slim-0.0.40}/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.38 → pydantic_ai_slim-0.0.40}/pydantic_ai/models/anthropic.py

@@ -33,13 +33,7 @@ from ..messages import (
 )
 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,7 +109,7 @@ 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)
 
     def __init__(
         self,
@@ -183,7 +177,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 +349,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.38 → pydantic_ai_slim-0.0.40}/pydantic_ai/models/bedrock.py

@@ -10,7 +10,6 @@ from typing import TYPE_CHECKING, Generic, Literal, Union, cast, overload
 
 import anyio
 import anyio.to_thread
-from mypy_boto3_bedrock_runtime.type_defs import ImageBlockTypeDef
 from typing_extensions import ParamSpec, assert_never
 
 from pydantic_ai import _utils, result
@@ -46,6 +45,7 @@ if TYPE_CHECKING:
         ConverseResponseTypeDef,
         ConverseStreamMetadataEventTypeDef,
         ConverseStreamOutputTypeDef,
+        ImageBlockTypeDef,
         InferenceConfigurationTypeDef,
         MessageUnionTypeDef,
         ToolChoiceTypeDef,
@@ -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.38 → pydantic_ai_slim-0.0.40}/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.38 → pydantic_ai_slim-0.0.40}/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,13 +65,19 @@ 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
+            else:
+                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))
+                return response, usage
 
         raise FallbackExceptionGroup('All models from FallbackModel failed', exceptions)
 
@@ -101,12 +110,11 @@ class FallbackModel(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.38 → pydantic_ai_slim-0.0.40}/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.38 → pydantic_ai_slim-0.0.40}/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__(
@@ -197,7 +197,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.38 → pydantic_ai_slim-0.0.40}/pydantic_ai/models/groq.py

@@ -9,7 +9,7 @@ from itertools import chain
 from typing import Literal, Union, cast, overload
 
 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
@@ -29,15 +29,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 groq import NOT_GIVEN, APIStatusError, AsyncGroq, AsyncStream
@@ -49,6 +44,7 @@ except ImportError as _import_error:
         "you can use the `groq` optional group — `pip install 'pydantic-ai-slim[groq]'`"
     ) from _import_error
 
+
 LatestGroqModelNames = Literal[
     'llama-3.3-70b-versatile',
     'llama-3.3-70b-specdec',
@@ -92,12 +88,33 @@ 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__(
+        self,
+        model_name: GroqModelName,
+        *,
+        provider: Literal['groq'] | Provider[AsyncGroq] = 'groq',
+    ) -> None: ...
+
+    @deprecated('Use the `provider` parameter instead of `api_key`, `groq_client`, and `http_client`.')
+    @overload
+    def __init__(
+        self,
+        model_name: GroqModelName,
+        *,
+        provider: None = None,
+        api_key: str | None = None,
+        groq_client: AsyncGroq | None = None,
+        http_client: AsyncHTTPClient | None = None,
+    ) -> None: ...
 
     def __init__(
         self,
         model_name: GroqModelName,
         *,
+        provider: Literal['groq'] | Provider[AsyncGroq] | None = None,
         api_key: str | None = None,
         groq_client: AsyncGroq | None = None,
         http_client: AsyncHTTPClient | None = None,
@@ -107,6 +124,9 @@ class GroqModel(Model):
         Args:
             model_name: The name of the Groq model to use. List of model names available
                 [here](https://console.groq.com/docs/models).
+            provider: The provider to use for authentication and API access. Can be either the string
+                'groq' or an instance of `Provider[AsyncGroq]`. If not provided, a new provider will be
+                created using the other parameters.
             api_key: The API key to use for authentication, if not provided, the `GROQ_API_KEY` environment variable
                 will be used if available.
             groq_client: An existing
@@ -115,7 +135,13 @@ class GroqModel(Model):
             http_client: An existing `httpx.AsyncClient` to use for making HTTP requests.
         """
         self._model_name = model_name
-        if groq_client is not None:
+
+        if provider is not None:
+            if isinstance(provider, str):
+                self.client = infer_provider(provider).client
+            else:
+                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`'
             self.client = groq_client
@@ -160,7 +186,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.38 → pydantic_ai_slim-0.0.40}/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.38 → pydantic_ai_slim-0.0.40}/pydantic_ai/models/mistral.py

@@ -110,7 +110,7 @@ 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)
 
     def __init__(
         self,
@@ -179,7 +179,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.38 → pydantic_ai_slim-0.0.40}/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.
 
@@ -224,7 +224,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.38 → pydantic_ai_slim-0.0.40}/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.38 → pydantic_ai_slim-0.0.40}/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.38 → pydantic_ai_slim-0.0.40}/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.38 → pydantic_ai_slim-0.0.40}/pydantic_ai/providers/__init__.py

@@ -65,5 +65,9 @@ def infer_provider(provider: str) -> Provider[Any]:
         from .bedrock import BedrockProvider
 
         return BedrockProvider()
+    elif provider == 'groq':
+        from .groq import GroqProvider
+
+        return GroqProvider()
     else:  # pragma: no cover
         raise ValueError(f'Unknown provider: {provider}')

pydantic_ai_slim-0.0.40/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.38 → pydantic_ai_slim-0.0.40}/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.38 → pydantic_ai_slim-0.0.40}/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.38 → pydantic_ai_slim-0.0.40}/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.40/pydantic_ai/providers/groq.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 groq import AsyncGroq
+except ImportError as _import_error:  # pragma: no cover
+    raise ImportError(
+        '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
+
+
+from . import Provider
+
+
+class GroqProvider(Provider[AsyncGroq]):
+    """Provider for Groq API."""
+
+    @property
+    def name(self) -> str:
+        return 'groq'
+
+    @property
+    def base_url(self) -> str:
+        return os.environ.get('GROQ_BASE_URL', 'https://api.groq.com')
+
+    @property
+    def client(self) -> AsyncGroq:
+        return self._client
+
+    @overload
+    def __init__(self, *, groq_client: AsyncGroq | 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,
+        groq_client: AsyncGroq | None = None,
+        http_client: AsyncHTTPClient | None = None,
+    ) -> None:
+        """Create a new Groq provider.
+
+        Args:
+            api_key: The API key to use for authentication, if not provided, the `GROQ_API_KEY` environment variable
+                will be used if available.
+            groq_client: An existing
+                [`AsyncGroq`](https://github.com/groq/groq-python?tab=readme-ov-file#async-usage)
+                client to use. If provided, `api_key` and `http_client` must be `None`.
+            http_client: An existing `AsyncHTTPClient` to use for making HTTP requests.
+        """
+        api_key = api_key or os.environ.get('GROQ_API_KEY')
+
+        if api_key is None and groq_client is None:
+            raise ValueError(
+                'Set the `GROQ_API_KEY` environment variable or pass it via `GroqProvider(api_key=...)`'
+                'to use the Groq provider.'
+            )
+
+        if groq_client is not None:
+            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)
+        else:
+            self._client = AsyncGroq(base_url=self.base_url, api_key=api_key, http_client=cached_async_http_client())

{pydantic_ai_slim-0.0.38 → pydantic_ai_slim-0.0.40}/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.38 → pydantic_ai_slim-0.0.40}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "pydantic-ai-slim"
-version = "0.0.38"
+version = "0.0.40"
 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.38",
+    "pydantic-graph==0.0.40",
     "exceptiongroup; python_version < '3.11'",
     "opentelemetry-api>=1.28.0",
     "typing-inspection>=0.4.0",

{pydantic_ai_slim-0.0.38 → pydantic_ai_slim-0.0.40}/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)