rasa-pro 3.12.0.dev12__py3-none-any.whl → 3.12.0rc1__py3-none-any.whl

rasa/e2e_test/utils/io.py

@@ -49,7 +49,6 @@ if TYPE_CHECKING:
     from rasa.e2e_test.e2e_test_result import TestResult
 
 
-RASA_PRO_BETA_E2E_ASSERTIONS_ENV_VAR_NAME = "RASA_PRO_BETA_E2E_ASSERTIONS"
 RASA_PRO_BETA_STUB_CUSTOM_ACTION_ENV_VAR_NAME = "RASA_PRO_BETA_STUB_CUSTOM_ACTION"
 
 structlogger = structlog.get_logger()
@@ -278,16 +277,6 @@ def split_into_passed_failed(
     return passed_cases, failed_cases
 
 
-def has_test_case_with_assertions(test_cases: List[TestCase]) -> bool:
-    """Check if the test cases contain assertions."""
-    try:
-        next(test_case for test_case in test_cases if test_case.uses_assertions())
-    except StopIteration:
-        return False
-
-    return True
-
-
 @lru_cache(maxsize=1)
 def extract_test_case_from_path(path: str) -> Tuple[str, str]:
     """Extract test case from path if specified.
@@ -442,7 +431,6 @@ def read_test_cases(path: str) -> TestSuite:
     fixtures: Dict[str, Fixture] = {}
     metadata: Dict[str, Metadata] = {}
     stub_custom_actions: Dict[str, StubCustomAction] = {}
-    beta_flag_verified = False
 
     # Process each test file
     for test_file in test_files:
@@ -460,10 +448,6 @@ def read_test_cases(path: str) -> TestSuite:
         stub_custom_actions.update(
             extract_stub_custom_actions(test_file_content, test_file)
         )
-
-        beta_flag_verified = verify_beta_feature_flag_for_assertions(
-            test_cases, beta_flag_verified
-        )
         input_test_cases.extend(test_cases)
 
     validate_test_case(test_case_name, input_test_cases, fixtures, metadata)
@@ -489,27 +473,6 @@ def check_beta_feature_flag_for_custom_actions_stubs() -> None:
         rasa.shared.utils.cli.print_error_and_exit(str(exc))
 
 
-def verify_beta_feature_flag_for_assertions(
-    test_cases: List[TestCase], beta_flag_verified: bool
-) -> bool:
-    """Verify the beta feature flag for assertions."""
-    if beta_flag_verified:
-        return True
-
-    if not has_test_case_with_assertions(test_cases):
-        return beta_flag_verified
-
-    try:
-        ensure_beta_feature_is_enabled(
-            "end-to-end testing with assertions",
-            RASA_PRO_BETA_E2E_ASSERTIONS_ENV_VAR_NAME,
-        )
-    except BetaNotEnabledException as exc:
-        rasa.shared.utils.cli.print_error_and_exit(str(exc))
-
-    return True
-
-
 def _save_coverage_report(
     report: Optional[pd.DataFrame], test_status: str, output_dir: str
 ) -> None:

rasa/engine/graph.py

@@ -640,3 +640,4 @@ class GraphModelConfiguration:
     language: Optional[Text]
     core_target: Optional[Text]
     nlu_target: Optional[Text]
+    additional_languages: Optional[List[Text]]

rasa/engine/language.py

@@ -0,0 +1,140 @@
+from dataclasses import dataclass
+from typing import Any, Dict, Text
+
+from langcodes import Language as LangcodesLanguage
+
+from rasa.shared.exceptions import RasaException
+
+CUSTOM_LANGUAGE_CODE_PREFIX = "x-"
+
+
+@dataclass(frozen=True)
+class Language:
+    code: str
+    label: str
+    is_default: bool
+
+    @classmethod
+    def from_language_code(
+        cls, language_code: str, is_default: bool = False
+    ) -> "Language":
+        """Creates a Language object from a language code.
+
+        Args:
+            language_code: The language code.
+            is_default: Whether the language is the default language.
+
+        Returns:
+            A Language object.
+
+        Raises:
+            RasaException: If the language code or custom language code is invalid.
+        """
+        language = LangcodesLanguage.make(language_code)
+        cls.validate_language(language)
+
+        return cls(
+            code=language_code,
+            label=cls.get_language_label(language),
+            is_default=is_default,
+        )
+
+    @staticmethod
+    def get_language_label(language: LangcodesLanguage) -> str:
+        """Gets the display name of a language.
+
+        For custom languages (in the format "x-<base_lang>-<custom_label>"),
+        the label is derived from the base language code.
+        This method considers that the language code has previously been validated.
+
+        Args:
+            language: The language code.
+
+        Returns:
+            The display name of the language.
+        """
+        language_code = str(language)
+
+        if language_code.startswith(CUSTOM_LANGUAGE_CODE_PREFIX):
+            # If it's a custom language, derive the label from the base language code.
+            parts = language_code.split("-")
+            base_language_code = parts[1]
+            base_language = LangcodesLanguage.make(base_language_code)
+            return base_language.display_name()
+        else:
+            return language.display_name()
+
+    @classmethod
+    def validate_language(cls, language: LangcodesLanguage) -> None:
+        """Validates a language code.
+
+        Args:
+            language: The language object to validate.
+
+        Raises:
+            RasaException: If the language validation fails.
+        """
+        if not language.is_valid():
+            raise RasaException(f"Language '{language}' is not a valid language code.")
+
+        language_code = str(language)
+        if language_code.startswith(CUSTOM_LANGUAGE_CODE_PREFIX):
+            cls.validate_custom_language(language_code)
+
+    @staticmethod
+    def validate_custom_language(custom_language_code: str) -> None:
+        """Validates a custom language code.
+
+        A valid custom language code should adhere to the format:
+          "x-<existing_language_code>-<custom_label>"
+        Example: x-en-formal
+
+        Args:
+            custom_language_code: The custom language code to validate.
+
+        Raises:
+            RasaException: If the custom language code validation fails.
+        """
+        # Ensure the custom language code starts with the custom prefix.
+        if not custom_language_code.startswith(CUSTOM_LANGUAGE_CODE_PREFIX):
+            raise RasaException(
+                f"Custom language '{custom_language_code}' must "
+                f"start with '{CUSTOM_LANGUAGE_CODE_PREFIX}'."
+            )
+
+        # Split the language code into parts.
+        parts = custom_language_code.split("-")
+        if len(parts) != 3:
+            raise RasaException(
+                f"Custom language '{custom_language_code}' must be in the format "
+                f"'{CUSTOM_LANGUAGE_CODE_PREFIX}<language_code>-<custom_label>'."
+            )
+
+        # Validate the base language code using langcodes.
+        base_language_code = parts[1]
+        base_language = LangcodesLanguage.make(base_language_code)
+        if not base_language.is_valid():
+            raise RasaException(
+                f"Base language '{base_language_code}' in custom language "
+                f"'{custom_language_code}' is not a valid language code."
+            )
+
+        # Ensure the custom label is not empty.
+        custom_label = parts[2]
+        if not custom_label:
+            raise RasaException(
+                f"Custom label in custom language "
+                f"'{custom_language_code}' cannot be empty."
+            )
+
+    def as_dict(self) -> Dict[Text, Any]:
+        """Converts the Language dataclass instance into a dictionary.
+
+        Returns:
+            A dictionary representing the Language object.
+        """
+        return {
+            "code": self.code,
+            "label": self.label,
+            "is_default": self.is_default,
+        }

rasa/engine/recipes/config_files/default_config.yml

@@ -9,6 +9,10 @@ assistant_id: placeholder_default
 # Configuration for the Rasa NLU components.
 # https://rasa.com/docs/rasa-pro/nlu-based-assistants/components
 language: en
+additional_languages:
+  - it
+  - de
+  - es
 
 pipeline:
   - name: WhitespaceTokenizer

rasa/engine/recipes/default_recipe.py

@@ -49,6 +49,7 @@ from rasa.graph_components.providers.training_tracker_provider import (
 )
 from rasa.shared.constants import (
     ASSISTANT_ID_KEY,
+    CONFIG_ADDITIONAL_LANGUAGES_KEY,
     CONFIG_LANGUAGE_KEY,
     CONFIG_NAME_KEY,
     CONFIG_PIPELINE_KEY,
@@ -247,6 +248,7 @@ class DefaultV1Recipe(Recipe):
             language=config.get(CONFIG_LANGUAGE_KEY),
             core_target=core_target,
             nlu_target=f"{GRAPH_NODE_RUN_PREFIX}{RegexMessageHandler.__name__}",
+            additional_languages=config.get(CONFIG_ADDITIONAL_LANGUAGES_KEY),
         )
 
     def _create_train_nodes(

rasa/engine/recipes/graph_recipe.py

@@ -5,6 +5,7 @@ from rasa.engine.graph import GraphModelConfiguration, GraphSchema
 from rasa.engine.recipes.recipe import Recipe
 from rasa.shared.constants import (
     ASSISTANT_ID_KEY,
+    CONFIG_ADDITIONAL_LANGUAGES_KEY,
     CONFIG_LANGUAGE_KEY,
     DOCS_URL_GRAPH_RECIPE,
 )
@@ -76,4 +77,5 @@ class GraphV1Recipe(Recipe):
             language=config.get(CONFIG_LANGUAGE_KEY),
             core_target=core_target,
             nlu_target=nlu_target,
+            additional_languages=config.get(CONFIG_ADDITIONAL_LANGUAGES_KEY),
         )

rasa/engine/storage/local_model_storage.py

@@ -240,6 +240,7 @@ class LocalModelStorage(ModelStorage):
             training_type=model_configuration.training_type,
             project_fingerprint=rasa.model.project_fingerprint(),
             language=model_configuration.language,
+            additional_languages=model_configuration.additional_languages,
             core_target=model_configuration.core_target,
             nlu_target=model_configuration.nlu_target,
         )

rasa/engine/storage/storage.py

@@ -7,7 +7,7 @@ from contextlib import contextmanager
 from dataclasses import dataclass
 from datetime import datetime
 from pathlib import Path
-from typing import Any, Dict, Generator, Optional, Text, Tuple, Union
+from typing import Any, Dict, Generator, List, Optional, Text, Tuple, Union
 
 from packaging import version
 
@@ -142,6 +142,7 @@ class ModelMetadata:
     core_target: Optional[Text]
     nlu_target: Text
     language: Optional[Text]
+    additional_languages: Optional[List[Text]]
     training_type: TrainingType = TrainingType.BOTH
 
     def __post_init__(self) -> None:
@@ -171,6 +172,7 @@ class ModelMetadata:
             "core_target": self.core_target,
             "nlu_target": self.nlu_target,
             "language": self.language,
+            "additional_languages": self.additional_languages,
         }
 
     @classmethod
@@ -198,4 +200,5 @@ class ModelMetadata:
             core_target=serialized["core_target"],
             nlu_target=serialized["nlu_target"],
             language=serialized["language"],
+            additional_languages=serialized.get("additional_languages"),
         )

rasa/model_manager/runner_service.py

@@ -258,10 +258,13 @@ def run_bot(
 
 async def update_bot_status(bot: BotSession) -> None:
     """Update the status of a bot based on the process return code."""
-    if bot.has_died_recently():
-        set_bot_status_to_stopped(bot)
-    elif await bot.completed_startup_recently():
-        set_bot_status_to_running(bot)
+    try:
+        if bot.has_died_recently():
+            set_bot_status_to_stopped(bot)
+        elif await bot.completed_startup_recently():
+            set_bot_status_to_running(bot)
+    except Exception as e:
+        structlogger.error("model_runner.update_bot_status.error", error=str(e))
 
 
 def terminate_bot(bot: BotSession) -> None:

rasa/model_manager/socket_bridge.py

@@ -4,6 +4,7 @@ from typing import Any, Dict, Optional
 import structlog
 from socketio import AsyncServer
 from socketio.asyncio_client import AsyncClient
+from socketio.exceptions import ConnectionRefusedError
 
 from rasa.model_manager.runner_service import BotSession
 from rasa.model_manager.studio_jwt_auth import (
@@ -29,7 +30,7 @@ async def socketio_websocket_traffic_wrapper(
 
     if auth_token is None:
         structlogger.error("model_runner.user_no_token", sid=sid)
-        return False
+        raise ConnectionRefusedError("model_runner.user_no_token")
 
     try:
         authenticate_user_to_service(auth_token)
@@ -38,22 +39,22 @@ async def socketio_websocket_traffic_wrapper(
         structlogger.error(
             "model_runner.user_authentication_failed", sid=sid, error=str(error)
         )
-        return False
+        raise ConnectionRefusedError("model_runner.user_authentication_failed")
 
     deployment_id = auth.get("deployment_id") if auth else None
 
     if deployment_id is None:
         structlogger.error("model_runner.bot_no_deployment_id", sid=sid)
-        return False
+        raise ConnectionRefusedError("model_runner.bot_no_deployment_id")
 
     bot = running_bots.get(deployment_id)
     if bot is None:
         structlogger.error("model_runner.bot_not_found", deployment_id=deployment_id)
-        return False
+        raise ConnectionRefusedError("model_runner.bot_not_found")
 
     if not bot.is_alive():
         structlogger.error("model_runner.bot_not_alive", deployment_id=deployment_id)
-        return False
+        raise ConnectionRefusedError("model_runner.bot_not_alive")
 
     client = await create_bridge_client(sio, bot.internal_url, sid, deployment_id)
 
@@ -67,7 +68,7 @@ async def socketio_websocket_traffic_wrapper(
         structlogger.error(
             "model_runner.bot_connection_failed", deployment_id=deployment_id
         )
-        return False
+        raise ConnectionRefusedError("model_runner.bot_connection_failed")
 
 
 def create_bridge_server(sio: AsyncServer, running_bots: Dict[str, BotSession]) -> None:

rasa/model_manager/warm_rasa_process.py

@@ -46,7 +46,6 @@ def _create_warm_rasa_process() -> WarmRasaProcess:
     ]
 
     envs = os.environ.copy()
-    envs["RASA_TELEMETRY_ENABLED"] = "false"
     envs[RASA_RECORD_COMMANDS_AND_PROMPTS_ENV_VAR_NAME] = "true"
 
     log_id = uuid.uuid4().hex

rasa/model_training.py

@@ -352,34 +352,31 @@ async def _train_graph(
         model_name = determine_model_name(fixed_model_name, training_type)
         full_model_path = Path(output_path, model_name)
 
-        with telemetry.track_model_training(
-            file_importer, model_type=training_type.model_type
-        ):
-            await trainer.train(
-                model_configuration,
-                file_importer,
-                full_model_path,
-                force_retraining=force_full_training,
-                is_finetuning=is_finetuning,
+        await trainer.train(
+            model_configuration,
+            file_importer,
+            full_model_path,
+            force_retraining=force_full_training,
+            is_finetuning=is_finetuning,
+        )
+        if remote_storage:
+            push_model_to_remote_storage(full_model_path, 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 '{remote_storage}'."
+                ),
+            )
+        else:
+            structlogger.info(
+                "model_training.train.finished_training",
+                event_info=(
+                    f"Your Rasa model is trained and saved at '{full_model_path}'."
+                ),
             )
-            if remote_storage:
-                push_model_to_remote_storage(full_model_path, 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 '{remote_storage}'."
-                    ),
-                )
-            else:
-                structlogger.info(
-                    "model_training.train.finished_training",
-                    event_info=(
-                        f"Your Rasa model is trained and saved at '{full_model_path}'."
-                    ),
-                )
 
         return TrainingResult(str(full_model_path), 0)
 

rasa/shared/constants.py

@@ -83,6 +83,7 @@ ENV_LOG_LEVEL_LLM = "LOG_LEVEL_LLM"
 ENV_LOG_LEVEL_LLM_MODULE_NAMES = {
     "LLMCommandGenerator": "LOG_LEVEL_LLM_COMMAND_GENERATOR",
     "SingleStepLLMCommandGenerator": "LOG_LEVEL_LLM_COMMAND_GENERATOR",
+    "CompactLLMCommandGenerator": "LOG_LEVEL_LLM_COMMAND_GENERATOR",
     "MultiStepLLMCommandGenerator": "LOG_LEVEL_LLM_COMMAND_GENERATOR",
     "EnterpriseSearchPolicy": "LOG_LEVEL_LLM_ENTERPRISE_SEARCH",
     "IntentlessPolicy": "LOG_LEVEL_LLM_INTENTLESS_POLICY",
@@ -106,6 +107,7 @@ CONFIG_NAME_KEY = "name"
 CONFIG_POLICIES_KEY = "policies"
 CONFIG_PIPELINE_KEY = "pipeline"
 CONFIG_LANGUAGE_KEY = "language"
+CONFIG_ADDITIONAL_LANGUAGES_KEY = "additional_languages"
 CONFIG_RECIPE_KEY = "recipe"
 CONFIG_LLM_KEY = "llm"
 CONFIG_MODEL_NAME_KEY = "model_name"
@@ -150,6 +152,8 @@ DEFAULT_MARKERS_CONFIG_PATH = "markers/config"
 DEFAULT_MARKERS_OUTPUT_PATH = "markers/output"
 DEFAULT_MARKERS_STATS_PATH = "markers/stats"
 
+DEFAULT_PROMPT_PACKAGE_NAME = "rasa.dialogue_understanding.generator.prompt_templates"
+
 DIAGNOSTIC_DATA = "diagnostic_data"
 
 RESPONSE_CONDITION = "condition"
@@ -162,6 +166,7 @@ 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_AD_SCOPES_ENV_VAR = "AZURE_AD_SCOPES"
 AZURE_SPEECH_API_KEY_ENV_VAR = "AZURE_SPEECH_API_KEY"
 
 DEEPGRAM_API_KEY_ENV_VAR = "DEEPGRAM_API_KEY"
@@ -198,7 +203,6 @@ 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"
@@ -232,12 +236,6 @@ 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"
@@ -273,17 +271,11 @@ RASA_PROVIDER = "rasa"
 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"
-
 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"
 
@@ -329,3 +321,13 @@ BUTTONS = "buttons"
 ATTACHMENT = "attachment"
 IMAGE = "image"
 CUSTOM = "custom"
+TITLE = "title"
+PAYLOAD = "payload"
+
+# Used for LLM command generation
+ROLE_USER = "user"
+ROLE_SYSTEM = "system"
+
+# Used for key values in ValidateSlotPatternFlowStackFrame
+REFILL_UTTER = "refill_utter"
+REJECTIONS = "rejections"

rasa/shared/core/constants.py

@@ -13,6 +13,7 @@ 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"
+LANGUAGE_SLOT = "language"
 
 DEFAULT_INTENTS = [
     USER_INTENT_RESTART,
@@ -51,6 +52,8 @@ ACTION_TRIGGER_CHITCHAT = "action_trigger_chitchat"
 ACTION_RESET_ROUTING = "action_reset_routing"
 ACTION_HANGUP = "action_hangup"
 ACTION_REPEAT_BOT_MESSAGES = "action_repeat_bot_messages"
+ACTION_BLOCK_DIGRESSION = "action_block_digression"
+ACTION_CONTINUE_DIGRESSION = "action_continue_digression"
 
 ACTION_METADATA_EXECUTION_SUCCESS = "execution_success"
 ACTION_METADATA_EXECUTION_ERROR_MESSAGE = "execution_error_message"
@@ -81,6 +84,8 @@ DEFAULT_ACTION_NAMES = [
     ACTION_RESET_ROUTING,
     ACTION_HANGUP,
     ACTION_REPEAT_BOT_MESSAGES,
+    ACTION_BLOCK_DIGRESSION,
+    ACTION_CONTINUE_DIGRESSION,
 ]
 
 ACTION_SHOULD_SEND_DOMAIN = "send_domain"
@@ -137,7 +142,11 @@ DEFAULT_SLOT_NAMES = {
 
 SLOT_MAPPINGS = "mappings"
 MAPPING_CONDITIONS = "conditions"
-MAPPING_TYPE = "type"
+KEY_MAPPING_TYPE = "type"
+KEY_ALLOW_NLU_CORRECTION = "allow_nlu_correction"
+KEY_ACTION = "action"
+KEY_RUN_ACTION_EVERY_TURN = "run_action_every_turn"
+KEY_COEXISTENCE_SYSTEM = "coexistence_system"
 
 
 class SlotMappingType(Enum):
@@ -148,7 +157,7 @@ class SlotMappingType(Enum):
     FROM_TRIGGER_INTENT = "from_trigger_intent"
     FROM_TEXT = "from_text"
     FROM_LLM = "from_llm"
-    CUSTOM = "custom"
+    CONTROLLED = "controlled"
 
     def __str__(self) -> str:
         """Returns the string representation that should be used in config files."""
@@ -156,7 +165,21 @@ class SlotMappingType(Enum):
 
     def is_predefined_type(self) -> bool:
         """Returns True if the mapping type is NLU-predefined."""
-        return not (self == SlotMappingType.CUSTOM or self == SlotMappingType.FROM_LLM)
+        return not (
+            self == SlotMappingType.CONTROLLED or self == SlotMappingType.FROM_LLM
+        )
+
+
+class SetSlotExtractor(Enum):
+    """The extractors that can set a slot."""
+
+    LLM = "LLM"
+    COMMAND_PAYLOAD_READER = "CommandPayloadReader"
+    NLU = "NLU"
+    CUSTOM = "CUSTOM"
+
+    def __str__(self) -> str:
+        return self.value
 
 
 # the keys for `State` (USER, PREVIOUS_ACTION, SLOTS, ACTIVE_LOOP)
@@ -181,3 +204,7 @@ POLICY_NAME_RULE = "RulePolicy"
 CLASSIFIER_NAME_FALLBACK = "FallbackClassifier"
 
 POLICIES_THAT_EXTRACT_ENTITIES = {"TEDPolicy"}
+
+# digression constants
+KEY_ASK_CONFIRM_DIGRESSIONS = "ask_confirm_digressions"
+KEY_BLOCK_DIGRESSIONS = "block_digressions"