rasa-pro 3.12.0.dev13__py3-none-any.whl → 3.12.0rc2__py3-none-any.whl

rasa/core/nlg/translate.py

@@ -0,0 +1,55 @@
+from typing import Any, Dict, List, Optional, Text
+
+from rasa.engine.language import Language
+from rasa.shared.core.flows.constants import KEY_TRANSLATION
+
+
+def get_translated_text(
+    text: Optional[Text],
+    translation: Dict[Text, Any],
+    language: Optional[Language] = None,
+) -> Optional[Text]:
+    """Get the translated text from the message.
+
+    Args:
+        text: The default text to use if no translation is found.
+        translation: The translations for the text.
+        language: The language to use for the translation.
+
+    Returns:
+        The translated text if found, otherwise the default text.
+    """
+    language_code = language.code if language else None
+    return translation.get(language_code, text)
+
+
+def get_translated_buttons(
+    buttons: Optional[List[Dict[Text, Any]]], language: Optional[Language] = None
+) -> Optional[List[Dict[Text, Any]]]:
+    """Get the translated buttons from the message.
+
+    Args:
+        buttons: The default buttons to use if no translation is found.
+        language: The language to use for the translation.
+
+    Returns:
+        The translated buttons if found; otherwise, the default buttons.
+    """
+    if buttons is None:
+        return None
+
+    language_code = language.code if language else None
+    translated_buttons = []
+    for button in buttons:
+        translation = button.get(KEY_TRANSLATION, {})
+        language_translation = translation.get(language_code, {})
+
+        # Maintain the original key order to ensure
+        # accurate comparisons of BotUtter events.
+        translated_button = {
+            key: language_translation.get(key, button.get(key))
+            for key, value in button.items()
+            if key != KEY_TRANSLATION
+        }
+        translated_buttons.append(translated_button)
+    return translated_buttons

rasa/core/policies/enterprise_search_prompt_with_citation_template.jinja2

@@ -4,7 +4,7 @@ If the answer is not known or cannot be determined from the provided documents o
 Use the following documents to answer the question:
 {% for doc in docs %}
 {{ loop.cycle("*")}}. {{ doc.metadata }}
-{{ doc.page_content }}
+{{ doc.text }}
 {% endfor %}
 
 {% if citation_enabled %}

rasa/core/policies/flows/flow_executor.py

@@ -85,9 +85,8 @@ from rasa.shared.core.flows.steps import (
     NoOperationFlowStep,
     SetSlotsFlowStep,
 )
-from rasa.shared.core.flows.steps.collect import SlotRejection
 from rasa.shared.core.flows.steps.constants import START_STEP
-from rasa.shared.core.slots import Slot
+from rasa.shared.core.slots import Slot, SlotRejection
 from rasa.shared.core.trackers import (
     DialogueStateTracker,
 )
