rasa-pro 3.11.0rc3__py3-none-any.whl → 3.11.1__py3-none-any.whl

rasa/model_manager/warm_rasa_process.py

@@ -0,0 +1,187 @@
+import shlex
+import subprocess
+from rasa.__main__ import main
+import os
+from typing import List
+import structlog
+from dataclasses import dataclass
+import uuid
+
+from rasa.model_manager import config
+from rasa.model_manager.utils import ensure_base_directory_exists, logs_path
+
+structlogger = structlog.get_logger(__name__)
+
+warm_rasa_processes: List["WarmRasaProcess"] = []
+
+NUMBER_OF_INITIAL_PROCESSES = 3
+
+
+@dataclass
+class WarmRasaProcess:
+    """Data class to store a warm Rasa process.
+
+    A "warm" Rasa process is one where we've done the heavy lifting of
+    importing key modules ahead of time (e.g. litellm). This is to avoid
+    long import times when we actually want to run a command.
+
+    This is a started process waiting for a Rasa CLI command. It's
+    output is stored in a log file identified by `log_id`.
+    """
+
+    process: subprocess.Popen
+    log_id: str
+
+
+def _create_warm_rasa_process() -> WarmRasaProcess:
+    """Create a new warm Rasa process."""
+    command = [
+        config.RASA_PYTHON_PATH,
+        "-m",
+        "rasa.model_manager.warm_rasa_process",
+    ]
+
+    envs = os.environ.copy()
+    envs["RASA_TELEMETRY_ENABLED"] = "false"
+
+    log_id = uuid.uuid4().hex
+    log_path = logs_path(log_id)
+
+    ensure_base_directory_exists(log_path)
+
+    process = subprocess.Popen(
+        command,
+        stdout=open(log_path, "w"),
+        stderr=subprocess.STDOUT,
+        stdin=subprocess.PIPE,
+        env=envs,
+    )
+
+    structlogger.debug(
+        "model_trainer.created_warm_rasa_process",
+        pid=process.pid,
+        command=command,
+        log_path=log_path,
+    )
+
+    return WarmRasaProcess(process=process, log_id=log_id)
+
+
+def initialize_warm_rasa_process() -> None:
+    """Initialize the warm Rasa processes."""
+    global warm_rasa_processes
+    for _ in range(NUMBER_OF_INITIAL_PROCESSES):
+        warm_rasa_processes.append(_create_warm_rasa_process())
+
+
+def shutdown_warm_rasa_processes() -> None:
+    """Shutdown all warm Rasa processes."""
+    global warm_rasa_processes
+    for warm_rasa_process in warm_rasa_processes:
+        warm_rasa_process.process.terminate()
+    warm_rasa_processes = []
+
+
+def start_rasa_process(cwd: str, arguments: List[str]) -> WarmRasaProcess:
+    """Start a Rasa process.
+
+    This will start a Rasa process with the given current working directory
+    and arguments. The process will be a warm one, meaning that it has already
+    imported all necessary modules.
+    """
+    warm_rasa_process = _get_warm_rasa_process()
+    _pass_arguments_to_process(warm_rasa_process.process, cwd, arguments)
+    return warm_rasa_process
+
+
+def _get_warm_rasa_process() -> WarmRasaProcess:
+    """Get a warm Rasa process.
+
+    This will return a warm Rasa process from the pool and create a
+    new one to replace it.
+    """
+    global warm_rasa_processes
+
+    if not warm_rasa_processes:
+        warm_rasa_processes = [_create_warm_rasa_process()]
+
+    previous_warm_rasa_process = warm_rasa_processes.pop(0)
+
+    if previous_warm_rasa_process.process.poll() is not None:
+        # process has finished (for some reason...)
+        # back up plan is to create a new one on the spot.
+        # this should not happen, but let's be safe
+        structlogger.warning(
+            "model_trainer.warm_rasa_process_finished_unexpectedly",
+            pid=previous_warm_rasa_process.process.pid,
+        )
+        previous_warm_rasa_process = _create_warm_rasa_process()
+
+    warm_rasa_processes.append(_create_warm_rasa_process())
+    return previous_warm_rasa_process
+
+
+def _pass_arguments_to_process(
+    process: subprocess.Popen, cwd: str, arguments: List[str]
+) -> None:
+    """Pass arguments to a warm Rasa process.
+
+    The process is waiting for input on stdin. We pass the current working
+    directory and the arguments to run a Rasa CLI command.
+    """
+    arguments_string = " ".join(arguments)
+    # send arguments to stdin
+    process.stdin.write(cwd.encode())  # type: ignore[union-attr]
+    process.stdin.write("\n".encode())  # type: ignore[union-attr]
+    process.stdin.write(arguments_string.encode())  # type: ignore[union-attr]
+    process.stdin.write("\n".encode())  # type: ignore[union-attr]
+    process.stdin.flush()  # type: ignore[union-attr]
+
+
+def warmup() -> None:
+    """Import all necessary modules to warm up the process.
+
+    This should include all the modules that take a long time to import.
+    We import them now, so that the training / deployment can later
+    directly start.
+    """
+    try:
+        import presidio_analyzer  # noqa: F401
+        import litellm  # noqa: F401
+        import langchain  # noqa: F401
+        import tensorflow  # noqa: F401
+        import matplotlib  # noqa: F401
+        import pandas  # noqa: F401
+        import numpy  # noqa: F401
+        import spacy  # noqa: F401
+        import rasa.validator  # noqa: F401
+    except ImportError:
+        pass
+
+
+def warm_rasa_main() -> None:
+    """Entry point for processes waiting for their command to run.
+
+    The process will wait for the current working directory and the command
+    to run. These will be send on stdin by the parent process. After receiving
+    the input, we will kick things of starting or running a bot.
+
+    Uses the normal Rasa CLI entry point (e.g. `rasa train --data ...`).
+    """
+    warmup()
+
+    cwd = input()
+
+    # this should be `train --data ...` or similar
+    cli_arguments_str = input()
+    # splits the arguments string into a list of arguments as expected by `argparse`
+    arguments = shlex.split(cli_arguments_str)
+
+    # needed to make sure the passed arguments are relative to the working directory
+    os.chdir(cwd)
+
+    main(arguments)
+
+
+if __name__ == "__main__":
+    warm_rasa_main()

