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

rasa/model_service.py

@@ -0,0 +1,112 @@
+import logging
+
+from sanic import Sanic
+import structlog
+
+from rasa.cli.scaffold import print_error_and_exit
+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, SERVER_PORT
+from rasa.utils.common import configure_logging_and_warnings
+import rasa.utils.licensing
+from urllib.parse import urlparse
+
+from rasa.utils.log_utils import configure_structlog
+from rasa.utils.sanic_error_handler import register_custom_sanic_error_handler
+
+structlogger = structlog.get_logger()
+
+
+def url_prefix_from_base_url() -> str:
+    """Return the path prefix from the base URL."""
+    # return path without any trailing slashes
+    prefix = urlparse(SERVER_BASE_URL).path.rstrip("/") if SERVER_BASE_URL else ""
+
+    # can't be empty
+    return prefix or config.DEFAULT_SERVER_PATH_PREFIX
+
+
+def validate_model_storage_type() -> None:
+    """Validate the storage type if remote storage is used for models."""
+    if config.SERVER_MODEL_REMOTE_STORAGE:
+        if config.SERVER_MODEL_REMOTE_STORAGE not in RemoteStorageType.list():
+            print_error_and_exit(
+                f"Invalid storage type '{config.SERVER_MODEL_REMOTE_STORAGE}'. "
+                f"Supported storage types: {', '.join(RemoteStorageType.list())}."
+                f"Alternatively, unset the remote storage type to store models locally."
+            )
+        else:
+            structlogger.info(
+                "model_api.storage.remote_storage_enabled",
+                remote_storage=config.SERVER_MODEL_REMOTE_STORAGE,
+            )
+        # try to create a client to validate the configuration
+        get_persistor(config.SERVER_MODEL_REMOTE_STORAGE)
+    else:
+        structlogger.info(
+            "model_api.storage.local_storage_enabled",
+            base_path=config.SERVER_BASE_WORKING_DIRECTORY,
+        )
+
+
+def _register_update_task(app: Sanic) -> None:
+    app.add_task(
+        model_api.continuously_update_process_status,
+        name="continuously_update_process_status",
+    )
+
+
+def main() -> None:
+    """Start the Rasa Model Manager server.
+
+    The API server can receive requests to train models, run bots, and manage
+    the lifecycle of models and bots.
+    """
+    log_level = logging.DEBUG
+    configure_logging_and_warnings(
+        log_level=log_level,
+        logging_config_file=None,
+        warn_only_once=True,
+        filter_repeated_logs=True,
+    )
+    configure_structlog(log_level, include_time=True)
+
+    rasa.utils.licensing.validate_license_from_env()
+
+    try:
+        model_api.prepare_working_directories()
+    except Exception as e:
+        structlogger.error(
+            "model_api.prepare_directories.failed",
+            error=str(e),
+            base_directory=config.SERVER_BASE_WORKING_DIRECTORY,
+        )
+        print_error_and_exit(
+            f"Failed to create working directories. Please make sure the "
+            f"server base directory at '{config.SERVER_BASE_WORKING_DIRECTORY}' "
+            f"is writable by the current user."
+        )
+
+    validate_model_storage_type()
+
+    structlogger.debug("model_api.starting_server", port=SERVER_PORT)
+
+    url_prefix = url_prefix_from_base_url()
+    # configure the sanic application
+    app = Sanic("RasaModelService")
+    app.after_server_start(_register_update_task)
+    app.blueprint(model_api.external_blueprint(), url_prefix=url_prefix)
+    app.blueprint(model_api.internal_blueprint())
+
+    # list all routes
+    list_routes(app)
+
+    register_custom_sanic_error_handler(app)
+
+    app.run(host="0.0.0.0", port=SERVER_PORT, legacy=True, motd=False)
+
+
+if __name__ == "__main__":
+    main()

rasa/model_training.py

