rasa-pro 3.11.4__py3-none-any.whl → 3.12.0__py3-none-any.whl

rasa/validator.py

@@ -3,70 +3,84 @@ import re
 import string
 import sys
 from collections import defaultdict
-from typing import Set, Text, Optional, Dict, Any, List, Tuple
+from typing import Any, Dict, List, Optional, Set, Text, Tuple
 
 import structlog
 from jinja2 import Template
 from pypred import Predicate
-from pypred.ast import Literal, CompareOperator, NegateOperator
+from pypred.ast import CompareOperator, Literal, NegateOperator
 
 import rasa.core.training.story_conflict
+import rasa.shared.nlu.constants
+import rasa.shared.utils.cli
+import rasa.shared.utils.io
 from rasa.core.channels import UserMessage
 from rasa.dialogue_understanding.stack.frames import PatternFlowStackFrame
-from rasa.shared.core.command_payload_reader import (
-    CommandPayloadReader,
-    MAX_NUMBER_OF_SLOTS,
-)
-from rasa.shared.core.flows.flow_step_links import IfFlowStepLink
-from rasa.shared.core.flows.steps.set_slots import SetSlotsFlowStep
-from rasa.shared.core.flows.steps.collect import CollectInformationFlowStep
-from rasa.shared.core.flows.steps.action import ActionFlowStep
-from rasa.shared.core.flows.steps.link import LinkFlowStep
-from rasa.shared.core.flows import FlowsList
-from rasa.shared.core.flows.utils import (
-    warn_deprecated_collect_step_config,
-    get_duplicate_slot_persistence_config_error_message,
-    get_invalid_slot_persistence_config_error_message,
-)
-import rasa.shared.nlu.constants
+from rasa.engine.language import Language
 from rasa.shared.constants import (
     ASSISTANT_ID_DEFAULT_VALUE,
     ASSISTANT_ID_KEY,
+    CONFIG_ADDITIONAL_LANGUAGES_KEY,
+    CONFIG_LANGUAGE_KEY,
     CONFIG_MANDATORY_KEYS,
+    CONFIG_PIPELINE_KEY,
+    DOCS_URL_ACTIONS,
     DOCS_URL_DOMAIN,
     DOCS_URL_DOMAINS,
     DOCS_URL_FORMS,
     DOCS_URL_RESPONSES,
-    UTTER_PREFIX,
-    DOCS_URL_ACTIONS,
     REQUIRED_SLOTS_KEY,
+    RESPONSE_CONDITION,
+    UTTER_PREFIX,
 )
 from rasa.shared.core import constants
-from rasa.shared.core.constants import MAPPING_CONDITIONS, ACTIVE_LOOP
-from rasa.shared.core.events import ActionExecuted, ActiveLoop
-from rasa.shared.core.events import UserUttered
+from rasa.shared.core.command_payload_reader import (
+    MAX_NUMBER_OF_SLOTS,
+    CommandPayloadReader,
+)
+from rasa.shared.core.constants import (
+    KEY_ALLOW_NLU_CORRECTION,
+    SLOTS,
+    SlotMappingType,
+)
 from rasa.shared.core.domain import (
-    Domain,
     RESPONSE_KEYS_TO_INTERPOLATE,
+    Domain,
+)
+from rasa.shared.core.events import ActionExecuted, ActiveLoop, UserUttered
+from rasa.shared.core.flows import Flow, FlowsList
+from rasa.shared.core.flows.constants import KEY_NAME, KEY_TRANSLATION
+from rasa.shared.core.flows.flow_step_links import IfFlowStepLink
+from rasa.shared.core.flows.steps.action import ActionFlowStep
+from rasa.shared.core.flows.steps.collect import CollectInformationFlowStep
+from rasa.shared.core.flows.steps.link import LinkFlowStep
+from rasa.shared.core.flows.steps.set_slots import SetSlotsFlowStep
+from rasa.shared.core.flows.utils import (
+    ALL_LABEL,
+    get_duplicate_slot_persistence_config_error_message,
+    get_invalid_slot_persistence_config_error_message,
+    warn_deprecated_collect_step_config,
 )
 from rasa.shared.core.generator import TrainingDataGenerator
