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

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,
@@ -41,10 +35,17 @@ from rasa.nlu.constants import (
     RESPONSE_SELECTOR_UTTER_ACTION_KEY,
 )
 from rasa.shared.constants import (
+    ATTACHMENT,
+    BUTTONS,
+    CUSTOM,
     DEFAULT_NLU_FALLBACK_INTENT_NAME,
     DOCS_BASE_URL,
+    ELEMENTS,
     FLOW_PREFIX,
+    IMAGE,
+    QUICK_REPLIES,
     ROUTE_TO_CALM_SLOT,
+    TEXT,
     UTTER_PREFIX,
 )
 from rasa.shared.core.constants import (
@@ -55,19 +56,19 @@ from rasa.shared.core.constants import (
     ACTION_DEFAULT_FALLBACK_NAME,
     ACTION_EXTRACT_SLOTS,
     ACTION_LISTEN_NAME,
+    ACTION_METADATA_EXECUTION_ERROR_MESSAGE,
+    ACTION_METADATA_EXECUTION_SUCCESS,
     ACTION_RESET_ROUTING,
     ACTION_RESTART_NAME,
     ACTION_REVERT_FALLBACK_EVENTS_NAME,
     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 (
@@ -83,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:
@@ -109,12 +108,16 @@ 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
     from rasa.core.actions.action_trigger_chitchat import ActionTriggerChitchat
     from rasa.core.actions.action_trigger_search import ActionTriggerSearch
     from rasa.core.actions.two_stage_fallback import TwoStageFallbackAction
-    from rasa.core.actions.action_hangup import ActionHangup
-    from rasa.core.actions.action_repeat_bot_messages import ActionRepeatBotMessages
     from rasa.dialogue_understanding.patterns.cancel import ActionCancelFlow
     from rasa.dialogue_understanding.patterns.clarify import ActionClarifyFlows
     from rasa.dialogue_understanding.patterns.correction import ActionCorrectFlowSlot
@@ -143,6 +146,8 @@ def default_actions(action_endpoint: Optional[EndpointConfig] = None) -> List["A
         ActionResetRouting(),
         ActionHangup(),
         ActionRepeatBotMessages(),
+        ActionBlockDigressions(),
+        ActionContinueDigression(),
     ]
 
 
@@ -252,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:
@@ -310,22 +326,30 @@ class Action:
         return f"{self.__class__.__name__}('{self.name()}')"
 
     def event_for_successful_execution(
-        self, prediction: PolicyPrediction
+        self,
+        prediction: PolicyPrediction,
+        was_successful: bool,
+        error_message: Optional[str],
     ) -> ActionExecuted:
         """Event which should be logged for the successful execution of this action.
 
         Args:
             prediction: Prediction which led to the execution of this event.
+            was_successful: Whether the action was executed successfully.
+            error_message: Error message if the action was not executed successfully.
 
         Returns:
             Event which should be logged onto the tracker.
         """
+        metadata = prediction.action_metadata or {}
+        metadata[ACTION_METADATA_EXECUTION_SUCCESS] = was_successful
+        metadata[ACTION_METADATA_EXECUTION_ERROR_MESSAGE] = error_message
         return ActionExecuted(
             self.name(),
             prediction.policy_name,
             prediction.max_confidence,
             hide_rule_turn=prediction.hide_rule_turn,
-            metadata=prediction.action_metadata,
+            metadata=metadata,
         )
 
 
@@ -375,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."""
@@ -409,25 +433,34 @@ 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, prediction: PolicyPrediction
+        self,
+        prediction: PolicyPrediction,
+        was_successful: bool,
+        error_message: Optional[str],
     ) -> ActionExecuted:
         """Event which should be logged for the successful execution of this action.
 
         Args:
             prediction: Prediction which led to the execution of this event.
+            was_successful: Whether the action was executed successfully.
+            error_message: Error message if the action was not executed successfully.
 
         Returns:
             Event which should be logged onto the tracker.
         """
+        metadata = prediction.action_metadata or {}
+        metadata[ACTION_METADATA_EXECUTION_SUCCESS] = was_successful
+        metadata[ACTION_METADATA_EXECUTION_ERROR_MESSAGE] = error_message
+
         return ActionExecuted(
             policy=prediction.policy_name,
             confidence=prediction.max_confidence,
             action_text=self.action_text,
             hide_rule_turn=prediction.hide_rule_turn,
-            metadata=prediction.action_metadata,
+            metadata=metadata,
         )
 
 
@@ -727,10 +760,7 @@ class ActionDeactivateLoop(Action):
 
 
 class RemoteActionJSONValidator:
-    """
-    A validator class for ensuring that the JSON response from a custom action executor
-    adheres to the expected schema.
-    """
+    """Check action responses for JSON schema validation."""
 
     @staticmethod
     def action_response_format_spec() -> Dict[Text, Any]:
@@ -753,8 +783,7 @@ class RemoteActionJSONValidator:
 
     @classmethod
     def validate(cls, result: Dict[Text, Any]) -> bool:
-        """
-        Validate the given JSON result against the expected Action response schema.
+        """Validate the given JSON result against the expected Action response schema.
 
         This method uses a cached JSON schema validator to check if the provided result
         conforms to the predefined schema.
@@ -781,15 +810,14 @@ class RemoteActionJSONValidator:
                 f". Failed to validate Action server response from API, "
                 f"make sure your response from the Action endpoint is valid. "
                 f"For more information about the format visit "
-                f"{DOCS_BASE_URL}/custom-actions"
+                f"{DOCS_BASE_URL}/action-server/actions"
             )
             raise e
 
     @classmethod
     @lru_cache(maxsize=1)
     def get_action_response_validator(cls) -> Draft202012Validator:
-        """
-        Retrieve a cached JSON schema validator for the Action response schema.
+        """Retrieve a cached JSON schema validator for the Action response schema.
 
         Returns:
             Draft202012Validator: An instance of the JSON schema validator.
@@ -889,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
 
@@ -919,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
@@ -1090,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):
@@ -1123,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):
@@ -1144,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",
@@ -1261,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