pydantic-ai-slim 1.2.1__py3-none-any.whl → 1.10.0__py3-none-any.whl

pydantic_ai/providers/bedrock.py

@@ -4,7 +4,7 @@ import os
 import re
 from collections.abc import Callable
 from dataclasses import dataclass
-from typing import Literal, overload
+from typing import Any, Literal, overload
 
 from pydantic_ai import ModelProfile
 from pydantic_ai.exceptions import UserError
@@ -21,6 +21,8 @@ try:
     from botocore.client import BaseClient
     from botocore.config import Config
     from botocore.exceptions import NoRegionError
+    from botocore.session import Session
+    from botocore.tokens import FrozenAuthToken
 except ImportError as _import_error:
     raise ImportError(
         'Please install the `boto3` package to use the Bedrock provider, '
@@ -117,10 +119,23 @@ class BedrockProvider(Provider[BaseClient]):
     def __init__(
         self,
         *,
+        api_key: str,
+        base_url: str | None = None,
         region_name: str | None = None,
+        profile_name: str | None = None,
+        aws_read_timeout: float | None = None,
+        aws_connect_timeout: float | None = None,
+    ) -> None: ...
+
+    @overload
+    def __init__(
+        self,
+        *,
         aws_access_key_id: str | None = None,
         aws_secret_access_key: str | None = None,
         aws_session_token: str | None = None,
+        base_url: str | None = None,
+        region_name: str | None = None,
         profile_name: str | None = None,
         aws_read_timeout: float | None = None,
         aws_connect_timeout: float | None = None,
@@ -130,11 +145,13 @@ class BedrockProvider(Provider[BaseClient]):
         self,
         *,
         bedrock_client: BaseClient | None = None,
-        region_name: str | None = None,
         aws_access_key_id: str | None = None,
         aws_secret_access_key: str | None = None,
         aws_session_token: str | None = None,
+        base_url: str | None = None,
+        region_name: str | None = None,
         profile_name: str | None = None,
+        api_key: str | None = None,
         aws_read_timeout: float | None = None,
         aws_connect_timeout: float | None = None,
     ) -> None:
@@ -142,10 +159,12 @@ class BedrockProvider(Provider[BaseClient]):
 
         Args:
             bedrock_client: A boto3 client for Bedrock Runtime. If provided, other arguments are ignored.
-            region_name: The AWS region name.
-            aws_access_key_id: The AWS access key ID.
-            aws_secret_access_key: The AWS secret access key.
-            aws_session_token: The AWS session token.
+            aws_access_key_id: The AWS access key ID. If not set, the `AWS_ACCESS_KEY_ID` environment variable will be used if available.
+            aws_secret_access_key: The AWS secret access key. If not set, the `AWS_SECRET_ACCESS_KEY` environment variable will be used if available.
+            aws_session_token: The AWS session token. If not set, the `AWS_SESSION_TOKEN` environment variable will be used if available.
+            api_key: The API key for Bedrock client. Can be used instead of `aws_access_key_id`, `aws_secret_access_key`, and `aws_session_token`. If not set, the `AWS_BEARER_TOKEN_BEDROCK` environment variable will be used if available.
+            base_url: The base URL for the Bedrock client.
+            region_name: The AWS region name. If not set, the `AWS_DEFAULT_REGION` environment variable will be used if available.
             profile_name: The AWS profile name.
             aws_read_timeout: The read timeout for Bedrock client.
             aws_connect_timeout: The connect timeout for Bedrock client.
@@ -153,19 +172,44 @@ class BedrockProvider(Provider[BaseClient]):
         if bedrock_client is not None:
             self._client = bedrock_client
         else:
+            read_timeout = aws_read_timeout or float(os.getenv('AWS_READ_TIMEOUT', 300))
+            connect_timeout = aws_connect_timeout or float(os.getenv('AWS_CONNECT_TIMEOUT', 60))
+            config: dict[str, Any] = {
+                'read_timeout': read_timeout,
+                'connect_timeout': connect_timeout,
+            }
             try:
-                read_timeout = aws_read_timeout or float(os.getenv('AWS_READ_TIMEOUT', 300))
-                connect_timeout = aws_connect_timeout or float(os.getenv('AWS_CONNECT_TIMEOUT', 60))
-                session = boto3.Session(
-                    aws_access_key_id=aws_access_key_id,
-                    aws_secret_access_key=aws_secret_access_key,
-                    aws_session_token=aws_session_token,
-                    region_name=region_name,
-                    profile_name=profile_name,
-                )
+                if api_key is not None:
+                    session = boto3.Session(
+                        botocore_session=_BearerTokenSession(api_key),
+                        region_name=region_name,
+                        profile_name=profile_name,
+                    )
+                    config['signature_version'] = 'bearer'
+                else:
+                    session = boto3.Session(
+                        aws_access_key_id=aws_access_key_id,
+                        aws_secret_access_key=aws_secret_access_key,
+                        aws_session_token=aws_session_token,
+                        region_name=region_name,
+                        profile_name=profile_name,
+                    )
                 self._client = session.client(  # type: ignore[reportUnknownMemberType]
                     'bedrock-runtime',
-                    config=Config(read_timeout=read_timeout, connect_timeout=connect_timeout),
+                    config=Config(**config),
+                    endpoint_url=base_url,
                 )
             except NoRegionError as exc:  # pragma: no cover
                 raise UserError('You must provide a `region_name` or a boto3 client for Bedrock Runtime.') from exc
+
+
+class _BearerTokenSession(Session):
+    def __init__(self, token: str):
+        super().__init__()
+        self.token = token
+
+    def get_auth_token(self, **_kwargs: Any) -> FrozenAuthToken:
+        return FrozenAuthToken(self.token)
+
+    def get_credentials(self) -> None:  # type: ignore[reportIncompatibleMethodOverride]
+        return None

pydantic_ai/providers/gateway.py

@@ -3,14 +3,16 @@
 from __future__ import annotations as _annotations
 
 import os
+from collections.abc import Awaitable, Callable
 from typing import TYPE_CHECKING, Any, Literal, overload
 
 import httpx
 
 from pydantic_ai.exceptions import UserError
-from pydantic_ai.models import Model, cached_async_http_client, get_user_agent
+from pydantic_ai.models import cached_async_http_client
 
 if TYPE_CHECKING:
+    from botocore.client import BaseClient
     from google.genai import Client as GoogleClient
     from groq import AsyncGroq
     from openai import AsyncOpenAI
@@ -18,6 +20,8 @@ if TYPE_CHECKING:
     from pydantic_ai.models.anthropic import AsyncAnthropicClient
     from pydantic_ai.providers import Provider
 
+GATEWAY_BASE_URL = 'https://gateway.pydantic.dev/proxy'
+
 
 @overload
 def gateway_provider(
@@ -57,13 +61,34 @@ def gateway_provider(
 ) -> Provider[AsyncAnthropicClient]: ...
 
 
+@overload
+def gateway_provider(
+    upstream_provider: Literal['bedrock'],
+    *,
+    api_key: str | None = None,
+    base_url: str | None = None,
+) -> Provider[BaseClient]: ...
+
+
+@overload
 def gateway_provider(
-    upstream_provider: Literal['openai', 'openai-chat', 'openai-responses', 'groq', 'google-vertex', 'anthropic'] | str,
+    upstream_provider: str,
+    *,
+    api_key: str | None = None,
+    base_url: str | None = None,
+) -> Provider[Any]: ...
+
+
+UpstreamProvider = Literal['openai', 'openai-chat', 'openai-responses', 'groq', 'google-vertex', 'anthropic', 'bedrock']
+
+
+def gateway_provider(
+    upstream_provider: UpstreamProvider | str,
     *,
     # Every provider
     api_key: str | None = None,
     base_url: str | None = None,
-    # OpenAI & Groq
+    # OpenAI, Groq & Anthropic
     http_client: httpx.AsyncClient | None = None,
 ) -> Provider[Any]:
     """Create a new Gateway provider.
@@ -73,25 +98,21 @@ def gateway_provider(
         api_key: The API key to use for authentication. If not provided, the `PYDANTIC_AI_GATEWAY_API_KEY`
             environment variable will be used if available.
         base_url: The base URL to use for the Gateway. If not provided, the `PYDANTIC_AI_GATEWAY_BASE_URL`
-            environment variable will be used if available. Otherwise, defaults to `http://localhost:8787/`.
+            environment variable will be used if available. Otherwise, defaults to `https://gateway.pydantic.dev/proxy`.
         http_client: The HTTP client to use for the Gateway.
     """
     api_key = api_key or os.getenv('PYDANTIC_AI_GATEWAY_API_KEY')
     if not api_key:
         raise UserError(
-            'Set the `PYDANTIC_AI_GATEWAY_API_KEY` environment variable or pass it via `gateway_provider(api_key=...)`'
+            'Set the `PYDANTIC_AI_GATEWAY_API_KEY` environment variable or pass it via `gateway_provider(..., api_key=...)`'
             ' to use the Pydantic AI Gateway provider.'
         )
 
-    base_url = base_url or os.getenv('PYDANTIC_AI_GATEWAY_BASE_URL', 'https://gateway.pydantic.dev/proxy')
-    http_client = http_client or cached_async_http_client(provider=f'gateway-{upstream_provider}')
-    http_client.event_hooks = {'request': [_request_hook]}
-
-    if upstream_provider in ('openai', 'openai-chat'):
-        from .openai import OpenAIProvider
+    base_url = base_url or os.getenv('PYDANTIC_AI_GATEWAY_BASE_URL', GATEWAY_BASE_URL)
+    http_client = http_client or cached_async_http_client(provider=f'gateway/{upstream_provider}')
+    http_client.event_hooks = {'request': [_request_hook(api_key)]}
 
-        return OpenAIProvider(api_key=api_key, base_url=_merge_url_path(base_url, 'openai'), http_client=http_client)
-    elif upstream_provider == 'openai-responses':
+    if upstream_provider in ('openai', 'openai-chat', 'openai-responses'):
         from .openai import OpenAIProvider
 
         return OpenAIProvider(api_key=api_key, base_url=_merge_url_path(base_url, 'openai'), http_client=http_client)
@@ -111,79 +132,46 @@ def gateway_provider(
                 http_client=http_client,
             )
         )
-    elif upstream_provider == 'google-vertex':
-        from google.genai import Client as GoogleClient
+    elif upstream_provider == 'bedrock':
+        from .bedrock import BedrockProvider
 
+        return BedrockProvider(
+            api_key=api_key,
+            base_url=_merge_url_path(base_url, 'bedrock'),
+            region_name='pydantic-ai-gateway',  # Fake region name to avoid NoRegionError
+        )
+    elif upstream_provider == 'google-vertex':
         from .google import GoogleProvider
 
         return GoogleProvider(
-            client=GoogleClient(
-                vertexai=True,
-                api_key='unset',
-                http_options={
-                    'base_url': _merge_url_path(base_url, 'google-vertex'),
-                    'headers': {'User-Agent': get_user_agent(), 'Authorization': api_key},
-                    # TODO(Marcelo): Until https://github.com/googleapis/python-genai/issues/1357 is solved.
-                    'async_client_args': {
-                        'transport': httpx.AsyncHTTPTransport(),
-                        'event_hooks': {'request': [_request_hook]},
-                    },
-                },
-            )
+            vertexai=True,
+            api_key=api_key,
+            base_url=_merge_url_path(base_url, 'google-vertex'),
+            http_client=http_client,
         )
-    else:  # pragma: no cover
-        raise UserError(f'Unknown provider: {upstream_provider}')
+    else:
+        raise UserError(f'Unknown upstream provider: {upstream_provider}')
 
 
-def infer_model(model_name: str) -> Model:
-    """Infer the model class that will be used to make requests to the gateway.
-
-    Args:
-        model_name: The name of the model to infer. Must be in the format "provider/model_name".
+def _request_hook(api_key: str) -> Callable[[httpx.Request], Awaitable[httpx.Request]]:
+    """Request hook for the gateway provider.
 
-    Returns:
-        The model class that will be used to make requests to the gateway.
+    It adds the `"traceparent"` and `"Authorization"` headers to the request.
     """
-    try:
-        upstream_provider, model_name = model_name.split('/', 1)
-    except ValueError:
-        raise UserError(f'The model name "{model_name}" is not in the format "provider/model_name".')
 
-    if upstream_provider in ('openai', 'openai-chat'):
-        from pydantic_ai.models.openai import OpenAIChatModel
+    async def _hook(request: httpx.Request) -> httpx.Request:
+        from opentelemetry.propagate import inject
 
-        return OpenAIChatModel(model_name, provider=gateway_provider('openai'))
-    elif upstream_provider == 'openai-responses':
-        from pydantic_ai.models.openai import OpenAIResponsesModel
-
-        return OpenAIResponsesModel(model_name, provider=gateway_provider('openai'))
-    elif upstream_provider == 'groq':
-        from pydantic_ai.models.groq import GroqModel
+        headers: dict[str, Any] = {}
+        inject(headers)
+        request.headers.update(headers)
 
-        return GroqModel(model_name, provider=gateway_provider('groq'))
-    elif upstream_provider == 'anthropic':
-        from pydantic_ai.models.anthropic import AnthropicModel
-
-        return AnthropicModel(model_name, provider=gateway_provider('anthropic'))
-    elif upstream_provider == 'google-vertex':
-        from pydantic_ai.models.google import GoogleModel
-
-        return GoogleModel(model_name, provider=gateway_provider('google-vertex'))
-    raise UserError(f'Unknown upstream provider: {upstream_provider}')
-
-
-async def _request_hook(request: httpx.Request) -> httpx.Request:
-    """Request hook for the gateway provider.
-
-    It adds the `"traceparent"` header to the request.
-    """
-    from opentelemetry.propagate import inject
+        if 'Authorization' not in request.headers:
+            request.headers['Authorization'] = f'Bearer {api_key}'
 
-    headers: dict[str, Any] = {}
-    inject(headers)
-    request.headers.update(headers)
+        return request
 
-    return request
+    return _hook
 
 
 def _merge_url_path(base_url: str, path: str) -> str:

pydantic_ai/providers/google.py

@@ -7,14 +7,15 @@ import httpx
 
 from pydantic_ai import ModelProfile
 from pydantic_ai.exceptions import UserError
-from pydantic_ai.models import get_user_agent
+from pydantic_ai.models import cached_async_http_client, get_user_agent
 from pydantic_ai.profiles.google import google_model_profile
 from pydantic_ai.providers import Provider
 
 try:
     from google.auth.credentials import Credentials
-    from google.genai import Client
-    from google.genai.types import HttpOptionsDict
+    from google.genai._api_client import BaseApiClient
+    from google.genai.client import Client, DebugConfig
+    from google.genai.types import HttpOptions
 except ImportError as _import_error:
     raise ImportError(
         'Please install the `google-genai` package to use the Google provider, '
@@ -41,7 +42,9 @@ class GoogleProvider(Provider[Client]):
         return google_model_profile(model_name)
 
     @overload
-    def __init__(self, *, api_key: str) -> None: ...
+    def __init__(
+        self, *, api_key: str, http_client: httpx.AsyncClient | None = None, base_url: str | None = None
+    ) -> None: ...
 
     @overload
     def __init__(
@@ -49,14 +52,23 @@ class GoogleProvider(Provider[Client]):
         *,
         credentials: Credentials | None = None,
         project: str | None = None,
-        location: VertexAILocation | Literal['global'] | None = None,
+        location: VertexAILocation | Literal['global'] | str | None = None,
+        http_client: httpx.AsyncClient | None = None,
+        base_url: str | None = None,
     ) -> None: ...
 
     @overload
     def __init__(self, *, client: Client) -> None: ...
 
     @overload
-    def __init__(self, *, vertexai: bool = False) -> None: ...
+    def __init__(
+        self,
+        *,
+        vertexai: bool = False,
+        api_key: str | None = None,
+        http_client: httpx.AsyncClient | None = None,
+        base_url: str | None = None,
+    ) -> None: ...
 
     def __init__(
         self,
@@ -64,16 +76,17 @@ class GoogleProvider(Provider[Client]):
         api_key: str | None = None,
         credentials: Credentials | None = None,
         project: str | None = None,
-        location: VertexAILocation | Literal['global'] | None = None,
-        client: Client | None = None,
+        location: VertexAILocation | Literal['global'] | str | None = None,
         vertexai: bool | None = None,
+        client: Client | None = None,
+        http_client: httpx.AsyncClient | None = None,
+        base_url: str | None = None,
     ) -> None:
         """Create a new Google provider.
 
         Args:
             api_key: The `API key <https://ai.google.dev/gemini-api/docs/api-key>`_ to
                 use for authentication. It can also be set via the `GOOGLE_API_KEY` environment variable.
-                Applies to the Gemini Developer API only.
             credentials: The credentials to use for authentication when calling the Vertex AI APIs. Credentials can be
                 obtained from environment variables and default credentials. For more information, see Set up
                 Application Default Credentials. Applies to the Vertex AI API only.
@@ -81,43 +94,60 @@ class GoogleProvider(Provider[Client]):
                 (for example, GOOGLE_CLOUD_PROJECT). Applies to the Vertex AI API only.
             location: The location to send API requests to (for example, us-central1). Can be obtained from environment variables.
                 Applies to the Vertex AI API only.
-            client: A pre-initialized client to use.
             vertexai: Force the use of the Vertex AI API. If `False`, the Google Generative Language API will be used.
-                Defaults to `False`.
+                Defaults to `False` unless `location`, `project`, or `credentials` are provided.
+            client: A pre-initialized client to use.
+            http_client: An existing `httpx.AsyncClient` to use for making HTTP requests.
+            base_url: The base URL for the Google API.
         """
         if client is None:
             # NOTE: We are keeping GEMINI_API_KEY for backwards compatibility.
             api_key = api_key or os.getenv('GOOGLE_API_KEY') or os.getenv('GEMINI_API_KEY')
 
+            vertex_ai_args_used = bool(location or project or credentials)
             if vertexai is None:
-                vertexai = bool(location or project or credentials)
-
-            http_options: HttpOptionsDict = {
-                'headers': {'User-Agent': get_user_agent()},
-                'async_client_args': {'transport': httpx.AsyncHTTPTransport()},
-            }
+                vertexai = vertex_ai_args_used
+
+            http_client = http_client or cached_async_http_client(
+                provider='google-vertex' if vertexai else 'google-gla'
+            )
+            http_options = HttpOptions(
+                base_url=base_url,
+                headers={'User-Agent': get_user_agent()},
+                httpx_async_client=http_client,
+                # TODO: Remove once https://github.com/googleapis/python-genai/issues/1565 is solved.
+                async_client_args={'transport': httpx.AsyncHTTPTransport()},
+            )
             if not vertexai:
                 if api_key is None:
-                    raise UserError(  # pragma: no cover
+                    raise UserError(
                         'Set the `GOOGLE_API_KEY` environment variable or pass it via `GoogleProvider(api_key=...)`'
                         'to use the Google Generative Language API.'
                     )
-                self._client = Client(vertexai=vertexai, api_key=api_key, http_options=http_options)
+                self._client = _SafelyClosingClient(vertexai=False, api_key=api_key, http_options=http_options)
             else:
-                self._client = Client(
-                    vertexai=vertexai,
-                    project=project or os.getenv('GOOGLE_CLOUD_PROJECT'),
+                if vertex_ai_args_used:
+                    api_key = None
+
+                if api_key is None:
+                    project = project or os.getenv('GOOGLE_CLOUD_PROJECT')
                     # From https://github.com/pydantic/pydantic-ai/pull/2031/files#r2169682149:
                     # Currently `us-central1` supports the most models by far of any region including `global`, but not
                     # all of them. `us-central1` has all google models but is missing some Anthropic partner models,
                     # which use `us-east5` instead. `global` has fewer models but higher availability.
                     # For more details, check: https://cloud.google.com/vertex-ai/generative-ai/docs/learn/locations#available-regions
-                    location=location or os.getenv('GOOGLE_CLOUD_LOCATION') or 'us-central1',
+                    location = location or os.getenv('GOOGLE_CLOUD_LOCATION') or 'us-central1'
+
+                self._client = _SafelyClosingClient(
+                    vertexai=True,
+                    api_key=api_key,
+                    project=project,
+                    location=location,
                     credentials=credentials,
                     http_options=http_options,
                 )
         else:
-            self._client = client
+            self._client = client  # pragma: no cover
 
 
 VertexAILocation = Literal[
@@ -154,3 +184,40 @@ VertexAILocation = Literal[
 """Regions available for Vertex AI.
 More details [here](https://cloud.google.com/vertex-ai/generative-ai/docs/learn/locations#genai-locations).
 """
+
+
+class _SafelyClosingClient(Client):
+    @staticmethod
+    def _get_api_client(
+        vertexai: bool | None = None,
+        api_key: str | None = None,
+        credentials: Credentials | None = None,
+        project: str | None = None,
+        location: str | None = None,
+        debug_config: DebugConfig | None = None,
+        http_options: HttpOptions | None = None,
+    ) -> BaseApiClient:
+        return _NonClosingApiClient(
+            vertexai=vertexai,
+            api_key=api_key,
+            credentials=credentials,
+            project=project,
+            location=location,
+            http_options=http_options,
+        )
+
+    def close(self) -> None:
+        # This is called from `Client.__del__`, even if `Client.__init__` raised an error before `self._api_client` is set, which would raise an `AttributeError` here.
+        # TODO: Remove once https://github.com/googleapis/python-genai/issues/1567 is solved.
+        try:
+            super().close()
+        except AttributeError:
+            pass
+
+
+class _NonClosingApiClient(BaseApiClient):
+    async def aclose(self) -> None:
+        # The original implementation also calls `await self._async_httpx_client.aclose()`, but we don't want to close our `cached_async_http_client` or the one the user passed in.
+        # TODO: Remove once https://github.com/googleapis/python-genai/issues/1566 is solved.
+        if self._aiohttp_session:
+            await self._aiohttp_session.close()  # pragma: no cover

pydantic_ai/providers/openrouter.py

@@ -81,6 +81,9 @@ class OpenRouterProvider(Provider[AsyncOpenAI]):
     @overload
     def __init__(self, *, api_key: str, http_client: httpx.AsyncClient) -> None: ...
 
+    @overload
+    def __init__(self, *, http_client: httpx.AsyncClient) -> None: ...
+
     @overload
     def __init__(self, *, openai_client: AsyncOpenAI | None = None) -> None: ...
 

pydantic_ai/providers/outlines.py

@@ -0,0 +1,40 @@
+from __future__ import annotations as _annotations
+
+from typing import Any
+
+from pydantic_ai.profiles import ModelProfile
+from pydantic_ai.providers import Provider
+
+
+class OutlinesProvider(Provider[Any]):
+    """Provider for Outlines API."""
+
+    @property
+    def name(self) -> str:
+        """The provider name."""
+        return 'outlines'
+
+    @property
+    def base_url(self) -> str:
+        """The base URL for the provider API."""
+        raise NotImplementedError(
+            'The Outlines provider does not have a set base URL as it functions '
+            + 'with a set of different underlying models.'
+        )
+
+    @property
+    def client(self) -> Any:
+        """The client for the provider."""
+        raise NotImplementedError(
+            'The Outlines provider does not have a set client as it functions '
+            + 'with a set of different underlying models.'
+        )
+
+    def model_profile(self, model_name: str) -> ModelProfile | None:
+        """The model profile for the named model, if available."""
+        return ModelProfile(
+            supports_tools=False,
+            supports_json_schema_output=True,
+            supports_json_object_output=True,
+            default_structured_output_mode='native',
+        )

pydantic_ai/providers/ovhcloud.py

@@ -0,0 +1,95 @@
+from __future__ import annotations as _annotations
+
+import os
+from typing import overload
+
+import httpx
+
+from pydantic_ai import ModelProfile
+from pydantic_ai.exceptions import UserError
+from pydantic_ai.models import cached_async_http_client
+from pydantic_ai.profiles.deepseek import deepseek_model_profile
+from pydantic_ai.profiles.harmony import harmony_model_profile
+from pydantic_ai.profiles.meta import meta_model_profile
+from pydantic_ai.profiles.mistral import mistral_model_profile
+from pydantic_ai.profiles.openai import OpenAIJsonSchemaTransformer, OpenAIModelProfile
+from pydantic_ai.profiles.qwen import qwen_model_profile
+from pydantic_ai.providers import Provider
+
+try:
+    from openai import AsyncOpenAI
+except ImportError as _import_error:  # pragma: no cover
+    raise ImportError(
+        'Please install the `openai` package to use OVHcloud AI Endpoints provider.'
+        'You can use the `openai` optional group — `pip install "pydantic-ai-slim[openai]"`'
+    ) from _import_error
+
+
+class OVHcloudProvider(Provider[AsyncOpenAI]):
+    """Provider for OVHcloud AI Endpoints."""
+
+    @property
+    def name(self) -> str:
+        return 'ovhcloud'
+
+    @property
+    def base_url(self) -> str:
+        return 'https://oai.endpoints.kepler.ai.cloud.ovh.net/v1'
+
+    @property
+    def client(self) -> AsyncOpenAI:
+        return self._client
+
+    def model_profile(self, model_name: str) -> ModelProfile | None:
+        model_name = model_name.lower()
+
+        prefix_to_profile = {
+            'llama': meta_model_profile,
+            'meta-': meta_model_profile,
+            'deepseek': deepseek_model_profile,
+            'mistral': mistral_model_profile,
+            'gpt': harmony_model_profile,
+            'qwen': qwen_model_profile,
+        }
+
+        profile = None
+        for prefix, profile_func in prefix_to_profile.items():
+            if model_name.startswith(prefix):
+                profile = profile_func(model_name)
+
+        # As the OVHcloud AI Endpoints API is OpenAI-compatible, let's assume we also need OpenAIJsonSchemaTransformer.
+        return OpenAIModelProfile(json_schema_transformer=OpenAIJsonSchemaTransformer).update(profile)
+
+    @overload
+    def __init__(self) -> None: ...
+
+    @overload
+    def __init__(self, *, api_key: str) -> None: ...
+
+    @overload
+    def __init__(self, *, api_key: str, http_client: httpx.AsyncClient) -> None: ...
+
+    @overload
+    def __init__(self, *, openai_client: AsyncOpenAI | None = None) -> None: ...
+
+    def __init__(
+        self,
+        *,
+        api_key: str | None = None,
+        openai_client: AsyncOpenAI | None = None,
+        http_client: httpx.AsyncClient | None = None,
+    ) -> None:
+        api_key = api_key or os.getenv('OVHCLOUD_API_KEY')
+        if not api_key and openai_client is None:
+            raise UserError(
+                'Set the `OVHCLOUD_API_KEY` environment variable or pass it via '
+                '`OVHcloudProvider(api_key=...)` to use OVHcloud AI Endpoints provider.'
+            )
+
+        if openai_client is not None:
+            self._client = openai_client
+        elif http_client is not None:
+            self._client = AsyncOpenAI(base_url=self.base_url, api_key=api_key, http_client=http_client)
+        else:
+            http_client = cached_async_http_client(provider='ovhcloud')
+            self._client = AsyncOpenAI(base_url=self.base_url, api_key=api_key, http_client=http_client)