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

rasa/model_training.py

@@ -1,12 +1,20 @@
 import sys
 import time
 from pathlib import Path
-from typing import Text, NamedTuple, Optional, List, Union, Dict, Any
+from typing import Any, Dict, List, NamedTuple, Optional, Text, Union
 
 import randomname
 import structlog
 
 import rasa.engine.validation
+import rasa.model
+import rasa.shared.constants
+import rasa.shared.exceptions
+import rasa.shared.utils.cli
+import rasa.shared.utils.common
+import rasa.shared.utils.io
+import rasa.utils.common
+from rasa import telemetry
 from rasa.engine.caching import LocalTrainingCache
 from rasa.engine.recipes.recipe import Recipe
 from rasa.engine.runner.dask import DaskGraphRunner
@@ -14,19 +22,13 @@ from rasa.engine.storage.local_model_storage import LocalModelStorage
 from rasa.engine.storage.storage import ModelStorage
 from rasa.engine.training.components import FingerprintStatus
 from rasa.engine.training.graph_trainer import GraphTrainer
+from rasa.nlu.persistor import RemoteStorageType, StorageType
+from rasa.shared.core.domain import Domain
 from rasa.shared.core.events import SlotSet
 from rasa.shared.core.training_data.structures import StoryGraph
 from rasa.shared.data import TrainingType
+from rasa.shared.exceptions import RasaException
 from rasa.shared.importers.importer import TrainingDataImporter
-from rasa import telemetry
-from rasa.shared.core.domain import Domain
-import rasa.utils.common
-import rasa.shared.utils.common
-import rasa.shared.utils.cli
-import rasa.shared.exceptions
-import rasa.shared.utils.io
-import rasa.shared.constants
-import rasa.model
 
 CODE_NEEDS_TO_BE_RETRAINED = 0b0001
 CODE_FORCED_TRAINING = 0b1000