rasa/model_service.py

@@ -8,7 +8,7 @@ from rasa.core.persistor import RemoteStorageType, get_persistor
 from rasa.core.utils import list_routes
 from rasa.model_manager import model_api
 from rasa.model_manager import config
-from rasa.model_manager.config import SERVER_BASE_URL
+from rasa.model_manager.config import SERVER_BASE_URL, SERVER_PORT
 from rasa.utils.common import configure_logging_and_warnings
 import rasa.utils.licensing
 from urllib.parse import urlparse
@@ -18,8 +18,6 @@ from rasa.utils.sanic_error_handler import register_custom_sanic_error_handler
 
 structlogger = structlog.get_logger()
 
-MODEL_SERVICE_PORT = 8000
-
 
 def url_prefix_from_base_url() -> str:
     """Return the path prefix from the base URL."""
@@ -93,7 +91,7 @@ def main() -> None:
 
     validate_model_storage_type()
 
-    structlogger.debug("model_api.starting_server", port=MODEL_SERVICE_PORT)
+    structlogger.debug("model_api.starting_server", port=SERVER_PORT)
 
     url_prefix = url_prefix_from_base_url()
     # configure the sanic application
@@ -107,7 +105,7 @@ def main() -> None:
 
     register_custom_sanic_error_handler(app)
 
-    app.run(host="0.0.0.0", port=MODEL_SERVICE_PORT, legacy=True, motd=False)
+    app.run(host="0.0.0.0", port=SERVER_PORT, legacy=True, motd=False)
 
 
 if __name__ == "__main__":

rasa/model_training.py