-from rasa.shared.core.constants import SlotMappingType, MAPPING_TYPE
+from rasa.shared.core.slot_mappings import CoexistenceSystemType
 from rasa.shared.core.slots import BooleanSlot, CategoricalSlot, ListSlot, Slot
 from rasa.shared.core.training_data.story_reader.yaml_story_reader import (
     YAMLStoryReader,
 )
 from rasa.shared.core.training_data.structures import StoryGraph
 from rasa.shared.data import create_regex_pattern_reader
+from rasa.shared.exceptions import RasaException
 from rasa.shared.importers.importer import TrainingDataImporter
 from rasa.shared.nlu.constants import COMMANDS
 from rasa.shared.nlu.training_data.message import Message
 from rasa.shared.nlu.training_data.training_data import TrainingData
-
-import rasa.shared.utils.cli
-import rasa.shared.utils.io
+from rasa.telemetry import track_validation_error_log
 
 logger = logging.getLogger(__name__)
-structlogger = structlog.get_logger()
+
+structlog_processors = structlog.get_config()["processors"]
+updated_processors = [track_validation_error_log] + structlog_processors
+structlogger = structlog.get_logger(processors=updated_processors)
 
 
 class Validator:
@@ -511,9 +525,9 @@ class Validator:
 
         for slot in self.domain.slots:
             for mapping in slot.mappings:
-                for condition in mapping.get(MAPPING_CONDITIONS, []):
-                    condition_active_loop = condition.get(ACTIVE_LOOP)
-                    mapping_type = SlotMappingType(mapping.get(MAPPING_TYPE))
+                for condition in mapping.conditions:
+                    condition_active_loop = condition.active_loop
+                    mapping_type = mapping.type
                     if (
                         condition_active_loop
                         and condition_active_loop not in self.domain.form_names
@@ -901,6 +915,16 @@ class Validator:
                         f"'{object_id}': {exception}"
                     ),
                 )
+            elif object_id.startswith("utter_"):
+                structlogger.error(
+                    "validator.validate_conditional_response_variation_predicates.error",
+                    utter=object_id,
+                    exception=exception,
+                    event_info=(
+                        f"Could not initialize the predicate found under response "
+                        f"variation '{object_id}': {exception}"
+                    ),
+                )
             else:
                 structlogger.error(
                     "validator.verify_predicates.flow_guard_predicate.error",
@@ -932,7 +956,7 @@ class Validator:
     def _extract_slot_name_and_slot_value(
         self,
         predicate_syntax_tree: Any,
-    ) -> tuple:
+    ) -> Tuple[Optional[List[str]], Optional[Any]]:
         """Extract the slot name and slot value from the predicate syntax tree.
 
         Args:
@@ -1037,15 +1061,15 @@ class Validator:
             False, if validation failed, previous value of all_good, otherwise
         """
         predicate_syntax_tree = self._extract_predicate_syntax_tree(predicate)
-        slot_name, slot_value = self._extract_slot_name_and_slot_value(
+        slot_namespace, slot_value = self._extract_slot_name_and_slot_value(
             predicate_syntax_tree
         )
 
-        if slot_name is None:
+        if slot_namespace is None:
             return all_good
 
-        if slot_name[0] == "slots":
-            slot_name = slot_name[1]
+        if slot_namespace[0] == "slots":
+            slot_name = slot_namespace[1]
             # slots.{{context.variable}} gets evaluated to `slots.None`,
             # these predicates can only be validated during runtime
             if slot_name == "None":
@@ -1257,6 +1281,7 @@ class Validator:
             self.verify_unique_flows(),
             self.verify_predicates(),
             self.verify_slot_persistence_configuration(),
+            self.verify_digression_configuration(),
         ]
 
         all_good = all(flow_validation_conditions)
@@ -1265,6 +1290,165 @@ class Validator:
 
         return all_good
 