@@ -153,6 +155,7 @@ async def train(
     nlu_additional_arguments: Optional[Dict] = None,
     model_to_finetune: Optional[Text] = None,
     finetuning_epoch_fraction: float = 1.0,
+    remote_storage: Optional[StorageType] = None,
 ) -> TrainingResult:
     """Trains a Rasa model (Core and NLU).
 
@@ -174,6 +177,7 @@ async def train(
             a directory in case the latest trained model should be used.
         finetuning_epoch_fraction: The fraction currently specified training epochs
             in the model configuration which should be used for finetuning.
+        remote_storage: The remote storage which should be used to store the model.
 
     Returns:
         An instance of `TrainingResult`.
@@ -253,6 +257,7 @@ async def train(
             persist_nlu_training_data=persist_nlu_training_data,
             finetuning_epoch_fraction=finetuning_epoch_fraction,
             dry_run=dry_run,
+            remote_storage=remote_storage,
             **(core_additional_arguments or {}),
             **(nlu_additional_arguments or {}),
         )
@@ -266,6 +271,7 @@ async def _train_graph(
     model_to_finetune: Optional[Union[Text, Path]] = None,
     force_full_training: bool = False,
     dry_run: bool = False,
+    remote_storage: Optional[StorageType] = None,
     **kwargs: Any,
 ) -> TrainingResult:
     if model_to_finetune:
@@ -306,6 +312,7 @@ 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_flow_component_dependencies(
         flows, model_configuration
     )
@@ -341,12 +348,30 @@ async def _train_graph(
                 force_retraining=force_full_training,
                 is_finetuning=is_finetuning,
             )
-            structlogger.info(
-                "model_training.train.finished_training",
-                event_info=(
-                    f"Your Rasa model is trained " f"and saved at '{full_model_path}'."
-                ),
-            )
+            if remote_storage:
+                push_model_to_remote_storage(full_model_path, remote_storage)
+                full_model_path.unlink()
+                remote_storage_string = (
+                    remote_storage.value
+                    if isinstance(remote_storage, RemoteStorageType)
+                    else remote_storage
+                )
+                structlogger.info(
+                    "model_training.train.finished_training",
+                    event_info=(
+                        f"Your Rasa model {model_name} is trained "
+                        f"and saved at remote storage provider "
+                        f"'{remote_storage_string}'."
+                    ),
+                )
+            else:
+                structlogger.info(
+                    "model_training.train.finished_training",
+                    event_info=(
+                        f"Your Rasa model is trained and saved at "
+                        f"'{full_model_path}'."
+                    ),
+                )
 
         return TrainingResult(str(full_model_path), 0)
 
@@ -534,3 +559,18 @@ async def train_nlu(
             **(additional_arguments or {}),
         )
     ).model
+
+
+def push_model_to_remote_storage(model_path: Path, remote_storage: StorageType) -> None:
+    """push model to remote storage"""
+    from rasa.nlu.persistor import get_persistor
+
+    persistor = get_persistor(remote_storage)
+
+    if persistor is not None:
+        persistor.persist(str(model_path))
+
+    else:
+        raise RasaException(
+            f"Persistor not found for remote storage: '{remote_storage}'."
+        )

rasa/nlu/persistor.py

@@ -1,13 +1,30 @@
+from __future__ import annotations
+
 import abc
-import structlog
 import os
 import shutil
-from typing import Optional, Text, Tuple, TYPE_CHECKING
+from enum import Enum
+from typing import TYPE_CHECKING, List, Optional, Text, Tuple, Union
 
-from rasa.shared.exceptions import RasaException
+import structlog
 
 import rasa.shared.utils.common
 import rasa.utils.common
+from rasa.constants import (
+    HTTP_STATUS_FORBIDDEN,
+    HTTP_STATUS_NOT_FOUND,
+    MODEL_ARCHIVE_EXTENSION,
+)
+from rasa.env import (
+    AWS_ENDPOINT_URL_ENV,
+    AZURE_ACCOUNT_KEY_ENV,
+    AZURE_ACCOUNT_NAME_ENV,
+    AZURE_CONTAINER_ENV,
+    BUCKET_NAME_ENV,
+    REMOTE_STORAGE_PATH_ENV,
+)
+from rasa.shared.exceptions import RasaException
+from rasa.shared.utils.io import raise_warning
 
 if TYPE_CHECKING:
     from azure.storage.blob import ContainerClient
@@ -15,34 +32,80 @@ if TYPE_CHECKING:
 structlogger = structlog.get_logger()
 
 
-def get_persistor(name: Text) -> Optional["Persistor"]:
+class RemoteStorageType(Enum):
+    """Enum for the different remote storage types."""
+
+    AWS = "aws"
+    GCS = "gcs"
+    AZURE = "azure"
+
+    @classmethod
+    def list(cls) -> List[str]:
+        """Returns a list of all available storage types."""
+        return [item.value for item in cls]
+
+
+"""Storage can be a built-in one or a module path to a custom persistor."""
+StorageType = Union[RemoteStorageType, str]
+
+
+def parse_remote_storage(value: str) -> StorageType:
+    try:
+        return RemoteStorageType(value)
+    except ValueError:
+        # if the value is not a valid storage type,
+        # but it is a string we assume it is a custom class
+        # and return it as is
+
+        supported_storages_help_text = (
+            f"Supported storages are: {RemoteStorageType.list()} "
+            "or path to a python class which implements `Persistor` interface."
+        )
+
+        if isinstance(value, str):
+            if value == "":
+                raise RasaException(
+                    f"The value can't be an empty string."
+                    f" {supported_storages_help_text}"
+                )
+
+            return value
+
+        raise RasaException(
+            f"Invalid storage type '{value}'. {supported_storages_help_text}"
+        )
+
+
+def get_persistor(storage: StorageType) -> Optional[Persistor]:
     """Returns an instance of the requested persistor.
 
     Currently, `aws`, `gcs`, `azure` and providing module paths are supported remote
     storages.
     """
-    if name == "aws":
+    if storage == RemoteStorageType.AWS:
         return AWSPersistor(
-            os.environ.get("BUCKET_NAME"), os.environ.get("AWS_ENDPOINT_URL")
+            os.environ.get(BUCKET_NAME_ENV), os.environ.get(AWS_ENDPOINT_URL_ENV)
         )
-    if name == "gcs":
-        return GCSPersistor(os.environ.get("BUCKET_NAME"))
+    if storage == RemoteStorageType.GCS:
+        return GCSPersistor(os.environ.get(BUCKET_NAME_ENV))
 
-    if name == "azure":
+    if storage == RemoteStorageType.AZURE:
         return AzurePersistor(
-            os.environ.get("AZURE_CONTAINER"),
-            os.environ.get("AZURE_ACCOUNT_NAME"),
-            os.environ.get("AZURE_ACCOUNT_KEY"),
+            os.environ.get(AZURE_CONTAINER_ENV),
+            os.environ.get(AZURE_ACCOUNT_NAME_ENV),
+            os.environ.get(AZURE_ACCOUNT_KEY_ENV),
         )
-    if name:
+    # If the persistor is not a built-in one, it is assumed to be a module path
+    # to a persistor implementation supplied by the user.
+    if storage:
         try:
-            persistor = rasa.shared.utils.common.class_from_module_path(name)
+            persistor = rasa.shared.utils.common.class_from_module_path(storage)
             return persistor()
         except ImportError:
             raise ImportError(
-                f"Unknown model persistor {name}. Please make sure to "
-                "either use an included model persistor (`aws`, `gcs` "
-                "or `azure`) or specify the module path to an external "
+                f"Unknown model persistor {storage}. Please make sure to "
+                f"either use an included model persistor ({RemoteStorageType.list()}) "
+                f"or specify the module path to an external "
                 "model persistor."
             )
     return None
@@ -51,24 +114,46 @@ def get_persistor(name: Text) -> Optional["Persistor"]:
 class Persistor(abc.ABC):
     """Store models in cloud and fetch them when needed."""
 
-    def persist(self, model_directory: Text, model_name: Text) -> None:
-        """Uploads a model persisted in the `target_dir` to cloud storage."""
-        if not os.path.isdir(model_directory):
-            raise ValueError(f"Target directory '{model_directory}' not found.")
+    def persist(self, trained_model: str) -> None:
+        """Uploads a trained model persisted in the `target_dir` to cloud storage."""
+        file_key = self._create_file_key(trained_model)
+        self._persist_tar(file_key, trained_model)
 
-        file_key, tar_path = self._compress(model_directory, model_name)
-        self._persist_tar(file_key, tar_path)
+    def retrieve(self, model_name: Text, target_path: Text) -> Text:
+        """Downloads a model that has been persisted to cloud storage.
 