@@ -322,8 +322,10 @@ async def _train_graph(
     rasa.engine.validation.validate_coexistance_routing_setup(
         domain, model_configuration, flows
     )
-    rasa.engine.validation.validate_model_client_configuration_setup(config)
     rasa.engine.validation.validate_model_group_configuration_setup()
+    rasa.engine.validation.validate_model_client_configuration_setup_during_training_time(
+        config
+    )
     rasa.engine.validation.validate_flow_component_dependencies(
         flows, model_configuration
     )

rasa/shared/constants.py

@@ -149,6 +149,10 @@ AZURE_AD_TOKEN_ENV_VAR = "AZURE_AD_TOKEN"
 AZURE_API_BASE_ENV_VAR = "AZURE_API_BASE"
 AZURE_API_VERSION_ENV_VAR = "AZURE_API_VERSION"
 AZURE_API_TYPE_ENV_VAR = "AZURE_API_TYPE"
+AZURE_SPEECH_API_KEY_ENV_VAR = "AZURE_SPEECH_API_KEY"
+
+DEEPGRAM_API_KEY_ENV_VAR = "DEEPGRAM_API_KEY"
+CARTESIA_API_KEY_ENV_VAR = "CARTESIA_API_KEY"
 
 OPENAI_API_KEY_ENV_VAR = "OPENAI_API_KEY"
 OPENAI_API_TYPE_ENV_VAR = "OPENAI_API_TYPE"
@@ -159,6 +163,9 @@ OPENAI_API_BASE_CONFIG_KEY = "openai_api_base"
 OPENAI_API_TYPE_CONFIG_KEY = "openai_api_type"
 OPENAI_API_VERSION_CONFIG_KEY = "openai_api_version"
 
+AWS_BEDROCK_PROVIDER = "bedrock"
+AWS_SAGEMAKER_PROVIDER = "sagemaker"
+
 API_BASE_CONFIG_KEY = "api_base"
 API_TYPE_CONFIG_KEY = "api_type"
 API_VERSION_CONFIG_KEY = "api_version"
@@ -219,6 +226,14 @@ AZURE_API_VERSION_ENV_VAR = "AZURE_API_VERSION"
 AZURE_API_TYPE_ENV_VAR = "AZURE_API_TYPE"
 
 AWS_REGION_NAME_CONFIG_KEY = "aws_region_name"
+AWS_ACCESS_KEY_ID_CONFIG_KEY = "aws_access_key_id"
+AWS_SECRET_ACCESS_KEY_CONFIG_KEY = "aws_secret_access_key"
+AWS_SESSION_TOKEN_CONFIG_KEY = "aws_session_token"
+
+AWS_ACCESS_KEY_ID_ENV_VAR = "AWS_ACCESS_KEY_ID"
+AWS_SECRET_ACCESS_KEY_ENV_VAR = "AWS_SECRET_ACCESS_KEY"
+AWS_REGION_NAME_ENV_VAR = "AWS_REGION_NAME"
+AWS_SESSION_TOKEN_ENV_VAR = "AWS_SESSION_TOKEN"
 
 HUGGINGFACE_MULTIPROCESS_CONFIG_KEY = "multi_process"
 HUGGINGFACE_CACHE_FOLDER_CONFIG_KEY = "cache_folder"
@@ -280,3 +295,10 @@ RASA_PATTERN_CANNOT_HANDLE_INVALID_INTENT = (
 )
 
 ROUTE_TO_CALM_SLOT = "route_session_to_calm"
+
+SENSITIVE_DATA = [
+    API_KEY,
+    AWS_ACCESS_KEY_ID_CONFIG_KEY,
+    AWS_SECRET_ACCESS_KEY_CONFIG_KEY,
+    AWS_SESSION_TOKEN_CONFIG_KEY,
+]

rasa/shared/core/domain.py

@@ -196,6 +196,7 @@ class Domain:
     """
 
     validate_yaml: ClassVar[bool] = True
+    expand_env_vars: ClassVar[bool] = True
 
     @classmethod
     def empty(cls) -> Domain:
@@ -1955,8 +1956,8 @@ class Domain:
         """Check whether the domain is empty."""
         return self.as_dict() == Domain.empty().as_dict()
 
-    @staticmethod
-    def is_domain_file(filename: Union[Text, Path]) -> bool:
+    @classmethod
+    def is_domain_file(cls, filename: Union[Text, Path]) -> bool:
         """Checks whether the given file path is a Rasa domain file.
 
         Args:
@@ -1975,7 +1976,7 @@ class Domain:
             return False
 
         try:
-            content = read_yaml_file(filename)
+            content = read_yaml_file(filename, expand_env_vars=cls.expand_env_vars)
         except (RasaException, YamlSyntaxException):
             structlogger.warning(
                 "domain.cannot_load_domain_file",
@@ -2104,10 +2105,12 @@ class Domain:
                 "domain.from_yaml.validating",
             )
             validate_raw_yaml_using_schema_file_with_responses(
-                raw_yaml_content, DOMAIN_SCHEMA_FILE
+                raw_yaml_content,
+                DOMAIN_SCHEMA_FILE,
+                expand_env_vars=cls.expand_env_vars,
             )
 
-        return read_yaml(raw_yaml_content)
+        return read_yaml(raw_yaml_content, expand_env_vars=cls.expand_env_vars)
 
 
 def warn_about_duplicates_found_during_domain_merging(

rasa/shared/core/flows/yaml_flows_io.py

@@ -1,5 +1,5 @@
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Text, Union
+from typing import Any, ClassVar, Dict, List, Optional, Text, Union
 
 import jsonschema
 import ruamel.yaml.nodes as yaml_nodes
@@ -25,6 +25,8 @@ KEY_FLOWS = "flows"
 class YAMLFlowsReader:
     """Class that reads flows information in YAML format."""
 
+    expand_env_vars: ClassVar[bool] = True
+
     @classmethod
     def read_from_file(
         cls, filename: Union[Text, Path], add_line_numbers: bool = True
@@ -217,14 +219,21 @@ class YAMLFlowsReader:
             `Flow`s read from `string`.
         """
         validate_yaml_with_jsonschema(
-            string, FLOWS_SCHEMA_FILE, humanize_error=cls.humanize_flow_error
+            string,
+            FLOWS_SCHEMA_FILE,
+            humanize_error=cls.humanize_flow_error,
+            expand_env_vars=cls.expand_env_vars,
         )
         if add_line_numbers:
-            yaml_content = read_yaml(string, custom_constructor=line_number_constructor)
+            yaml_content = read_yaml(
+                string,
+                custom_constructor=line_number_constructor,
+                expand_env_vars=cls.expand_env_vars,
+            )
             yaml_content = process_yaml_content(yaml_content)
 
         else:
-            yaml_content = read_yaml(string)
+            yaml_content = read_yaml(string, expand_env_vars=cls.expand_env_vars)
 
         return FlowsList.from_json(yaml_content.get(KEY_FLOWS, {}), file_path=file_path)
 

rasa/shared/importers/importer.py

@@ -1,7 +1,18 @@
 import logging
 from abc import ABC, abstractmethod
 from functools import reduce
-from typing import Any, Dict, List, Optional, Set, Text, Tuple, Type, Union, cast
+from typing import (
+    Any,
+    Dict,
+    List,
+    Optional,
+    Set,
+    Text,
+    Tuple,
+    Type,
+    Union,
+    cast,
+)
 
 import importlib_resources
 
@@ -167,6 +178,7 @@ class TrainingDataImporter(ABC):
         domain_path: Optional[Text] = None,
         training_data_paths: Optional[List[Text]] = None,
         args: Optional[Dict[Text, Any]] = None,
+        expand_env_vars: bool = True,
     ) -> "TrainingDataImporter":
         """Loads a `TrainingDataImporter` instance from a dictionary."""
         from rasa.shared.importers.rasa import RasaFileImporter
@@ -182,7 +194,12 @@ class TrainingDataImporter(ABC):
         importers = [importer for importer in importers if importer]
         if not importers:
             importers = [
-                RasaFileImporter(config_path, domain_path, training_data_paths)
+                RasaFileImporter(
+                    config_path,
+                    domain_path,
+                    training_data_paths,
+                    expand_env_vars=expand_env_vars,
+                )
             ]
 
         return E2EImporter(

rasa/shared/importers/rasa.py

@@ -29,7 +29,9 @@ class RasaFileImporter(TrainingDataImporter):
         config_file: Optional[Text] = None,
         domain_path: Optional[Text] = None,
         training_data_paths: Optional[Union[List[Text], Text]] = None,
+        expand_env_vars: bool = True,
     ):
+        self.expand_env_vars = expand_env_vars
         self._domain_path = domain_path
 
         self._nlu_files = rasa.shared.data.get_data_files(
@@ -54,7 +56,9 @@ class RasaFileImporter(TrainingDataImporter):
             logger.debug("No configuration file was provided to the RasaFileImporter.")
             return {}
 
-        config = read_model_configuration(self.config_file)
+        config = read_model_configuration(
+            self.config_file, expand_env_vars=self.expand_env_vars
+        )
         return config
 
     def get_config_file_for_auto_config(self) -> Optional[Text]:

rasa/shared/nlu/training_data/formats/rasa_yaml.py

@@ -1,7 +1,18 @@
 import logging
 from collections import OrderedDict
 from pathlib import Path
-from typing import Text, Any, List, Dict, Tuple, Union, Iterator, Optional, Callable
+from typing import (
+    ClassVar,
+    Text,
+    Any,
+    List,
+    Dict,
+    Tuple,
+    Union,
+    Iterator,
+    Optional,
+    Callable,
+)
 
 import rasa.shared.data
 from rasa.shared.core.domain import Domain
@@ -55,6 +66,8 @@ STRIP_SYMBOLS = "\n\r "
 class RasaYAMLReader(TrainingDataReader):
     """Reads YAML training data and creates a TrainingData object."""
 
+    expand_env_vars: ClassVar[bool] = True
+
     def __init__(self) -> None:
         super().__init__()
         self.training_examples: List[Message] = []
@@ -69,7 +82,9 @@ class RasaYAMLReader(TrainingDataReader):
         If the string is not in the right format, an exception will be raised.
         """
         try:
-            validate_raw_yaml_using_schema_file_with_responses(string, NLU_SCHEMA_FILE)
+            validate_raw_yaml_using_schema_file_with_responses(
+                string, NLU_SCHEMA_FILE, expand_env_vars=self.expand_env_vars
+            )
         except YamlException as e:
             e.filename = self.filename
             raise e
@@ -88,7 +103,7 @@ class RasaYAMLReader(TrainingDataReader):
         """
         self.validate(string)
 
-        yaml_content = read_yaml(string)
+        yaml_content = read_yaml(string, expand_env_vars=self.expand_env_vars)
 
         if not validate_training_data_format_version(yaml_content, self.filename):
             return TrainingData()

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/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()

rasa/shared/providers/llm/default_litellm_llm_client.py

@@ -1,8 +1,13 @@
 from typing import Dict, Any
 
+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.llm._base_litellm_client import _BaseLiteLLMClient
 
 
@@ -82,3 +87,22 @@ class DefaultLiteLLMClient(_BaseLiteLLMClient):
         to the client provider and deployed model.
         """
         return self._extra_parameters
+
+    def validate_client_setup(self) -> None:
+        # TODO: Temporarily change the 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_llm_client",
+            )
+        else:
+            super().validate_client_setup()

rasa/shared/utils/common.py

@@ -3,14 +3,16 @@ import functools
 import importlib
 import inspect
 import logging
+import os
 import pkgutil
 import sys
 from types import ModuleType
-from typing import Text, Dict, Optional, Any, List, Callable, Collection, Type
+from typing import Sequence, Text, Dict, Optional, Any, List, Callable, Collection, Type
 
 import rasa.shared.utils.io
+from rasa.exceptions import MissingDependencyException
 from rasa.shared.constants import DOCS_URL_MIGRATION_GUIDE
-from rasa.shared.exceptions import RasaException
+from rasa.shared.exceptions import ProviderClientValidationError, RasaException
 
 logger = logging.getLogger(__name__)
 
@@ -295,3 +297,28 @@ def warn_and_exit_if_module_path_contains_rasa_plus(
             docs=DOCS_URL_MIGRATION_GUIDE,
         )
         sys.exit(1)
+
+
+def validate_environment(
+    required_env_vars: Sequence[str],
+    required_packages: Sequence[str],
+    component_name: str,
+) -> None:
+    """Make sure all needed requirements for a component are met.
+    Args:
+         required_env_vars: List of environment variables that should be set
+         required_packages: List of packages that should be installed
+         component_name: component name that needs the requirements
+    """
+    for e in required_env_vars:
+        if not os.environ.get(e):
+            raise ProviderClientValidationError(
+                f"Missing environment variable for {component_name}: {e}"
+            )
+    for p in required_packages:
+        try:
+            importlib.import_module(p)
+        except ImportError:
+            raise MissingDependencyException(
+                f"Missing package for {component_name}: {p}"
+            )