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

rasa/anonymization/anonymization_rule_executor.py

@@ -4,20 +4,14 @@ from dataclasses import dataclass
 from typing import Any, Dict, List, Optional, Text, Union
 
 from faker import Faker
-from presidio_analyzer import AnalyzerEngine
-from presidio_analyzer.nlp_engine import (
-    SpacyNlpEngine,
-    StanzaNlpEngine,
-    TransformersNlpEngine,
-)
-from presidio_anonymizer import AnonymizerEngine
-from presidio_anonymizer.entities import OperatorConfig
 
 from rasa.shared.exceptions import RasaException
 from rasa.utils.singleton import Singleton
 
 if typing.TYPE_CHECKING:
+    from presidio_analyzer import AnalyzerEngine
     from presidio_analyzer.nlp_engine.nlp_engine import NlpEngine
+    from presidio_anonymizer.entities import OperatorConfig
 
 DEFAULT_PRESIDIO_LANG_CODE = "en"
 DEFAULT_PRESIDIO_MODEL_NAME = "en_core_web_lg"
@@ -61,8 +55,10 @@ class AnonymizationAnalyzer(metaclass=Singleton):
     @staticmethod
     def _get_analyzer_engine(
         anonymization_rule_list: AnonymizationRuleList,
-    ) -> AnalyzerEngine:
+    ) -> "AnalyzerEngine":
         """Returns an analyzer engine for all the anonymization rule lists."""
+        from presidio_analyzer import AnalyzerEngine
+
         try:
             nlp_engine = AnonymizationAnalyzer._build_presidio_nlp_engine(
                 anonymization_rule_list
@@ -84,6 +80,12 @@ class AnonymizationAnalyzer(metaclass=Singleton):
         anonymization_rule_list: AnonymizationRuleList,
     ) -> "NlpEngine":
         """Creates an instance of the Presidio nlp engine."""
