rasa-pro 3.12.6.dev2__py3-none-any.whl → 3.13.0.dev2__py3-none-any.whl

rasa/core/policies/intentless_policy.py

@@ -30,10 +30,6 @@ from rasa.graph_components.providers.forms_provider import Forms
 from rasa.graph_components.providers.responses_provider import Responses
 from rasa.shared.constants import (
     EMBEDDINGS_CONFIG_KEY,
-    LANGFUSE_CUSTOM_METADATA_DICT,
-    LANGFUSE_METADATA_SESSION_ID,
-    LANGFUSE_METADATA_USER_ID,
-    LANGFUSE_TAGS,
     LLM_CONFIG_KEY,
     MODEL_CONFIG_KEY,
     MODEL_GROUP_ID_CONFIG_KEY,
@@ -623,7 +619,6 @@ class IntentlessPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Policy):
         response_examples: List[str],
         conversation_samples: List[str],
         history: str,
-        sender_id: str,
     ) -> Optional[str]:
         """Make the llm call to generate an answer."""
         llm = llm_factory(self.config.get(LLM_CONFIG_KEY), DEFAULT_LLM_CONFIG)
@@ -639,19 +634,11 @@ class IntentlessPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Policy):
             log_event="intentless_policy.generate_answer.prompt_rendered",
             prompt=prompt,
         )
-        return await self._generate_llm_answer(llm, prompt, sender_id)
+        return await self._generate_llm_answer(llm, prompt)
 
-    async def _generate_llm_answer(
-        self, llm: LLMClient, prompt: str, sender_id: str
-    ) -> Optional[str]:
-        metadata = {
-            LANGFUSE_METADATA_USER_ID: self.user_id,
-            LANGFUSE_METADATA_SESSION_ID: sender_id,
-            LANGFUSE_CUSTOM_METADATA_DICT: {"component": self.__class__.__name__},
-            LANGFUSE_TAGS: [self.__class__.__name__],
-        }
+    async def _generate_llm_answer(self, llm: LLMClient, prompt: str) -> Optional[str]:
         try:
-            llm_response = await llm.acompletion(prompt, metadata)
+            llm_response = await llm.acompletion(prompt)
             return llm_response.choices[0]
         except Exception as e:
             # unfortunately, langchain does not wrap LLM exceptions which means
@@ -727,7 +714,7 @@ class IntentlessPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Policy):
                 final_response_examples.append(resp)
 
         llm_response = await self.generate_answer(
-            final_response_examples, conversation_samples, history, tracker.sender_id
+            final_response_examples, conversation_samples, history
         )
         if not llm_response:
             structlogger.debug("intentless_policy.prediction.skip_llm_fail")

rasa/core/policies/policy.py

@@ -39,7 +39,6 @@ from rasa.shared.core.generator import TrackerWithCachedStates
 from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.shared.exceptions import FileIOException, RasaException
 from rasa.shared.nlu.constants import ACTION_NAME, ACTION_TEXT, ENTITIES, INTENT, TEXT