-    def retrieve(self, model_name: Text, target_path: Text) -> None:
-        """Downloads a model that has been persisted to cloud storage."""
-        tar_name = model_name
+        Downloaded model will be saved to the `target_path`.
+        If `target_path` is a directory, the model will be downloaded to that directory.
+        If `target_path` is a file, the model will be downloaded to that file.
 
-        if not model_name.endswith("tar.gz"):
+        Args:
+            model_name: The name of the model to retrieve.
+            target_path: The path to which the model should be downloaded.
+        """
+        tar_name = model_name
+        if not model_name.endswith(MODEL_ARCHIVE_EXTENSION):
             # ensure backward compatibility
             tar_name = self._tar_name(model_name)
+        remote_object_path = self._create_file_key(tar_name)
+        self._retrieve_tar(remote_object_path)
+
+        target_tar_file_name = os.path.basename(tar_name)
+        if os.path.isdir(target_path):
+            target_path = os.path.join(target_path, target_tar_file_name)
+
+        if not os.path.exists(target_path):
+            structlogger.debug(
+                "persistor.retrieve.copy_model",
+                event_info=f"Copying model '{target_tar_file_name}' to "
+                f"'{target_path}'.",
+            )
+            self._copy(target_tar_file_name, target_path)
 
-        self._retrieve_tar(tar_name)
-        self._copy(os.path.basename(tar_name), target_path)
+        structlogger.debug(
+            "persistor.retrieve.model_retrieved",
+            event_info=f"Model retrieved and saved to '{target_path}'.",
+        )
+        return target_path
 
     @abc.abstractmethod
     def _retrieve_tar(self, filename: Text) -> None:
@@ -97,13 +182,37 @@ class Persistor(abc.ABC):
 
     @staticmethod
     def _tar_name(model_name: Text, include_extension: bool = True) -> Text:
-        ext = ".tar.gz" if include_extension else ""
+        ext = f".{MODEL_ARCHIVE_EXTENSION}" if include_extension else ""
         return f"{model_name}{ext}"
 
     @staticmethod
     def _copy(compressed_path: Text, target_path: Text) -> None:
         shutil.copy2(compressed_path, target_path)
 
+    @staticmethod
+    def _create_file_key(model_path: str) -> Text:
+        """Appends remote storage folders when provided to upload or retrieve file"""
+        bucket_object_path = os.environ.get(REMOTE_STORAGE_PATH_ENV)
+
+        # To keep the backward compatibility, if REMOTE_STORAGE_PATH is not provided,
+        # the model_name (which might be a complete path) will be returned as it is.
+        if bucket_object_path is None:
+            return str(model_path)
+        else:
+            raise_warning(
+                f"{REMOTE_STORAGE_PATH_ENV} is deprecated and will be "
+                "removed in future versions. "
+                "Please use the -m path/to/model.tar.gz option to "
+                "specify the model path when loading a model."
+                "Or use --output and --fixed-model-name to specify the "
+                "output directory and the model name when saving a "
+                "trained model to remote storage.",
+            )
+
+        file_key = os.path.basename(model_path)
+        file_key = os.path.join(bucket_object_path, file_key)
+        return file_key
+
 
 class AWSPersistor(Persistor):
     """Store models on S3.