+        from presidio_analyzer.nlp_engine import (
+            SpacyNlpEngine,
+            StanzaNlpEngine,
+            TransformersNlpEngine,
+        )
+
         if anonymization_rule_list.model_provider == "transformers":
             nlp_engine = TransformersNlpEngine(
                 models={
@@ -111,6 +113,8 @@ class AnonymizationRuleExecutor:
 
     def __init__(self, anonymization_rule_list: AnonymizationRuleList):
         """Initialize the anonymization rule executor."""
+        from presidio_anonymizer import AnonymizerEngine
+
         self.anonymization_rule_list = anonymization_rule_list
 
         is_valid_rule_list = self._validate_anonymization_rule_list(
@@ -243,8 +247,10 @@ class AnonymizationRuleExecutor:
 
         return func
 
-    def get_operators(self) -> Dict[Text, OperatorConfig]:
+    def get_operators(self) -> Dict[Text, "OperatorConfig"]:
         """Returns a dictionary of operators for the given anonymization rule list."""
+        from presidio_anonymizer.entities import OperatorConfig
+
         operators = {}
 
         for rule in self.anonymization_rule_list.rule_list:

rasa/cli/data.py

@@ -178,6 +178,22 @@ def _add_data_validate_parsers(
     )
     arguments.set_validator_arguments(flows_structure_parser)
 
+    translations_structure_parser = validate_subparsers.add_parser(
+        "translations",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+        parents=parents,
+        help="Checks for inconsistencies of the flow and response translation.",
+    )
+    translations_structure_parser.set_defaults(
+        func=lambda args: rasa.cli.utils.validate_files(
+            args.fail_on_warnings,
+            args.max_history,
+            _build_training_data_importer(args),
+            translations_only=True,
+        )
+    )
+    arguments.set_validator_arguments(translations_structure_parser)
+
 
 def _build_training_data_importer(args: argparse.Namespace) -> "TrainingDataImporter":
     config = rasa.cli.utils.get_validated_path(

rasa/cli/inspect.py

@@ -9,6 +9,10 @@ from rasa import telemetry
 from rasa.cli import SubParsersAction
 from rasa.cli.arguments import shell as arguments
 from rasa.core import constants
+from rasa.engine.storage.local_model_storage import LocalModelStorage
+from rasa.exceptions import ModelNotFound
+from rasa.model import get_local_model
+from rasa.shared.utils.cli import print_error
 from rasa.utils.cli import remove_argument_from_parser
 
 
@@ -55,6 +59,8 @@ async def open_inspector_in_browser(server_url: Text, voice: bool = False) -> No
 def inspect(args: argparse.Namespace) -> None:
     """Inspect the bot using the most recent model."""
     import rasa.cli.run
+    from rasa.cli.utils import get_validated_path
+    from rasa.shared.constants import DEFAULT_MODELS_PATH
 
     async def after_start_hook_open_inspector(_: Sanic, __: AbstractEventLoop) -> None:
         """Hook to open the browser on server start."""
@@ -71,5 +77,18 @@ def inspect(args: argparse.Namespace) -> None:
     args.credentials = None
     args.server_listeners = [(after_start_hook_open_inspector, "after_server_start")]
 
-    telemetry.track_inspect_started(args.connector)
+    model = get_validated_path(args.model, "model", DEFAULT_MODELS_PATH)
+
+    try:
+        model = get_local_model(model)
+    except ModelNotFound:
+        print_error(
+            "No model found. Train a model before running the "
+            "server using `rasa train`."
+        )
+        return
+
+    metadata = LocalModelStorage.metadata_from_archive(model)
+
+    telemetry.track_inspect_started(args.connector, metadata.assistant_id)
     rasa.cli.run.run(args)

rasa/cli/project_templates/calm/config.yml

@@ -1,9 +1,9 @@
 recipe: default.v1
 language: en
 pipeline:
-  - name: SingleStepLLMCommandGenerator
+  - name: CompactLLMCommandGenerator
     llm:
-      model_group: openai-gpt-4
+      model_group: openai-gpt-4o
 
 policies:
   - name: FlowPolicy

rasa/cli/project_templates/calm/endpoints.yml

@@ -50,9 +50,9 @@ action_endpoint:
 #   type: rephrase
 
 model_groups:
-  - id: openai-gpt-4
+  - id: openai-gpt-4o
     models:
       - provider: openai
-        model: openai/gpt-4
+        model: gpt-4o-2024-11-20
         request_timeout: 7
         max_tokens: 256

rasa/cli/shell.py

@@ -95,7 +95,7 @@ def shell_nlu(args: argparse.Namespace) -> None:
         )
         return
 
-    telemetry.track_shell_started("nlu")
+    telemetry.track_shell_started("nlu", metadata.assistant_id)
     rasa.nlu.run.run_cmdline(model)
 
 
@@ -129,12 +129,12 @@ def shell(args: argparse.Namespace) -> None:
     if metadata.training_type == TrainingType.NLU:
         import rasa.nlu.run
 
-        telemetry.track_shell_started("nlu")
+        telemetry.track_shell_started("nlu", metadata.assistant_id)
 
         rasa.nlu.run.run_cmdline(model)
     else:
         import rasa.cli.run
 
-        telemetry.track_shell_started("rasa")
+        telemetry.track_shell_started("rasa", metadata.assistant_id)
 
         rasa.cli.run.run(args)

rasa/cli/utils.py

@@ -248,6 +248,7 @@ def validate_files(
     importer: TrainingDataImporter,
     stories_only: bool = False,
     flows_only: bool = False,
+    translations_only: bool = False,
 ) -> None:
     """Validates either the story structure or the entire project.
 
@@ -257,6 +258,7 @@ def validate_files(
         importer: The `TrainingDataImporter` to use to load the training data.
         stories_only: If `True`, only the story structure is validated.
         flows_only: If `True`, only the flows are validated.
+        translations_only: If `True`, only the translations data is validated.
     """
     from rasa.validator import Validator
 
@@ -266,6 +268,8 @@ def validate_files(
         all_good = _validate_story_structure(validator, max_history, fail_on_warnings)
     elif flows_only:
         all_good = validator.verify_flows()
+    elif translations_only:
+        all_good = validator.verify_translations()
     else:
         if importer.get_domain().is_empty():
             structlogger.error(
@@ -280,6 +284,7 @@ def validate_files(
             validator, max_history, fail_on_warnings
         )
         valid_flows = validator.verify_flows()
+        valid_translations = validator.verify_translations(summary_mode=True)
         valid_CALM_slot_mappings = validator.validate_CALM_slot_mappings()
 
         all_good = (
@@ -287,6 +292,7 @@ def validate_files(
             and valid_nlu
             and valid_stories
             and valid_flows
+            and valid_translations
             and valid_CALM_slot_mappings
         )
 
@@ -309,6 +315,10 @@ def _validate_domain(validator: "Validator") -> bool:
     valid_slot_mappings = validator.verify_slot_mappings()
     valid_responses = validator.check_for_no_empty_parenthesis_in_responses()
     valid_buttons = validator.validate_button_payloads()
+    valid_slot_validation = validator.verify_slot_validation()
+    valid_conditional_responses = (
+        validator.validate_conditional_response_variation_predicates()
+    )
     return (
         valid_domain_validity
         and valid_actions_in_stories_rules
@@ -317,6 +327,8 @@ def _validate_domain(validator: "Validator") -> bool:
         and valid_slot_mappings
         and valid_responses
         and valid_buttons
+        and valid_slot_validation
+        and valid_conditional_responses
     )
 
 

rasa/core/actions/action.py

@@ -1,17 +1,7 @@
 import copy
 import logging
 from functools import lru_cache
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Dict,
-    List,
-    Optional,
-    Set,
-    Text,
-    Tuple,
-    cast,
-)
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Text, cast
 
 from jsonschema import Draft202012Validator
 
@@ -29,11 +19,15 @@ from rasa.core.actions.e2e_stub_custom_action_executor import (
 from rasa.core.actions.grpc_custom_action_executor import GRPCCustomActionExecutor
 from rasa.core.actions.http_custom_action_executor import HTTPCustomActionExecutor
 from rasa.core.constants import (
+    KEY_IS_CALM_SYSTEM,
+    KEY_IS_COEXISTENCE_ASSISTANT,
     UTTER_SOURCE_METADATA_KEY,
 )
+from rasa.core.nlg.translate import get_translated_buttons, get_translated_text
 from rasa.core.policies.policy import PolicyPrediction
 from rasa.core.utils import add_bot_utterance_metadata
 from rasa.e2e_test.constants import KEY_STUB_CUSTOM_ACTIONS
+from rasa.engine.language import Language
 from rasa.nlu.constants import (
     RESPONSE_SELECTOR_DEFAULT_INTENT,
     RESPONSE_SELECTOR_PREDICTION_KEY,
@@ -70,13 +64,11 @@ from rasa.shared.core.constants import (
     ACTION_SEND_TEXT_NAME,
     ACTION_SESSION_START_NAME,
     ACTION_UNLIKELY_INTENT_NAME,
-    ACTION_VALIDATE_SLOT_MAPPINGS,
     DEFAULT_SLOT_NAMES,
     KNOWLEDGE_BASE_SLOT_NAMES,
-    MAPPING_TYPE,
     REQUESTED_SLOT,
     USER_INTENT_OUT_OF_SCOPE,
-    SlotMappingType,
+    SetSlotExtractor,
 )
 from rasa.shared.core.domain import Domain
 from rasa.shared.core.events import (
@@ -92,19 +84,17 @@ from rasa.shared.core.events import (
     UserUttered,
 )
 from rasa.shared.core.flows import FlowsList
+from rasa.shared.core.flows.constants import KEY_TRANSLATION
 from rasa.shared.core.slot_mappings import (
     SlotFillingManager,
     extract_slot_value,
 )
 from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.shared.exceptions import RasaException
-from rasa.shared.nlu.constants import (
-    INTENT_NAME_KEY,
-    INTENT_RANKING_KEY,
-)
+from rasa.shared.nlu.constants import INTENT_NAME_KEY, INTENT_RANKING_KEY
 from rasa.shared.utils.io import raise_warning
 from rasa.shared.utils.schemas.events import EVENTS_SCHEMA
-from rasa.utils.endpoints import ClientResponseError, EndpointConfig
+from rasa.utils.endpoints import EndpointConfig
 from rasa.utils.url_tools import UrlSchema, get_url_schema
 
 if TYPE_CHECKING:
@@ -118,6 +108,10 @@ logger = logging.getLogger(__name__)
 def default_actions(action_endpoint: Optional[EndpointConfig] = None) -> List["Action"]:
     """List default actions."""
     from rasa.core.actions.action_clean_stack import ActionCleanStack
+    from rasa.core.actions.action_handle_digressions import (
+        ActionBlockDigressions,
+        ActionContinueDigression,
+    )
     from rasa.core.actions.action_hangup import ActionHangup
     from rasa.core.actions.action_repeat_bot_messages import ActionRepeatBotMessages
     from rasa.core.actions.action_run_slot_rejections import ActionRunSlotRejections
@@ -152,6 +146,8 @@ def default_actions(action_endpoint: Optional[EndpointConfig] = None) -> List["A
         ActionResetRouting(),
         ActionHangup(),
         ActionRepeatBotMessages(),
+        ActionBlockDigressions(),
+        ActionContinueDigression(),
     ]
 
 
@@ -261,25 +257,36 @@ def action_for_name_or_text(
     return RemoteAction(action_name_or_text, action_endpoint)
 
 
-def create_bot_utterance(message: Dict[Text, Any]) -> BotUttered:
-    """Create BotUttered event from message."""
-    bot_message = BotUttered(
-        text=message.pop(TEXT, None),
-        data={
-            ELEMENTS: message.pop(ELEMENTS, None),
-            QUICK_REPLIES: message.pop(QUICK_REPLIES, None),
-            BUTTONS: message.pop(BUTTONS, None),
-            # for legacy / compatibility reasons we need to set the image
-            # to be the attachment if there is no other attachment (the
-            # `.get` is intentional - no `pop` as we still need the image`
-            # property to set it in the following line)
-            ATTACHMENT: message.pop(ATTACHMENT, None) or message.get(IMAGE, None),
-            IMAGE: message.pop(IMAGE, None),
-            CUSTOM: message.pop(CUSTOM, None),
-        },
-        metadata=message,
+def create_bot_utterance(
+    message: Dict[Text, Any], language: Optional[Language] = None
+) -> BotUttered:
+    """Create BotUttered event from message with translation support."""
+    message_copy = copy.deepcopy(message)
+
+    text = get_translated_text(
+        text=message_copy.pop(TEXT, None),
+        translation=message_copy.pop(KEY_TRANSLATION, {}),
+        language=language,
     )
-    return bot_message
+
+    buttons = get_translated_buttons(
+        buttons=message_copy.pop(BUTTONS, None), language=language
+    )
+
+    data = {
+        ELEMENTS: message_copy.pop(ELEMENTS, None),
+        QUICK_REPLIES: message_copy.pop(QUICK_REPLIES, None),
+        BUTTONS: buttons,
+        # for legacy / compatibility reasons we need to set the image
+        # to be the attachment if there is no other attachment (the
+        # `.get` is intentional - no `pop` as we still need the image`
+        # property to set it in the following line)
+        ATTACHMENT: message_copy.pop(ATTACHMENT, None) or message_copy.get(IMAGE, None),
+        IMAGE: message_copy.pop(IMAGE, None),
+        CUSTOM: message_copy.pop(CUSTOM, None),
+    }
+
+    return BotUttered(text=text, data=data, metadata=message_copy)
 
 
 class Action:
@@ -392,7 +399,7 @@ class ActionBotResponse(Action):
         message = add_bot_utterance_metadata(
             message, self.utter_action, nlg, domain, tracker
         )
-        return [create_bot_utterance(message)]
+        return [create_bot_utterance(message, tracker.current_language)]
 
     def name(self) -> Text:
         """Returns action name."""
@@ -426,7 +433,7 @@ class ActionEndToEndResponse(Action):
     ) -> List[Event]:
         """Runs action (see parent class for full docstring)."""
         message = {"text": self.action_text}
-        return [create_bot_utterance(message)]
+        return [create_bot_utterance(message, tracker.current_language)]
 
     def event_for_successful_execution(
         self,
@@ -910,7 +917,7 @@ class RemoteAction(Action):
             # Avoid overwriting `draft` values with empty values
             response = {k: v for k, v in response.items() if v}
             draft.update(response)
-            bot_messages.append(create_bot_utterance(draft))
+            bot_messages.append(create_bot_utterance(draft, tracker.current_language))
 
         return bot_messages
 
@@ -940,7 +947,14 @@ class RemoteAction(Action):
         )
 
         events = rasa.shared.core.events.deserialise_events(events_json)
-        return cast(List[Event], bot_messages) + events
+
+        processed_events = []
+        for event in events:
+            if isinstance(event, SlotSet) and event.filled_by is None:
+                event.filled_by = SetSlotExtractor.CUSTOM.value
+            processed_events.append(event)
+
+        return cast(List[Event], bot_messages) + processed_events
 
     def name(self) -> Text:
         return self._name
@@ -1111,7 +1125,7 @@ class ActionDefaultAskAffirmation(Action):
             "utter_action": self.name(),
         }
 
-        return [create_bot_utterance(message)]
+        return [create_bot_utterance(message, tracker.current_language)]
 
 
 class ActionDefaultAskRephrase(ActionBotResponse):
@@ -1144,7 +1158,7 @@ class ActionSendText(Action):
         fallback = {"text": ""}
         metadata_copy = copy.deepcopy(metadata) if metadata else {}
         message = metadata_copy.get("message", fallback)
-        return [create_bot_utterance(message)]
+        return [create_bot_utterance(message, tracker.current_language)]
 
 
 class ActionExtractSlots(Action):
@@ -1165,113 +1179,6 @@ class ActionExtractSlots(Action):
         """Returns action_extract_slots name."""
         return ACTION_EXTRACT_SLOTS
 
-    async def _run_custom_action(
-        self,
-        custom_action: Text,
-        output_channel: "OutputChannel",
-        nlg: "NaturalLanguageGenerator",
-        tracker: "DialogueStateTracker",
-        domain: "Domain",
-    ) -> List[Event]:
-        slot_events: List[Event] = []
-        remote_action = RemoteAction(custom_action, self._action_endpoint)
-        disallowed_types = set()
-
-        try:
-            custom_events = await remote_action.run(
-                output_channel, nlg, tracker, domain
-            )
-            for event in custom_events:
-                if isinstance(event, SlotSet):
-                    slot_events.append(event)
-                elif isinstance(event, BotUttered):
-                    slot_events.append(event)
-                else:
-                    disallowed_types.add(event.type_name)
-        except (RasaException, ClientResponseError) as e:
-            logger.warning(
-                f"Failed to execute custom action '{custom_action}' "
-                f"as a result of error '{e!s}'. The default action "
-                f"'{self.name()}' failed to fill slots with custom "
-                f"mappings."
-            )
-
-        for type_name in disallowed_types:
-            logger.info(
-                f"Running custom action '{custom_action}' has resulted "
-                f"in an event of type '{type_name}'. This is "
-                f"disallowed and the tracker will not be "
-                f"updated with this event."
-            )
-
-        return slot_events
-
-    async def _execute_custom_action(
-        self,
-        mapping: Dict[Text, Any],
-        executed_custom_actions: Set[Text],
-        output_channel: "OutputChannel",
-        nlg: "NaturalLanguageGenerator",
-        tracker: "DialogueStateTracker",
-        domain: "Domain",
-        calm_custom_action_names: Optional[Set[str]] = None,
-    ) -> Tuple[List[Event], Set[Text]]:
-        custom_action = mapping.get("action")
-
-        if not custom_action or custom_action in executed_custom_actions:
-            return [], executed_custom_actions
-
-        if (
-            calm_custom_action_names is not None
-            and custom_action in calm_custom_action_names
-        ):
-            return [], executed_custom_actions
-
-        slot_events = await self._run_custom_action(
-            custom_action, output_channel, nlg, tracker, domain
-        )
-
-        executed_custom_actions.add(custom_action)
-
-        return slot_events, executed_custom_actions
-
-    async def _execute_validation_action(
-        self,
-        extraction_events: List[Event],
-        output_channel: "OutputChannel",
-        nlg: "NaturalLanguageGenerator",
-        tracker: "DialogueStateTracker",
-        domain: "Domain",
-    ) -> List[Event]:
-        slot_events: List[SlotSet] = [
-            event for event in extraction_events if isinstance(event, SlotSet)
-        ]
-
-        slot_candidates = "\n".join([e.key for e in slot_events])
-        logger.debug(f"Validating extracted slots: {slot_candidates}")
-
-        if ACTION_VALIDATE_SLOT_MAPPINGS not in domain.user_actions:
-            return cast(List[Event], slot_events)
-
-        _tracker = DialogueStateTracker.from_events(
-            tracker.sender_id,
-            tracker.events_after_latest_restart() + cast(List[Event], slot_events),
-            slots=domain.slots,
-        )
-        validate_events = await self._run_custom_action(
-            ACTION_VALIDATE_SLOT_MAPPINGS, output_channel, nlg, _tracker, domain
-        )
-        validated_slot_names = [
-            event.key for event in validate_events if isinstance(event, SlotSet)
-        ]
-
-        # If the custom action doesn't return a SlotSet event for an extracted slot
-        # candidate we assume that it was valid. The custom action has to return a
-        # SlotSet(slot_name, None) event to mark a Slot as invalid.
-        return validate_events + [
-            event for event in slot_events if event.key not in validated_slot_names
-        ]
-
     async def run(
         self,
         output_channel: "OutputChannel",
@@ -1282,60 +1189,59 @@ class ActionExtractSlots(Action):
     ) -> List[Event]:
         """Runs action. Please see parent class for the full docstring."""
         slot_events: List[Event] = []
-        executed_custom_actions: Set[Text] = set()
-
         user_slots = [
             slot
             for slot in domain.slots
             if slot.name not in DEFAULT_SLOT_NAMES | KNOWLEDGE_BASE_SLOT_NAMES
         ]
 
-        calm_slot_names = set()
-        calm_custom_action_names = None
-        flows = None
-
-        if metadata is not None:
-            flows = metadata.get("all_flows")
-
-        if flows is not None:
-            flows = FlowsList.from_json(flows)
-            calm_slot_names = flows.available_slot_names()
-            calm_custom_action_names = flows.available_custom_actions()
-
+        all_flows = metadata.get("all_flows") if metadata else None
+        flows = FlowsList.from_json(all_flows) if all_flows else None
+        calm_slot_names = flows.available_slot_names() if flows else set()
+        is_calm_system = metadata.get(KEY_IS_CALM_SYSTEM) if metadata else False
+        is_coexistence_bot = (
+            metadata.get(KEY_IS_COEXISTENCE_ASSISTANT) if metadata else False
+        )
         slot_filling_manager = SlotFillingManager(
-            domain, tracker, action_endpoint=self._action_endpoint
+            domain,
+            tracker,
+            action_endpoint=self._action_endpoint,
         )
 
         for slot in user_slots:
             # allows the action to set slots that are shared between
             # the NLU-based system and CALM system in a coexistence bot
-            if slot.name in calm_slot_names and not slot.shared_for_coexistence:
-                continue
-
-            slot_value, is_extracted = extract_slot_value(slot, slot_filling_manager)
-            if is_extracted:
-                slot_events.append(SlotSet(slot.name, slot_value))
-
-            for mapping in slot.mappings:
-                mapping_type = SlotMappingType(mapping.get(MAPPING_TYPE))
-                should_fill_custom_slot = mapping_type == SlotMappingType.CUSTOM
-
-                if should_fill_custom_slot:
-                    (
-                        custom_evts,
-                        executed_custom_actions,
-                    ) = await self._execute_custom_action(
-                        mapping,
-                        executed_custom_actions,
-                        output_channel,
-                        nlg,
-                        tracker,
-                        domain,
-                        calm_custom_action_names,
+            if is_coexistence_bot:
+                should_fill_slot_in_coexistence = (
+                    slot_filling_manager.should_fill_slot_in_coexistence(
+                        is_calm_system=is_calm_system,
+                        slot=slot,
+                        calm_slot_names=calm_slot_names,
                     )
-                    slot_events.extend(custom_evts)
+                )
+                if not should_fill_slot_in_coexistence:
+                    continue
 
-        validated_events = await self._execute_validation_action(
-            slot_events, output_channel, nlg, tracker, domain
-        )
-        return validated_events
+            if not is_calm_system:
+                slot_value, is_extracted = extract_slot_value(
+                    slot, slot_filling_manager
+                )
+                if is_extracted:
+                    slot_events.append(SlotSet(slot.name, slot_value))
+
+            custom_events = await slot_filling_manager.run_action_at_every_turn(
+                slot,
+                output_channel,
+                nlg,
+            )
+            slot_events.extend(custom_events)
+
+        if not is_calm_system:
+            validated_events = await slot_filling_manager.execute_validation_action(
+                slot_events,
+                output_channel,
+                nlg,
+            )
+            return validated_events
+
+        return slot_events