rasa-pro 3.10.16__py3-none-any.whl → 3.11.0__py3-none-any.whl

rasa/shared/providers/_configs/model_group_config.py

@@ -0,0 +1,167 @@
+from dataclasses import asdict, dataclass, field
+from typing import List, Optional
+
+import structlog
+from rasa.shared.constants import (
+    API_BASE_CONFIG_KEY,
+    API_KEY,
+    API_TYPE_CONFIG_KEY,
+    API_VERSION_CONFIG_KEY,
+    DEPLOYMENT_CONFIG_KEY,
+    PROVIDER_CONFIG_KEY,
+    MODEL_CONFIG_KEY,
+    MODEL_GROUP_ID_CONFIG_KEY,
+    MODELS_CONFIG_KEY,
+    MODEL_GROUPS_CONFIG_KEY,
+    EXTRA_PARAMETERS_KEY,
+)
+from rasa.shared.providers.mappings import get_client_config_class_from_provider
+
+structlogger = structlog.get_logger()
+
+
+@dataclass
+class ModelConfig:
+    """Parses the model config.
+
+    Raises:
+        ValueError: If the provider config key is missing in the config.
+    """
+
+    provider: str
+    model: Optional[str] = None
+    deployment: Optional[str] = None
+    api_base: Optional[str] = None
+    api_key: Optional[str] = None
+    api_version: Optional[str] = None
+    extra_parameters: dict = field(default_factory=dict)
+    # Retained for backward compatibility with older configurations,
+    # but intentionally not included in extra_parameters
+    api_type: Optional[str] = None
+
+    @classmethod
+    def from_dict(cls, config: dict) -> "ModelConfig":
+        """Initializes a dataclass from the passed config. The provider config param is
+        used to determine the client config class to use. The client config class takes
+        care of resolving config aliases and throwing deprecation warnings.
+
+        Args:
+            config: (dict) The config from which to initialize.
+
+        Raises:
+            ValueError: Config is missing required keys.
+
+        Returns:
+            ModelConfig
+        """
+        from rasa.shared.utils.llm import get_provider_from_config
+
+        # Get the provider from config, this also inferring the provider from
+        # deprecated configurations
+        provider = get_provider_from_config(config)
+
+        # Retrieve the client configuration class for the specified provider.
+        client_config_clazz = get_client_config_class_from_provider(provider)
+
+        # Try to instantiate the config object in order to resolve deprecated
+        # aliases and throw deprecation warnings.
+        client_config_obj = client_config_clazz.from_dict(config)
+
+        # Convert back to dictionary and instantiate the ModelConfig object.
+        client_config = client_config_obj.to_dict()
+
+        # Check for provider after resolving all aliases
+        if PROVIDER_CONFIG_KEY not in client_config:
+            raise ValueError(
+                f"Missing required key '{PROVIDER_CONFIG_KEY}' in "
+                f"'{MODELS_CONFIG_KEY}' config."
+            )
+
+        return ModelConfig(
+            provider=client_config.pop(PROVIDER_CONFIG_KEY, None),
+            model=client_config.pop(MODEL_CONFIG_KEY, None),
+            deployment=client_config.pop(DEPLOYMENT_CONFIG_KEY, None),
+            api_type=client_config.pop(API_TYPE_CONFIG_KEY, None),
+            api_base=client_config.pop(API_BASE_CONFIG_KEY, None),
+            api_key=client_config.pop(API_KEY, None),
+            api_version=client_config.pop(API_VERSION_CONFIG_KEY, None),
+            extra_parameters=client_config,
+        )
+
+    def to_dict(self) -> dict:
+        """Converts the config instance into a dictionary."""
+        d = asdict(self)
+
+        # Extra parameters should also be on the top level
+        d.pop(EXTRA_PARAMETERS_KEY, None)
+        d.update(self.extra_parameters)
+
+        # Remove keys with None values
+        return {key: value for key, value in d.items() if value is not None}
+
+
+@dataclass
+class ModelGroupConfig:
+    """Parses the models config. The models config is a list of model configs.
+
+    Raises:
+        ValueError: If the model group ID is None or if the models list is empty.
+    """
+
+    model_group_id: str
+    models: List[ModelConfig]
+
+    def __post_init__(self) -> None:
+        if self.model_group_id is None:
+            message = "Model group ID cannot be set to None."
+            structlogger.error(
+                "model_group_config.validation_error",
+                message=message,
+                model_group_id=self.model_group_id,
+            )
+            raise ValueError(message)
+        if not self.models:
+            message = "Models cannot be empty."
+            structlogger.error(
+                "model_group_config.validation_error",
+                message=message,
+                model_group_id=self.model_group_id,
+            )
+            raise ValueError(message)
+
+    @classmethod
+    def from_dict(cls, config: dict) -> "ModelGroupConfig":
+        """Initializes a dataclass from the passed config.
+
+        Args:
+            config: (dict) The config from which to initialize.
+
+        Raises:
+            ValueError: Config is missing required keys.
+
+        Returns:
+            ModelGroupConfig
+        """
+        if MODELS_CONFIG_KEY not in config:
+            raise ValueError(
+                f"Missing required key '{MODELS_CONFIG_KEY}' in "
+                f"'{MODEL_GROUPS_CONFIG_KEY}' config."
+            )
+
+        models_config = [
+            ModelConfig.from_dict(model_config)
+            for model_config in config[MODELS_CONFIG_KEY]
+        ]
+
+        return cls(
+            model_group_id=config.get(MODEL_GROUP_ID_CONFIG_KEY),
+            models=models_config,
+        )
+
+    def to_dict(self) -> dict:
+        """Converts the config instance into a dictionary."""
+        d = {
+            MODEL_GROUP_ID_CONFIG_KEY: self.model_group_id,
+            MODELS_CONFIG_KEY: [model.to_dict() for model in self.models],
+        }
+        return d