@@ -137,7 +246,7 @@ class AWSPersistor(Persistor):
             self.s3.meta.client.head_bucket(Bucket=bucket_name)
         except botocore.exceptions.ClientError as e:
             error_code = int(e.response["Error"]["Code"])
-            if error_code == 403:
+            if error_code == HTTP_STATUS_FORBIDDEN:
                 log = (
                     f"Access to the specified bucket '{bucket_name}' is forbidden. "
                     "Please make sure you have the necessary "
@@ -149,7 +258,7 @@ class AWSPersistor(Persistor):
                     event_info=log,
                 )
                 raise RasaException(log)
-            elif error_code == 404:
+            elif error_code == HTTP_STATUS_NOT_FOUND:
                 log = (
                     f"The specified bucket '{bucket_name}' does not exist. "
                     "Please make sure to create the bucket first."
@@ -163,6 +272,11 @@ class AWSPersistor(Persistor):
 
     def _persist_tar(self, file_key: Text, tar_path: Text) -> None:
         """Uploads a model persisted in the `target_dir` to s3."""
+        structlogger.debug(
+            "aws_persistor.persist_tar.uploading_model",
+            event_info=f"Uploading tar archive {file_key} to "
+            f"s3 bucket '{self.bucket_name}'.",
+        )
         with open(tar_path, "rb") as f:
             self.s3.Object(self.bucket_name, file_key).put(Body=f)
 
@@ -183,7 +297,7 @@ class GCSPersistor(Persistor):
         """Initialise class with client and bucket."""
         # there are no type hints in this repo for now
         # https://github.com/googleapis/python-storage/issues/393
-        from google.cloud import storage  # type: ignore[attr-defined]
+        from google.cloud import storage
 
         super().__init__()
 
@@ -230,7 +344,7 @@ class GCSPersistor(Persistor):
     def _retrieve_tar(self, target_filename: Text) -> None:
         """Downloads a model that has previously been persisted to GCS."""
         blob = self.bucket.blob(target_filename)
-        blob.download_to_filename(target_filename)
+        blob.download_to_filename(os.path.basename(target_filename))
 
 
 class AzurePersistor(Persistor):
@@ -271,12 +385,19 @@ class AzurePersistor(Persistor):
     def _persist_tar(self, file_key: Text, tar_path: Text) -> None:
         """Uploads a model persisted in the `target_dir` to Azure."""
         with open(tar_path, "rb") as data:
-            self._container_client().upload_blob(name=file_key, data=data)
+            self._container_client().upload_blob(
+                name=file_key,
+                data=data,
+                # overwrite is set to True to keep in line with
+                # how GCS and AWS APIs work this enables easy
+                # updating of models in the cloud
+                overwrite=True,
+            )
 
     def _retrieve_tar(self, target_filename: Text) -> None:
         """Downloads a model that has previously been persisted to Azure."""
         blob_client = self._container_client().get_blob_client(target_filename)
 
-        with open(target_filename, "wb") as blob:
+        with open(os.path.basename(target_filename), "wb") as blob:
             download_stream = blob_client.download_blob()
             blob.write(download_stream.readall())

rasa/server.py

@@ -11,17 +11,17 @@ from http import HTTPStatus
 from inspect import isawaitable
 from pathlib import Path
 from typing import (
+    TYPE_CHECKING,
     Any,
     Callable,
+    Coroutine,
     DefaultDict,
+    Dict,
     List,
+    NoReturn,
     Optional,
     Text,
     Union,
-    Dict,
-    TYPE_CHECKING,
-    NoReturn,
-    Coroutine,
 )
 
 import aiohttp
@@ -54,15 +54,16 @@ from rasa.core.test import test
 from rasa.core.utils import AvailableEndpoints
 from rasa.nlu.emulators.emulator import Emulator
 from rasa.nlu.emulators.no_emulator import NoEmulator
+from rasa.nlu.persistor import parse_remote_storage
 from rasa.nlu.test import CVEvaluationResult
 from rasa.shared.constants import (
-    DOCS_URL_TRAINING_DATA,
-    DOCS_BASE_URL,
-    DEFAULT_SENDER_ID,
     DEFAULT_MODELS_PATH,
+    DEFAULT_SENDER_ID,
+    DOCS_BASE_URL,
+    DOCS_URL_TRAINING_DATA,
     TEST_STORIES_FILE_PREFIX,
 )
-from rasa.shared.core.domain import InvalidDomain, Domain
+from rasa.shared.core.domain import Domain, InvalidDomain
 from rasa.shared.core.events import Event
 from rasa.shared.core.trackers import (
     DialogueStateTracker,
@@ -80,8 +81,10 @@ from rasa.utils.endpoints import EndpointConfig
 
 if TYPE_CHECKING:
     from ssl import SSLContext
+
+    from mypy_extensions import Arg, KwArg, VarArg
+
     from rasa.core.processor import MessageProcessor
-    from mypy_extensions import Arg, VarArg, KwArg
 
     SanicResponse = Union[
         response.HTTPResponse, Coroutine[Any, Any, response.HTTPResponse]
@@ -532,6 +535,32 @@ def add_root_route(app: Sanic) -> None:
         """
         return response.html(html_content)
 
+    @app.get("/license")
+    async def license(request: Request) -> HTTPResponse:
+        """Respond with the license expiration date."""
+        from rasa.utils.licensing import (
+            get_license_expiration_date,
+            property_of_active_license,
+        )
+
+        body = {
+            "id": property_of_active_license(lambda active_license: active_license.jti),
+            "company": property_of_active_license(
+                lambda active_license: active_license.company
+            ),
+            "scope": property_of_active_license(
+                lambda active_license: active_license.scope
+            ),
+            "email": property_of_active_license(
+                lambda active_license: active_license.email
+            ),
+            "expires": get_license_expiration_date(),
+        }
+        return response.json(
+            body=body,
+            headers={"Content-Type": "application/json"},
+        )
+
 
 def async_if_callback_url(f: Callable[..., Coroutine]) -> Callable:
     """Decorator to enable async request handling.
@@ -1351,7 +1380,13 @@ def create_app(
 
         model_path = request.json.get("model_file", None)
         model_server = request.json.get("model_server", None)
-        remote_storage = request.json.get("remote_storage", None)
+
+        remote_storage_argument = request.json.get("remote_storage", None)
+        remote_storage = (
+            parse_remote_storage(remote_storage_argument)
+            if remote_storage_argument
+            else None
+        )
 
         if model_server:
             try:

rasa/shared/constants.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from typing import List, Text
 
+from rasa.shared.engine.caching import get_local_cache_location
 
 DOCS_BASE_URL = "https://rasa.com/docs/rasa-pro"
 DOCS_URL_CONCEPTS = DOCS_BASE_URL + "/concepts"
@@ -51,6 +52,8 @@ MODEL_CONFIG_SCHEMA_FILE = "shared/utils/schemas/model_config.yml"
 CONFIG_SCHEMA_FILE = "shared/utils/schemas/config.yml"
 RESPONSES_SCHEMA_FILE = "shared/nlu/training_data/schemas/responses.yml"
 SCHEMA_EXTENSIONS_FILE = "shared/utils/pykwalify_extensions.py"
+ASSERTIONS_SCHEMA_FILE = "e2e_test/assertions_schema.yml"
+ASSERTIONS_SCHEMA_EXTENSIONS_FILE = "e2e_test/pykwalify_extensions.py"
 LATEST_TRAINING_DATA_FORMAT_VERSION = "3.1"
 
 DOMAIN_SCHEMA_FILE = "shared/utils/schemas/domain.yml"
@@ -83,6 +86,8 @@ ENV_LOG_LEVEL_LLM_MODULE_NAMES = {
     "EnterpriseSearchPolicy": "LOG_LEVEL_LLM_ENTERPRISE_SEARCH",
     "IntentlessPolicy": "LOG_LEVEL_LLM_INTENTLESS_POLICY",
     "ContextualResponseRephraser": "LOG_LEVEL_LLM_REPHRASER",
+    "NLUCommandAdapter": "LOG_LEVEL_NLU_COMMAND_ADAPTER",
+    "LLMBasedRouter": "LOG_LEVEL_LLM_BASED_ROUTER",
 }
 TCP_PROTOCOL = "TCP"
 
@@ -106,7 +111,10 @@ CONFIG_KEYS_NLU = ["language", "pipeline"] + CONFIG_MANDATORY_COMMON_KEYS
 CONFIG_KEYS = CONFIG_KEYS_CORE + CONFIG_KEYS_NLU
 CONFIG_MANDATORY_KEYS_CORE: List[Text] = [] + CONFIG_MANDATORY_COMMON_KEYS
 CONFIG_MANDATORY_KEYS_NLU = ["language"] + CONFIG_MANDATORY_COMMON_KEYS
-CONFIG_MANDATORY_KEYS = CONFIG_MANDATORY_KEYS_CORE + CONFIG_MANDATORY_KEYS_NLU
+# we need the list to contain unique values
+CONFIG_MANDATORY_KEYS = list(
+    set(CONFIG_MANDATORY_KEYS_CORE + CONFIG_MANDATORY_KEYS_NLU)
+)
 
 # Keys related to Forms (in the Domain)
 REQUIRED_SLOTS_KEY = "required_slots"
@@ -137,34 +145,91 @@ DIAGNOSTIC_DATA = "diagnostic_data"
 RESPONSE_CONDITION = "condition"
 CHANNEL = "channel"
 
+API_KEY = "api_key"
+
+AZURE_API_KEY_ENV_VAR = "AZURE_API_KEY"
+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"
+
 OPENAI_API_KEY_ENV_VAR = "OPENAI_API_KEY"
 OPENAI_API_TYPE_ENV_VAR = "OPENAI_API_TYPE"
 OPENAI_API_VERSION_ENV_VAR = "OPENAI_API_VERSION"
 OPENAI_API_BASE_ENV_VAR = "OPENAI_API_BASE"
 
+OPENAI_API_BASE_CONFIG_KEY = "openai_api_base"
 OPENAI_API_TYPE_CONFIG_KEY = "openai_api_type"
-OPENAI_API_TYPE_NO_PREFIX_CONFIG_KEY = "api_type"
-
 OPENAI_API_VERSION_CONFIG_KEY = "openai_api_version"
-OPENAI_API_VERSION_NO_PREFIX_CONFIG_KEY = "api_version"
 
-OPENAI_API_BASE_CONFIG_KEY = "openai_api_base"
-OPENAI_API_BASE_NO_PREFIX_CONFIG_KEY = "api_base"
+API_BASE_CONFIG_KEY = "api_base"
+API_TYPE_CONFIG_KEY = "api_type"
+API_VERSION_CONFIG_KEY = "api_version"
+LANGCHAIN_TYPE_CONFIG_KEY = "_type"
+RASA_TYPE_CONFIG_KEY = "type"
+PROVIDER_CONFIG_KEY = "provider"
 
-OPENAI_DEPLOYMENT_NAME_CONFIG_KEY = "deployment_name"
-OPENAI_DEPLOYMENT_CONFIG_KEY = "deployment"
-OPENAI_ENGINE_CONFIG_KEY = "engine"
+REQUEST_TIMEOUT_CONFIG_KEY = "request_timeout"  # deprecated
+TIMEOUT_CONFIG_KEY = "timeout"
 
-RASA_TYPE_CONFIG_KEY = "type"
-LANGCHAIN_TYPE_CONFIG_KEY = "_type"
+DEPLOYMENT_NAME_CONFIG_KEY = "deployment_name"
+DEPLOYMENT_CONFIG_KEY = "deployment"
+EMBEDDINGS_CONFIG_KEY = "embeddings"
+ENGINE_CONFIG_KEY = "engine"
+LLM_CONFIG_KEY = "llm"
+MODEL_CONFIG_KEY = "model"
+MODEL_NAME_CONFIG_KEY = "model_name"
+PROMPT_CONFIG_KEY = "prompt"
+PROMPT_TEMPLATE_CONFIG_KEY = "prompt_template"
+
+STREAM_CONFIG_KEY = "stream"
+N_REPHRASES_CONFIG_KEY = "n"
+USE_CHAT_COMPLETIONS_ENDPOINT_CONFIG_KEY = "use_chat_completions_endpoint"
+
+AZURE_API_KEY_ENV_VAR = "AZURE_API_KEY"
+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"
+
+HUGGINGFACE_MULTIPROCESS_CONFIG_KEY = "multi_process"
+HUGGINGFACE_CACHE_FOLDER_CONFIG_KEY = "cache_folder"
+HUGGINGFACE_SHOW_PROGRESS_CONFIG_KEY = "show_progress"
+HUGGINGFACE_MODEL_KWARGS_CONFIG_KEY = "model_kwargs"
+HUGGINGFACE_ENCODE_KWARGS_CONFIG_KEY = "encode_kwargs"
+HUGGINGFACE_LOCAL_EMBEDDING_CACHING_FOLDER = (
+    get_local_cache_location() / "huggingface_local_embeddings"
+)
 
 REQUESTS_CA_BUNDLE_ENV_VAR = "REQUESTS_CA_BUNDLE"
 REQUESTS_SSL_CONTEXT_PURPOSE_ENV_VAR = "REQUESTS_SSL_CONTEXT_PURPOSE"
+RASA_CA_BUNDLE_ENV_VAR = "RASA_CA_BUNDLE"  # used in verify
+RASA_SSL_CERTIFICATE_ENV_VAR = "RASA_SSL_CERTIFICATE"  # used in cert (client side)
+LITELLM_SSL_VERIFY_ENV_VAR = "SSL_VERIFY"
+LITELLM_SSL_CERTIFICATE_ENV_VAR = "SSL_CERTIFICATE"
+
+OPENAI_PROVIDER = "openai"
+AZURE_OPENAI_PROVIDER = "azure"
+SELF_HOSTED_PROVIDER = "self-hosted"
+HUGGINGFACE_LOCAL_EMBEDDING_PROVIDER = "huggingface_local"
+
+VALID_PROVIDERS_FOR_API_TYPE_CONFIG_KEY = [
+    OPENAI_PROVIDER,
+    AZURE_OPENAI_PROVIDER,
+]
+
+SELF_HOSTED_VLLM_PREFIX = "hosted_vllm"
+SELF_HOSTED_VLLM_API_KEY_ENV_VAR = "HOSTED_VLLM_API_KEY"
 
+AZURE_API_TYPE = "azure"
+OPENAI_API_TYPE = "openai"
 
 RASA_DEFAULT_FLOW_PATTERN_PREFIX = "pattern_"
 CONTEXT = "context"
 
+RASA_PATTERN_INTERNAL_ERROR = "pattern_internal_error"
+RASA_PATTERN_HUMAN_HANDOFF = "pattern_human_handoff"
+
 RASA_INTERNAL_ERROR_PREFIX = "rasa_internal_error_"
 RASA_PATTERN_INTERNAL_ERROR_DEFAULT = RASA_INTERNAL_ERROR_PREFIX + "default"
 RASA_PATTERN_INTERNAL_ERROR_USER_INPUT_TOO_LONG = (
@@ -185,8 +250,3 @@ RASA_PATTERN_CANNOT_HANDLE_INVALID_INTENT = (
 )
 
 ROUTE_TO_CALM_SLOT = "route_session_to_calm"
-EMBEDDINGS_CONFIG_KEY = "embeddings"
-MODEL_CONFIG_KEY = "model"
-MODEL_NAME_CONFIG_KEY = "model_name"
-PROMPT_CONFIG_KEY = "prompt"
-PROMPT_TEMPLATE_CONFIG_KEY = "prompt_template"