deepeval 3.5.1__py3-none-any.whl → 3.5.3__py3-none-any.whl

deepeval/models/embedding_models/azure_embedding_model.py

@@ -1,4 +1,4 @@
-from typing import List
+from typing import Dict, List
 from openai import AzureOpenAI, AsyncAzureOpenAI
 from deepeval.key_handler import (
     EmbeddingKeyValues,
@@ -6,10 +6,18 @@ from deepeval.key_handler import (
     KEY_FILE_HANDLER,
 )
 from deepeval.models import DeepEvalBaseEmbeddingModel
+from deepeval.models.retry_policy import (
+    create_retry_decorator,
+    sdk_retries_for,
+)
+from deepeval.constants import ProviderSlug as PS
+
+
+retry_azure = create_retry_decorator(PS.AZURE)
 
 
 class AzureOpenAIEmbeddingModel(DeepEvalBaseEmbeddingModel):
-    def __init__(self):
+    def __init__(self, **kwargs):
         self.azure_openai_api_key = KEY_FILE_HANDLER.fetch_data(
             ModelKeyValues.AZURE_OPENAI_API_KEY
         )
@@ -23,7 +31,9 @@ class AzureOpenAIEmbeddingModel(DeepEvalBaseEmbeddingModel):
             ModelKeyValues.AZURE_OPENAI_ENDPOINT
         )
         self.model_name = self.azure_embedding_deployment
+        self.kwargs = kwargs
 
+    @retry_azure
     def embed_text(self, text: str) -> List[float]:
         client = self.load_model(async_mode=False)
         response = client.embeddings.create(
@@ -32,6 +42,7 @@ class AzureOpenAIEmbeddingModel(DeepEvalBaseEmbeddingModel):
         )
         return response.data[0].embedding
 
+    @retry_azure
     def embed_texts(self, texts: List[str]) -> List[List[float]]:
         client = self.load_model(async_mode=False)
         response = client.embeddings.create(
@@ -40,6 +51,7 @@ class AzureOpenAIEmbeddingModel(DeepEvalBaseEmbeddingModel):
         )
         return [item.embedding for item in response.data]
 
+    @retry_azure
     async def a_embed_text(self, text: str) -> List[float]:
         client = self.load_model(async_mode=True)
         response = await client.embeddings.create(
@@ -48,6 +60,7 @@ class AzureOpenAIEmbeddingModel(DeepEvalBaseEmbeddingModel):
         )
         return response.data[0].embedding
 