@@ -15,6 +15,7 @@ import rasa.shared.utils.common
 import rasa.shared.utils.io
 import rasa.utils.common
 from rasa import telemetry
+from rasa.core.persistor import StorageType
 from rasa.engine.caching import LocalTrainingCache
 from rasa.engine.recipes.recipe import Recipe
 from rasa.engine.runner.dask import DaskGraphRunner
@@ -22,7 +23,6 @@ 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
@@ -156,6 +156,8 @@ async def train(
     model_to_finetune: Optional[Text] = None,
     finetuning_epoch_fraction: float = 1.0,
     remote_storage: Optional[StorageType] = None,
+    file_importer: Optional[TrainingDataImporter] = None,
+    keep_local_model_copy: bool = False,
 ) -> TrainingResult:
     """Trains a Rasa model (Core and NLU).
 
@@ -177,14 +179,20 @@ 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.
+        remote_storage: Optional name of the remote storage to
+            use for storing the model.
+        file_importer: Instance of `TrainingDataImporter` to use for training.
+            If it is not provided, a new instance will be created.
+        keep_local_model_copy: If `True` the model will be stored locally even if
+            remote storage is configured.
 
     Returns:
         An instance of `TrainingResult`.
     """
-    file_importer = TrainingDataImporter.load_from_config(
-        config, domain, training_files, core_additional_arguments
-    )
+    if not file_importer:
+        file_importer = TrainingDataImporter.load_from_config(
+            config, domain, training_files, core_additional_arguments
+        )
 
     stories = file_importer.get_stories()
     flows = file_importer.get_flows()
@@ -258,6 +266,7 @@ async def train(
             finetuning_epoch_fraction=finetuning_epoch_fraction,
             dry_run=dry_run,
             remote_storage=remote_storage,
+            keep_local_model_copy=keep_local_model_copy,
             **(core_additional_arguments or {}),
             **(nlu_additional_arguments or {}),
         )
@@ -272,6 +281,7 @@ async def _train_graph(
     force_full_training: bool = False,
     dry_run: bool = False,
     remote_storage: Optional[StorageType] = None,
+    keep_local_model_copy: bool = False,
     **kwargs: Any,
 ) -> TrainingResult:
     if model_to_finetune:
@@ -312,7 +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
     )
@@ -335,7 +348,7 @@ async def _train_graph(
             )
             return _dry_run_result(fingerprint_status, force_full_training)
 
-        model_name = _determine_model_name(fixed_model_name, training_type)
+        model_name = determine_model_name(fixed_model_name, training_type)
         full_model_path = Path(output_path, model_name)
 
         with telemetry.track_model_training(
@@ -350,26 +363,20 @@ async def _train_graph(
             )
             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
-                )
+                if not keep_local_model_copy:
+                    full_model_path.unlink()
                 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}'."
+                        f"and saved at remote storage provider '{remote_storage}'."
                     ),
                 )
             else:
                 structlogger.info(
                     "model_training.train.finished_training",
                     event_info=(
-                        f"Your Rasa model is trained and saved at "
-                        f"'{full_model_path}'."
+                        f"Your Rasa model is trained and saved at '{full_model_path}'."
                     ),
                 )
 
