rasa-pro 3.8.18__py3-none-any.whl → 3.9.15__py3-none-any.whl

rasa/shared/core/generator.py

@@ -401,8 +401,9 @@ class TrainingDataGenerator:
 
             if num_active_trackers:
                 logger.debug(
-                    "Starting {} ... (with {} trackers)"
-                    "".format(phase_name, num_active_trackers)
+                    "Starting {} ... (with {} trackers)".format(
+                        phase_name, num_active_trackers
+                    )
                 )
             else:
                 logger.debug(f"There are no trackers for {phase_name}")
@@ -516,14 +517,14 @@ class TrainingDataGenerator:
                     phase = 0
                 else:
                     logger.debug(
-                        "Found {} unused checkpoints "
-                        "in current phase."
-                        "".format(len(unused_checkpoints))
+                        "Found {} unused checkpoints in current phase.".format(
+                            len(unused_checkpoints)
+                        )
                     )
                     logger.debug(
-                        "Found {} active trackers "
-                        "for these checkpoints."
-                        "".format(num_active_trackers)
+                        "Found {} active trackers for these checkpoints.".format(
+                            num_active_trackers
+                        )
                     )
 
             if everything_reachable_is_reached:
@@ -552,8 +553,9 @@ class TrainingDataGenerator:
                 augmented_trackers, self.config.max_number_of_augmented_trackers
             )
             logger.debug(
-                "Subsampled to {} augmented training trackers."
-                "".format(len(augmented_trackers))
+                "Subsampled to {} augmented training trackers.".format(
+                    len(augmented_trackers)
+                )
             )
             logger.debug(
                 "There are {} original trackers.".format(len(original_trackers))
@@ -672,7 +674,6 @@ class TrainingDataGenerator:
 
         trackers = []
         if events:  # small optimization
-
             # need to copy the tracker as multiple story steps
             # might start with the same checkpoint and all of them
             # will use the same set of incoming trackers

rasa/shared/core/slot_mappings.py

@@ -1,16 +1,24 @@
-from typing import Text, Dict, Any, List, Optional, TYPE_CHECKING
+import logging
+from typing import Text, Dict, Any, List, Optional, TYPE_CHECKING, Tuple, cast
 
 from rasa.shared.constants import DOCS_URL_NLU_BASED_SLOTS, IGNORED_INTENTS
 import rasa.shared.utils.io
+from rasa.shared.core.slots import ListSlot, Slot
 from rasa.shared.nlu.constants import (
+    ENTITIES,
     ENTITY_ATTRIBUTE_TYPE,
     ENTITY_ATTRIBUTE_ROLE,
     ENTITY_ATTRIBUTE_GROUP,
+    ENTITY_ATTRIBUTE_VALUE,
     INTENT,
     NOT_INTENT,
     INTENT_NAME_KEY,
+    TEXT,
 )
 from rasa.shared.core.constants import (
+    ACTIVE_FLOW,
+    ACTIVE_LOOP,
+    REQUESTED_SLOT,
     SLOT_MAPPINGS,
     MAPPING_TYPE,
     SlotMappingType,
@@ -20,6 +28,11 @@ from rasa.shared.core.constants import (
 if TYPE_CHECKING:
     from rasa.shared.core.trackers import DialogueStateTracker
     from rasa.shared.core.domain import Domain
+    from rasa.shared.nlu.training_data.message import Message
+    from rasa.utils.endpoints import EndpointConfig
+
+
+logger = logging.getLogger(__name__)
 
 
 class SlotMapping:
@@ -60,6 +73,7 @@ class SlotMapping:
             SlotMappingType.FROM_TRIGGER_INTENT: ["value"],
             SlotMappingType.FROM_TEXT: [],
             SlotMappingType.CUSTOM: [],
+            SlotMappingType.FROM_LLM: [],
         }
 
         required_keys = validations[mapping_type]
@@ -99,7 +113,10 @@ class SlotMapping:
 
     @staticmethod
     def intent_is_desired(
-        mapping: Dict[Text, Any], tracker: "DialogueStateTracker", domain: "Domain"
+        mapping: Dict[Text, Any],
+        tracker: "DialogueStateTracker",
+        domain: "Domain",
+        message: Optional["Message"] = None,
     ) -> bool:
         """Checks whether user intent matches slot mapping intent specifications."""
         mapping_intents = SlotMapping.to_list(mapping.get(INTENT, []))
@@ -114,7 +131,9 @@ class SlotMapping:
                 )
             )
 