+    @retry_azure
     async def a_embed_texts(self, texts: List[str]) -> List[List[float]]:
         client = self.load_model(async_mode=True)
         response = await client.embeddings.create(
@@ -61,15 +74,33 @@ class AzureOpenAIEmbeddingModel(DeepEvalBaseEmbeddingModel):
 
     def load_model(self, async_mode: bool = False):
         if not async_mode:
-            return AzureOpenAI(
-                api_key=self.azure_openai_api_key,
-                api_version=self.openai_api_version,
-                azure_endpoint=self.azure_endpoint,
-                azure_deployment=self.azure_embedding_deployment,
-            )
-        return AsyncAzureOpenAI(
+            return self._build_client(AzureOpenAI)
+        return self._build_client(AsyncAzureOpenAI)
+
+    def _client_kwargs(self) -> Dict:
+        """
+        If Tenacity is managing retries, force OpenAI SDK retries off to avoid double retries.
+        If the user opts into SDK retries for 'azure' via DEEPEVAL_SDK_RETRY_PROVIDERS,
+        leave their retry settings as is.
+        """
+        kwargs = dict(self.kwargs or {})
+        if not sdk_retries_for(PS.AZURE):
+            kwargs["max_retries"] = 0
+        return kwargs
+
+    def _build_client(self, cls):
+        kw = dict(
             api_key=self.azure_openai_api_key,
             api_version=self.openai_api_version,
             azure_endpoint=self.azure_endpoint,
             azure_deployment=self.azure_embedding_deployment,
+            **self._client_kwargs(),
         )
+        try:
+            return cls(**kw)
+        except TypeError as e:
+            # older OpenAI SDKs may not accept max_retries, in that case remove and retry once
+            if "max_retries" in str(e):
+                kw.pop("max_retries", None)
+                return cls(**kw)
+            raise

deepeval/models/embedding_models/local_embedding_model.py

@@ -1,12 +1,21 @@
-from openai import OpenAI
-from typing import List
+from openai import OpenAI, AsyncOpenAI
+from typing import Dict, List
 
 from deepeval.key_handler import EmbeddingKeyValues, KEY_FILE_HANDLER
 from deepeval.models import DeepEvalBaseEmbeddingModel
+from deepeval.models.retry_policy import (
+    create_retry_decorator,
+    sdk_retries_for,
+)
+from deepeval.constants import ProviderSlug as PS
+
+
+# consistent retry rules
+retry_local = create_retry_decorator(PS.LOCAL)
 
 
 class LocalEmbeddingModel(DeepEvalBaseEmbeddingModel):
-    def __init__(self, *args, **kwargs):
+    def __init__(self, **kwargs):
         self.base_url = KEY_FILE_HANDLER.fetch_data(
             EmbeddingKeyValues.LOCAL_EMBEDDING_BASE_URL
         )
@@ -16,13 +25,10 @@ class LocalEmbeddingModel(DeepEvalBaseEmbeddingModel):
         self.api_key = KEY_FILE_HANDLER.fetch_data(
             EmbeddingKeyValues.LOCAL_EMBEDDING_API_KEY
         )
-        self.args = args
         self.kwargs = kwargs
         super().__init__(model_name)
 
-    def load_model(self):
-        return OpenAI(base_url=self.base_url, api_key=self.api_key)
-
+    @retry_local
     def embed_text(self, text: str) -> List[float]:
         embedding_model = self.load_model()
         response = embedding_model.embeddings.create(
@@ -31,6 +37,7 @@ class LocalEmbeddingModel(DeepEvalBaseEmbeddingModel):
         )
         return response.data[0].embedding
 
+    @retry_local
     def embed_texts(self, texts: List[str]) -> List[List[float]]:
         embedding_model = self.load_model()
         response = embedding_model.embeddings.create(
@@ -39,21 +46,57 @@ class LocalEmbeddingModel(DeepEvalBaseEmbeddingModel):
         )
         return [data.embedding for data in response.data]
 
+    @retry_local
     async def a_embed_text(self, text: str) -> List[float]:
-        embedding_model = self.load_model()
-        response = embedding_model.embeddings.create(
+        embedding_model = self.load_model(async_mode=True)
+        response = await embedding_model.embeddings.create(
             model=self.model_name,
             input=[text],
         )
         return response.data[0].embedding
 
+    @retry_local
     async def a_embed_texts(self, texts: List[str]) -> List[List[float]]:
-        embedding_model = self.load_model()
-        response = embedding_model.embeddings.create(
+        embedding_model = self.load_model(async_mode=True)
+        response = await embedding_model.embeddings.create(
             model=self.model_name,
             input=texts,
         )
         return [data.embedding for data in response.data]
 
+    ###############################################
+    # Model
+    ###############################################
+
     def get_model_name(self):
         return self.model_name
+
+    def load_model(self, async_mode: bool = False):
+        if not async_mode:
+            return self._build_client(OpenAI)
+        return self._build_client(AsyncOpenAI)
+
+    def _client_kwargs(self) -> Dict:
+        """
+        If Tenacity manages retries, turn off OpenAI SDK retries to avoid double retrying.
+        If users opt into SDK retries via DEEPEVAL_SDK_RETRY_PROVIDERS=local, leave them enabled.
+        """
+        kwargs = dict(self.kwargs or {})
+        if not sdk_retries_for(PS.LOCAL):
+            kwargs["max_retries"] = 0
+        return kwargs
+
+    def _build_client(self, cls):
+        kw = dict(
+            api_key=self.api_key,
+            base_url=self.base_url,
+            **self._client_kwargs(),
+        )
+        try:
+            return cls(**kw)
+        except TypeError as e:
+            # Older OpenAI SDKs may not accept max_retries; drop and retry once.
+            if "max_retries" in str(e):
+                kw.pop("max_retries", None)
+                return cls(**kw)
+            raise

deepeval/models/embedding_models/ollama_embedding_model.py

@@ -3,6 +3,13 @@ from typing import List
 
 from deepeval.key_handler import EmbeddingKeyValues, KEY_FILE_HANDLER
 from deepeval.models import DeepEvalBaseEmbeddingModel
+from deepeval.models.retry_policy import (
+    create_retry_decorator,
+)
+from deepeval.constants import ProviderSlug as PS
+
+
+retry_ollama = create_retry_decorator(PS.OLLAMA)
 
 
 class OllamaEmbeddingModel(DeepEvalBaseEmbeddingModel):
@@ -13,6 +20,7 @@ class OllamaEmbeddingModel(DeepEvalBaseEmbeddingModel):
         model_name = KEY_FILE_HANDLER.fetch_data(
             EmbeddingKeyValues.LOCAL_EMBEDDING_MODEL_NAME
         )
+        # TODO: This is not being used. Clean it up in consistency PR
         self.api_key = KEY_FILE_HANDLER.fetch_data(
             EmbeddingKeyValues.LOCAL_EMBEDDING_API_KEY
         )
@@ -20,12 +28,7 @@ class OllamaEmbeddingModel(DeepEvalBaseEmbeddingModel):
         self.kwargs = kwargs
         super().__init__(model_name)
 
-    def load_model(self, async_mode: bool = False):
-        if not async_mode:
-            return Client(host=self.base_url)
-
-        return AsyncClient(host=self.base_url)
-
+    @retry_ollama
     def embed_text(self, text: str) -> List[float]:
         embedding_model = self.load_model()
         response = embedding_model.embed(
@@ -34,6 +37,7 @@ class OllamaEmbeddingModel(DeepEvalBaseEmbeddingModel):
         )
         return response["embeddings"][0]
 
+    @retry_ollama
     def embed_texts(self, texts: List[str]) -> List[List[float]]:
         embedding_model = self.load_model()
         response = embedding_model.embed(
@@ -42,6 +46,7 @@ class OllamaEmbeddingModel(DeepEvalBaseEmbeddingModel):
         )
         return response["embeddings"]
 
+    @retry_ollama
     async def a_embed_text(self, text: str) -> List[float]:
         embedding_model = self.load_model(async_mode=True)
         response = await embedding_model.embed(
@@ -50,6 +55,7 @@ class OllamaEmbeddingModel(DeepEvalBaseEmbeddingModel):
         )
         return response["embeddings"][0]
 
+    @retry_ollama
     async def a_embed_texts(self, texts: List[str]) -> List[List[float]]:
         embedding_model = self.load_model(async_mode=True)
         response = await embedding_model.embed(
@@ -58,5 +64,17 @@ class OllamaEmbeddingModel(DeepEvalBaseEmbeddingModel):
         )
         return response["embeddings"]
 
+    ###############################################
+    # Model
+    ###############################################
+
+    def load_model(self, async_mode: bool = False):
+        if not async_mode:
+            return self._build_client(Client)
+        return self._build_client(AsyncClient)
+
+    def _build_client(self, cls):
+        return cls(host=self.base_url, **self.kwargs)
+
     def get_model_name(self):
-        return self.model_name
+        return f"{self.model_name} (Ollama)"

deepeval/models/embedding_models/openai_embedding_model.py

@@ -1,6 +1,14 @@
-from typing import Optional, List
+from typing import Dict, Optional, List
 from openai import OpenAI, AsyncOpenAI
 from deepeval.models import DeepEvalBaseEmbeddingModel
+from deepeval.models.retry_policy import (
+    create_retry_decorator,
+    sdk_retries_for,
+)
+from deepeval.constants import ProviderSlug as PS
+
+
+retry_openai = create_retry_decorator(PS.OPENAI)
 
 valid_openai_embedding_models = [
     "text-embedding-3-small",
@@ -15,6 +23,7 @@ class OpenAIEmbeddingModel(DeepEvalBaseEmbeddingModel):
         self,
         model: Optional[str] = None,
         _openai_api_key: Optional[str] = None,
+        **kwargs,
     ):
         model_name = model if model else default_openai_embedding_model
         if model_name not in valid_openai_embedding_models:
@@ -23,7 +32,9 @@ class OpenAIEmbeddingModel(DeepEvalBaseEmbeddingModel):
             )
         self._openai_api_key = _openai_api_key
         self.model_name = model_name
+        self.kwargs = kwargs
 
+    @retry_openai
     def embed_text(self, text: str) -> List[float]:
         client = self.load_model(async_mode=False)
         response = client.embeddings.create(
@@ -32,6 +43,7 @@ class OpenAIEmbeddingModel(DeepEvalBaseEmbeddingModel):
         )
         return response.data[0].embedding
 
+    @retry_openai
     def embed_texts(self, texts: List[str]) -> List[List[float]]:
         client = self.load_model(async_mode=False)
         response = client.embeddings.create(
@@ -40,6 +52,7 @@ class OpenAIEmbeddingModel(DeepEvalBaseEmbeddingModel):
         )
         return [item.embedding for item in response.data]
 
+    @retry_openai
     async def a_embed_text(self, text: str) -> List[float]:
         client = self.load_model(async_mode=True)
         response = await client.embeddings.create(
@@ -48,6 +61,7 @@ class OpenAIEmbeddingModel(DeepEvalBaseEmbeddingModel):
         )
         return response.data[0].embedding
 
+    @retry_openai
     async def a_embed_texts(self, texts: List[str]) -> List[List[float]]:
         client = self.load_model(async_mode=True)
         response = await client.embeddings.create(
@@ -56,11 +70,39 @@ class OpenAIEmbeddingModel(DeepEvalBaseEmbeddingModel):
         )
         return [item.embedding for item in response.data]
 
-    def get_model_name(self) -> str:
+    ###############################################
+    # Model
+    ###############################################
+
+    def get_model_name(self):
         return self.model_name
 
-    def load_model(self, async_mode: bool):
+    def load_model(self, async_mode: bool = False):
         if not async_mode:
-            return OpenAI(api_key=self._openai_api_key)
+            return self._build_client(OpenAI)
+        return self._build_client(AsyncOpenAI)
 
-        return AsyncOpenAI(api_key=self._openai_api_key)
+    def _client_kwargs(self) -> Dict:
+        """
+        If Tenacity is managing retries, force OpenAI SDK retries off to avoid double retries.
+        If the user opts into SDK retries for 'openai' via DEEPEVAL_SDK_RETRY_PROVIDERS,
+        leave their retry settings as is.
+        """
+        kwargs = dict(self.kwargs or {})
+        if not sdk_retries_for(PS.OPENAI):
+            kwargs["max_retries"] = 0
+        return kwargs
+
+    def _build_client(self, cls):
+        kw = dict(
+            api_key=self._openai_api_key,
+            **self._client_kwargs(),
+        )
+        try:
+            return cls(**kw)
+        except TypeError as e:
+            # older OpenAI SDKs may not accept max_retries, in that case remove and retry once
+            if "max_retries" in str(e):
+                kw.pop("max_retries", None)
+                return cls(**kw)
+            raise

deepeval/models/llms/amazon_bedrock_model.py

@@ -1,10 +1,16 @@
+import asyncio
+
 from typing import Optional, Tuple, Union, Dict
 from contextlib import AsyncExitStack
 from pydantic import BaseModel
-import asyncio
 
+from deepeval.models.retry_policy import (
+    create_retry_decorator,
+    sdk_retries_for,
+)
 from deepeval.models import DeepEvalBaseLLM
 from deepeval.models.llms.utils import trim_and_load_json
+from deepeval.constants import ProviderSlug as PS
 
 # check aiobotocore availability
 try:
@@ -15,6 +21,9 @@ try:
 except ImportError:
     aiobotocore_available = False
 
+# define retry policy
+retry_bedrock = create_retry_decorator(PS.BEDROCK)
+
 
 def _check_aiobotocore_available():
     if not aiobotocore_available:
@@ -53,11 +62,11 @@ class AmazonBedrockModel(DeepEvalBaseLLM):
 
         # prepare aiobotocore session, config, and async exit stack
         self._session = get_session()
-        self._config = Config(retries={"max_attempts": 5, "mode": "adaptive"})
         self._exit_stack = AsyncExitStack()
         self.kwargs = kwargs
         self.generation_kwargs = generation_kwargs or {}
         self._client = None
+        self._sdk_retry_mode: Optional[bool] = None
 
     ###############################################
     # Generate functions
@@ -68,6 +77,7 @@ class AmazonBedrockModel(DeepEvalBaseLLM):
     ) -> Tuple[Union[str, Dict], float]:
         return asyncio.run(self.a_generate(prompt, schema))
 
+    @retry_bedrock
     async def a_generate(
         self, prompt: str, schema: Optional[BaseModel] = None
     ) -> Tuple[Union[str, Dict], float]:
@@ -94,16 +104,33 @@ class AmazonBedrockModel(DeepEvalBaseLLM):
     ###############################################
 
     async def _ensure_client(self):
-        if self._client is None:
+        use_sdk = sdk_retries_for(PS.BEDROCK)
+
+        # only rebuild if client is missing or the sdk retry mode changes
+        if self._client is None or self._sdk_retry_mode != use_sdk:
+            # Close any previous
+            if self._client is not None:
+                await self._exit_stack.aclose()
+                self._client = None
+
+            # create retry config for botocore
+            retries_config = {"max_attempts": (5 if use_sdk else 1)}
+            if use_sdk:
+                retries_config["mode"] = "adaptive"
+
+            config = Config(retries=retries_config)
+
             cm = self._session.create_client(
                 "bedrock-runtime",
                 region_name=self.region_name,
                 aws_access_key_id=self.aws_access_key_id,
                 aws_secret_access_key=self.aws_secret_access_key,
-                config=self._config,
+                config=config,
                 **self.kwargs,
             )
             self._client = await self._exit_stack.enter_async_context(cm)
+            self._sdk_retry_mode = use_sdk
+
         return self._client
 
     async def close(self):

deepeval/models/llms/anthropic_model.py

@@ -1,12 +1,22 @@
+import warnings
+
 from typing import Optional, Tuple, Union, Dict
 from anthropic import Anthropic, AsyncAnthropic
 from pydantic import BaseModel
-import os
-import warnings
 
 from deepeval.models import DeepEvalBaseLLM
 from deepeval.models.llms.utils import trim_and_load_json
+from deepeval.models.retry_policy import (
+    create_retry_decorator,
+    sdk_retries_for,
+)
 from deepeval.models.utils import parse_model_name
+from deepeval.config.settings import get_settings
+from deepeval.constants import ProviderSlug as PS
+
+
+# consistent retry rules
+retry_anthropic = create_retry_decorator(PS.ANTHROPIC)
 
 model_pricing = {
     "claude-opus-4-20250514": {"input": 15.00 / 1e6, "output": 75.00 / 1e6},
@@ -45,6 +55,7 @@ class AnthropicModel(DeepEvalBaseLLM):
     # Generate functions
     ###############################################
 
+    @retry_anthropic
     def generate(
         self, prompt: str, schema: Optional[BaseModel] = None
     ) -> Tuple[Union[str, Dict], float]:
@@ -70,6 +81,7 @@ class AnthropicModel(DeepEvalBaseLLM):
             json_output = trim_and_load_json(message.content[0].text)
             return schema.model_validate(json_output), cost
 
+    @retry_anthropic
     async def a_generate(
         self, prompt: str, schema: Optional[BaseModel] = None
     ) -> Tuple[str, float]:
@@ -128,17 +140,31 @@ class AnthropicModel(DeepEvalBaseLLM):
 
     def load_model(self, async_mode: bool = False):
         if not async_mode:
-            return Anthropic(
-                api_key=os.environ.get("ANTHROPIC_API_KEY")
-                or self._anthropic_api_key,
-                **self.kwargs,
-            )
-        else:
-            return AsyncAnthropic(
-                api_key=os.environ.get("ANTHROPIC_API_KEY")
-                or self._anthropic_api_key,
-                **self.kwargs,
-            )
+            return self._build_client(Anthropic)
+        return self._build_client(AsyncAnthropic)
 
     def get_model_name(self):
         return f"{self.model_name}"
+
+    def _client_kwargs(self) -> Dict:
+        kwargs = dict(self.kwargs or {})
+        # If we are managing retries with Tenacity, force SDK retries off to avoid double retries.
+        # if the user opts into SDK retries via DEEPEVAL_SDK_RETRY_PROVIDERS, then honor their max_retries.
+        if not sdk_retries_for(PS.ANTHROPIC):
+            kwargs["max_retries"] = 0
+        return kwargs
+
+    def _build_client(self, cls):
+        settings = get_settings()
+        kw = dict(
+            api_key=settings.ANTHROPIC_API_KEY or self._anthropic_api_key,
+            **self._client_kwargs(),
+        )
+        try:
+            return cls(**kw)
+        except TypeError as e:
+            # in case older SDKs don’t accept max_retries, drop it and retry
+            if "max_retries" in str(e):
+                kw.pop("max_retries", None)
+                return cls(**kw)
+            raise

deepeval/models/llms/azure_model.py

@@ -1,9 +1,7 @@
-from tenacity import retry, retry_if_exception_type, wait_exponential_jitter
 from openai.types.chat.chat_completion import ChatCompletion
 from openai import AzureOpenAI, AsyncAzureOpenAI
 from typing import Optional, Tuple, Union, Dict
 from pydantic import BaseModel
-import openai
 
 from deepeval.models import DeepEvalBaseLLM
 from deepeval.key_handler import ModelKeyValues, KEY_FILE_HANDLER
@@ -11,17 +9,18 @@ from deepeval.models.llms.openai_model import (
     structured_outputs_models,
     json_mode_models,
     model_pricing,
-    log_retry_error,
 )
+from deepeval.models.retry_policy import (
+    create_retry_decorator,
+    sdk_retries_for,
+)
+
 from deepeval.models.llms.utils import trim_and_load_json
 from deepeval.models.utils import parse_model_name
+from deepeval.constants import ProviderSlug as PS
 
-retryable_exceptions = (
-    openai.RateLimitError,
-    openai.APIConnectionError,
-    openai.APITimeoutError,
-    openai.LengthFinishReasonError,
-)
+
+retry_azure = create_retry_decorator(PS.AZURE)
 
 
 class AzureOpenAIModel(DeepEvalBaseLLM):
@@ -67,11 +66,7 @@ class AzureOpenAIModel(DeepEvalBaseLLM):
     # Other generate functions
     ###############################################
 
-    @retry(
-        wait=wait_exponential_jitter(initial=1, exp_base=2, jitter=2, max=10),
-        retry=retry_if_exception_type(openai.RateLimitError),
-        after=log_retry_error,
-    )
+    @retry_azure
     def generate(
         self, prompt: str, schema: Optional[BaseModel] = None
     ) -> Tuple[Union[str, Dict], float]:
@@ -130,11 +125,7 @@ class AzureOpenAIModel(DeepEvalBaseLLM):
         else:
             return output, cost
 
-    @retry(
-        wait=wait_exponential_jitter(initial=1, exp_base=2, jitter=2, max=10),
-        retry=retry_if_exception_type(openai.RateLimitError),
-        after=log_retry_error,
-    )
+    @retry_azure
     async def a_generate(
         self, prompt: str, schema: Optional[BaseModel] = None
     ) -> Tuple[Union[str, BaseModel], float]:
@@ -199,11 +190,7 @@ class AzureOpenAIModel(DeepEvalBaseLLM):
     # Other generate functions
     ###############################################
 
-    @retry(
-        wait=wait_exponential_jitter(initial=1, exp_base=2, jitter=2, max=10),
-        retry=retry_if_exception_type(retryable_exceptions),
-        after=log_retry_error,
-    )
+    @retry_azure
     def generate_raw_response(
         self,
         prompt: str,
@@ -226,11 +213,7 @@ class AzureOpenAIModel(DeepEvalBaseLLM):
 
         return completion, cost
 
-    @retry(
-        wait=wait_exponential_jitter(initial=1, exp_base=2, jitter=2, max=10),
-        retry=retry_if_exception_type(retryable_exceptions),
-        after=log_retry_error,
-    )
+    @retry_azure
     async def a_generate_raw_response(
         self,
         prompt: str,
@@ -272,17 +255,33 @@ class AzureOpenAIModel(DeepEvalBaseLLM):
 
     def load_model(self, async_mode: bool = False):
         if not async_mode:
-            return AzureOpenAI(
-                api_key=self.azure_openai_api_key,
-                api_version=self.openai_api_version,
-                azure_endpoint=self.azure_endpoint,
-                azure_deployment=self.deployment_name,
-                **self.kwargs,  # ← Keep this for client initialization
-            )
-        return AsyncAzureOpenAI(
+            return self._build_client(AzureOpenAI)
+        return self._build_client(AsyncAzureOpenAI)
+
+    def _client_kwargs(self) -> Dict:
+        """
+        If Tenacity is managing retries, force OpenAI SDK retries off to avoid double retries.
+        If the user opts into SDK retries for 'azure' via DEEPEVAL_SDK_RETRY_PROVIDERS,
+        leave their retry settings as is.
+        """
+        kwargs = dict(self.kwargs or {})
+        if not sdk_retries_for(PS.AZURE):
+            kwargs["max_retries"] = 0
+        return kwargs
+
+    def _build_client(self, cls):
+        kw = dict(
             api_key=self.azure_openai_api_key,
             api_version=self.openai_api_version,
             azure_endpoint=self.azure_endpoint,
             azure_deployment=self.deployment_name,
-            **self.kwargs,  # ← Keep this for client initialization
+            **self._client_kwargs(),
         )
+        try:
+            return cls(**kw)
+        except TypeError as e:
+            # older OpenAI SDKs may not accept max_retries, in that case remove and retry once
+            if "max_retries" in str(e):
+                kw.pop("max_retries", None)
+                return cls(**kw)
+            raise