+    def _get_response_translation_warnings(self) -> list:
+        """Collect warnings for responses missing translations.
+
+        Returns:
+            List of warnings for responses missing translations.
+        """
+        additional_languages = self.config.get(CONFIG_ADDITIONAL_LANGUAGES_KEY) or []
+        response_warnings = []
+
+        for response_name, responses in self.domain.responses.items():
+            provided_languages = set()
+            # For each response variation, we check if the additional
+            # languages are available in at least on variation
+            for response in responses:
+                translation = response.get(KEY_TRANSLATION) or {}
+                for language_code in additional_languages:
+                    if translation.get(language_code):
+                        provided_languages.add(language_code)
+
+            missing_languages = [
+                lang for lang in additional_languages if lang not in provided_languages
+            ]
+            if missing_languages:
+                language_code_str = ", ".join(missing_languages)
+                response_warnings.append(
+                    {
+                        "event": (
+                            "validator.verify_translations.missing_response_translation"
+                        ),
+                        "response": response_name,
+                        "missing_languages": missing_languages,
+                        "event_info": (
+                            f"The response '{response_name}' is "
+                            f"missing a translation for the following "
+                            f"languages: {language_code_str}."
+                        ),
+                    }
+                )
+        return response_warnings
+
+    def _get_flow_translation_warnings(self) -> list:
+        """Collect warnings for flows missing translations.
+
+        Returns:
+            List of warnings for flows missing translations.
+        """
+        additional_languages = self.config.get(CONFIG_ADDITIONAL_LANGUAGES_KEY) or []
+
+        flow_warnings = []
+        for flow in self.flows.underlying_flows:
+            required_field_translation = [KEY_NAME]
+            missing_languages = []
+            for language_code in additional_languages:
+                translation = flow.translation.get(language_code)
+                # If translation for the language code doesn't exist,
+                # or the required fields are not set properly,
+                # we add the language code to the list.
+                if not translation or not all(
+                    getattr(translation, field, None)
+                    for field in required_field_translation
+                ):
+                    missing_languages.append(language_code)
+
+            if missing_languages:
+                language_code_str = ", ".join(missing_languages)
+                flow_warnings.append(
+                    {
+                        "event": (
+                            "validator.verify_translations.missing_flow_translation"
+                        ),
+                        "flow": flow.id,
+                        "missing_languages": missing_languages,
+                        "event_info": (
+                            f"The flow '{flow.id}' is missing the translation for "
+                            f"the following languages: {language_code_str}."
+                        ),
+                    }
+                )
+        return flow_warnings
+
+    def verify_config_language(self) -> bool:
+        """Verify that config languages are properly set up.
+
+        Returns:
+            `True` if all languages are properly set up, `False` otherwise.
+
+        Raises:
+            RasaException: If the default language is listed as an
+            additional language or if the language code is invalid.
+        """
+        language = self.config.get(CONFIG_LANGUAGE_KEY)
+        additional_languages = self.config.get(CONFIG_ADDITIONAL_LANGUAGES_KEY, [])
+
+        # Check if the default language is in the additional languages.
+        if language in additional_languages:
+            raise RasaException(
+                f"The default language '{language}' is listed as an additional "
+                f"language in the configuration file. Please remove it from "
+                f"the list of additional languages."
+            )
+
+        # Verify the language codes by initializing the Language class.
+        for language_code in [language] + additional_languages:
+            Language.from_language_code(language_code=language_code)
+
+        return True
+
+    def verify_translations(self, summary_mode: bool = False) -> bool:
+        """Checks for inconsistencies in translations.
+
+        Args:
+            summary_mode: If True, logs a single aggregated warning per category;
+                otherwise, logs each warning individually.
+
+        Returns:
+            `True` if no inconsistencies were found, `False` otherwise.
+
+        Raises:
+            Warning: Single warning per response or flow missing translations
+            if `summary_mode` is `True`, otherwise one warning per missing translation.
+        """
+        all_good = self.verify_config_language()
+
+        additional_languages = self.config.get(CONFIG_ADDITIONAL_LANGUAGES_KEY, [])
+        if not additional_languages:
+            return all_good
+
+        response_warnings = self._get_response_translation_warnings()
+        flow_warnings = self._get_flow_translation_warnings()
+
+        if summary_mode:
+            if response_warnings:
+                count = len(response_warnings)
+                structlogger.warn(
+                    "validator.verify_translations.missing_response_translation_summary",
+                    count=count,
+                    event_info=(
+                        f"{count} response{' is' if count == 1 else 's are'} "
+                        f"missing translations for some languages. "
+                        "Run 'rasa data validate translations' for details."
+                    ),
+                )
+            if flow_warnings:
+                count = len(flow_warnings)
+                structlogger.warn(
+                    "validator.verify_translations.missing_flow_translation_summary",
+                    count=count,
+                    event_info=(
+                        f"{count} flow{' is' if count == 1 else 's are'} "
+                        f"missing translations for some languages. "
+                        "Run 'rasa data validate translations' for details."
+                    ),
+                )
+        else:
+            for warning in response_warnings + flow_warnings:
+                structlogger.warn(**warning)
+
+        return all_good
+
     def validate_button_payloads(self) -> bool:
         """Check if the response button payloads are valid."""
         all_good = True
