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

rasa/dialogue_understanding/generator/command_parser.py

@@ -125,7 +125,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.strip()):
+        if match := pattern.search(action):
             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

@@ -1,14 +1,18 @@
 from abc import ABC, abstractmethod
 from functools import lru_cache
-from typing import Any, Dict, List, Optional, Text, Tuple, Union
+from typing import Any, Dict, List, Optional, Set, Text, Tuple, Union
 
 import structlog
 from jinja2 import Template
 
+import rasa.dialogue_understanding.generator.utils
 import rasa.shared.utils.io
 from rasa.dialogue_understanding.commands import (
     Command,
+    SetSlotCommand,
+    StartFlowCommand,
 )
+from rasa.dialogue_understanding.constants import KEY_MINIMIZE_NUM_CALLS
 from rasa.dialogue_understanding.generator import CommandGenerator
 from rasa.dialogue_understanding.generator.constants import (
     DEFAULT_LLM_CONFIG,
@@ -18,13 +22,18 @@ from rasa.dialogue_understanding.generator.constants import (
     LLM_CONFIG_KEY,
 )
 from rasa.dialogue_understanding.generator.flow_retrieval import FlowRetrieval
+from rasa.dialogue_understanding.stack.utils import top_flow_frame
 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.domain import Domain
 from rasa.shared.core.flows import Flow, FlowsList, FlowStep
 from rasa.shared.core.flows.steps.collect import CollectInformationFlowStep
+from rasa.shared.core.slot_mappings import SlotFillingManager
 from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.shared.exceptions import FileIOException, ProviderClientAPIException
 from rasa.shared.nlu.constants import FLOWS_IN_PROMPT
@@ -357,8 +366,7 @@ class LLMBasedCommandGenerator(
                     "slots": slots_with_info,
                 }
             )