@@ -243,7 +242,10 @@ def events_for_collect_step_execution(
 
 
 def trigger_pattern_continue_interrupted(
-    current_frame: DialogueStackFrame, stack: DialogueStack, flows: FlowsList
+    current_frame: DialogueStackFrame,
+    stack: DialogueStack,
+    flows: FlowsList,
+    tracker: DialogueStateTracker,
 ) -> List[Event]:
     """Trigger the pattern to continue an interrupted flow if needed."""
     events: List[Event] = []
@@ -266,7 +268,9 @@ def trigger_pattern_continue_interrupted(
     ):
         stack.push(
             ContinueInterruptedPatternFlowStackFrame(
-                previous_flow_name=interrupted_user_flow.readable_name(),
+                previous_flow_name=interrupted_user_flow.readable_name(
+                    language=tracker.current_language
+                ),
             )
         )
         events.append(
@@ -283,8 +287,13 @@ def trigger_pattern_clarification(
     if not isinstance(current_frame, UserFlowStackFrame):
         return None
 
-    if current_frame.frame_type == FlowStackFrameType.CALL:
-        # we want to return to the flow that called the current flow
+    if current_frame.frame_type in [
+        FlowStackFrameType.CALL,
+        FlowStackFrameType.INTERRUPT,
+    ]:
+        # we want to return to the flow that called
+        # the current flow or the flow that was interrupted
+        # by the current flow
         return None
 
     pending_flows = [
@@ -309,6 +318,9 @@ def trigger_pattern_completed(
         or isinstance(current_frame, SearchPatternFlowStackFrame)
     ):
         completed_flow = current_frame.flow(flows)
+        if not completed_flow.run_pattern_completed:
+            return
+
         completed_flow_name = completed_flow.readable_name() if completed_flow else None
         stack.push(
             CompletedPatternFlowStackFrame(
@@ -670,7 +682,7 @@ def _run_end_step(
         trigger_pattern_clarification(current_frame, stack, flows)
     else:
         resumed_events = trigger_pattern_continue_interrupted(
-            current_frame, stack, flows
+            current_frame, stack, flows, tracker
         )
     reset_events: List[Event] = reset_scoped_slots(current_frame, flow, tracker)
     return ContinueFlowWithNextStep(

rasa/core/processor.py

@@ -25,6 +25,7 @@ from rasa.core.channels.channel import (
     OutputChannel,
     UserMessage,
 )
+from rasa.core.constants import KEY_IS_CALM_SYSTEM, KEY_IS_COEXISTENCE_ASSISTANT
 from rasa.core.http_interpreter import RasaNLUHttpInterpreter
 from rasa.core.lock_store import LockStore
 from rasa.core.nlg import NaturalLanguageGenerator
@@ -35,6 +36,12 @@ from rasa.dialogue_understanding.commands import (
     NoopCommand,
     SetSlotCommand,
 )
+from rasa.dialogue_understanding.commands.utils import (
+    create_validate_frames_from_slot_set_events,
+)
+from rasa.dialogue_understanding.patterns.validate_slot import (
+    ValidateSlotPatternFlowStackFrame,
+)
 from rasa.dialogue_understanding.utils import add_commands_to_message_parse_data
 from rasa.engine import loader
 from rasa.engine.constants import (
@@ -201,10 +208,7 @@ class MessageProcessor:
             )
             return None
 
-        if not self.message_contains_commands(tracker.latest_message):
-            tracker = await self.run_action_extract_slots(
-                message.output_channel, tracker
-            )
+        tracker = await self.run_action_extract_slots(message.output_channel, tracker)
 
         await self._run_prediction_loop(message.output_channel, tracker)
 
@@ -218,7 +222,9 @@ class MessageProcessor:
         return None
 
     async def run_action_extract_slots(
-        self, output_channel: OutputChannel, tracker: DialogueStateTracker
+        self,
+        output_channel: OutputChannel,
+        tracker: DialogueStateTracker,
     ) -> DialogueStateTracker:
         """Run action to extract slots and update the tracker accordingly.
 
@@ -233,6 +239,10 @@ class MessageProcessor:
             ACTION_EXTRACT_SLOTS, self.domain, self.action_endpoint
         )
         metadata = await self._add_flows_to_metadata()
+        metadata[KEY_IS_CALM_SYSTEM] = self.message_contains_commands(
+            tracker.latest_message
+        )
+        metadata[KEY_IS_COEXISTENCE_ASSISTANT] = self._is_coexistence_assistant(tracker)
 
         extraction_events = await action_extract_slots.run(
             output_channel, self.nlg, tracker, self.domain, metadata
@@ -1251,6 +1261,12 @@ class MessageProcessor:
         # events and return values are used to update
         # the tracker state after an action has been taken
         try:
+            validate_frames: List[ValidateSlotPatternFlowStackFrame] = []
+            # check if the last action was a correction action
+            # before validating the corrected slots
+            if tracker.latest_action_name == ACTION_CORRECT_FLOW_SLOT:
+                tracker, validate_frames = self.validate_corrected_slots(tracker)
+
             # Use temporary tracker as we might need to discard the policy events in
             # case of a rejection.
             temporary_tracker = tracker.copy()
@@ -1262,6 +1278,12 @@ class MessageProcessor:
 
                 if isinstance(action, FormAction):
                     flows_metadata = await self._add_flows_to_metadata()
+                    flows_metadata[KEY_IS_CALM_SYSTEM] = self.message_contains_commands(
+                        temporary_tracker.latest_message
+                    )
+                    flows_metadata[KEY_IS_COEXISTENCE_ASSISTANT] = (
+                        self._is_coexistence_assistant(temporary_tracker)
+                    )
                     metadata = prediction.action_metadata or {}
                     metadata.update(flows_metadata)
 
@@ -1276,6 +1298,14 @@ class MessageProcessor:
                 events = await action.run(
                     output_channel, nlg, temporary_tracker, self.domain
                 )
+
+            if validate_frames:
+                stack = tracker.stack
+                for frame in validate_frames:
+                    stack.push(frame)
+                new_events = tracker.create_stack_updated_events(stack)
+                tracker.update_with_events(new_events)
+
             self._log_action_and_events_on_tracker(tracker, action, events, prediction)
         except ActionExecutionRejection:
             events = [
@@ -1479,18 +1509,50 @@ class MessageProcessor:
         Returns:
             bool: True if any node in the graph schema uses `FlowPolicy`.
         """
+        flow_policy_class_path = "rasa.core.policies.flow_policy.FlowPolicy"
+        return self._is_component_present_in_graph_nodes(flow_policy_class_path)
+
+    @staticmethod
+    def _is_coexistence_assistant(tracker: DialogueStateTracker) -> bool:
+        """Inspect the tracker to decide if we are in coexistence.
+
+        Returns:
+            bool: True if the tracker contains the routine slot.
+        """
+        return tracker.slots.get(ROUTE_TO_CALM_SLOT) is not None
+
+    def _is_component_present_in_graph_nodes(self, component_path: Text) -> bool:
+        """Check if a component is present in the graph nodes.
+
+        Args:
+            component_path: The path of the component to check for.
+
+        Returns:
+            `True` if the component is present in the graph nodes, `False` otherwise.
+        """
         # Get the graph schema's nodes from the graph runner.
         nodes: dict[str, Any] = self.graph_runner._graph_schema.nodes  # type: ignore[attr-defined]
 
-        flow_policy_class_path = "rasa.core.policies.flow_policy.FlowPolicy"
-        # Iterate over the nodes and check if any node uses `FlowPolicy`.
         for node_name, schema_node in nodes.items():
             if (
                 schema_node.uses is not None
                 and f"{schema_node.uses.__module__}.{schema_node.uses.__name__}"
-                == flow_policy_class_path
+                == component_path
             ):
                 return True
 
-        # Return False if no node is found using `FlowPolicy`.
         return False
+
+    def validate_corrected_slots(
+        self,
+        tracker: DialogueStateTracker,
+    ) -> Tuple[DialogueStateTracker, List[ValidateSlotPatternFlowStackFrame]]:
+        """Validate the slots that were corrected in the tracker."""
+        prior_tracker_events = list(reversed(tracker.events))
+        tracker, validate_frames = create_validate_frames_from_slot_set_events(
+            tracker,
+            prior_tracker_events,
+            should_break=True,
+        )
+
+        return tracker, validate_frames

rasa/dialogue_understanding/commands/can_not_handle_command.py

@@ -5,6 +5,10 @@ from dataclasses import dataclass
 from typing import Any, Dict, List, Optional, Text
 
 from rasa.dialogue_understanding.commands.command import Command
+from rasa.dialogue_understanding.commands.command_syntax_manager import (
+    CommandSyntaxManager,
+    CommandSyntaxVersion,
+)
 from rasa.dialogue_understanding.patterns.cannot_handle import (
     CannotHandlePatternFlowStackFrame,
 )
@@ -74,7 +78,14 @@ class CannotHandleCommand(Command):
 
     def to_dsl(self) -> str:
         """Converts the command to a DSL string."""
-        return "CannotHandle()"
+        mapper = {
+            CommandSyntaxVersion.v1: "CannotHandle()",
+            CommandSyntaxVersion.v2: "cannot handle",
+        }
+        return mapper.get(
+            CommandSyntaxManager.get_syntax_version(),
+            mapper[CommandSyntaxManager.get_default_syntax_version()],
+        )
 
     @classmethod
     def from_dsl(cls, match: re.Match, **kwargs: Any) -> CannotHandleCommand:
@@ -86,4 +97,11 @@ class CannotHandleCommand(Command):
 
     @staticmethod
     def regex_pattern() -> str:
-        return r"CannotHandle\(\)"
+        mapper = {
+            CommandSyntaxVersion.v1: r"CannotHandle\(\)",
+            CommandSyntaxVersion.v2: r"""^[\s\W\d]*cannot handle['"`]*$""",
+        }
+        return mapper.get(
+            CommandSyntaxManager.get_syntax_version(),
+            mapper[CommandSyntaxManager.get_default_syntax_version()],
+        )

rasa/dialogue_understanding/commands/cancel_flow_command.py

@@ -8,12 +8,14 @@ from typing import Any, Dict, List
 import structlog
 
 from rasa.dialogue_understanding.commands.command import Command
+from rasa.dialogue_understanding.commands.command_syntax_manager import (
+    CommandSyntaxManager,
+    CommandSyntaxVersion,
+)
 from rasa.dialogue_understanding.patterns.cancel import CancelPatternFlowStackFrame
 from rasa.dialogue_understanding.patterns.clarify import ClarifyPatternFlowStackFrame
 from rasa.dialogue_understanding.stack.dialogue_stack import DialogueStack
-from rasa.dialogue_understanding.stack.frames import (
-    UserFlowStackFrame,
-)
+from rasa.dialogue_understanding.stack.frames import UserFlowStackFrame
 from rasa.dialogue_understanding.stack.frames.flow_stack_frame import FlowStackFrameType
 from rasa.dialogue_understanding.stack.utils import top_user_flow_frame
 from rasa.shared.core.events import Event, FlowCancelled
@@ -111,7 +113,9 @@ class CancelFlowCommand(Command):
 
         stack.push(
             CancelPatternFlowStackFrame(
-                canceled_name=current_flow.readable_name(),
+                canceled_name=current_flow.readable_name(
+                    language=tracker.current_language
+                ),
                 canceled_frames=canceled_frames,
             )
         )
@@ -144,7 +148,14 @@ class CancelFlowCommand(Command):
 
     def to_dsl(self) -> str:
         """Converts the command to a DSL string."""
-        return "CancelFlow()"
+        mapper = {
+            CommandSyntaxVersion.v1: "CancelFlow()",
+            CommandSyntaxVersion.v2: "cancel flow",
+        }
+        return mapper.get(
+            CommandSyntaxManager.get_syntax_version(),
+            mapper[CommandSyntaxManager.get_default_syntax_version()],
+        )
 
     @classmethod
     def from_dsl(cls, match: re.Match, **kwargs: Any) -> CancelFlowCommand:
@@ -153,7 +164,14 @@ class CancelFlowCommand(Command):
 
     @staticmethod
     def regex_pattern() -> str:
-        return r"CancelFlow\(\)"
+        mapper = {
+            CommandSyntaxVersion.v1: r"CancelFlow\(\)",
+            CommandSyntaxVersion.v2: r"""^[\s\W\d]*cancel flow['"`]*$""",
+        }
+        return mapper.get(
+            CommandSyntaxManager.get_syntax_version(),
+            mapper[CommandSyntaxManager.get_default_syntax_version()],
+        )
 
 
 def cancel_all_pending_clarification_options(

rasa/dialogue_understanding/commands/change_flow_command.py

@@ -5,6 +5,10 @@ from dataclasses import dataclass
 from typing import Any, Dict, List
 
 from rasa.dialogue_understanding.commands.command import Command
+from rasa.dialogue_understanding.commands.command_syntax_manager import (
+    CommandSyntaxManager,
+    CommandSyntaxVersion,
+)
 from rasa.shared.core.events import Event
 from rasa.shared.core.flows import FlowsList
 from rasa.shared.core.trackers import DialogueStateTracker
@@ -48,7 +52,14 @@ class ChangeFlowCommand(Command):
 
     def to_dsl(self) -> str:
         """Converts the command to a DSL string."""
-        return "ChangeFlow()"
+        mapper = {
+            CommandSyntaxVersion.v1: "ChangeFlow()",
+            CommandSyntaxVersion.v2: "change",
+        }
+        return mapper.get(
+            CommandSyntaxManager.get_syntax_version(),
+            mapper[CommandSyntaxManager.get_default_syntax_version()],
+        )
 
     @staticmethod
     def from_dsl(match: re.Match, **kwargs: Any) -> ChangeFlowCommand:
@@ -57,4 +68,11 @@ class ChangeFlowCommand(Command):
 
     @staticmethod
     def regex_pattern() -> str:
-        return r"ChangeFlow\(\)"
+        mapper = {
+            CommandSyntaxVersion.v1: r"ChangeFlow\(\)",
+            CommandSyntaxVersion.v2: r"""^[\s\W\d]*change['"`]*$""",
+        }
+        return mapper.get(
+            CommandSyntaxManager.get_syntax_version(),
+            mapper[CommandSyntaxManager.get_default_syntax_version()],
+        )

rasa/dialogue_understanding/commands/chit_chat_answer_command.py

@@ -4,6 +4,10 @@ import re
 from dataclasses import dataclass
 from typing import Any, Dict, List
 
+from rasa.dialogue_understanding.commands.command_syntax_manager import (
+    CommandSyntaxManager,
+    CommandSyntaxVersion,
+)
 from rasa.dialogue_understanding.commands.free_form_answer_command import (
     FreeFormAnswerCommand,
 )
@@ -59,7 +63,14 @@ class ChitChatAnswerCommand(FreeFormAnswerCommand):
 
     def to_dsl(self) -> str:
         """Converts the command to a DSL string."""
-        return "ChitChat()"
+        mapper = {
+            CommandSyntaxVersion.v1: "ChitChat()",
+            CommandSyntaxVersion.v2: "offtopic reply",
+        }
+        return mapper.get(
+            CommandSyntaxManager.get_syntax_version(),
+            mapper[CommandSyntaxManager.get_default_syntax_version()],
+        )
 
     @classmethod
     def from_dsl(cls, match: re.Match, **kwargs: Any) -> ChitChatAnswerCommand:
@@ -68,4 +79,11 @@ class ChitChatAnswerCommand(FreeFormAnswerCommand):
 
     @staticmethod
     def regex_pattern() -> str:
-        return r"ChitChat\(\)"
+        mapper = {
+            CommandSyntaxVersion.v1: r"ChitChat\(\)",
+            CommandSyntaxVersion.v2: r"""^[\s\W\d]*offtopic reply['"`]*$""",
+        }
+        return mapper.get(
+            CommandSyntaxManager.get_syntax_version(),
+            mapper[CommandSyntaxManager.get_default_syntax_version()],
+        )

rasa/dialogue_understanding/commands/clarify_command.py

@@ -7,6 +7,10 @@ from typing import Any, Dict, List, Optional
 import structlog
 
 from rasa.dialogue_understanding.commands.command import Command
+from rasa.dialogue_understanding.commands.command_syntax_manager import (
+    CommandSyntaxManager,
+    CommandSyntaxVersion,
+)
 from rasa.dialogue_understanding.commands.utils import extract_cleaned_options
 from rasa.dialogue_understanding.patterns.clarify import ClarifyPatternFlowStackFrame
 from rasa.shared.core.events import Event
@@ -74,7 +78,13 @@ class ClarifyCommand(Command):
 
         stack = tracker.stack
         relevant_flows = [all_flows.flow_by_id(opt) for opt in clean_options]
-        names = [flow.readable_name() for flow in relevant_flows if flow is not None]
+
+        names = [
+            flow.readable_name(language=tracker.current_language)
+            for flow in relevant_flows
+            if flow is not None
+        ]
+
         stack.push(ClarifyPatternFlowStackFrame(names=names))
         return tracker.create_stack_updated_events(stack)
 
@@ -89,7 +99,14 @@ class ClarifyCommand(Command):
 
     def to_dsl(self) -> str:
         """Converts the command to a DSL string."""
-        return f"Clarify({', '.join(self.options)})"
+        mapper = {
+            CommandSyntaxVersion.v1: f"Clarify({', '.join(self.options)})",
+            CommandSyntaxVersion.v2: f"disambiguate flows {' '.join(self.options)}",
+        }
+        return mapper.get(
+            CommandSyntaxManager.get_syntax_version(),
+            mapper[CommandSyntaxManager.get_default_syntax_version()],
+        )
 
     @classmethod
     def from_dsl(cls, match: re.Match, **kwargs: Any) -> Optional[ClarifyCommand]:
@@ -99,4 +116,13 @@ class ClarifyCommand(Command):
 
     @staticmethod
     def regex_pattern() -> str:
-        return r"Clarify\(([\"\'a-zA-Z0-9_, ]*)\)"
+        mapper = {
+            CommandSyntaxVersion.v1: r"Clarify\(([\"\'a-zA-Z0-9_, ]*)\)",
+            CommandSyntaxVersion.v2: (
+                r"""^[\s\W\d]*disambiguate flows (["'a-zA-Z0-9_, ]*)['"`]*$"""
+            ),
+        }
+        return mapper.get(
+            CommandSyntaxManager.get_syntax_version(),
+            mapper[CommandSyntaxManager.get_default_syntax_version()],
+        )

rasa/dialogue_understanding/commands/command.py

@@ -1,9 +1,8 @@
 from __future__ import annotations
 
 import dataclasses
-import re
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List
 
 import rasa.shared.utils.common
 from rasa.shared.core.events import Event
@@ -85,17 +84,3 @@ class Command:
             The events to apply to the tracker.
         """
         raise NotImplementedError()
-
-    def to_dsl(self) -> str:
-        """Converts the command to a DSL string."""
-        raise NotImplementedError()
-
-    @classmethod
-    def from_dsl(cls, match: re.Match, **kwargs: Any) -> Optional[Command]:
-        """Converts the DSL string to a command."""
-        raise NotImplementedError()
-
-    @staticmethod
-    def regex_pattern() -> str:
-        """Returns the regex pattern for the command."""
-        raise NotImplementedError()

rasa/dialogue_understanding/commands/command_syntax_manager.py

@@ -0,0 +1,55 @@
+from enum import Enum
+from typing import Optional
+
+import structlog
+
+
+class CommandSyntaxVersion(Enum):
+    """Defines different syntax versions for commands."""
+
+    v1 = "v1"
+    v2 = "v2"
+
+
+structlogger = structlog.get_logger()
+
+
+class CommandSyntaxManager:
+    """A class to manage the command syntax version. It is used to set and get the
+    command syntax version. This class provides a way to introduce new syntax versions
+    for commands in the future. Hence, it is for internal use only.
+    """
+
+    _version = None  # Directly store the version as a class attribute
+
+    @classmethod
+    def set_syntax_version(cls, version: CommandSyntaxVersion) -> None:
+        """Sets the command syntax version on the class itself.
+        This method is called only once at the time of LLMCommandGenerator
+        initialization to set the command syntax version, which ensures that the command
+        syntax version remains consistent throughout the lifetime of the generator.
+        """
+        if cls._version:
+            structlogger.debug(
+                "command_syntax_manager.syntax_version_already_set",
+                event_info=(
+                    f"The command syntax version has already been set. Overwriting "
+                    f"the existing version with the new version - {version}."
+                ),
+            )
+        cls._version = version
+
+    @classmethod
+    def get_syntax_version(cls) -> Optional[CommandSyntaxVersion]:
+        """Fetches the stored command syntax version."""
+        return cls._version
+
+    @staticmethod
+    def get_default_syntax_version() -> CommandSyntaxVersion:
+        """Returns the default command syntax version."""
+        return CommandSyntaxVersion.v1
+
+    @classmethod
+    def reset_syntax_version(cls) -> None:
+        """Resets the command syntax version. Implemented for use in testing."""
+        cls._version = None

rasa/dialogue_understanding/commands/handle_digressions_command.py

@@ -14,7 +14,6 @@ from rasa.dialogue_understanding.patterns.handle_digressions import (
 )
 from rasa.dialogue_understanding.stack.utils import (
     top_flow_frame,
-    user_flows_on_the_stack,
 )
 from rasa.shared.core.events import Event
 from rasa.shared.core.flows import FlowsList
@@ -71,12 +70,7 @@ class HandleDigressionsCommand(Command):
         stack = tracker.stack
         original_stack = original_tracker.stack
 
-        if self.flow in user_flows_on_the_stack(stack):
-            structlogger.debug(
-                "command_executor.skip_command.already_started_flow", command=self
-            )
-            return []
-        elif self.flow not in all_flows.flow_ids:
+        if self.flow not in all_flows.flow_ids:
             structlogger.debug(
                 "command_executor.push_cannot_handle.start_invalid_flow_id",
                 command=self,

rasa/dialogue_understanding/commands/human_handoff_command.py

@@ -7,6 +7,10 @@ from typing import Any, Dict, List
 import structlog
 
 from rasa.dialogue_understanding.commands.command import Command
+from rasa.dialogue_understanding.commands.command_syntax_manager import (
+    CommandSyntaxManager,
+    CommandSyntaxVersion,
+)
 from rasa.dialogue_understanding.patterns.human_handoff import (
     HumanHandoffPatternFlowStackFrame,
 )
@@ -66,7 +70,14 @@ class HumanHandoffCommand(Command):
 
     def to_dsl(self) -> str:
         """Converts the command to a DSL string."""
-        return "HumanHandoff()"
+        mapper = {
+            CommandSyntaxVersion.v1: "HumanHandoff()",
+            CommandSyntaxVersion.v2: "hand over",
+        }
+        return mapper.get(
+            CommandSyntaxManager.get_syntax_version(),
+            mapper[CommandSyntaxManager.get_default_syntax_version()],
+        )
 
     @classmethod
     def from_dsl(cls, match: re.Match, **kwargs: Any) -> HumanHandoffCommand:
@@ -75,4 +86,11 @@ class HumanHandoffCommand(Command):
 
     @staticmethod
     def regex_pattern() -> str:
-        return r"HumanHandoff\(\)"
+        mapper = {
+            CommandSyntaxVersion.v1: r"HumanHandoff\(\)",
+            CommandSyntaxVersion.v2: r"""^[\s\W\d]*hand over['"`]*$""",
+        }
+        return mapper.get(
+            CommandSyntaxManager.get_syntax_version(),
+            mapper[CommandSyntaxManager.get_default_syntax_version()],
+        )