-from rasa.utils.licensing import get_human_readable_licence_owner
 
 if TYPE_CHECKING:
     from rasa.core.featurizers.tracker_featurizers import (
@@ -173,7 +172,6 @@ class Policy(GraphComponent):
 
         self._model_storage = model_storage
         self._resource = resource
-        self.user_id = get_human_readable_licence_owner()
 
     @classmethod
     def create(

rasa/core/processor.py

@@ -76,6 +76,7 @@ from rasa.shared.core.constants import (
     SLOT_SILENCE_TIMEOUT,
     USER_INTENT_RESTART,
     USER_INTENT_SILENCE_TIMEOUT,
+    SetSlotExtractor,
 )
 from rasa.shared.core.events import (
     ActionExecuted,
@@ -766,13 +767,26 @@ class MessageProcessor:
         if self.http_interpreter:
             parse_data = await self.http_interpreter.parse(message)
         else:
-            regex_reader = create_regex_pattern_reader(message, self.domain)
-
             processed_message = Message({TEXT: message.text})
-            if regex_reader:
-                processed_message = regex_reader.unpack_regex_message(
-                    message=processed_message, domain=self.domain
+
+            all_flows = await self.get_flows()
+            should_force_slot_command, slot_name = (
+                rasa.core.utils.should_force_slot_filling(tracker, all_flows)
+            )
+
+            if should_force_slot_command:
+                command = SetSlotCommand(
+                    name=slot_name,
+                    value=message.text,
+                    extractor=SetSlotExtractor.COMMAND_PAYLOAD_READER.value,
                 )
+                processed_message.set(COMMANDS, [command.as_dict()], add_to_output=True)
+            else:
+                regex_reader = create_regex_pattern_reader(message, self.domain)
+                if regex_reader:
+                    processed_message = regex_reader.unpack_regex_message(
+                        message=processed_message, domain=self.domain
+                    )
 
             # Invalid use of slash syntax, sanitize the message before passing
             # it to the graph
@@ -1009,7 +1023,14 @@ class MessageProcessor:
 
     @staticmethod
     def _should_handle_message(tracker: DialogueStateTracker) -> bool:
-        return not tracker.is_paused() or (
+        return not tracker.is_paused() or MessageProcessor._last_user_intent_is_restart(
+            tracker
+        )
+
+    @staticmethod
+    def _last_user_intent_is_restart(tracker: DialogueStateTracker) -> bool:
+        """Check if the last user intent is a restart intent."""
+        return (
             tracker.latest_message is not None
             and tracker.latest_message.intent.get(INTENT_NAME_KEY)
             == USER_INTENT_RESTART

rasa/core/utils.py

@@ -19,6 +19,7 @@ from rasa.core.constants import (
 )
 from rasa.core.lock_store import InMemoryLockStore, LockStore, RedisLockStore
 from rasa.shared.constants import DEFAULT_ENDPOINTS_PATH, TCP_PROTOCOL
+from rasa.shared.core.constants import SlotMappingType
 from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.utils.endpoints import (
     EndpointConfig,
@@ -30,6 +31,7 @@ from rasa.utils.io import write_yaml
 if TYPE_CHECKING:
     from rasa.core.nlg import NaturalLanguageGenerator
     from rasa.shared.core.domain import Domain
+    from rasa.shared.core.flows.flows_list import FlowsList
 
 structlogger = structlog.get_logger()
 
@@ -364,3 +366,54 @@ def add_bot_utterance_metadata(
         ]
 
     return message
+
+
+def should_force_slot_filling(
+    tracker: Optional[DialogueStateTracker], flows: "FlowsList"
+) -> Tuple[bool, Optional[str]]:
+    """Check if the flow should force slot filling.
+
+    This is only valid when the flow is at a collect information step which
+    has set `force_slot_filling` to true and the slot has a valid `from_text` mapping.
+
+    Args:
+        tracker: The dialogue state tracker.
+        flows: The list of flows.
+
+    Returns:
+        A tuple of a boolean indicating if the flow should force slot filling
+        and the name of the slot if applicable.
+    """
+    from rasa.dialogue_understanding.processor.command_processor import (
+        get_current_collect_step,
+    )
+
+    if tracker is None:
+        structlogger.error(
+            "slot.force_slot_filling.error",
+            event_info="Tracker is None. Cannot force slot filling.",
+        )
+        return False, None
+
+    stack = tracker.stack
+    step = get_current_collect_step(stack, flows)
+    if step is None or not step.force_slot_filling:
+        return False, None
+
+    slot_name = step.collect
+    slot = tracker.slots.get(slot_name)
+
+    if not slot:
+        structlogger.debug(
+            "slot.force_slot_filling.error",
+            event_info=f"Slot '{slot_name}' not found in tracker. "
+            f"Cannot force slot filling. "
+            f"Please check if the slot is defined in the domain.",
+        )
+        return False, None
+
+    for slot_mapping in slot.mappings:
+        if slot_mapping.type == SlotMappingType.FROM_TEXT:
+            return True, slot_name
+
+    return False, None

rasa/dialogue_understanding/coexistence/llm_based_router.py

@@ -23,10 +23,6 @@ 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.constants import (
-    LANGFUSE_CUSTOM_METADATA_DICT,
-    LANGFUSE_METADATA_SESSION_ID,
-    LANGFUSE_METADATA_USER_ID,
-    LANGFUSE_TAGS,
     MODEL_CONFIG_KEY,
     OPENAI_PROVIDER,
     PROMPT_CONFIG_KEY,
@@ -47,7 +43,6 @@ from rasa.shared.utils.llm import (
     llm_factory,
     resolve_model_client_config,
 )
-from rasa.utils.licensing import get_human_readable_licence_owner
 from rasa.utils.log_utils import log_llm
 
 LLM_BASED_ROUTER_PROMPT_FILE_NAME = "llm_based_router_prompt.jinja2"
@@ -118,7 +113,6 @@ class LLMBasedRouter(LLMHealthCheckMixin, GraphComponent):
         self._model_storage = model_storage
         self._resource = resource
         self.validate_config()
-        self.user_id = get_human_readable_licence_owner()
 
     def validate_config(self) -> None:
         """Validate the config of the router."""
@@ -166,6 +160,7 @@ class LLMBasedRouter(LLMHealthCheckMixin, GraphComponent):
         **kwargs: Any,
     ) -> "LLMBasedRouter":
         """Loads trained component (see parent class for full docstring)."""
+
         # Perform health check on the resolved LLM client config
         llm_config = resolve_model_client_config(config.get(LLM_CONFIG_KEY, {}))
         cls.perform_llm_health_check(
@@ -237,7 +232,7 @@ class LLMBasedRouter(LLMHealthCheckMixin, GraphComponent):
                 prompt=prompt,
             )
             # generating answer
-            answer = await self._generate_answer_using_llm(prompt, tracker.sender_id)
+            answer = await self._generate_answer_using_llm(prompt)
             log_llm(
                 logger=structlogger,
                 log_module="LLMBasedRouter",
@@ -297,9 +292,7 @@ class LLMBasedRouter(LLMHealthCheckMixin, GraphComponent):
 
         return Template(self.prompt_template).render(**inputs)
 
-    async def _generate_answer_using_llm(
-        self, prompt: str, sender_id: str
-    ) -> Optional[str]:
+    async def _generate_answer_using_llm(self, prompt: str) -> Optional[str]:
         """Use LLM to generate a response.
 
         Args:
@@ -310,15 +303,8 @@ class LLMBasedRouter(LLMHealthCheckMixin, GraphComponent):
         """
         llm = llm_factory(self.config.get(LLM_CONFIG_KEY), DEFAULT_LLM_CONFIG)
 
-        metadata = {
-            LANGFUSE_METADATA_USER_ID: self.user_id,
-            LANGFUSE_METADATA_SESSION_ID: sender_id,
-            LANGFUSE_CUSTOM_METADATA_DICT: {"component": self.__class__.__name__},
-            LANGFUSE_TAGS: [self.__class__.__name__],
-        }
-
         try:
-            llm_response = await llm.acompletion(prompt, metadata)
+            llm_response = await llm.acompletion(prompt)
             return llm_response.choices[0]
         except Exception as e:
             # unfortunately, langchain does not wrap LLM exceptions which means

rasa/dialogue_understanding/commands/cancel_flow_command.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import copy
 import re
 from dataclasses import dataclass
 from typing import Any, Dict, List
@@ -13,10 +12,11 @@ from rasa.dialogue_understanding.commands.command_syntax_manager import (
     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.flow_stack_frame import FlowStackFrameType
+from rasa.dialogue_understanding.stack.frames.flow_stack_frame import (
+    FlowStackFrameType,
+    UserFlowStackFrame,
+)
 from rasa.dialogue_understanding.stack.utils import top_user_flow_frame
 from rasa.shared.core.events import Event, FlowCancelled
 from rasa.shared.core.flows import FlowsList
@@ -95,8 +95,6 @@ class CancelFlowCommand(Command):
         original_stack = original_tracker.stack
 
         applied_events: List[Event] = []
-        # capture the top frame before we push new frames onto the stack
-        initial_top_frame = stack.top()
         user_frame = top_user_flow_frame(original_stack)
         current_flow = user_frame.flow(all_flows) if user_frame else None
 
@@ -123,21 +121,6 @@ class CancelFlowCommand(Command):
         if user_frame:
             applied_events.append(FlowCancelled(user_frame.flow_id, user_frame.step_id))
 
-        if initial_top_frame and isinstance(
-            initial_top_frame, ClarifyPatternFlowStackFrame
-        ):
-            structlogger.debug(
-                "command_executor.cancel_flow.cancel_clarification_options",
-                clarification_options=initial_top_frame.clarification_options,
-            )
-            applied_events += cancel_all_pending_clarification_options(
-                initial_top_frame,
-                original_stack,
-                canceled_frames,
-                all_flows,
-                stack,
-            )
-
         return applied_events + tracker.create_stack_updated_events(stack)
 
     def __hash__(self) -> int:
@@ -172,41 +155,3 @@ class CancelFlowCommand(Command):
             CommandSyntaxManager.get_syntax_version(),
             mapper[CommandSyntaxManager.get_default_syntax_version()],
         )
-
-
-def cancel_all_pending_clarification_options(
-    initial_top_frame: ClarifyPatternFlowStackFrame,
-    original_stack: DialogueStack,
-    canceled_frames: List[str],
-    all_flows: FlowsList,
-    stack: DialogueStack,
-) -> List[FlowCancelled]:
-    """Cancel all pending clarification options.
-
-    This is a special case when the assistant asks the user to clarify
-    which pending digression flow to start after the completion of an active flow.
-    If the user chooses to cancel all options, this function takes care of
-    updating the stack by removing all pending flow stack frames
-    listed as clarification options.
-    """
-    clarification_names = set(initial_top_frame.names)
-    to_be_canceled_frames = []
-    applied_events = []
-    for frame in reversed(original_stack.frames):
-        if frame.frame_id in canceled_frames:
-            continue
-
-        to_be_canceled_frames.append(frame.frame_id)
-        if isinstance(frame, UserFlowStackFrame):
-            readable_flow_name = frame.flow(all_flows).readable_name()
-            if readable_flow_name in clarification_names:
-                stack.push(
-                    CancelPatternFlowStackFrame(
-                        canceled_name=readable_flow_name,
-                        canceled_frames=copy.deepcopy(to_be_canceled_frames),
-                    )
-                )
-                applied_events.append(FlowCancelled(frame.flow_id, frame.step_id))
-                to_be_canceled_frames.clear()
-
-    return applied_events

rasa/dialogue_understanding/commands/knowledge_answer_command.py

@@ -65,7 +65,7 @@ class KnowledgeAnswerCommand(FreeFormAnswerCommand):
         """Converts the command to a DSL string."""
         mapper = {
             CommandSyntaxVersion.v1: "SearchAndReply()",
-            CommandSyntaxVersion.v2: "provide info",
+            CommandSyntaxVersion.v2: "search and reply",
         }
         return mapper.get(
             CommandSyntaxManager.get_syntax_version(),
@@ -81,7 +81,7 @@ class KnowledgeAnswerCommand(FreeFormAnswerCommand):
     def regex_pattern() -> str:
         mapper = {
             CommandSyntaxVersion.v1: r"SearchAndReply\(\)",
-            CommandSyntaxVersion.v2: r"""^[\s\W\d]*provide info['"`]*$""",
+            CommandSyntaxVersion.v2: r"""^[\s\W\d]*search and reply['"`]*$""",
         }
         return mapper.get(
             CommandSyntaxManager.get_syntax_version(),

rasa/dialogue_understanding/commands/start_flow_command.py

@@ -11,11 +11,6 @@ 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,
-)
-from rasa.dialogue_understanding.stack.dialogue_stack import DialogueStack
 from rasa.dialogue_understanding.stack.frames.flow_stack_frame import (
     FlowStackFrameType,
     UserFlowStackFrame,
@@ -77,10 +72,6 @@ class StartFlowCommand(Command):
         applied_events: List[Event] = []
 
         if self.flow in user_flows_on_the_stack(stack):
-            top_frame = stack.top()
-            if top_frame is not None and top_frame.type() == FLOW_PATTERN_CLARIFICATION:
-                return self.change_flow_frame_position_in_the_stack(stack, tracker)
-
             structlogger.debug(
                 "command_executor.skip_command.already_started_flow", command=self
             )
@@ -149,35 +140,3 @@ class StartFlowCommand(Command):
             CommandSyntaxManager.get_syntax_version(),
             mapper[CommandSyntaxManager.get_default_syntax_version()],
         )
-
-    def change_flow_frame_position_in_the_stack(
-        self, stack: DialogueStack, tracker: DialogueStateTracker
-    ) -> List[Event]:
-        """Changes the position of the flow frame in the stack.
-
-        This is a special case when pattern clarification is the active flow and
-        the same flow is selected to start. In this case, the existing flow frame
-        should be moved up in the stack.
-        """
-        frames = stack.frames[:]
-
-        for idx, frame in enumerate(frames):
-            if isinstance(frame, UserFlowStackFrame) and frame.flow_id == self.flow:
-                structlogger.debug(
-                    "command_executor.change_flow_position_during_clarification",
-                    command=self,
-                    index=idx,
-                )
-                # pop the continue interrupted flow frame if it exists
-                next_frame = frames[idx + 1] if idx + 1 < len(frames) else None
-                if (
-                    isinstance(next_frame, ContinueInterruptedPatternFlowStackFrame)
-                    and next_frame.previous_flow_name == self.flow
-                ):
-                    stack.frames.pop(idx + 1)
-                # move up the existing flow from the stack
-                stack.frames.pop(idx)
-                stack.push(frame)
-                return tracker.create_stack_updated_events(stack)
-
-        return []

rasa/dialogue_understanding/generator/command_generator.py

@@ -4,6 +4,7 @@ from typing import Any, Dict, List, Optional, Set, Text, Tuple
 import structlog
 
 from rasa.dialogue_understanding.commands import (
+    CannotHandleCommand,
     Command,
     CorrectSlotsCommand,
     ErrorCommand,
@@ -107,6 +108,14 @@ class CommandGenerator:
             commands = self._check_commands_against_startable_flows(
                 commands, startable_flows
             )
+
+            # During force slot filling, keep only the command that sets the
+            # slot asked by the active collect step.
+            # Or return a CannotHandleCommand if no matching command is found.
+            commands = self._filter_commands_during_force_slot_filling(
+                commands, available_flows, tracker
+            )
+
             commands_dicts = [command.as_dict() for command in commands]
             message.set(COMMANDS, commands_dicts, add_to_output=True)
 
@@ -370,6 +379,64 @@ class CommandGenerator:
             Command.command_from_json(command) for command in message.get(COMMANDS, [])
         ]
 
+    @staticmethod
+    def _filter_commands_during_force_slot_filling(
+        commands: List[Command],
+        available_flows: FlowsList,
+        tracker: Optional[DialogueStateTracker] = None,
+    ) -> List[Command]:
+        """Filter commands during a collect step that has set `force_slot_filling`.
+
+        Args:
+            commands: The commands to filter.
+            available_flows: The available flows.
+            tracker: The tracker.
+
+        Returns:
+            The filtered commands.
+        """
+        from rasa.dialogue_understanding.processor.command_processor import (
+            get_current_collect_step,
+        )
+
+        if tracker is None:
+            structlogger.error(
+                "command_generator.filter_commands_during_force_slot_filling.tracker_not_found",
+            )
+            return commands
+
+        stack = tracker.stack
+        step = get_current_collect_step(stack, available_flows)
+
+        if step is None or not step.force_slot_filling:
+            return commands
+
+        # Retain only the command that sets the slot asked by
+        # the active collect step
+        filtered_commands: List[Command] = [
+            command
+            for command in commands
+            if (isinstance(command, SetSlotCommand) and command.name == step.collect)
+        ]
+
+        if not filtered_commands:
+            # If no commands were predicted, we need to return a CannotHandleCommand
+            structlogger.debug(
+                "command_generator.filter_commands_during_force_slot_filling.no_commands",
+                event_info=f"The command generator did not find any SetSlot "
+                f"command at the collect step for the slot '{step.collect}'. "
+                f"Returning a CannotHandleCommand instead.",
+            )
+            return [CannotHandleCommand()]
+
+        structlogger.debug(
+            "command_generator.filter_commands_during_force_slot_filling.filtered_commands",
+            slot_name=step.collect,
+            filtered_commands=filtered_commands,
+        )
+
+        return filtered_commands
+
 
 def gather_slot_names(commands: List[Command]) -> Set[str]:
     """Gather all slot names from the commands."""

rasa/dialogue_understanding/generator/command_parser.py

@@ -169,7 +169,7 @@ def _parse_standard_commands(
     commands: List[Command] = []
     for command_clz in standard_commands:
         pattern = _get_compiled_pattern(command_clz.regex_pattern())
-        if match := pattern.search(action):
+        if match := pattern.search(action.strip()):
             parsed_command = command_clz.from_dsl(match, **kwargs)
             if _additional_parsing_fn := _get_additional_parsing_logic(command_clz):
                 parsed_command = _additional_parsing_fn(parsed_command, flows, **kwargs)

rasa/dialogue_understanding/generator/llm_based_command_generator.py

@@ -12,9 +12,6 @@ from rasa.dialogue_understanding.commands import (
     SetSlotCommand,
     StartFlowCommand,
 )
-from rasa.dialogue_understanding.commands.handle_digressions_command import (
-    HandleDigressionsCommand,
-)
 from rasa.dialogue_understanding.constants import KEY_MINIMIZE_NUM_CALLS
 from rasa.dialogue_understanding.generator import CommandGenerator
 from rasa.dialogue_understanding.generator._jinja_filters import to_json_escaped_string
@@ -49,7 +46,6 @@ from rasa.shared.utils.llm import (
     llm_factory,
     resolve_model_client_config,
 )
-from rasa.utils.licensing import get_human_readable_licence_owner
 from rasa.utils.log_utils import log_llm
 
 structlogger = structlog.get_logger()
@@ -93,8 +89,6 @@ class LLMBasedCommandGenerator(
         else:
             self.flow_retrieval = None
 
-        self.user_id = get_human_readable_licence_owner()
-
     ### Abstract methods
     @staticmethod
     @abstractmethod
@@ -233,19 +227,18 @@ class LLMBasedCommandGenerator(
     def compile_template(self, template: str) -> Template:
         """
         Compile the prompt template and register custom filters.
+
         Compiling the template is an expensive operation,
         so we cache the result.
         """
         # Create an environment
         # Autoescaping disabled explicitly for LLM prompt templates rendered from
-
         # strings (safe, not HTML)
         env = Environment(
             autoescape=select_autoescape(
                 disabled_extensions=["jinja2"], default_for_string=False, default=True
             )
         )
-
         # Register filters
         env.filters[TO_JSON_ESCAPED_STRING_JINJA_FILTER] = to_json_escaped_string
 
@@ -334,9 +327,7 @@ class LLMBasedCommandGenerator(
 
     @measure_llm_latency
     async def invoke_llm(
-        self,
-        prompt: Union[List[dict], List[str], str],
-        metadata: Optional[Dict[str, Any]] = None,
+        self, prompt: Union[List[dict], List[str], str]
     ) -> Optional[LLMResponse]:
         """Use LLM to generate a response.
 
@@ -349,7 +340,6 @@ class LLMBasedCommandGenerator(
                 - 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.
-            metadata: Optional metadata to be passed to the LLM call.
 
         Returns:
             An LLMResponse object.
@@ -361,7 +351,7 @@ class LLMBasedCommandGenerator(
             self.config.get(LLM_CONFIG_KEY), self.get_default_llm_config()
         )
         try:
-            return await llm.acompletion(prompt, metadata)
+            return await llm.acompletion(prompt)
         except Exception as e:
             # unfortunately, langchain does not wrap LLM exceptions which means
             # we have to catch all exceptions here
@@ -400,7 +390,8 @@ class LLMBasedCommandGenerator(
                     "slots": slots_with_info,
                 }
             )
-        return result
+
+        return sorted(result, key=lambda x: x["name"])
 
     @staticmethod
     def is_extractable(
@@ -616,16 +607,9 @@ class LLMBasedCommandGenerator(
     ) -> bool:
         """Check if the LLM current commands should be merged with the prior commands.
 
-        This can be done if there are no prior start flow commands and
-        no prior handle digressions commands.
+        This can be done if there are no prior start flow commands.
         """
-        prior_handle_digressions = [
-            command
-            for command in prior_commands
-            if isinstance(command, HandleDigressionsCommand)
-        ]
-
-        return not prior_start_flow_names and not prior_handle_digressions
+        return not prior_start_flow_names
 
     def _check_start_flow_command_overlap(
         self,

rasa/dialogue_understanding/generator/llm_command_generator.py

@@ -55,9 +55,7 @@ class LLMCommandGenerator(SingleStepLLMCommandGenerator):
         )
 
     async def invoke_llm(
-        self,
-        prompt: Union[List[dict], List[str], str],
-        metadata: Optional[Dict[str, Any]] = None,
+        self, prompt: Union[List[dict], List[str], str]
     ) -> Optional[LLMResponse]:
         try:
             return await super().invoke_llm(prompt)

rasa/dialogue_understanding/generator/prompt_templates/command_prompt_template.jinja2

@@ -57,4 +57,4 @@ Strictly adhere to the provided action types listed above.
 Focus on the last message and take it one step at a time.
 Use the previous conversation steps only to aid understanding.
 
-Your action list:
+Your action list:

rasa/dialogue_understanding/generator/prompt_templates/command_prompt_v2_claude_3_5_sonnet_20240620_template.jinja2

@@ -8,7 +8,7 @@ Your task is to analyze the current conversation context and generate a list of
 * `set slot slot_name slot_value`: Slot setting. For example, `set slot transfer_money_recipient Freddy`. Can be used to correct and change previously set values.
 * `cancel flow`: Cancelling the current flow.
 * `disambiguate flows flow_name1 flow_name2 ... flow_name_n`: Disambiguate which flow should be started when user input is ambiguous by listing the potential flows as options. For example, `disambiguate flows list_contacts add_contact remove_contact ...` if the user just wrote "contacts".
-* `provide info`: Responding to the user's questions by supplying relevant information, such as answering FAQs or explaining services.
+* `search and reply`: Responding to the user's questions by supplying relevant information, such as answering FAQs or explaining services.
 * `offtopic reply`: Responding to casual or social user messages that are unrelated to any flows, engaging in friendly conversation and addressing off-topic remarks.
 * `hand over`: Handing over to a human, in case the user seems frustrated or explicitly asks to speak to one.