-
-        return sorted(result, key=lambda x: x["name"])
+        return result
 
     @staticmethod
     def is_extractable(
@@ -454,3 +462,153 @@ class LLMBasedCommandGenerator(
             if isinstance(current_step, CollectInformationFlowStep)
             else (None, None)
         )
+
+    @staticmethod
+    def _prior_commands_contain_start_flow(prior_commands: List[Command]) -> bool:
+        return any(isinstance(command, StartFlowCommand) for command in prior_commands)
+
+    @staticmethod
+    def _prior_commands_contain_set_slot_for_active_collect_step(
+        prior_commands: List[Command],
+        flows: FlowsList,
+        tracker: DialogueStateTracker,
+    ) -> bool:
+        latest_user_frame = top_flow_frame(tracker.stack, ignore_call_frames=False)
+
+        if latest_user_frame is None:
+            return False
+
+        active_flow = latest_user_frame.flow(flows)
+        active_step = active_flow.step_by_id(latest_user_frame.step_id)
+
+        if not isinstance(active_step, CollectInformationFlowStep):
+            return False
+
+        return any(
+            command.name == active_step.collect
+            for command in prior_commands
+            if isinstance(command, SetSlotCommand)
+        )
+
+    def _should_skip_llm_call(
+        self,
+        prior_commands: List[Command],
+        flows: FlowsList,
+        tracker: DialogueStateTracker,
+    ) -> bool:
+        """Skip invoking the LLM.
+
+        This returns True if the bot builder sets the property
+        KEY_MINIMIZE_NUM_CALLS to True and the prior commands
+        either contain a StartFlowCommand or a SetSlot command
+        for the current collect step.
+        """
+        return self.config.get(KEY_MINIMIZE_NUM_CALLS, False) and (
+            self._prior_commands_contain_start_flow(prior_commands)
+            or self._prior_commands_contain_set_slot_for_active_collect_step(
+                prior_commands, flows, tracker
+            )
+        )
+
+    @staticmethod
+    def _check_commands_against_slot_mappings(
+        commands: List[Command],
+        tracker: DialogueStateTracker,
+        domain: Optional[Domain] = None,
+    ) -> List[Command]:
+        """Check if the LLM-issued slot commands are fillable.
+
+        The LLM-issued slot commands are fillable if the slot
+        mappings are satisfied (in particular the mapping conditions).
+        """
+        if not domain:
+            return commands
+
+        llm_fillable_slots = [
+            tracker.slots.get(command.name)
+            for command in commands
+            if isinstance(command, SetSlotCommand)
+            and command.extractor == SetSlotExtractor.LLM.value
+            and tracker.slots.get(command.name) is not None
+        ]
+
+        if not llm_fillable_slots:
+            return commands
+
+        slot_filling_manager = SlotFillingManager(domain, tracker)
+        slots_to_be_removed = []
+
+        structlogger.debug(
+            "command_processor.check_commands_against_slot_mappings.active_flow",
+            active_flow=tracker.active_flow,
+        )
+
+        for slot in llm_fillable_slots:
+            should_fill_slot = False
+            for mapping in slot.mappings:  # type: ignore[union-attr]
+                should_fill_slot = slot_filling_manager.should_fill_slot(
+                    slot.name,  # type: ignore[union-attr]
+                    mapping,
+                )
+
+                if should_fill_slot:
+                    break
+
+            if not should_fill_slot:
+                structlogger.debug(
+                    "command_processor.check_commands_against_slot_mappings.slot_not_fillable",
+                    slot_name=slot.name,  # type: ignore[union-attr]
+                )
+                slots_to_be_removed.append(slot.name)  # type: ignore[union-attr]
+
+        if not slots_to_be_removed:
+            return commands
+
+        filtered_commands = [
+            command
+            for command in commands
+            if not (
+                isinstance(command, SetSlotCommand)
+                and command.name in slots_to_be_removed
+            )
+        ]
+
+        return filtered_commands
+
+    def _check_start_flow_command_overlap(
+        self,
+        prior_commands: List[Command],
+        commands: List[Command],
+        prior_start_flow_names: Set[str],
+        current_start_flow_names: Set[str],
+    ) -> List[Command]:
+        """Prioritize the prior commands over the LLM-issued commands."""
+        different_flow_names = current_start_flow_names.difference(
+            prior_start_flow_names
+        )
+
+        if not different_flow_names:
+            return prior_commands + commands
+
+        # discard the flow names that are different to prior start flow commands
+        filtered_commands = [
+            command
+            for command in commands
+            if not isinstance(command, StartFlowCommand)
+            or command.flow not in different_flow_names
+        ]
+        return prior_commands + filtered_commands
+
+    def _filter_slot_commands(
+        self,
+        prior_commands: List[Command],
+        commands: List[Command],
+        overlapping_slot_names: Set[str],
+    ) -> Tuple[List[Command], List[Command]]:
+        """Prioritize prior commands over LLM ones in the case of same slot."""
+        filtered_commands = (
+            rasa.dialogue_understanding.generator.utils.filter_slot_commands(
+                commands, overlapping_slot_names
+            )
+        )
+        return prior_commands, filtered_commands

rasa/dialogue_understanding/generator/multi_step/multi_step_llm_command_generator.py

@@ -190,9 +190,14 @@ class MultiStepLLMCommandGenerator(LLMBasedCommandGenerator):
         Returns:
             The commands generated by the llm.
         """
+        prior_commands = self._get_prior_commands(message)
+
         if tracker is None or flows.is_empty():
             # cannot do anything if there are no flows or no tracker
-            return []
+            return prior_commands
+
+        if self._should_skip_llm_call(prior_commands, flows, tracker):
+            return prior_commands
 
         try:
             commands = await self._predict_commands_with_multi_step(
@@ -221,7 +226,10 @@ class MultiStepLLMCommandGenerator(LLMBasedCommandGenerator):
             commands=commands,
         )
 
-        return commands
+        domain = kwargs.get("domain")
+        commands = self._check_commands_against_slot_mappings(commands, tracker, domain)
+
+        return self._check_commands_overlap(prior_commands, commands)
 
     @classmethod
     def parse_commands(

rasa/dialogue_understanding/generator/nlu_command_adapter.py

@@ -1,7 +1,8 @@
-from typing import Any, Dict, List, Optional, Text
+from typing import Any, Dict, List, Optional, Set, Text, Tuple
 
 import structlog
 
+import rasa.dialogue_understanding.generator.utils
 from rasa.dialogue_understanding.commands import (
     Command,
     SetSlotCommand,
@@ -98,9 +99,11 @@ class NLUCommandAdapter(GraphComponent, CommandGenerator):
         Returns:
             The commands triggered by NLU.
         """
+        prior_commands = self._get_prior_commands(message)
+
         if tracker is None or flows.is_empty():
             # cannot do anything if there are no flows or no tracker
-            return []
+            return prior_commands
 
         domain = kwargs.get("domain", None)
         commands = self.convert_nlu_to_commands(message, tracker, flows, domain)
@@ -146,7 +149,7 @@ class NLUCommandAdapter(GraphComponent, CommandGenerator):
                 commands=commands,
             )
 
