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

rasa/dialogue_understanding/commands/knowledge_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 KnowledgeAnswerCommand(FreeFormAnswerCommand):
 
     def to_dsl(self) -> str:
         """Converts the command to a DSL string."""
-        return "SearchAndReply()"
+        mapper = {
+            CommandSyntaxVersion.v1: "SearchAndReply()",
+            CommandSyntaxVersion.v2: "provide info",
+        }
+        return mapper.get(
+            CommandSyntaxManager.get_syntax_version(),
+            mapper[CommandSyntaxManager.get_default_syntax_version()],
+        )
 
     @classmethod
     def from_dsl(cls, match: re.Match, **kwargs: Any) -> KnowledgeAnswerCommand:
@@ -68,4 +79,11 @@ class KnowledgeAnswerCommand(FreeFormAnswerCommand):
 
     @staticmethod
     def regex_pattern() -> str:
-        return r"SearchAndReply\(\)"
+        mapper = {
+            CommandSyntaxVersion.v1: r"SearchAndReply\(\)",
+            CommandSyntaxVersion.v2: r"""^[\s\W\d]*provide info['"`]*$""",
+        }
+        return mapper.get(
+            CommandSyntaxManager.get_syntax_version(),
+            mapper[CommandSyntaxManager.get_default_syntax_version()],
+        )

rasa/dialogue_understanding/commands/prompt_command.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+import re
+from typing import Any, Dict, List, Optional, Protocol, runtime_checkable
+
+from rasa.shared.core.events import Event
+from rasa.shared.core.flows import FlowsList
+from rasa.shared.core.trackers import DialogueStateTracker
+
+
+@runtime_checkable
+class PromptCommand(Protocol):
+    """
+    A protocol for commands predicted by the LLM model and incorporated into the prompt.
+    """
+
+    @classmethod
+    def command(cls) -> str:
+        """
+        Returns the command name.
+
+        This class method should be implemented to return the name of the command.
+        """
+        ...
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> PromptCommand:
+        """
+        Converts the dictionary to a command.
+
+        This class method should be implemented to create a command instance from the
+        given dictionary.
+        """
+        ...
+
+    def run_command_on_tracker(
+        self,
+        tracker: DialogueStateTracker,
+        all_flows: FlowsList,
+        original_tracker: DialogueStateTracker,
+    ) -> List[Event]:
+        """
+        Runs the command on the tracker.
+
+        This method should be implemented to execute the command on the given tracker.
+        """
+        ...
+
+    def __hash__(self) -> int:
+        """
+        Returns the hash of the command.
+
+        This method should be implemented to return the hash of the command.
+        Useful for comparing commands and storing them in sets.
+        """
+        ...
+
+    def __eq__(self, other: object) -> bool:
+        """
+        Compares the command with another object.
+
+        This method should be implemented to compare the command with another object.
+        """
+        ...
+
+    def to_dsl(self) -> str:
+        """
+        Converts the command to a DSL string.
+
+        This method should be implemented to convert the command to a DSL string.
+        A DSL string is a string representation of the command that is used in the
+        prompt.
+        """
+        ...
+
+    @classmethod
+    def from_dsl(cls, match: re.Match, **kwargs: Any) -> Optional[PromptCommand]:
+        """
+        Converts the regex match to a command.
+
+        This class method should be implemented to create a command instance from the
+        given DSL string.
+        """
+        ...
+
+    @staticmethod
+    def regex_pattern() -> str:
+        """
+        Returns the regex pattern for the command.
+
+        This method should be implemented to return the regex pattern that matches the
+        command in the prompt.
+        """
+        ...

rasa/dialogue_understanding/commands/repeat_bot_messages_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.dialogue_understanding.patterns.repeat import (
     RepeatBotMessagesPatternFlowStackFrame,
 )
@@ -60,7 +64,14 @@ class RepeatBotMessagesCommand(Command):
 
     def to_dsl(self) -> str:
         """Converts the command to a DSL string."""