@@ -1385,36 +1569,26 @@ class Validator:
 
         for slot in self.domain._user_slots:
             nlu_mappings = any(
-                [
-                    SlotMappingType(
-                        mapping.get("type", SlotMappingType.FROM_LLM.value)
-                    ).is_predefined_type()
-                    for mapping in slot.mappings
-                ]
+                [mapping.type.is_predefined_type() for mapping in slot.mappings]
             )
             llm_mappings = any(
-                [
-                    SlotMappingType(mapping.get("type", SlotMappingType.FROM_LLM.value))
-                    == SlotMappingType.FROM_LLM
-                    for mapping in slot.mappings
-                ]
+                [mapping.type == SlotMappingType.FROM_LLM for mapping in slot.mappings]
             )
-            custom_mappings = any(
+            controlled_mappings = any(
                 [
-                    SlotMappingType(mapping.get("type", SlotMappingType.FROM_LLM.value))
-                    == SlotMappingType.CUSTOM
+                    mapping.type == SlotMappingType.CONTROLLED
                     for mapping in slot.mappings
                 ]
             )
 
-            all_good = self._slot_contains_all_mappings_types(
-                llm_mappings, nlu_mappings, custom_mappings, slot.name, all_good
-            )
+            all_good = self._allow_nlu_correction_is_valid(slot, nlu_mappings, all_good)
 
             all_good = self._custom_action_name_is_defined_in_the_domain(
-                custom_mappings, slot, all_good
+                controlled_mappings, slot, all_good
             )
 
+            all_good = self._validate_controlled_mappings(slot, all_good)
+
             all_good = self._config_contains_nlu_command_adapter(
                 nlu_mappings, slot.name, all_good
             )
@@ -1426,23 +1600,45 @@ class Validator:
         return all_good
 
     @staticmethod
-    def _slot_contains_all_mappings_types(
-        llm_mappings: bool,
-        nlu_mappings: bool,
-        custom_mappings: bool,
-        slot_name: str,
-        all_good: bool,
+    def _allow_nlu_correction_is_valid(
+        slot: Slot, nlu_mappings: bool, all_good: bool
     ) -> bool:
-        if llm_mappings and (nlu_mappings or custom_mappings):
+        """Verify that `allow_nlu_correction` property is used correctly in a `from_llm` mappings only."""  # noqa: E501
+        if not slot.mappings:
+            return all_good
+
+        invalid_usage = False
+
+        for mapping in slot.mappings:
+            allow_nlu_correction = mapping.allow_nlu_correction
+            if allow_nlu_correction and mapping.type != SlotMappingType.FROM_LLM:
+                invalid_usage = True
+
+            if allow_nlu_correction and not nlu_mappings:
+                structlogger.error(
+                    "validator.validate_slot_mappings_in_CALM.nlu_mappings_not_present",
+                    slot_name=slot.name,
+                    event_info=(
+                        f"The slot '{slot.name}' does not have any "
+                        f"NLU-based slot mappings. "
+                        f"The property `allow_nlu_correction` is only "
+                        f"applicable when the slot "
+                        f"contains both NLU-based and LLM-based slot mappings."
+                    ),
+                )
+                all_good = False
+
+        if invalid_usage:
             structlogger.error(
-                "validator.validate_slot_mappings_in_CALM.llm_and_nlu_mappings",
-                slot_name=slot_name,
+                "validator.validate_slot_mappings_in_CALM.allow_nlu_correction",
+                slot_name=slot.name,
                 event_info=(
-                    f"The slot '{slot_name}' has both LLM and "
-                    f"NLU or custom slot mappings. "
-                    f"Please make sure that the slot has only one type of mapping."
+                    f"The slot '{slot.name}' has at least 1 slot mapping with "
+                    f"'{KEY_ALLOW_NLU_CORRECTION}' set to 'true', but "
+                    f"the slot mapping type is not 'from_llm'. "
+                    f"Please set the slot mapping type to 'from_llm' "
+                    f"to allow the LLM to correct this slot."
                 ),
-                docs_link=DOCS_URL_DOMAIN + "#calm-slot-mappings",
             )
             all_good = False
 
@@ -1450,55 +1646,32 @@ class Validator:
 
     def _custom_action_name_is_defined_in_the_domain(
         self,
-        custom_mappings: bool,
+        controlled_mappings: bool,
         slot: Slot,
         all_good: bool,
     ) -> bool:
-        if not custom_mappings:
+        if not controlled_mappings:
             return all_good
 
-        if not self.flows:
-            return all_good
-
-        is_custom_action_defined = any(
-            [
-                mapping.get("action") is not None
-                and mapping.get("action") in self.domain.action_names_or_texts
-                for mapping in slot.mappings
-            ]
-        )
-
-        if is_custom_action_defined:
-            return all_good
-
-        slot_collected_by_flows = any(
-            [
-                step.collect == slot.name
-                for flow in self.flows.underlying_flows
-                for step in flow.steps
-                if isinstance(step, CollectInformationFlowStep)
-            ]
-        )
-
-        if not slot_collected_by_flows:
-            # if the slot is not collected by any flow,
-            # it could be a DM1 custom slot
-            return all_good
-
-        custom_action_ask_name = f"action_ask_{slot.name}"
-        if custom_action_ask_name not in self.domain.action_names_or_texts:
-            structlogger.error(
-                "validator.validate_slot_mappings_in_CALM.custom_action_not_in_domain",
-                slot_name=slot.name,
-                event_info=(
-                    f"The slot '{slot.name}' has a custom slot mapping, but "
-                    f"neither the action '{custom_action_ask_name}' nor "
-                    f"another custom action are defined in the domain file. "
-                    f"Please add one of the actions to your domain file."
-                ),
-                docs_link=DOCS_URL_DOMAIN + "#custom-slot-mappings",
-            )
-            all_good = False
+        for mapping in slot.mappings:
+            if (
+                mapping.run_action_every_turn is not None
+                and mapping.run_action_every_turn
+                not in self.domain.action_names_or_texts
+            ):
+                structlogger.error(
+                    "validator.validate_slot_mappings_in_CALM.custom_action_not_in_domain",
+                    slot_name=slot.name,
+                    action_name=mapping.run_action_every_turn,
+                    event_info=(
+                        f"The slot '{slot.name}' has a custom action "
+                        f"'{mapping.run_action_every_turn}' "
+                        f"defined in its slot mappings, "
+                        f"but the action is not listed in the domain actions. "
+                        f"Please add the action to your domain file."
+                    ),
+                )
+                all_good = False
 
         return all_good
 
@@ -1514,7 +1687,7 @@ class Validator:
         contains_nlu_command_adapter = any(
             [
                 component.get("name") == "NLUCommandAdapter"
-                for component in self.config.get("pipeline", [])
+                for component in self.config.get(CONFIG_PIPELINE_KEY, [])
             ]
         )
 
@@ -1583,7 +1756,7 @@ class Validator:
                     collect_step = step.collect
                     flow_slots.add(collect_step)
                     if not step.reset_after_flow_ends:
-                        warn_deprecated_collect_step_config(flow_id, collect_step)
+                        warn_deprecated_collect_step_config()
 
                         if has_flow_level_persistence:
                             structlogger.error(
@@ -1644,10 +1817,316 @@ class Validator:
                 self.verify_predicates(),
             ]
         )
+        valid_translations = self.verify_translations(summary_mode=True)
         valid_calm_slot_mappings = self.validate_CALM_slot_mappings()
 
         all_good = (
-            valid_responses and valid_nlu and valid_flows and valid_calm_slot_mappings
+            valid_responses
+            and valid_nlu
+            and valid_flows
+            and valid_translations
+            and valid_calm_slot_mappings
         )
 
         return all_good
+
+    def verify_digression_configuration(self) -> bool:
+        """Validates the digression configuration in flows."""
+        all_good = True
+
+        for flow in self.flows.underlying_flows:
+            all_good = self._validate_ask_confirm_digressions(flow, all_good)
+            all_good = self._validate_block_digressions(flow, all_good)
+
+        return all_good
+
+    def _validate_ask_confirm_digressions(self, flow: Flow, all_good: bool) -> bool:
+        """Validates the ask_confirm_digressions configuration in a flow."""
+        for flow_id in flow.ask_confirm_digressions:
+            if flow_id == ALL_LABEL:
+                continue
+            if flow_id not in self.flows.flow_ids:
+                structlogger.error(
+                    "validator.verify_digression_configuration.ask_confirm_digressions",
+                    flow=flow.id,
+                    event_info=(
+                        f"The flow '{flow_id}' is listed in the "
+                        f"`ask_confirm_digressions` configuration of flow "
+                        f"'{flow.id}', but it is not found in the "
+                        f"flows file. Please make sure that the flow id is correct."
+                    ),
+                )
+                all_good = False
+
+            if flow_id in flow.block_digressions:
+                structlogger.error(
+                    "validator.verify_digression_configuration.overlap_digressions",
+                    flow=flow.id,
+                    event_info=(
+                        f"The flow '{flow_id}' is listed in both the "
+                        f"`ask_confirm_digressions` and `block_digressions` "
+                        f"configuration of flow '{flow.id}'. "
+                        f"Please make sure that the flow id is not listed in both "
+                        f"configurations."
+                    ),
+                )
+                all_good = False
+
+        for step in flow.get_collect_steps():
+            for flow_id in step.ask_confirm_digressions:
+                if flow_id == ALL_LABEL:
+                    continue
+
+                if flow_id not in self.flows.flow_ids:
+                    structlogger.error(
+                        "validator.verify_digression_configuration.ask_confirm_digressions",
+                        flow=flow.id,
+                        step_id=step.id,
+                        event_info=(
+                            f"The flow '{flow_id}' is listed in the "
+                            f"`ask_confirm_digressions` configuration of step "
+                            f"'{step.id}' in flow '{flow.id}', but it is "
+                            f"not found in the flows file. "
+                            f"Please make sure that the flow id is correct."
+                        ),
+                    )
+                    all_good = False
+
+                if flow_id in step.block_digressions:
+                    structlogger.error(
+                        "validator.verify_digression_configuration.overlap_digressions",
+                        flow=flow.id,
+                        step_id=step.id,
+                        event_info=(
+                            f"The flow '{flow_id}' is listed in both the "
+                            f"`ask_confirm_digressions` and `block_digressions` "
+                            f"configuration of step '{step.id}' in flow '{flow.id}'. "
+                            f"Please make sure that the flow id is not listed in both "
+                            f"configurations."
+                        ),
+                    )
+                    all_good = False
+
+        return all_good
+
+    def _validate_block_digressions(self, flow: Flow, all_good: bool) -> bool:
+        """Validates the block_digressions configuration in a flow."""
+        for flow_id in flow.block_digressions:
+            if flow_id == ALL_LABEL:
+                continue
+
+            if flow_id not in self.flows.flow_ids:
+                structlogger.error(
+                    "validator.verify_digression_configuration.block_digressions",
+                    flow=flow.id,
+                    event_info=(
+                        f"The flow '{flow_id}' is listed in the `block_digressions` "
+                        f"configuration of flow '{flow.id}', but it is not found "
+                        f"in the flows file. Please make sure that the flow id "
+                        f"is correct."
+                    ),
+                )
+                all_good = False
+
+        for step in flow.get_collect_steps():
+            for flow_id in step.block_digressions:
+                if flow_id == ALL_LABEL:
+                    continue
+
+                if flow_id not in self.flows.flow_ids:
+                    structlogger.error(
+                        "validator.verify_digression_configuration.block_digressions",
+                        flow=flow.id,
+                        step_id=step.id,
+                        event_info=(
+                            f"The flow '{flow_id}' is listed in the "
+                            f"`block_digressions` configuration of step "
+                            f"'{step.id}' in flow '{flow.id}', but it is "
+                            f"not found in the flows file. "
+                            f"Please make sure that the flow id is correct."
+                        ),
+                    )
+                    all_good = False
+
+        return all_good
+
+    def verify_slot_validation(self) -> bool:
+        """Validates the slot validation configuration in the domain file."""
+        all_good = True
+
+        for slot in self.domain._user_slots:
+            if slot.requires_validation():
+                refill_utter = slot.validation.refill_utter  # type: ignore[union-attr]
+                if refill_utter and refill_utter not in self.domain.responses:
+                    self._log_slot_validation_error(
+                        slot.name, "refill utterance", refill_utter
+                    )
+                    all_good = False
+                rejections = slot.validation.rejections  # type: ignore[union-attr]
+                for rejection in rejections:
+                    if rejection.utter not in self.domain.responses:
+                        self._log_slot_validation_error(
+                            slot.name, "rejection utterance", rejection.utter
+                        )
+                        all_good = False
+
+        return all_good
+
+    def _log_slot_validation_error(self, slot_name: str, key: str, value: str) -> None:
+        structlogger.error(
+            "validator.verify_slot_validation.response_not_in_domain",
+            slot=slot_name,
+            event_info=(
+                f"The slot '{slot_name}' requires validation, "
+                f"but the {key} '{value}' "
+                f"is not listed in the domain responses. "
+                f"Please add it to your domain file."
+            ),
+        )
+
+    @staticmethod
+    def _validate_controlled_mappings(slot: Slot, all_good: bool) -> bool:
+        for mapping in slot.mappings:
+            if (
+                mapping.run_action_every_turn is not None
+                and mapping.type != SlotMappingType.CONTROLLED
+            ):
+                structlogger.error(
+                    "validator.validate_slot_mappings_in_CALM.run_action_every_turn_invalid",
+                    slot_name=slot.name,
+                    event_info=(
+                        f"The slot '{slot.name}' has a custom action "
+                        f"'{mapping.run_action_every_turn}' "
+                        f"defined in its slot mapping, "
+                        f"but the slot mapping type is not 'controlled'. "
+                    ),
+                )
+                all_good = False
+
+            if (
+                mapping.coexistence_system is not None
+                and mapping.type != SlotMappingType.CONTROLLED
+            ):
+                structlogger.error(
+                    "validator.validate_slot_mappings_in_CALM.coexistence_system_invalid",
+                    slot_name=slot.name,
+                    event_info=(
+                        f"The slot '{slot.name}' has a coexistence system "
+                        f"'{mapping.coexistence_system.value}' "
+                        f"defined in its slot mapping, "
+                        f"but the slot mapping type is not 'controlled'. "
+                    ),
+                )
+                all_good = False
+
+            if (
+                mapping.coexistence_system is not None
+                and mapping.coexistence_system != CoexistenceSystemType.SHARED
+                and slot.shared_for_coexistence
+            ):
+                structlogger.error(
+                    "validator.validate_slot_mappings_in_CALM.shared_for_coexistence_invalid",
+                    slot_name=slot.name,
+                    event_info=(
+                        f"The slot '{slot.name}' has the `shared_for_coexistence` "
+                        f"property set to `True`, but the slot mapping `controlled` "
+                        f"type defines the `coexistence_system` property with a "
+                        f"value different to the expected `SHARED` value. "
+                    ),
+                )
+                all_good = False
+
+        multiple_controlled_mappings = {
+            mapping.coexistence_system.value
+            for mapping in slot.mappings
+            if mapping.type == SlotMappingType.CONTROLLED
+            and mapping.coexistence_system is not None
+        }
+        contains_inconsistent_coexistence_system = len(multiple_controlled_mappings) > 1
+
+        if contains_inconsistent_coexistence_system:
+            structlogger.error(
+                "validator.validate_slot_mappings_in_CALM.inconsistent_multiple_mappings",
+                slot_name=slot.name,
+                event_info=(
+                    f"The slot '{slot.name}' has multiple `controlled` mappings "
+                    f"with different coexistence systems defined: "
+                    f"'{sorted(list(multiple_controlled_mappings))}'. "
+                    f"Please only define one coexistence system for the slot. "
+                ),
+            )
+            all_good = False
+
+        return all_good
+
+    def validate_conditional_response_variation_predicates(self) -> bool:
+        """Validate the conditional response variation predicates."""
+        context = {SLOTS: {slot.name: None for slot in self.domain.slots}}
+        all_good = True
+
+        for utter_name, variations in self.domain.responses.items():
+            for variation in variations:
+                condition = variation.get(RESPONSE_CONDITION)
+                if not isinstance(condition, str):
+                    continue
+
+                predicate, all_good = self._construct_predicate(
+                    condition,
+                    utter_name,
+                    context,
+                    is_step=False,
+                    all_good=all_good,
+                )
+                if not predicate:
+                    continue
+
+                if not predicate.is_valid():
+                    structlogger.error(
+                        "validator.validate_conditional_response_variation_predicates.invalid_condition",
+                        utter=utter_name,
+                        event_info=(
+                            f"Detected invalid condition '{condition}' "
+                            f"for response variation '{utter_name}'. "
+                            f"Please make sure that all conditions are valid."
+                        ),
+                    )
+                    all_good = False
+                    continue
+
+                predicate_syntax_tree = self._extract_predicate_syntax_tree(predicate)
+                slot_namespace, _ = self._extract_slot_name_and_slot_value(
+                    predicate_syntax_tree
+                )
+
+                if slot_namespace is not None and slot_namespace[0] != SLOTS:
+                    structlogger.error(
+                        "validator.validate_conditional_response_variation_predicates.invalid_namespace",
+                        utter=utter_name,
+                        event_info=(
+                            f"Detected invalid namespace '{slot_namespace[0]}' in "
+                            f"condition '{condition}' for response variation "
+                            f"'{utter_name}'. Please make sure that you're "
+                            f"using a valid namespace. "
+                            f"The current supported option is: 'slots'."
+                        ),
+                    )
+                    all_good = False
+                    continue
+
+                if (
+                    slot_namespace is not None
+                    and slot_namespace[1] not in context[SLOTS]
+                ):
+                    structlogger.error(
+                        "validator.validate_conditional_response_variation_predicates.invalid_slot",
+                        utter=utter_name,
+                        event_info=(
+                            f"Detected invalid slot '{slot_namespace[1]}' in "
+                            f"condition '{condition}' for response variation "
+                            f"'{utter_name}'. Please make sure that all slots "
+                            f"are specified in the domain file."
+                        ),
+                    )
+                    all_good = False
+
+        return all_good