-        return commands
+        return self._check_commands_overlap(prior_commands, commands)
 
     @staticmethod
     def convert_nlu_to_commands(
@@ -208,6 +211,44 @@ class NLUCommandAdapter(GraphComponent, CommandGenerator):
         )
         return commands
 
+    def _check_start_flow_command_overlap(
+        self,
+        prior_commands: List[Command],
+        commands: List[Command],
+        prior_start_flow_names: Set[str],
+        current_start_flow_names: Set[str],
+    ) -> List[Command]:
+        """Prioritize the current NLU commands over the prior commands."""
+        different_flow_names = prior_start_flow_names.difference(
+            current_start_flow_names
+        )
+
+        if not different_flow_names:
+            return prior_commands + commands
+
+        filtered_commands = [
+            command
+            for command in prior_commands
+            if not isinstance(command, StartFlowCommand)
+            or command.flow not in different_flow_names
+        ]
+
+        return filtered_commands + commands
+
+    def _filter_slot_commands(
+        self,
+        prior_commands: List[Command],
+        commands: List[Command],
+        overlapping_slot_names: Set[str],
+    ) -> Tuple[List[Command], List[Command]]:
+        """Prioritize NLU commands over prior_commands in the case of same slot."""
+        filtered_prior_commands = (
+            rasa.dialogue_understanding.generator.utils.filter_slot_commands(
+                prior_commands, overlapping_slot_names
+            )
+        )
+        return filtered_prior_commands, commands
+
 
 def _issue_set_slot_commands(
     message: Message,

rasa/dialogue_understanding/generator/single_step/command_prompt_template.jinja2

@@ -1,84 +1,58 @@
-## Task Description
 Your task is to analyze the current conversation context and generate a list of actions to start new business processes that we call flows, to extract slots, or respond to small talk and knowledge requests.
 
---
+These are the flows that can be started, with their description and slots:
+{% for flow in available_flows %}
+{{ flow.name }}: {{ flow.description }}
+    {% for slot in flow.slots -%}
+    slot: {{ slot.name }}{% if slot.description %} ({{ slot.description }}){% endif %}{% if slot.allowed_values %}, allowed values: {{ slot.allowed_values }}{% endif %}
+    {% endfor %}
+{%- endfor %}
 
-## Available Actions:
-* `start flow flow_name`: Starting a flow. For example, `start flow transfer_money` or `start flow list_contacts`
-* `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, `clarify 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
-* `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
-
---
-
-## General Tips
-* Do not fill slots with abstract values or placeholders.
-* Only use information provided by the user.
-* Use clarification in ambiguous cases.
-* Multiple flows can be started. If a user wants to digress into a second flow, you do not need to cancel the current flow.
-* Strictly adhere to the provided action format.
-* For categorical slots try to match the user message with potential slot values. Use "other" if you cannot match it
-* Focus on the last message and take it one step at a time.
-* Use the previous conversation steps only to aid understanding.
-
---
-
-## Available Flows and Slots
-Use the following structured date:
-```json
-{
-    "flows": [
-        {% for flow in available_flows %}{
-            "name": "{{ flow.name }}",
-            "description": "{{ flow.description }}"{% if flow.slots %},
-            "slots": [{% for slot in flow.slots %}
-                {
-                    "name": "{{ slot.name }}"{% if slot.description %},
-                    "description": "{{ slot.description }}"{% endif %}{% if slot.allowed_values %},
-                    "allowed_values": {{ slot.allowed_values }}{% endif %}
-                }{% if not loop.last %},{% endif %}{% endfor %}
-            ]{% endif %}
-        }{% if not loop.last %},
-        {% endif %}{% endfor %}
-    ]
-}
-```
-
---
-
-## Current State
-{% if current_flow != None %}Use the following structured date:
-```json
-{
-    "active_flow": "{{ current_flow }}",
-    "current_step": {
-        "requested_slot": "{{ current_slot }}",
-        "requested_slot_description": "{{ current_slot_description }}"
-    },
-    "slots": [{% for slot in flow_slots %}
-        {
-            "name": "{{ slot.name }}",
-            "value": "{{ slot.value }}",
-            "type": "{{ slot.type }}"{% if slot.description %},
-            "description": "{{ slot.description }}"{% endif %}{% if slot.allowed_values %},
-            "allowed_values": "{{ slot.allowed_values }}"{% endif %}
-        }{% if not loop.last %},{% endif %}{% endfor %}
-    ]
-}
-```{% else %}
-You are currently not inside any flow.{% endif %}
-
----
-
-## Conversation History
+===
+Here is what happened previously in the conversation:
 {{ current_conversation }}
 
----
-
-## Task
-Create an action list with one action per line in response to the users last message: """{{ user_message }}""".
-
-Your action list:
+===
+{% if current_flow != None %}
+You are currently in the flow "{{ current_flow }}".
+You have just asked the user for the slot "{{ current_slot }}"{% if current_slot_description %} ({{ current_slot_description }}){% endif %}.
+
+{% if flow_slots|length > 0 %}
+Here are the slots of the currently active flow:
+{% for slot in flow_slots -%}
+- name: {{ slot.name }}, value: {{ slot.value }}, type: {{ slot.type }}, description: {{ slot.description}}{% if slot.allowed_values %}, allowed values: {{ slot.allowed_values }}{% endif %}
+{% endfor %}
+{% endif %}
+{% else %}
+You are currently not in any flow and so there are no active slots.
+This means you can only set a slot if you first start a flow that requires that slot.
+{% endif %}
+If you start a flow, first start the flow and then optionally fill that flow's slots with information the user provided in their message.
+
+The user just said """{{ user_message }}""".
+
+===
+Based on this information generate a list of actions you want to take. Your job is to start flows and to fill slots where appropriate. Any logic of what happens afterwards is handled by the flow engine. These are your available actions:
+* Slot setting, described by "SetSlot(slot_name, slot_value)". An example would be "SetSlot(recipient, Freddy)"
+* Starting another flow, described by "StartFlow(flow_name)". An example would be "StartFlow(transfer_money)"
+* Cancelling the current flow, described by "CancelFlow()"
+* Clarifying which flow should be started. An example would be Clarify(list_contacts, add_contact, remove_contact) if the user just wrote "contacts" and there are multiple potential candidates. It also works with a single flow name to confirm you understood correctly, as in Clarify(transfer_money).
+* Intercepting and handle user messages with the intent to bypass the current step in the flow, described by "SkipQuestion()". Examples of user skip phrases are: "Go to the next question", "Ask me something else".
+* 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()".
+* Repeat the last bot messages, described by "RepeatLastBotMessages()". This is useful when the user asks to repeat the last bot messages.
+
+===
+Write out the actions you want to take, one per line, in the order they should take place.
+Do not fill slots with abstract values or placeholders.
+Only use information provided by the user.
+Only start a flow if it's completely clear what the user wants. Imagine you were a person reading this message. If it's not 100% clear, clarify the next step.
+Don't be overly confident. Take a conservative approach and clarify before proceeding.
+If the user asks for two things which seem contradictory, clarify before starting a flow.
+If it's not clear whether the user wants to skip the step or to cancel the flow, cancel the flow.
+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:

rasa/dialogue_understanding/generator/single_step/single_step_llm_command_generator.py

@@ -51,7 +51,6 @@ from rasa.shared.utils.llm import (
     sanitize_message_for_prompt,
     tracker_as_readable_transcript,
 )
-from rasa.utils.beta import BetaNotEnabledException, ensure_beta_feature_is_enabled
 from rasa.utils.log_utils import log_llm
 
 COMMAND_PROMPT_FILE_NAME = "command_prompt.jinja2"
@@ -111,7 +110,6 @@ class SingleStepLLMCommandGenerator(LLMBasedCommandGenerator):
         )
 
         self.trace_prompt_tokens = self.config.get("trace_prompt_tokens", False)
-        self.repeat_command_enabled = self.is_repeat_command_enabled()
 
     ### Implementations of LLMBasedCommandGenerator parent
     @staticmethod
@@ -198,9 +196,14 @@ class SingleStepLLMCommandGenerator(LLMBasedCommandGenerator):
         Returns:
             The commands generated by the llm.
         """
+        prior_commands = self._get_prior_commands(message)
+
         if tracker is None or flows.is_empty():
             # cannot do anything if there are no flows or no tracker
-            return []
+            return prior_commands
+
+        if self._should_skip_llm_call(prior_commands, flows, tracker):
+            return prior_commands
 
         try:
             commands = await self._predict_commands(message, flows, tracker)
@@ -209,7 +212,7 @@ class SingleStepLLMCommandGenerator(LLMBasedCommandGenerator):
             # "predict" the ErrorCommand
             commands = [ErrorCommand()]
 
-        if not commands:
+        if not commands and not prior_commands:
             # no commands are parsed or there's an invalid command
             structlogger.warning(
                 "single_step_llm_command_generator.predict_commands",
@@ -230,7 +233,10 @@ class SingleStepLLMCommandGenerator(LLMBasedCommandGenerator):
             commands=commands,
         )
 
-        return commands
+        domain = kwargs.get("domain")
+        commands = self._check_commands_against_slot_mappings(commands, tracker, domain)
+
+        return self._check_commands_overlap(prior_commands, commands)
 
     async def _predict_commands(
         self,
@@ -406,20 +412,6 @@ class SingleStepLLMCommandGenerator(LLMBasedCommandGenerator):
             "current_slot": current_slot,
             "current_slot_description": current_slot_description,
             "user_message": latest_user_message,
-            "is_repeat_command_enabled": self.repeat_command_enabled,
         }
 
         return self.compile_template(self.prompt_template).render(**inputs)
-
-    def is_repeat_command_enabled(self) -> bool:
-        """Check for feature flag"""
-        RASA_PRO_BETA_REPEAT_COMMAND_ENV_VAR_NAME = "RASA_PRO_BETA_REPEAT_COMMAND"
-        try:
-            ensure_beta_feature_is_enabled(
-                "Repeat Command",
-                env_flag=RASA_PRO_BETA_REPEAT_COMMAND_ENV_VAR_NAME,
-            )
-        except BetaNotEnabledException:
-            return False
-
-        return True

rasa/dialogue_understanding/generator/utils.py

@@ -1,14 +1,16 @@
-from typing import Dict, Type
+from typing import Dict, List, Set, Type
 
 from rasa.dialogue_understanding.commands import (
     CancelFlowCommand,
     CannotHandleCommand,
     ChitChatAnswerCommand,
     Command,
+    CorrectSlotsCommand,
     HumanHandoffCommand,
     KnowledgeAnswerCommand,
     RestartCommand,
     SessionStartCommand,
+    SetSlotCommand,
     SkipQuestionCommand,
 )
 from rasa.dialogue_understanding.commands.user_silence_command import UserSilenceCommand
@@ -43,3 +45,32 @@ triggerable_pattern_to_command_class: Dict[str, Type[Command]] = {
     CannotHandlePatternFlowStackFrame.flow_id: CannotHandleCommand,
     RestartPatternFlowStackFrame.flow_id: RestartCommand,
 }
+
+
+def filter_slot_commands(
+    commands: List[Command], overlapping_slot_names: Set[str]
+) -> List[Command]:
+    """Filter out slot commands that set overlapping slots."""
+    filtered_commands = []
+
+    for command in commands:
+        if (
+            isinstance(command, SetSlotCommand)
+            and command.name in overlapping_slot_names
+        ):
+            continue
+
+        if isinstance(command, CorrectSlotsCommand):
+            allowed_slots = [
+                slot
+                for slot in command.corrected_slots
+                if slot.name not in overlapping_slot_names
+            ]
+            if not allowed_slots:
+                continue
+
+            command.corrected_slots = allowed_slots
+
+        filtered_commands.append(command)
+
+    return filtered_commands

rasa/dialogue_understanding/patterns/correction.py

@@ -54,6 +54,8 @@ class CorrectionPatternFlowStackFrame(PatternFlowStackFrame):
     """The ID of the flow to reset to."""
     reset_step_id: Optional[str] = None
     """The ID of the step to reset to."""
+    new_slot_values: List[Any] = field(default_factory=list)
+    """The new values for the corrected slots."""
 
     @classmethod
     def type(cls) -> str:
@@ -70,6 +72,10 @@ class CorrectionPatternFlowStackFrame(PatternFlowStackFrame):
         Returns:
             The created `DialogueStackFrame`.
         """
+        new_slot_values = [
+            val.get("value") for _, val in data["corrected_slots"].items()
+        ]
+
         return CorrectionPatternFlowStackFrame(
             frame_id=data["frame_id"],
             step_id=data["step_id"],
@@ -77,6 +83,7 @@ class CorrectionPatternFlowStackFrame(PatternFlowStackFrame):
             corrected_slots=data["corrected_slots"],
             reset_flow_id=data["reset_flow_id"],
             reset_step_id=data["reset_step_id"],
+            new_slot_values=new_slot_values,
         )
 
 
@@ -118,7 +125,12 @@ class ActionCorrectFlowSlot(action.Action):
             )
             events.extend(tracker.create_stack_updated_events(updated_stack))
 
-        events.extend([SlotSet(k, v) for k, v in top.corrected_slots.items()])
+        events.extend(
+            [
+                SlotSet(name, value=val.get("value"), filled_by=val.get("filled_by"))
+                for name, val in top.corrected_slots.items()
+            ]
+        )
         return events