-        return "RepeatLastBotMessages()"
+        mapper = {
+            CommandSyntaxVersion.v1: "RepeatLastBotMessages()",
+            CommandSyntaxVersion.v2: "repeat message",
+        }
+        return mapper.get(
+            CommandSyntaxManager.get_syntax_version(),
+            mapper[CommandSyntaxManager.get_default_syntax_version()],
+        )
 
     @classmethod
     def from_dsl(cls, match: re.Match, **kwargs: Any) -> RepeatBotMessagesCommand:
@@ -69,4 +80,11 @@ class RepeatBotMessagesCommand(Command):
 
     @staticmethod
     def regex_pattern() -> str:
-        return r"RepeatLastBotMessages\(\)"
+        mapper = {
+            CommandSyntaxVersion.v1: r"RepeatLastBotMessages\(\)",
+            CommandSyntaxVersion.v2: r"""^[\s\W\d]*repeat message['"`]*$""",
+        }
+        return mapper.get(
+            CommandSyntaxManager.get_syntax_version(),
+            mapper[CommandSyntaxManager.get_default_syntax_version()],
+        )

rasa/dialogue_understanding/commands/set_slot_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.commands.utils import (
     clean_extracted_value,
     get_nullable_slot_value,
@@ -162,7 +166,14 @@ class SetSlotCommand(Command):
 
     def to_dsl(self) -> str:
         """Converts the command to a DSL string."""
-        return f"SetSlot({self.name}, {self.value})"
+        mapper = {
+            CommandSyntaxVersion.v1: f"SetSlot({self.name}, {self.value})",
+            CommandSyntaxVersion.v2: f"set slot {self.name} {self.value}",
+        }
+        return mapper.get(
+            CommandSyntaxManager.get_syntax_version(),
+            mapper[CommandSyntaxManager.get_default_syntax_version()],
+        )
 
     @classmethod
     def from_dsl(cls, match: re.Match, **kwargs: Any) -> SetSlotCommand:
@@ -173,4 +184,15 @@ class SetSlotCommand(Command):
 
     @staticmethod
     def regex_pattern() -> str:
-        return r"""SetSlot\(['"]?([a-zA-Z_][a-zA-Z0-9_-]*)['"]?, ?['"]?(.*)['"]?\)"""
+        mapper = {
+            CommandSyntaxVersion.v1: (
+                r"""SetSlot\(['"]?([a-zA-Z_][a-zA-Z0-9_-]*)['"]?, ?['"]?(.*)['"]?\)"""
+            ),
+            CommandSyntaxVersion.v2: (
+                r"""^[\s\W\d]*set slot ['"`]?([a-zA-Z_][a-zA-Z0-9_-]*)['"`]? ['"`]?(.+?)['"`]*$"""  # noqa: E501
+            ),
+        }
+        return mapper.get(
+            CommandSyntaxManager.get_syntax_version(),
+            mapper[CommandSyntaxManager.get_default_syntax_version()],
+        )

rasa/dialogue_understanding/commands/skip_question_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.skip_question import (
     SkipQuestionPatternFlowStackFrame,
 )
@@ -75,7 +79,14 @@ class SkipQuestionCommand(Command):
 
     def to_dsl(self) -> str:
         """Converts the command to a DSL string."""
-        return "SkipQuestion()"
+        mapper = {
+            CommandSyntaxVersion.v1: "SkipQuestion()",
+            CommandSyntaxVersion.v2: "skip question",
+        }
+        return mapper.get(
+            CommandSyntaxManager.get_syntax_version(),
+            mapper[CommandSyntaxManager.get_default_syntax_version()],
+        )
 
     @classmethod
     def from_dsl(cls, match: re.Match, **kwargs: Any) -> SkipQuestionCommand:
@@ -84,4 +95,11 @@ class SkipQuestionCommand(Command):
 
     @staticmethod
     def regex_pattern() -> str:
-        return r"SkipQuestion\(\)"
+        mapper = {
+            CommandSyntaxVersion.v1: r"SkipQuestion\(\)",
+            CommandSyntaxVersion.v2: r"""^[\s\W\d]*skip question['"`]*$""",
+        }
+        return mapper.get(
+            CommandSyntaxManager.get_syntax_version(),
+            mapper[CommandSyntaxManager.get_default_syntax_version()],
+        )

rasa/dialogue_understanding/commands/start_flow_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.patterns.clarify import FLOW_PATTERN_CLARIFICATION
 from rasa.dialogue_understanding.patterns.continue_interrupted import (
     ContinueInterruptedPatternFlowStackFrame,
@@ -119,7 +123,14 @@ class StartFlowCommand(Command):
 
     def to_dsl(self) -> str:
         """Converts the command to a DSL string."""
-        return f"StartFlow({self.flow})"
+        mapper = {
+            CommandSyntaxVersion.v1: f"StartFlow({self.flow})",
+            CommandSyntaxVersion.v2: f"start flow {self.flow}",
+        }
+        return mapper.get(
+            CommandSyntaxManager.get_syntax_version(),
+            mapper[CommandSyntaxManager.get_default_syntax_version()],
+        )
 
     @classmethod
     def from_dsl(cls, match: re.Match, **kwargs: Any) -> Optional[StartFlowCommand]:
@@ -128,7 +139,16 @@ class StartFlowCommand(Command):
 
     @staticmethod
     def regex_pattern() -> str:
-        return r"StartFlow\(['\"]?([a-zA-Z0-9_-]+)['\"]?\)"
+        mapper = {
+            CommandSyntaxVersion.v1: r"StartFlow\(['\"]?([a-zA-Z0-9_-]+)['\"]?\)",
+            CommandSyntaxVersion.v2: (
+                r"""^[\s\W\d]*start flow ['"`]?([a-zA-Z0-9_-]+)['"`]*"""
+            ),
+        }
+        return mapper.get(
+            CommandSyntaxManager.get_syntax_version(),
+            mapper[CommandSyntaxManager.get_default_syntax_version()],
+        )
 
     def change_flow_frame_position_in_the_stack(
         self, stack: DialogueStack, tracker: DialogueStateTracker

rasa/dialogue_understanding/commands/utils.py

@@ -1,7 +1,18 @@
-from typing import TYPE_CHECKING, List, Optional, Union
+from typing import TYPE_CHECKING, List, Optional, Tuple, Union
 
 import structlog
 
+from rasa.dialogue_understanding.patterns.validate_slot import (
+    ValidateSlotPatternFlowStackFrame,
+)
+from rasa.shared.constants import (
+    ACTION_ASK_PREFIX,
+    UTTER_ASK_PREFIX,
+)
+from rasa.shared.core.events import Event, SlotSet
+from rasa.shared.core.slots import Slot
+from rasa.shared.core.trackers import DialogueStateTracker
+
 if TYPE_CHECKING:
     from rasa.dialogue_understanding.commands import StartFlowCommand
     from rasa.shared.core.flows import FlowsList
@@ -25,10 +36,13 @@ def start_flow_by_name(
 
 def extract_cleaned_options(options_str: str) -> List[str]:
     """Extract and clean options from a string."""
+    delimiters = [",", " "]
+
+    for delimiter in delimiters:
+        options_str = options_str.replace(delimiter, " ")
+
     return sorted(
-        opt.strip().strip('"').strip("'")
-        for opt in options_str.split(",")
-        if opt.strip()
+        opt.strip().strip('"').strip("'") for opt in options_str.split() if opt.strip()
     )
 
 
@@ -62,3 +76,56 @@ def get_nullable_slot_value(slot_value: str) -> Union[str, None]:
         The slot value or None if the value is a none value.
     """
     return slot_value if not is_none_value(slot_value) else None
+
+
+def initialize_pattern_validate_slot(
+    slot: Slot,
+) -> Optional[ValidateSlotPatternFlowStackFrame]:
+    """Initialize the pattern to validate a slot value."""
+    if not slot.requires_validation():
+        return None
+
+    validation = slot.validation
+    slot_name = slot.name
+    return ValidateSlotPatternFlowStackFrame(
+        validate=slot_name,
+        refill_utter=validation.refill_utter or f"{UTTER_ASK_PREFIX}{slot_name}",  # type: ignore[union-attr]
+        refill_action=f"{ACTION_ASK_PREFIX}{slot_name}",
+        rejections=validation.rejections,  # type: ignore[union-attr]
+    )
+
+
+def create_validate_frames_from_slot_set_events(
+    tracker: DialogueStateTracker,
+    events: List[Event],
+    validate_frames: List[ValidateSlotPatternFlowStackFrame] = [],
+    should_break: bool = False,
+) -> Tuple[DialogueStateTracker, List[ValidateSlotPatternFlowStackFrame]]:
+    """Process SlotSet events and create validation frames.
+
+    Args:
+        tracker: The dialogue state tracker.
+        events: List of events to process.
+        should_break:  whether or not to break after the first non-SlotSet event.
+            if True, break out of the event loop as soon as the first non-SlotSet
+            event is encountered.
+            if False, continue processing the events until the end.
+
+    Returns:
+        Tuple of (updated tracker, list of validation frames).
+    """
+    for event in events:
+        if not isinstance(event, SlotSet):
+            if should_break:
+                # we want to only process the most recent SlotSet events
+                # so we break once we encounter a different event
+                break
+            continue
+
+        slot = tracker.slots.get(event.key)
+        frame = initialize_pattern_validate_slot(slot)
+
+        if frame:
+            validate_frames.append(frame)
+
+    return tracker, validate_frames

rasa/dialogue_understanding/generator/__init__.py

@@ -9,6 +9,7 @@ from rasa.dialogue_understanding.generator.multi_step.multi_step_llm_command_gen
     MultiStepLLMCommandGenerator,
 )
 from rasa.dialogue_understanding.generator.single_step.single_step_llm_command_generator import (  # noqa: E501
+    CompactLLMCommandGenerator,
     SingleStepLLMCommandGenerator,
 )
 
@@ -18,4 +19,5 @@ __all__ = [
     "LLMCommandGenerator",
     "MultiStepLLMCommandGenerator",
     "SingleStepLLMCommandGenerator",
+    "CompactLLMCommandGenerator",
 ]

rasa/dialogue_understanding/generator/command_parser.py

@@ -16,6 +16,7 @@ from rasa.dialogue_understanding.commands import (
     SkipQuestionCommand,
     StartFlowCommand,
 )
+from rasa.dialogue_understanding.commands.prompt_command import PromptCommand
 from rasa.dialogue_understanding.commands.utils import start_flow_by_name
 from rasa.shared.core.flows import FlowsList
 
@@ -41,8 +42,8 @@ def _get_compiled_pattern(pattern_str: str) -> re.Pattern:
 
 
 def _create_default_commands(
-    default_commands_to_remove: Union[List[Type[Command]], List[str]],
-) -> List[Type[Command]]:
+    default_commands_to_remove: Union[List[Type[PromptCommand]], List[str]],
+) -> List[Type[PromptCommand]]:
     """Return an updated list of default commands after removing the provided commands.
 
     Args:
@@ -64,11 +65,11 @@ def _create_default_commands(
 
 
 def _get_additional_parsing_logic(
-    command_clz: Type[Command],
-) -> Optional[Callable[[Command, FlowsList], Optional[Command]]]:
+    command_clz: Type[PromptCommand],
+) -> Optional[Callable[[PromptCommand, FlowsList], Optional[PromptCommand]]]:
     """Get additional parsing logic for a command."""
     command_to_parsing_fn_mapper: Dict[
-        Type[Command], Callable[..., Optional[Command]]
+        Type[PromptCommand], Callable[..., Optional[PromptCommand]]
     ] = {
         ClarifyCommand: _parse_clarify_command,
         SetSlotCommand: _parse_set_slot_command,
@@ -81,8 +82,10 @@ def parse_commands(
     actions: Optional[str],
     flows: FlowsList,
     is_handle_flows_prompt: bool = False,
-    additional_commands: Optional[List[Type[Command]]] = None,
-    default_commands_to_remove: Optional[Union[List[Type[Command]], List[str]]] = None,
+    additional_commands: Optional[List[Type[PromptCommand]]] = None,
+    default_commands_to_remove: Optional[
+        Union[List[Type[PromptCommand]], List[str]]
+    ] = None,
     **kwargs: Any,
 ) -> List[Command]:
     """Parse a list of action commands."""
@@ -116,7 +119,7 @@ def parse_commands(
 
 
 def _parse_standard_commands(
-    standard_commands: List[Type[Command]],
+    standard_commands: List[Type[PromptCommand]],
     action: str,
     flows: FlowsList,
     **kwargs: Any,
@@ -135,7 +138,7 @@ def _parse_standard_commands(
 
 
 def _parse_custom_commands(
-    custom_commands: List[Type[Command]],
+    custom_commands: List[Type[PromptCommand]],
     action: str,
     flows: FlowsList,
     **kwargs: Any,
@@ -152,7 +155,7 @@ def _parse_custom_commands(
 
 def _parse_set_slot_command(
     parsed_command: Optional[SetSlotCommand], flows: FlowsList, **kwargs: Any
-) -> Optional[Command]:
+) -> Optional[PromptCommand]:
     """Additional parsing logic for the SetSlotCommand."""
     if not parsed_command:
         return None
@@ -164,7 +167,7 @@ def _parse_set_slot_command(
 
 def _parse_clarify_command(
     parsed_command: Optional[ClarifyCommand], flows: FlowsList, **kwargs: Any
-) -> Optional[Command]:
+) -> Optional[PromptCommand]:
     """Additional parsing logic for the ClarifyCommand."""
     if not parsed_command:
         return None
@@ -194,7 +197,7 @@ def _parse_clarify_command(
 
 def _parse_start_flow_command(
     parsed_command: Optional[StartFlowCommand], flows: FlowsList, **kwargs: Any
-) -> Optional[Command]:
+) -> Optional[PromptCommand]:
     """Additional parsing logic for the StartFlowCommand."""
     if not parsed_command:
         return None

rasa/dialogue_understanding/generator/constants.py

@@ -25,3 +25,6 @@ FLOW_RETRIEVAL_ACTIVE_KEY = "active"
 FLOW_RETRIEVAL_EMBEDDINGS_CONFIG_KEY = "embeddings"
 
 FLOW_RETRIEVAL_FLOW_THRESHOLD = 20
+
+COMMAND_PROMPT_FILE_NAME = "command_prompt.jinja2"
+LLM_BASED_COMMAND_GENERATOR_CONFIG_FILE = "config.json"

rasa/dialogue_understanding/generator/llm_based_command_generator.py

@@ -27,9 +27,7 @@ from rasa.engine.graph import ExecutionContext, GraphComponent
 from rasa.engine.recipes.default_recipe import DefaultV1Recipe
 from rasa.engine.storage.resource import Resource
 from rasa.engine.storage.storage import ModelStorage
-from rasa.shared.core.constants import (
-    SetSlotExtractor,
-)
+from rasa.shared.core.constants import SetSlotExtractor
 from rasa.shared.core.domain import Domain
 from rasa.shared.core.flows import Flow, FlowsList, FlowStep
 from rasa.shared.core.flows.steps.collect import CollectInformationFlowStep
@@ -313,11 +311,20 @@ class LLMBasedCommandGenerator(
         return filtered_flows
 
     @measure_llm_latency
-    async def invoke_llm(self, prompt: Text) -> Optional[LLMResponse]:
+    async def invoke_llm(
+        self, prompt: Union[List[dict], List[str], str]
+    ) -> Optional[LLMResponse]:
         """Use LLM to generate a response.
 
         Args:
-            prompt: The prompt to send to the LLM.
+            prompt: The prompt can be,
+                - a list of preformatted messages. Each message should be a dictionary
+                    with the following keys:
+                    - content: The message content.
+                    - role: The role of the message (e.g. user or system).
+                - a list of messages. Each message is a string and will be formatted
+                    as a user message.
+                - a single message as a string which will be formatted as user message.
 
         Returns:
             An LLMResponse object.

rasa/dialogue_understanding/generator/llm_command_generator.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, Optional, Text
+from typing import Any, Dict, List, Optional, Text, Union
 
 import structlog
 from deprecated import deprecated  # type: ignore[import]
@@ -25,7 +25,7 @@ structlogger = structlog.get_logger()
 @deprecated(
     reason=(
         "The LLMCommandGenerator is deprecated and will be removed in Rasa 4.0.0. "
-        "Please use use SingleStepLLMCommandGenerator instead."
+        "Please use SingleStepLLMCommandGenerator instead."
     )
 )
 class LLMCommandGenerator(SingleStepLLMCommandGenerator):
@@ -54,7 +54,9 @@ class LLMCommandGenerator(SingleStepLLMCommandGenerator):
             **kwargs,
         )
 
-    async def invoke_llm(self, prompt: Text) -> Optional[LLMResponse]:
+    async def invoke_llm(
+        self, prompt: Union[List[dict], List[str], str]
+    ) -> Optional[LLMResponse]:
         try:
             return await super().invoke_llm(prompt)
         except ProviderClientAPIException:

rasa/dialogue_understanding/generator/multi_step/multi_step_llm_command_generator.py

@@ -2,6 +2,7 @@ import importlib.resources
 from typing import Any, Dict, List, Optional, Text, Tuple, Union
 
 import structlog
+from deprecated import deprecated  # type: ignore[import]
 from jinja2 import Template
 
 import rasa.shared.utils.io
@@ -51,7 +52,7 @@ from rasa.shared.exceptions import ProviderClientAPIException
 from rasa.shared.nlu.constants import TEXT
 from rasa.shared.nlu.training_data.message import Message
 from rasa.shared.providers.llm.llm_response import LLMResponse
-from rasa.shared.utils.io import deep_container_fingerprint
+from rasa.shared.utils.io import deep_container_fingerprint, raise_deprecation_warning
 from rasa.shared.utils.llm import (
     allowed_values_for_slot,
     get_prompt_template,
@@ -100,6 +101,12 @@ structlogger = structlog.get_logger()
     ],
     is_trainable=True,
 )
+@deprecated(
+    reason=(
+        "The MultiStepLLMCommandGenerator is deprecated and will be removed in "
+        "Rasa `4.0.0`."
+    )
+)
 class MultiStepLLMCommandGenerator(LLMBasedCommandGenerator):
     """An multi step command generator using LLM."""
 
@@ -111,6 +118,14 @@ class MultiStepLLMCommandGenerator(LLMBasedCommandGenerator):
         prompt_templates: Optional[Dict[Text, Optional[Text]]] = None,
         **kwargs: Any,
     ) -> None:
+        raise_deprecation_warning(
+            message=(
+                "Support for `MultiStepLLMCommandGenerator` will be removed in Rasa "
+                "`4.0.0`. Please modify your assistant's configuration to use other "
+                "LLM command generators like the `SingleStepLLMCommandGenerator`."
+            )
+        )
+
         super().__init__(
             config, model_storage, resource, prompt_templates=prompt_templates, **kwargs
         )
@@ -120,7 +135,6 @@ class MultiStepLLMCommandGenerator(LLMBasedCommandGenerator):
             FILL_SLOTS_KEY: None,
         }
         self._init_prompt_templates(prompt_templates)
-
         self.trace_prompt_tokens = self.config.get("trace_prompt_tokens", False)
 
     ### Implementations of LLMBasedCommandGenerator parent
@@ -212,7 +226,7 @@ class MultiStepLLMCommandGenerator(LLMBasedCommandGenerator):
             # be completed, "predict" the ErrorCommand
             commands = [ErrorCommand()]
 
-        if not commands:
+        if not commands and not prior_commands:
             # if for any reason the final list of commands is empty,
             # "predict" CannotHandle
             commands = [CannotHandleCommand()]

rasa/dialogue_understanding/generator/{single_step → prompt_templates}/command_prompt_template.jinja2

@@ -41,7 +41,9 @@ Based on this information generate a list of actions you want to take. Your job
 * Responding to knowledge-oriented user messages, described by "SearchAndReply()"
 * Responding to a casual, non-task-oriented user message, described by "ChitChat()".
 * Handing off to a human, in case the user seems frustrated or explicitly asks to speak to one, described by "HumanHandoff()".
+{% if is_repeat_command_enabled %}
 * Repeat the last bot messages, described by "RepeatLastBotMessages()". This is useful when the user asks to repeat the last bot messages.
+{% endif %}
 
 ===
 Write out the actions you want to take, one per line, in the order they should take place.