@@ -389,9 +396,14 @@ def _create_model_storage(
     return model_storage
 
 
-def _determine_model_name(
+def generate_random_model_name() -> str:
+    time_format = "%Y%m%d-%H%M%S"
+    return f"{time.strftime(time_format)}-{randomname.get_name()}"
+
+
+def determine_model_name(
     fixed_model_name: Optional[Text], training_type: TrainingType
-) -> Text:
+) -> str:
     if fixed_model_name:
         if not fixed_model_name.endswith(".tar.gz"):
             return f"{fixed_model_name}.tar.gz"
@@ -401,8 +413,7 @@ def _determine_model_name(
     if training_type in [TrainingType.CORE, TrainingType.NLU]:
         prefix = f"{training_type.model_type}-"
 
-    time_format = "%Y%m%d-%H%M%S"
-    return f"{prefix}{time.strftime(time_format)}-{randomname.get_name()}.tar.gz"
+    return f"{prefix}{generate_random_model_name()}.tar.gz"
 
 
 async def train_core(
@@ -414,6 +425,7 @@ async def train_core(
     additional_arguments: Optional[Dict] = None,
     model_to_finetune: Optional[Text] = None,
     finetuning_epoch_fraction: float = 1.0,
+    keep_local_model_copy: bool = False,
 ) -> Optional[Text]:
     """Trains a Core model.
 
@@ -428,6 +440,8 @@ async def train_core(
             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.
+        keep_local_model_copy: If `True` the model will be stored locally even if
+            remote storage is configured.
 
     Returns:
         Path to the model archive.
@@ -483,6 +497,7 @@ async def train_core(
             model_to_finetune=model_to_finetune,
             fixed_model_name=fixed_model_name,
             finetuning_epoch_fraction=finetuning_epoch_fraction,
+            keep_local_model_copy=keep_local_model_copy,
             **(additional_arguments or {}),
         )
     ).model
@@ -498,6 +513,7 @@ async def train_nlu(
     domain: Optional[Union[Domain, Text]] = None,
     model_to_finetune: Optional[Text] = None,
     finetuning_epoch_fraction: float = 1.0,
+    keep_local_model_copy: bool = False,
 ) -> Optional[Text]:
     """Trains an NLU model.
 
@@ -515,6 +531,8 @@ async def train_nlu(
             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.
+        keep_local_model_copy: If `True` the model will be stored locally even if
+            remote storage is configured.
 
     Returns:
         Path to the model archive.
@@ -556,14 +574,15 @@ async def train_nlu(
             fixed_model_name=fixed_model_name,
             finetuning_epoch_fraction=finetuning_epoch_fraction,
             persist_nlu_training_data=persist_nlu_training_data,
+            keep_local_model_copy=keep_local_model_copy,
             **(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
+    """Push model to remote storage."""
+    from rasa.core.persistor import get_persistor
 
     persistor = get_persistor(remote_storage)
 

rasa/nlu/tokenizers/whitespace_tokenizer.py

@@ -43,8 +43,6 @@ class WhitespaceTokenizer(Tokenizer):
     def __init__(self, config: Dict[Text, Any]) -> None:
         """Initialize the tokenizer."""
         super().__init__(config)
-        self.emoji_pattern = rasa.utils.io.get_emoji_regex()
-
         if "case_sensitive" in self._config:
             rasa.shared.utils.io.raise_warning(
                 "The option 'case_sensitive' was moved from the tokenizers to the "
@@ -64,18 +62,9 @@ class WhitespaceTokenizer(Tokenizer):
         # Path to the dictionaries on the local filesystem.
         return cls(config)
 
-    def remove_emoji(self, text: Text) -> Text:
-        """Remove emoji if the full text, aka token, matches the emoji regex."""
-        match = self.emoji_pattern.fullmatch(text)
-
-        if match is not None:
-            return ""
-
-        return text
-
     def tokenize(self, message: Message, attribute: Text) -> List[Token]:
-        text = message.get(attribute)
-
+        original_text = message.get(attribute)
+        text = rasa.utils.io.remove_emojis(original_text)
         # we need to use regex instead of re, because of
         # https://stackoverflow.com/questions/12746458/python-unicode-regular-expression-matching-failing-with-some-unicode-characters
 
@@ -94,11 +83,11 @@ class WhitespaceTokenizer(Tokenizer):
             text,
         ).split()
 
-        words = [self.remove_emoji(w) for w in words]
         words = [w for w in words if w]
 
         # if we removed everything like smiles `:)`, use the whole text as 1 token
         if not words:
+            text = original_text
             words = [text]
 
         tokens = self._convert_words_to_tokens(words, text)

rasa/server.py

@@ -50,11 +50,11 @@ from rasa.core.channels.channel import (
     UserMessage,
 )
 from rasa.core.constants import DEFAULT_RESPONSE_TIMEOUT
+from rasa.core.persistor import parse_remote_storage
 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 (
     DEFAULT_MODELS_PATH,
@@ -78,6 +78,7 @@ from rasa.shared.utils.schemas.events import EVENTS_SCHEMA
 from rasa.shared.utils.yaml import validate_training_data
 from rasa.utils.common import TempDirectoryPath, get_temp_dir_name
 from rasa.utils.endpoints import EndpointConfig
+from rasa.utils.sanic_error_handler import register_custom_sanic_error_handler
 
 if TYPE_CHECKING:
     from ssl import SSLContext
@@ -528,7 +529,7 @@ def add_root_route(app: Sanic) -> None:
                 <p>Hello from Rasa: {rasa.__version__}</p>
                 <a href="./webhooks/inspector/inspect.html">Go to the inspector</a>
                 <script>
-                    window.location.replace("./webhooks/inspector/inspect.html");
+                    window.location.replace("./webhooks/socketio/inspect.html");
                 </script>
             </body>
         </html>
@@ -687,6 +688,7 @@ def create_app(
     app = Sanic("rasa_server")
     app.config.RESPONSE_TIMEOUT = response_timeout
     configure_cors(app, cors_origins)
+    register_custom_sanic_error_handler(app)
 
     # Reset Sanic warnings filter that allows the triggering of Sanic warnings
     warnings.filterwarnings("ignore", category=DeprecationWarning, module=r"sanic.*")

rasa/shared/constants.py

@@ -111,10 +111,7 @@ 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
-# we need the list to contain unique values
-CONFIG_MANDATORY_KEYS = list(
-    set(CONFIG_MANDATORY_KEYS_CORE + CONFIG_MANDATORY_KEYS_NLU)
-)
+CONFIG_MANDATORY_KEYS = CONFIG_MANDATORY_KEYS_CORE + CONFIG_MANDATORY_KEYS_NLU
 
 # Keys related to Forms (in the Domain)
 REQUIRED_SLOTS_KEY = "required_slots"
@@ -152,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"
@@ -162,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"
@@ -186,12 +190,51 @@ STREAM_CONFIG_KEY = "stream"
 N_REPHRASES_CONFIG_KEY = "n"
 USE_CHAT_COMPLETIONS_ENDPOINT_CONFIG_KEY = "use_chat_completions_endpoint"
 
+ROUTER_CONFIG_KEY = "router"
+ROUTING_STRATEGY_CONFIG_KEY = "routing_strategy"
+REDIS_HOST_CONFIG_KEY = "redis_host"
+ROUTING_STRATEGIES_REQUIRING_REDIS_CACHE = [
+    "cost-based-routing",
+    "usage-based-routing",
+]
+ROUTING_STRATEGIES_NOT_REQUIRING_CACHE = [
+    "latency-based-routing",
+    "least-busy",
+    "simple-shuffle",
+]
+VALID_ROUTING_STRATEGIES = (
+    ROUTING_STRATEGIES_REQUIRING_REDIS_CACHE + ROUTING_STRATEGIES_NOT_REQUIRING_CACHE
+)
+
+MODELS_CONFIG_KEY = "models"
+MODEL_GROUPS_CONFIG_KEY = "model_groups"
+MODEL_GROUP_CONFIG_KEY = "model_group"
+MODEL_GROUP_ID_CONFIG_KEY = "id"
+
+EXTRA_PARAMETERS_KEY = "extra_parameters"
+MODEL_GROUP_ID_KEY = "model_group_id"
+MODEL_LIST_KEY = "model_list"
+LITELLM_PARAMS_KEY = "litellm_params"
+
+LLM_API_HEALTH_CHECK_ENV_VAR = "LLM_API_HEALTH_CHECK"
+LLM_API_HEALTH_CHECK_DEFAULT_VALUE = "false"
+
 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"
 
+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"
 HUGGINGFACE_SHOW_PROGRESS_CONFIG_KEY = "show_progress"
@@ -212,11 +255,13 @@ OPENAI_PROVIDER = "openai"
 AZURE_OPENAI_PROVIDER = "azure"
 SELF_HOSTED_PROVIDER = "self-hosted"
 HUGGINGFACE_LOCAL_EMBEDDING_PROVIDER = "huggingface_local"
+RASA_PROVIDER = "rasa"
 
-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"
+
+SELF_HOSTED_VLLM_PREFIX = "hosted_vllm"
+SELF_HOSTED_VLLM_API_KEY_ENV_VAR = "HOSTED_VLLM_API_KEY"
 
 SELF_HOSTED_VLLM_PREFIX = "hosted_vllm"
 SELF_HOSTED_VLLM_API_KEY_ENV_VAR = "HOSTED_VLLM_API_KEY"
@@ -250,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/constants.py

@@ -10,6 +10,8 @@ USER_INTENT_RESTART = "restart"
 USER_INTENT_BACK = "back"
 USER_INTENT_OUT_OF_SCOPE = "out_of_scope"
 USER_INTENT_SESSION_START = "session_start"
+USER_INTENT_SESSION_END = "session_end"
+USER_INTENT_SILENCE_TIMEOUT = "silence_timeout"
 SESSION_START_METADATA_SLOT = "session_started_metadata"
 
 DEFAULT_INTENTS = [
@@ -17,6 +19,8 @@ DEFAULT_INTENTS = [
     USER_INTENT_BACK,
     USER_INTENT_OUT_OF_SCOPE,
     USER_INTENT_SESSION_START,
+    USER_INTENT_SESSION_END,
+    USER_INTENT_SILENCE_TIMEOUT,
     constants.DEFAULT_NLU_FALLBACK_INTENT_NAME,
 ]
 
@@ -45,6 +49,8 @@ ACTION_CLEAN_STACK = "action_clean_stack"
 ACTION_TRIGGER_SEARCH = "action_trigger_search"
 ACTION_TRIGGER_CHITCHAT = "action_trigger_chitchat"
 ACTION_RESET_ROUTING = "action_reset_routing"
+ACTION_HANGUP = "action_hangup"
+ACTION_REPEAT_BOT_MESSAGES = "action_repeat_bot_messages"
 
 
 DEFAULT_ACTION_NAMES = [
@@ -70,6 +76,8 @@ DEFAULT_ACTION_NAMES = [
     ACTION_TRIGGER_SEARCH,
     ACTION_TRIGGER_CHITCHAT,
     ACTION_RESET_ROUTING,
+    ACTION_HANGUP,
+    ACTION_REPEAT_BOT_MESSAGES,
 ]
 
 ACTION_SHOULD_SEND_DOMAIN = "send_domain"
@@ -100,6 +108,11 @@ FLOW_HASHES_SLOT = "flow_hashes"
 
 FLOW_SLOT_NAMES = [FLOW_HASHES_SLOT]
 
+# slots for audio timeout
+SLOT_SILENCE_TIMEOUT = "silence_timeout"
+SLOT_CONSECUTIVE_SILENCE_TIMEOUTS = "consecutive_silence_timeouts"
+SILENCE_TIMEOUT_DEFAULT_VALUE = 6.0
+SILENCE_SLOTS = [SLOT_SILENCE_TIMEOUT, SLOT_CONSECUTIVE_SILENCE_TIMEOUTS]
 # slots for knowledge base
 SLOT_LISTED_ITEMS = "knowledge_base_listed_objects"
 SLOT_LAST_OBJECT = "knowledge_base_last_object"