rasa/shared/providers/_configs/openai_client_config.py

@@ -19,8 +19,8 @@ from rasa.shared.constants import (
     REQUEST_TIMEOUT_CONFIG_KEY,
     TIMEOUT_CONFIG_KEY,
     PROVIDER_CONFIG_KEY,
-    OPENAI_PROVIDER,
     OPENAI_API_TYPE,
+    OPENAI_PROVIDER,
 )
 from rasa.shared.providers._configs.utils import (
     resolve_aliases,

rasa/shared/providers/_configs/rasa_llm_client_config.py

@@ -0,0 +1,73 @@
+from dataclasses import asdict, dataclass, field
+from typing import Optional
+
+import structlog
+
+from rasa.shared.constants import (
+    MODEL_CONFIG_KEY,
+    RASA_PROVIDER,
+    PROVIDER_CONFIG_KEY,
+    API_BASE_CONFIG_KEY,
+)
+from rasa.shared.providers._configs.utils import (
+    validate_required_keys,
+)
+
+REQUIRED_KEYS = [MODEL_CONFIG_KEY, PROVIDER_CONFIG_KEY, API_BASE_CONFIG_KEY]
+
+structlogger = structlog.get_logger()
+
+
+@dataclass
+class RasaLLMClientConfig:
+    """Parses configuration for a Rasa Hosted LiteLLM client,
+    checks required keys present.
+
+    Raises:
+        ValueError: Raised in cases of invalid configuration:
+            - If any of the required configuration keys are missing.
+    """
+
+    model: Optional[str]
+    api_base: Optional[str]
+    # Provider is not used by LiteLLM backend, but we define it here since it's
+    # used as switch between different clients.
+    provider: str = RASA_PROVIDER
+
+    extra_parameters: dict = field(default_factory=dict)
+
+    @classmethod
+    def from_dict(cls, config: dict) -> "RasaLLMClientConfig":
+        """
+        Initializes a dataclass from the passed config.
+
+        Args:
+            config: (dict) The config from which to initialize.
+
+        Raises:
+            ValueError: Raised in cases of invalid configuration:
+                - If any of the required configuration keys are missing.
+                - If `api_type` has a value different from `azure`.
+
+        Returns:
+            RasaLLMClientConfig
+        """
+        # Validate that required keys are set
+        validate_required_keys(config, REQUIRED_KEYS)
+
+        extra_parameters = {k: v for k, v in config.items() if k not in REQUIRED_KEYS}
+
+        return cls(
+            model=config.get(MODEL_CONFIG_KEY),
+            api_base=config.get(API_BASE_CONFIG_KEY),
+            provider=config.get(PROVIDER_CONFIG_KEY, RASA_PROVIDER),
+            extra_parameters=extra_parameters,
+        )
+
+    def to_dict(self) -> dict:
+        """Converts the config instance into a dictionary."""
+        d = asdict(self)
+        # Extra parameters should also be on the top level
+        d.pop("extra_parameters", None)
+        d.update(self.extra_parameters)
+        return d

rasa/shared/providers/_configs/self_hosted_llm_client_config.py

@@ -23,6 +23,7 @@ from rasa.shared.constants import (
     SELF_HOSTED_PROVIDER,
     USE_CHAT_COMPLETIONS_ENDPOINT_CONFIG_KEY,
 )
+
 from rasa.shared.providers._configs.utils import (
     raise_deprecation_warnings,
     resolve_aliases,

rasa/shared/providers/_configs/utils.py

@@ -99,3 +99,19 @@ def validate_forbidden_keys(config: dict, forbidden_keys: list) -> None:
             config=config,
         )
         raise ValueError(message)
+
+
+def get_provider_prefixed_model_name(provider: str, model: str) -> str:
+    """
+    Returns the model name with the provider prefixed.
+
+    Args:
+        provider: The provider of the model.
+        model: The model name.
+
+    Returns:
+        The model name with the provider prefixed.
+    """
+    if model and f"{provider}/" not in model:
+        return f"{provider}/{model}"
+    return model

rasa/shared/providers/_utils.py

@@ -0,0 +1,79 @@
+import structlog
+
+from rasa.shared.constants import (
+    AWS_ACCESS_KEY_ID_ENV_VAR,
+    AWS_ACCESS_KEY_ID_CONFIG_KEY,
+    AWS_SECRET_ACCESS_KEY_ENV_VAR,
+    AWS_SECRET_ACCESS_KEY_CONFIG_KEY,
+    AWS_REGION_NAME_ENV_VAR,
+    AWS_REGION_NAME_CONFIG_KEY,
+    AWS_SESSION_TOKEN_CONFIG_KEY,
+    AWS_SESSION_TOKEN_ENV_VAR,
+)
+from rasa.shared.exceptions import ProviderClientValidationError
+from litellm import validate_environment
+from rasa.shared.providers.embedding._base_litellm_embedding_client import (
+    _VALIDATE_ENVIRONMENT_MISSING_KEYS_KEY,
+)
+
+structlogger = structlog.get_logger()
+
+
+def validate_aws_setup_for_litellm_clients(
+    litellm_model_name: str, litellm_call_kwargs: dict, source_log: str
+) -> None:
+    """Validates the AWS setup for LiteLLM clients to ensure all required
+    environment variables or corresponding call kwargs are set.
+
+    Args:
+        litellm_model_name (str): The name of the LiteLLM model being validated.
+        litellm_call_kwargs (dict): Additional keyword arguments passed to the client,
+            which may include configuration values for AWS credentials.
+        source_log (str): The source log identifier for structured logging.
+
+    Raises:
+        ProviderClientValidationError: If any required AWS environment variable
+            or corresponding configuration key is missing.
+    """
+
+    # Mapping of environment variable names to their corresponding config keys
+    envs_to_args = {
+        AWS_ACCESS_KEY_ID_ENV_VAR: AWS_ACCESS_KEY_ID_CONFIG_KEY,
+        AWS_SECRET_ACCESS_KEY_ENV_VAR: AWS_SECRET_ACCESS_KEY_CONFIG_KEY,
+        AWS_REGION_NAME_ENV_VAR: AWS_REGION_NAME_CONFIG_KEY,
+        AWS_SESSION_TOKEN_ENV_VAR: AWS_SESSION_TOKEN_CONFIG_KEY,
+    }
+
+    # Validate the environment setup for the model
+    validation_info = validate_environment(litellm_model_name)
+    missing_environment_variables = validation_info.get(
+        _VALIDATE_ENVIRONMENT_MISSING_KEYS_KEY, []
+    )
+    # Filter out missing environment variables that have been set trough arguments
+    # in extra parameters
+    missing_environment_variables = [
+        missing_env_var
+        for missing_env_var in missing_environment_variables
+        if litellm_call_kwargs.get(envs_to_args.get(missing_env_var)) is None
+    ]
+
+    if missing_environment_variables:
+        missing_environment_details = [
+            (
+                f"'{missing_env_var}' environment variable or "
+                f"'{envs_to_args.get(missing_env_var)}' config key"
+            )
+            for missing_env_var in missing_environment_variables
+        ]
+        event_info = (
+            f"The following environment variables or configuration keys are "
+            f"missing: "
+            f"{', '.join(missing_environment_details)}. "
+            f"These settings are required for API calls."
+        )
+        structlogger.error(
+            f"{source_log}.validate_aws_environment_variables",
+            event_info=event_info,
+            missing_environment_variables=missing_environment_variables,
+        )
+        raise ProviderClientValidationError(event_info)

rasa/shared/providers/embedding/_base_litellm_embedding_client.py

@@ -1,12 +1,12 @@
+import logging
 from abc import abstractmethod
 from typing import Any, Dict, List
 
 import litellm
-import logging
 import structlog
 from litellm import aembedding, embedding, validate_environment
 
-from rasa.shared.constants import API_BASE_CONFIG_KEY
+from rasa.shared.constants import API_BASE_CONFIG_KEY, API_KEY
 from rasa.shared.exceptions import (
     ProviderClientAPIException,
     ProviderClientValidationError,
@@ -19,7 +19,7 @@ from rasa.shared.providers.embedding.embedding_response import (
     EmbeddingResponse,
     EmbeddingUsage,
 )
-from rasa.shared.utils.io import suppress_logs
+from rasa.shared.utils.io import suppress_logs, resolve_environment_variables
 
 structlogger = structlog.get_logger()
 
@@ -27,8 +27,7 @@ _VALIDATE_ENVIRONMENT_MISSING_KEYS_KEY = "missing_keys"
 
 
 class _BaseLiteLLMEmbeddingClient:
-    """
-    An abstract base class for LiteLLM embedding clients.
+    """An abstract base class for LiteLLM embedding clients.
 
     This class defines the interface and common functionality for all clients
     based on LiteLLM.
@@ -83,12 +82,12 @@ class _BaseLiteLLMEmbeddingClient:
             ProviderClientValidationError if validation fails.
         """
         self._validate_environment_variables()
-        self._validate_api_key_not_in_config()
 
     def _validate_environment_variables(self) -> None:
         """Validate that the required environment variables are set."""
         validation_info = validate_environment(
             self._litellm_model_name,
+            api_key=self._litellm_extra_parameters.get(API_KEY),
             api_base=self._litellm_extra_parameters.get(API_BASE_CONFIG_KEY),
         )
         if missing_environment_variables := validation_info.get(
@@ -105,21 +104,8 @@ class _BaseLiteLLMEmbeddingClient:
             )
             raise ProviderClientValidationError(event_info)
 
-    def _validate_api_key_not_in_config(self) -> None:
-        if "api_key" in self._litellm_extra_parameters:
-            event_info = (
-                "API Key is set through `api_key` extra parameter."
-                "Set API keys through environment variables."
-            )
-            structlogger.error(
-                "base_litellm_client.validate_api_key_not_in_config",
-                event_info=event_info,
-            )
-            raise ProviderClientValidationError(event_info)
-
     def validate_documents(self, documents: List[str]) -> None:
-        """
-        Validates a list of documents to ensure they are suitable for embedding.
+        """Validates a list of documents to ensure they are suitable for embedding.
 
         Args:
             documents: List of documents to be validated.
@@ -135,8 +121,7 @@ class _BaseLiteLLMEmbeddingClient:
 
     @suppress_logs(log_level=logging.WARNING)
     def embed(self, documents: List[str]) -> EmbeddingResponse:
-        """
-        Embeds a list of documents synchronously.
+        """Embeds a list of documents synchronously.
 
         Args:
             documents: List of documents to be embedded.
@@ -149,7 +134,8 @@ class _BaseLiteLLMEmbeddingClient:
         """
         self.validate_documents(documents)
         try:
-            response = embedding(input=documents, **self._embedding_fn_args)
+            arguments = resolve_environment_variables(self._embedding_fn_args)
+            response = embedding(input=documents, **arguments)
             return self._format_response(response)
         except Exception as e:
             raise ProviderClientAPIException(
@@ -158,8 +144,7 @@ class _BaseLiteLLMEmbeddingClient:
 
     @suppress_logs(log_level=logging.WARNING)
     async def aembed(self, documents: List[str]) -> EmbeddingResponse:
-        """
-        Embeds a list of documents asynchronously.
+        """Embeds a list of documents asynchronously.
 
         Args:
             documents: List of documents to be embedded.
@@ -172,7 +157,8 @@ class _BaseLiteLLMEmbeddingClient:
         """
         self.validate_documents(documents)
         try:
-            response = await aembedding(input=documents, **self._embedding_fn_args)
+            arguments = resolve_environment_variables(self._embedding_fn_args)
+            response = await aembedding(input=documents, **arguments)
             return self._format_response(response)
         except Exception as e:
             raise ProviderClientAPIException(
@@ -187,7 +173,6 @@ class _BaseLiteLLMEmbeddingClient:
         Raises:
             ValueError: If any response data is None.
         """
-
         # If data is not available (None), raise a ValueError
         if response.data is None:
             message = (
@@ -244,8 +229,7 @@ class _BaseLiteLLMEmbeddingClient:
 
     @staticmethod
     def _ensure_certificates() -> None:
-        """
-        Configures SSL certificates for LiteLLM. This method is invoked during
+        """Configures SSL certificates for LiteLLM. This method is invoked during
         client initialization.
 
         LiteLLM may utilize `openai` clients or other providers that require

rasa/shared/providers/embedding/azure_openai_embedding_client.py

@@ -1,5 +1,6 @@
-from typing import Any, Dict, List, Optional
 import os
+from typing import Any, Dict, List, Optional
+
 import structlog
 
 from rasa.shared.constants import (
@@ -42,6 +43,7 @@ class AzureOpenAIEmbeddingClient(_BaseLiteLLMEmbeddingClient):
             If not provided, it will be set via environment variable.
         kwargs (Optional[Dict[str, Any]]): Optional configuration parameters specific
             to the embedding model deployment.
+
     Raises:
         ProviderClientValidationError: If validation of the client setup fails.
         DeprecationWarning: If deprecated environment variables are used for
@@ -60,6 +62,7 @@ class AzureOpenAIEmbeddingClient(_BaseLiteLLMEmbeddingClient):
         super().__init__()  # type: ignore
         self._deployment = deployment
         self._model = model
+        self._extra_parameters = kwargs or {}
 
         # Set api_base with the following priority:
         # parameter -> Azure Env Var -> (deprecated) OpenAI Env Var
@@ -81,17 +84,55 @@ class AzureOpenAIEmbeddingClient(_BaseLiteLLMEmbeddingClient):
         # Litellm does not support use of OPENAI_API_KEY, so we need to map it
         # because of backward compatibility. However, we're first looking at
         # AZURE_API_KEY.
-        self._api_key = os.environ.get(AZURE_API_KEY_ENV_VAR) or os.environ.get(
-            OPENAI_API_KEY_ENV_VAR
-        )
+        self._api_key_env_var = self._resolve_api_key_env_var()
 
-        self._extra_parameters = kwargs or {}
         self.validate_client_setup()
 
+    def _resolve_api_key_env_var(self) -> str:
+        """Resolves the environment variable to use for the API key.
+
+        Returns:
+            str: The env variable in dollar syntax format to use for the API key.
+        """
+        if API_KEY in self._extra_parameters:
+            # API key is set to an env var in the config itself
+            # in case the model is defined in the endpoints.yml
+            return self._extra_parameters[API_KEY]
+
+        if os.getenv(AZURE_API_KEY_ENV_VAR) is not None:
+            return "${AZURE_API_KEY}"
+
+        if os.getenv(OPENAI_API_KEY_ENV_VAR) is not None:
+            # API key can be set through OPENAI_API_KEY too,
+            # because of the backward compatibility
+            raise_deprecation_warning(
+                message=(
+                    f"Usage of '{OPENAI_API_KEY_ENV_VAR}' environment variable "
+                    "for setting the API key of "
+                    "Azure OpenAI client is deprecated and will "
+                    "be removed in 4.0.0. Please "
+                    f"use '{AZURE_API_KEY_ENV_VAR}' instead."
+                )
+            )
+            return "${OPENAI_API_KEY}"
+
+        structlogger.error(
+            "azure_openai_embedding_client.api_key_not_set",
+            event_info=(
+                "API key not set, it is required for API calls. "
+                f"Set it either via the environment variable "
+                f"'{AZURE_API_KEY_ENV_VAR}' or directly"
+                f"via the config key '{API_KEY}'."
+            ),
+        )
+        raise ProviderClientValidationError(
+            f"Missing required environment variable/config key '{API_KEY}' for "
+            f"API calls."
+        )
+
     @classmethod
     def from_config(cls, config: Dict[str, Any]) -> "AzureOpenAIEmbeddingClient":
-        """
-        Initializes the client from given configuration.
+        """Initializes the client from given configuration.
 
         Args:
             config (Dict[str, Any]): Configuration.
@@ -142,8 +183,7 @@ class AzureOpenAIEmbeddingClient(_BaseLiteLLMEmbeddingClient):
 
     @property
     def model(self) -> Optional[str]:
-        """
-        Returns the name of the model deployed on Azure. If model name is not
+        """Returns the name of the model deployed on Azure. If model name is not
         provided, returns "N/A".
         """
         return self._model
@@ -170,8 +210,7 @@ class AzureOpenAIEmbeddingClient(_BaseLiteLLMEmbeddingClient):
 
     @property
     def _litellm_extra_parameters(self) -> Dict[str, Any]:
-        """
-        Returns the model parameters for the azure openai embedding client.
+        """Returns the model parameters for the azure openai embedding client.
 
         Returns:
             Dictionary containing the model parameters.
@@ -186,7 +225,7 @@ class AzureOpenAIEmbeddingClient(_BaseLiteLLMEmbeddingClient):
             "api_base": self.api_base,
             "api_type": self.api_type,
             "api_version": self.api_version,
-            "api_key": self._api_key,
+            "api_key": self._api_key_env_var,
         }
 
     @property
@@ -197,8 +236,9 @@ class AzureOpenAIEmbeddingClient(_BaseLiteLLMEmbeddingClient):
         return self.deployment
 
     def validate_client_setup(self) -> None:
-        """Perform client validation. By default only environment variables
-        are validated.
+        """Perform client validation.
+
+        By default, only environment variables are validated.
 
         Raises:
             ProviderClientValidationError if validation fails.
@@ -214,13 +254,6 @@ class AzureOpenAIEmbeddingClient(_BaseLiteLLMEmbeddingClient):
                 "current_value": self.api_base,
                 "new_env_key": AZURE_API_BASE_ENV_VAR,
             },
-            {
-                "param_name": "API key",
-                "config_key": API_KEY,
-                "deprecated_env_key": OPENAI_API_KEY_ENV_VAR,
-                "current_value": self._api_key,
-                "new_env_key": AZURE_API_KEY_ENV_VAR,
-            },
             {
                 "param_name": "API version",
                 "config_key": API_VERSION_CONFIG_KEY,

rasa/shared/providers/embedding/default_litellm_embedding_client.py

@@ -1,8 +1,13 @@
 from typing import Any, Dict
 
+from rasa.shared.constants import (
+    AWS_BEDROCK_PROVIDER,
+    AWS_SAGEMAKER_PROVIDER,
+)
 from rasa.shared.providers._configs.default_litellm_client_config import (
     DefaultLiteLLMClientConfig,
 )
+from rasa.shared.providers._utils import validate_aws_setup_for_litellm_clients
 from rasa.shared.providers.embedding._base_litellm_embedding_client import (
     _BaseLiteLLMEmbeddingClient,
 )
@@ -100,3 +105,22 @@ class DefaultLiteLLMEmbeddingClient(_BaseLiteLLMEmbeddingClient):
             "model": self._litellm_model_name,
             **self._litellm_extra_parameters,
         }
+
+    def validate_client_setup(self) -> None:
+        # TODO: Temporarily disable environment variable validation for AWS setup
+        #       (Bedrock and SageMaker) until resolved by either:
+        #       1. An update from the LiteLLM package addressing the issue.
+        #       2. The implementation of a Bedrock client on our end.
+        #       ---
+        #       This fix ensures a consistent user experience for Bedrock (and
+        #       SageMaker) in Rasa by allowing AWS secrets to be provided as extra
+        #       parameters without triggering validation errors due to missing AWS
+        #       environment variables.
+        if self.provider.lower() in [AWS_BEDROCK_PROVIDER, AWS_SAGEMAKER_PROVIDER]:
+            validate_aws_setup_for_litellm_clients(
+                self._litellm_model_name,
+                self._litellm_extra_parameters,
+                "default_litellm_embedding_client",
+            )
+        else:
+            super().validate_client_setup()