-        if tracker.latest_message:
+        if message is not None:
+            intent = message.get(INTENT, {}).get("name")
+        elif tracker.latest_message:
             intent = tracker.latest_message.intent.get(INTENT_NAME_KEY)
         else:
             intent = None
@@ -138,40 +157,44 @@ class SlotMapping:
 
     @staticmethod
     def entity_is_desired(
-        mapping: Dict[Text, Any], tracker: "DialogueStateTracker"
-    ) -> bool:
+        mapping: Dict[Text, Any],
+        tracker: "DialogueStateTracker",
+        message: Optional["Message"] = None,
+    ) -> List[str]:
         """Checks whether slot should be filled by an entity in the input or not.
 
         Args:
             mapping: Slot mapping.
             tracker: The tracker.
+            message: The message being processed.
 
         Returns:
-            True, if slot should be filled, false otherwise.
+            A list of matching values.
         """
-        slot_fulfils_entity_mapping = False
-        if tracker.latest_message:
-            extracted_entities = tracker.latest_message.entities
-        else:
-            extracted_entities = []
-
-        for entity in extracted_entities:
-            if (
-                mapping.get(ENTITY_ATTRIBUTE_TYPE) == entity[ENTITY_ATTRIBUTE_TYPE]
-                and mapping.get(ENTITY_ATTRIBUTE_ROLE)
-                == entity.get(ENTITY_ATTRIBUTE_ROLE)
-                and mapping.get(ENTITY_ATTRIBUTE_GROUP)
-                == entity.get(ENTITY_ATTRIBUTE_GROUP)
-            ):
-                matching_values = tracker.get_latest_entity_values(
+        if message is not None:
+            extracted_entities = message.get(ENTITIES, [])
+            matching_values = [
+                cast(Text, entity[ENTITY_ATTRIBUTE_VALUE])
+                for entity in extracted_entities
+                if entity.get(ENTITY_ATTRIBUTE_TYPE)
+                == mapping.get(ENTITY_ATTRIBUTE_TYPE)
+                and entity.get(ENTITY_ATTRIBUTE_GROUP)
+                == mapping.get(ENTITY_ATTRIBUTE_GROUP)
+                and entity.get(ENTITY_ATTRIBUTE_ROLE)
+                == mapping.get(ENTITY_ATTRIBUTE_ROLE)
+            ]
+        elif tracker.latest_message and tracker.latest_message.text is not None:
+            matching_values = list(
+                tracker.get_latest_entity_values(
                     mapping.get(ENTITY_ATTRIBUTE_TYPE),
                     mapping.get(ENTITY_ATTRIBUTE_ROLE),
                     mapping.get(ENTITY_ATTRIBUTE_GROUP),
                 )
-                slot_fulfils_entity_mapping = matching_values is not None
-                break
+            )
+        else:
+            matching_values = []
 
-        return slot_fulfils_entity_mapping
+        return matching_values
 
     @staticmethod
     def check_mapping_validity(
@@ -233,3 +256,271 @@ def validate_slot_mappings(domain_slots: Dict[Text, Any]) -> None:
 
         for slot_mapping in mappings:
             SlotMapping.validate(slot_mapping, slot_name)
+
+
+class SlotFillingManager:
+    """Manages slot filling based on conversation context."""
+
+    def __init__(
+        self,
+        domain: "Domain",
+        tracker: "DialogueStateTracker",
+        message: Optional["Message"] = None,
+        action_endpoint: Optional["EndpointConfig"] = None,
+    ) -> None:
+        self.domain = domain
+        self.tracker = tracker
+        self.message = message
+        self._action_endpoint = action_endpoint
+
+    def is_slot_mapping_valid(
+        self,
+        slot_name: str,
+        mapping_type: SlotMappingType,
+        mapping: Dict[str, Any],
+    ) -> bool:
+        """Check if a slot mapping is valid."""
+        return SlotMapping.check_mapping_validity(
+            slot_name=slot_name,
+            mapping_type=mapping_type,
+            mapping=mapping,
+            domain=self.domain,
+        )
+
+    def is_intent_desired(self, mapping: Dict[str, Any]) -> bool:
+        """Check if the intent matches the one indicated in the slot mapping."""
+        return SlotMapping.intent_is_desired(
+            mapping=mapping,
+            tracker=self.tracker,
+            domain=self.domain,
+            message=self.message,
+        )
+
+    def _verify_mapping_conditions(
+        self, mapping: Dict[Text, Any], slot_name: Text
+    ) -> bool:
+        if mapping.get(MAPPING_CONDITIONS) and mapping[MAPPING_TYPE] != str(
+            SlotMappingType.FROM_TRIGGER_INTENT
+        ):
+            if not self._matches_mapping_conditions(mapping, slot_name):
+                return False
+
+        return True
+
+    def _matches_mapping_conditions(
+        self, mapping: Dict[Text, Any], slot_name: Text
+    ) -> bool:
+        slot_mapping_conditions = mapping.get(MAPPING_CONDITIONS)
+
+        if not slot_mapping_conditions:
+            return True
+
+        active_flow = self.tracker.active_flow
+
+        if active_flow:
+            return self._mapping_conditions_match_flow(
+                active_flow, slot_mapping_conditions
+            )
+
+        # if we are not in a flow, we could be in a form
+        return self._mapping_conditions_match_form(slot_name, slot_mapping_conditions)
+
+    @staticmethod
+    def _mapping_conditions_match_flow(
+        active_flow: str,
+        slot_mapping_conditions: List[Dict[str, str]],
+    ) -> bool:
+        active_flow_conditions = list(
+            filter(lambda x: x.get(ACTIVE_FLOW) is not None, slot_mapping_conditions)
+        )
+        return any(
+            [
+                condition.get(ACTIVE_FLOW) == active_flow
+                for condition in active_flow_conditions
+            ]
+        )
+
+    def _mapping_conditions_match_form(
+        self, slot_name: str, slot_mapping_conditions: List[Dict[str, str]]
+    ) -> bool:
+        if (
+            self.tracker.is_active_loop_rejected
+            and self.tracker.get_slot(REQUESTED_SLOT) == slot_name
+        ):
+            return False
+
+        # check if found mapping conditions matches form
+        for condition in slot_mapping_conditions:
+            # we allow None as a valid value for active_loop
+            # therefore we need to set a different default value
+            active_loop = condition.get(ACTIVE_LOOP, "")
+
+            if active_loop and active_loop == self.tracker.active_loop_name:
+                condition_requested_slot = condition.get(REQUESTED_SLOT)
+                if not condition_requested_slot:
+                    return True
+                if condition_requested_slot == self.tracker.get_slot(REQUESTED_SLOT):
+                    return True
+
+            if active_loop is None and self.tracker.active_loop_name is None:
+                return True
+
+        return False
+
+    def _fails_unique_entity_mapping_check(
+        self,
+        slot_name: Text,
+        mapping: Dict[Text, Any],
+    ) -> bool:
+        from rasa.core.actions.forms import FormAction
+
+        if mapping[MAPPING_TYPE] != str(SlotMappingType.FROM_ENTITY):
+            return False
+
+        form_name = self.tracker.active_loop_name
+
+        if not form_name:
+            return False
+
+        if self.tracker.get_slot(REQUESTED_SLOT) == slot_name:
+            return False
+
+        form = FormAction(form_name, self._action_endpoint)
+
+        if slot_name not in form.required_slots(self.domain):
+            return False
+
+        if form.entity_mapping_is_unique(mapping, self.domain):
+            return False
+
+        return True
+
+    def _is_trigger_intent_mapping_condition_met(
+        self, mapping: Dict[Text, Any]
+    ) -> bool:
+        active_loops_in_mapping_conditions = [
+            condition.get(ACTIVE_LOOP)
+            for condition in mapping.get(MAPPING_CONDITIONS, [])
+        ]
+
+        trigger_mapping_condition_met = True
+
+        if self.tracker.active_loop_name is None:
+            trigger_mapping_condition_met = False
+        elif (
+            active_loops_in_mapping_conditions
+            and self.tracker.active_loop_name is not None
+            and (
+                self.tracker.active_loop_name not in active_loops_in_mapping_conditions
+            )
+        ):
+            trigger_mapping_condition_met = False
+
+        return trigger_mapping_condition_met
+
+    def extract_slot_value_from_predefined_mapping(
+        self,
+        mapping_type: SlotMappingType,
+        mapping: Dict[Text, Any],
+    ) -> List[Any]:
+        """Extracts slot value if slot has an applicable predefined mapping."""
+        if (
+            self.message is None
+            and self.tracker.has_bot_message_after_latest_user_message()
+        ):
+            # TODO: this needs further validation - not sure if this breaks something!!!
+
+            # If the bot sent a message after the user sent a message, we can't
+            # extract any slots from the user message. We assume that the user
+            # message was already processed by the bot and the slot value was
+            # already extracted (e.g. for a prior form slot).
+            return []
+
+        should_fill_entity_slot = mapping_type == SlotMappingType.FROM_ENTITY
+
+        should_fill_intent_slot = mapping_type == SlotMappingType.FROM_INTENT
+
+        should_fill_text_slot = mapping_type == SlotMappingType.FROM_TEXT
+
+        trigger_mapping_condition_met = self._is_trigger_intent_mapping_condition_met(
+            mapping
+        )
+
+        should_fill_trigger_slot = (
+            mapping_type == SlotMappingType.FROM_TRIGGER_INTENT
+            and trigger_mapping_condition_met
+        )
+
+        value: List[Any] = []
+
+        if should_fill_entity_slot:
+            value = SlotMapping.entity_is_desired(mapping, self.tracker, self.message)
+        elif should_fill_intent_slot or should_fill_trigger_slot:
+            value = [mapping.get("value")]
+        elif should_fill_text_slot:
+            value = [self.message.get(TEXT)] if self.message is not None else []
+            if not value:
+                value = [
+                    self.tracker.latest_message.text
+                    if self.tracker.latest_message is not None
+                    else None
+                ]
+
+        return value
+
+    def should_fill_slot(
+        self, slot_name: str, mapping_type: SlotMappingType, mapping: Dict[Text, Any]
+    ) -> bool:
+        """Checks if a slot should be filled based on the conversation context."""
+        if not self.is_slot_mapping_valid(slot_name, mapping_type, mapping):
+            return False
+
+        if not self.is_intent_desired(mapping):
+            return False
+
+        if not self._verify_mapping_conditions(mapping, slot_name):
+            return False
+
+        if self._fails_unique_entity_mapping_check(slot_name, mapping):
+            return False
+
+        return True
+
+
+def extract_slot_value(
+    slot: Slot, slot_filling_manager: SlotFillingManager
+) -> Tuple[Any, bool]:
+    """Extracts the value of a slot based on the conversation context."""
+    is_extracted = False
+
+    for mapping in slot.mappings:
+        mapping_type = SlotMappingType(
+            mapping.get(MAPPING_TYPE, SlotMappingType.FROM_LLM.value)
+        )
+
+        if mapping_type in [SlotMappingType.FROM_LLM, SlotMappingType.CUSTOM]:
+            continue
+
+        if not slot_filling_manager.should_fill_slot(slot.name, mapping_type, mapping):
+            continue
+
+        value: List[Any] = (
+            slot_filling_manager.extract_slot_value_from_predefined_mapping(
+                mapping_type, mapping
+            )
+        )
+
+        if value:
+            if not isinstance(slot, ListSlot):
+                value = value[-1]
+
+            if (
+                value is not None
+                or slot_filling_manager.tracker.get_slot(slot.name) is not None
+            ):
+                logger.debug(f"Extracted value '{value}' for slot '{slot.name}'.")
+
+                is_extracted = True
+                return value, is_extracted
+
+    return None, is_extracted

rasa/shared/core/slots.py

@@ -364,7 +364,7 @@ class ListSlot(Slot):
         """Sets the slot's value."""
         # Call property setter of superclass
         # FIXME: https://github.com/python/mypy/issues/8085
-        super(ListSlot, self.__class__).value.fset(self, self.coerce_value(value))  # type: ignore[attr-defined] # noqa: E501
+        super(ListSlot, self.__class__).value.fset(self, self.coerce_value(value))  # type: ignore[attr-defined]
 
 
 class CategoricalSlot(Slot):
@@ -579,7 +579,9 @@ class CategoricalSlot(Slot):
         """
         # Call property setter of superclass
         # FIXME: https://github.com/python/mypy/issues/8085
-        super(CategoricalSlot, self.__class__).value.fset(self, self.coerce_value(value))  # type: ignore[attr-defined] # noqa: E501
+        super(CategoricalSlot, self.__class__).value.fset(  # type: ignore[attr-defined]
+            self, self.coerce_value(value)
+        )
 
 
 class AnySlot(Slot):

rasa/shared/core/trackers.py

@@ -289,7 +289,7 @@ class DialogueStateTracker:
         parse_data_with_nlu_state = self.latest_message.parse_data.copy()
         # Combine entities predicted by NLU with entities predicted by policies so that
         # users can access them together via `latest_message` (e.g. in custom actions)
-        parse_data_with_nlu_state[ENTITIES] = self.latest_message.entities  # type: ignore[literal-required]  # noqa: E501
+        parse_data_with_nlu_state[ENTITIES] = self.latest_message.entities  # type: ignore[literal-required]
 
         return parse_data_with_nlu_state
 
@@ -443,6 +443,12 @@ class DialogueStateTracker:
         """
         return self._underlying_stack.copy()
 
+    @property
+    def active_flow(self) -> Optional[Text]:
+        """Returns the name of the active flow."""
+        current_context = self.stack.current_context()
+        return current_context.get("flow_id")
+
     @property
     def has_coexistence_routing_slot(self) -> bool:
         """Returns whether the coexistence routing slot is present."""
@@ -482,8 +488,10 @@ class DialogueStateTracker:
         entity_role: Optional[Text] = None,
         entity_group: Optional[Text] = None,
     ) -> Iterator[Text]:
-        """Get entity values found for the passed entity type and optional role and
-        group in latest message.
+        """Get entity values for latest message.
+
+        Returns entity values found for the passed entity type and
+        optional role and group in latest message.
 
         If you are only interested in the first entity of a given type use
         `next(tracker.get_latest_entity_values(`"`my_entity_name`"`), None)`.
@@ -556,7 +564,6 @@ class DialogueStateTracker:
         tracker = self.init_copy()
 
         for event in self.applied_events(True):
-
             if isinstance(event, ActionExecuted):
                 yield tracker, event.hide_rule_turn
 
@@ -718,7 +725,7 @@ class DialogueStateTracker:
 
     def copy(self) -> "DialogueStateTracker":
         """Creates a duplicate of this tracker."""
-        return self.travel_back_in_time(float("inf"))
+        return copy.deepcopy(self)
 
     def travel_back_in_time(self, target_time: float) -> "DialogueStateTracker":
         """Creates a new tracker with a state at a specific timestamp.
@@ -999,8 +1006,9 @@ class DialogueStateTracker:
         flows: FlowsList,
         max_turns: Optional[int] = 20,
     ) -> FlowsList:
-        """
-        Retrieves a list of flows that have been started in the past within a given
+        """Retrieves a list of previously started flows.
+
+        Returned flows have been started in the past within a given
         number of conversation turns.
 
         Args:
@@ -1015,7 +1023,6 @@ class DialogueStateTracker:
 
         # cycle through events in reverse order (newest events are appended at the end)
         for event in reversed(self.events):
-
             # check for FlowStarted event and append flow if it's in the flows lists
             if (
                 isinstance(event, FlowStarted)
@@ -1033,8 +1040,9 @@ class DialogueStateTracker:
         return FlowsList(underlying_flows=list(previously_started_flows.values()))
 
     def get_startable_flows(self, flows: FlowsList) -> FlowsList:
-        """
-        Retrieves a list of flows that are startable given the current
+        """Retrieves a list of flows that can be started.
+
+        Returned flows are startable given the current
         state (context and slot values) of the tracker.
 
         Args:
@@ -1048,9 +1056,15 @@ class DialogueStateTracker:
         slots = self.slots
         return flows.get_startable_flows(context, slots)
 
+    @property
+    def has_active_user_flow(self) -> bool:
+        from rasa.dialogue_understanding.stack.utils import top_user_flow_frame
+
+        top_relevant_frame = top_user_flow_frame(self.stack)
+        return bool(top_relevant_frame and top_relevant_frame.flow_id)
+
     def get_active_flows(self, flows: FlowsList) -> FlowsList:
-        """
-        Retrieve a list of all currently active flows.
+        """Retrieve a list of all currently active flows.
 
         Args:
             flows: list of flows to check against for active flows.
@@ -1083,11 +1097,15 @@ class TrackerEventDiffEngine:
     def event_difference(
         original: DialogueStateTracker, tracker: DialogueStateTracker
     ) -> List[Event]:
-        """Returns all events from the new tracker which are not present
-        in the original tracker.
+        """Find all events in the tracker not present in the original tracker.
 
         Args:
+            original: Original tracker to compare against.
             tracker: Tracker containing events from the current conversation session.
+
+        Returns:
+            List of events from the new tracker which are not present
+            in the original tracker.
         """
         offset = len(original.events) if original else 0
         events = tracker.events

rasa/shared/core/training_data/loading.py

@@ -74,7 +74,6 @@ def load_data_from_files(
     story_steps = []
 
     for story_file in story_files:
-
         reader = _get_reader(story_file, domain)
 
         steps = reader.read_from_file(story_file)

rasa/shared/core/training_data/story_reader/story_reader.py

@@ -83,8 +83,9 @@ class StoryReader:
         )
         if parsed_events is None:
             raise StoryParseError(
-                "Unknown event '{}'. It is Neither an event "
-                "nor an action).".format(event_name)
+                "Unknown event '{}'. It is Neither an event nor an action).".format(
+                    event_name
+                )
             )
 
         return parsed_events
@@ -110,7 +111,6 @@ class StoryReader:
     def _add_checkpoint(
         self, name: Text, conditions: Optional[Dict[Text, Any]]
     ) -> None:
-
         # Ensure story part already has a name
         if not self.current_step_builder:
             raise StoryParseError(

rasa/shared/core/training_data/story_reader/yaml_story_reader.py

@@ -87,6 +87,14 @@ CORE_SCHEMA_FILE = "shared/utils/schemas/stories.yml"
 DEFAULT_VALUE_TEXT_SLOTS = "filled"
 DEFAULT_VALUE_LIST_SLOTS = [DEFAULT_VALUE_TEXT_SLOTS]
 
+INTENT_ENTITIES_PATTERN = (
+    f"^{INTENT_MESSAGE_PREFIX}"
+    f"(?P<{INTENT_NAME_KEY}>[^{{@]+)"  # "{{" is a masked "{" in an f-string
+    f"(?P<{PREDICTED_CONFIDENCE_KEY}>@[0-9.]+)?"
+    f"(?P<{ENTITIES}>{{.+}})?"  # "{{" is a masked "{" in an f-string
+    f"(?P<rest>.*)"
+)
+
 
 class YAMLStoryReader(StoryReader):
     """Class that reads Core training data and rule data in YAML format."""
@@ -444,7 +452,7 @@ class YAMLStoryReader(StoryReader):
                 f"{self._get_item_title()}:\n"
                 f"User intent '{user_intent}' is a full retrieval intent. "
                 f"Stories shouldn't contain full retrieval intents. "
-                f"Rasa Open Source will only use base intent '{base_intent}' "
+                f"Rasa Pro will only use base intent '{base_intent}' "
                 f"for training.",
                 docs=self._get_docs_link(),
             )
@@ -482,7 +490,7 @@ class YAMLStoryReader(StoryReader):
 
     @staticmethod
     def _parse_raw_entities(
-        raw_entities: Union[List[Dict[Text, Text]], List[Text]]
+        raw_entities: Union[List[Dict[Text, Text]], List[Text]],
     ) -> List[Dict[Text, Optional[Text]]]:
         final_entities = []
         for entity in raw_entities:
@@ -556,7 +564,6 @@ class YAMLStoryReader(StoryReader):
         return default_value
 
     def _parse_action(self, step: Dict[Text, Any]) -> None:
-
         action_name = step.get(KEY_ACTION, "")
         if not action_name:
             rasa.shared.utils.io.raise_warning(
@@ -582,7 +589,6 @@ class YAMLStoryReader(StoryReader):
         self._add_event(ActiveLoop.type_name, {LOOP_NAME: active_loop_name})
 
     def _parse_checkpoint(self, step: Dict[Text, Any]) -> None:
-
         checkpoint_name = step.get(KEY_CHECKPOINT, "")
         slots = step.get(KEY_CHECKPOINT_SLOTS, [])
 
@@ -611,13 +617,7 @@ class YAMLStoryReader(StoryReader):
         Returns:
             pattern with named groups
         """
-        return re.compile(
-            f"^{INTENT_MESSAGE_PREFIX}"
-            f"(?P<{INTENT_NAME_KEY}>[^{{@]+)"  # "{{" is a masked "{" in an f-string
-            f"(?P<{PREDICTED_CONFIDENCE_KEY}>@[0-9.]+)?"
-            f"(?P<{ENTITIES}>{{.+}})?"  # "{{" is a masked "{" in an f-string
-            f"(?P<rest>.*)"
-        )
+        return re.compile(INTENT_ENTITIES_PATTERN)
 
     @staticmethod
     def unpack_regex_message(