rasa-pro 3.8.17__py3-none-any.whl → 3.9.14__py3-none-any.whl

rasa/dialogue_understanding/patterns/default_flows_for_patterns.yml

@@ -11,7 +11,7 @@ responses:
         template: jinja
 
   utter_can_do_something_else:
-    - text: "What else I can help you with?"
+    - text: "What else can I help you with?"
       metadata:
         rephrase: True
 
@@ -55,7 +55,7 @@ responses:
         template: jinja
 
   utter_free_chitchat_response:
-    - text: "Sorry, I'm not able to answer that right now."
+    - text: placeholder_this_utterance_needs_the_rephraser
       metadata:
         rephrase: True
         rephrase_prompt: |
@@ -100,11 +100,11 @@ slots:
   confirm_correction:
     type: bool
     mappings:
-      - type: custom
+      - type: from_llm
 
 flows:
   pattern_cancel_flow:
-    description: A meta flow that's started when a flow is cancelled.
+    description: Conversation repair flow that starts when a flow is cancelled
     name: pattern_cancel_flow
     steps:
       - action: action_cancel_flow
@@ -112,72 +112,77 @@ flows:
 
   pattern_cannot_handle:
     description: |
-      pattern that is triggered when the command generators fail to create (any) valid commands
+      Conversation repair flow for addressing failed command generation scenarios
     name: pattern cannot handle
     steps:
       - noop: true
         next:
           # chitchat fallback
-          - if: "'{{context.reason}}' == 'cannot_handle_chitchat'"
+          - if: "'{{context.reason}}' = 'cannot_handle_chitchat'"
             then:
               - action: utter_cannot_handle
                 next: "END"
+          # fallback for things that are not supported
+          - if: "'{{context.reason}}' = 'cannot_handle_not_supported'"
+            then:
+              - action: utter_cannot_handle
+                next: END
           # default
           - else:
               - action: utter_ask_rephrase
-                next: "END"
+                next: END
 
   pattern_chitchat:
-    description: handle interactions with the user that are not task-oriented
+    description: Conversation repair flow for off-topic interactions that won't disrupt the main conversation
     name: pattern chitchat
     steps:
       - action: action_trigger_chitchat
 
   pattern_clarification:
-    description: handle clarifications with the user
+    description: Conversation repair flow for handling ambiguous requests that could match multiple flows
     name: pattern clarification
     steps:
       - action: action_clarify_flows
       - action: utter_clarification_options_rasa
 
   pattern_code_change:
-    description: flow used to clean the stack after a bot update
+    description: Conversation repair flow for cleaning the stack after an assistant update
     name: pattern code change
     steps:
       - action: utter_inform_code_change
       - action: action_clean_stack
 
   pattern_collect_information:
-    description: flow used to fill a slot
+    description: Flow for collecting information from users
     name: pattern collect information
     steps:
-      - id: "start"
+      - id: start
         action: action_run_slot_rejections
       - action: validate_{{context.collect}}
         next:
-          - if: "slots.{{context.collect}} is not null"
-            then: "END"
-          - else: "ask_collect"
-      - id: "ask_collect"
+        - if: "slots.{{context.collect}} is not null"
+          then: END
+        - else: ask_collect
+      - id: ask_collect
         action: "{{context.utter}}"
       - action: "{{context.collect_action}}"
       - action: action_listen
-        next: "start"
+        next: start
 
   pattern_completed:
-    description: a flow has been completed and there is nothing else to be done
+    description: Flow that asks if the user needs more help after completing their initiated use cases
     name: pattern completed
     steps:
       - action: utter_can_do_something_else
 
   pattern_continue_interrupted:
-    description: A flow that should will be started to continue an interrupted flow.
+    description: Conversation repair flow for managing when users switch between different flows
     name: pattern continue interrupted
     steps:
       - action: utter_flow_continue_interrupted
 
   pattern_correction:
-    description: Handle a correction of a slot value.
+    description: Conversation repair flow for managing user input changes or error corrections
     name: pattern correction
     steps:
       - action: action_correct_flow_slot
@@ -185,36 +190,36 @@ flows:
           - if: not context.is_reset_only
             then:
               - action: utter_corrected_previous_input
-                next: "END"
-          - else: "END"
+                next: END
+          - else: END
 
   pattern_human_handoff:
-    description: human handoff
+    description: Conversation repair flow for switching users to a human agent if their request can't be handled
     name: pattern human handoff
     steps:
       - action: utter_human_handoff_not_available
 
   pattern_internal_error:
-    description: internal error
+    description: Conversation repair flow for informing users about internal errors
     name: pattern internal error
     steps:
       - noop: true
         next:
-          - if: "'{{context.error_type}}' == 'rasa_internal_error_user_input_too_long'"
-            then:
-              - action: utter_user_input_too_long_error_rasa
-                next: "END"
-          - if: "'{{context.error_type}}' == 'rasa_internal_error_user_input_empty'"
-            then:
-              - action: utter_user_input_empty_error_rasa
-                next: "END"
-          - else:
-              - action: utter_internal_error_rasa
-                next: "END"
+        - if: "'{{context.error_type}}' = 'rasa_internal_error_user_input_too_long'"
+          then:
+          - action: utter_user_input_too_long_error_rasa
+            next: END
+        - if: "'{{context.error_type}}' = 'rasa_internal_error_user_input_empty'"
+          then:
+            - action: utter_user_input_empty_error_rasa
+              next: END
+        - else:
+            - action: utter_internal_error_rasa
+              next: END
 
 
   pattern_restart:
-    description: flow used to restart the conversation
+    description: Flow for restarting the conversation
     name: pattern restart
     nlu_trigger:
       - intent: restart
@@ -222,14 +227,14 @@ flows:
       - action: action_restart
 
   pattern_search:
-    description: handle a knowledge-based question or request
+    description: Flow for handling knowledge-based questions
     name: pattern search
     steps:
       - action: utter_no_knowledge_base
       # - action: action_trigger_search to use doc search policy if present
 
   pattern_session_start:
-    description: flow used to start the conversation
+    description: Flow for starting the conversation
     name: pattern session start
     nlu_trigger:
       - intent: session_start
@@ -237,7 +242,7 @@ flows:
       - action: action_session_start
 
   pattern_skip_question:
-    description: flow used to handle users intent to skip questions (steps)
+    description: Conversation repair flow for managing user intents to skip questions (steps)
     name: pattern skip question
     steps:
       - action: utter_skip_question_answer

rasa/dialogue_understanding/processor/command_processor.py

@@ -16,6 +16,7 @@ from rasa.dialogue_understanding.commands import (
 from rasa.dialogue_understanding.commands.handle_code_change_command import (
     HandleCodeChangeCommand,
 )
+from rasa.dialogue_understanding.commands.set_slot_command import SetSlotExtractor
 from rasa.dialogue_understanding.patterns.chitchat import FLOW_PATTERN_CHITCHAT
 from rasa.dialogue_understanding.patterns.collect_information import (
     CollectInformationPatternFlowStackFrame,
@@ -36,16 +37,23 @@ from rasa.shared.constants import (
     ROUTE_TO_CALM_SLOT,
     RASA_PATTERN_CANNOT_HANDLE_CHITCHAT,
 )
-from rasa.shared.core.constants import ACTION_TRIGGER_CHITCHAT
+from rasa.shared.core.constants import ACTION_TRIGGER_CHITCHAT, SlotMappingType
 from rasa.shared.core.constants import FLOW_HASHES_SLOT
 from rasa.shared.core.events import Event, SlotSet
 from rasa.shared.core.flows import FlowsList
 from rasa.shared.core.flows.steps.collect import CollectInformationFlowStep
+from rasa.shared.core.slots import Slot
 from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.shared.nlu.constants import COMMANDS
 
 structlogger = structlog.get_logger()
 
+CANNOT_HANDLE_REASON = (
+    "A command generator attempted to set a slot "
+    "with a value extracted by an extractor "
+    "that is incompatible with the slot mapping type."
+)
+
 
 def contains_command(commands: List[Command], typ: Type[Command]) -> bool:
     """Check if a list of commands contains a command of a given type.
@@ -118,7 +126,7 @@ def validate_state_of_commands(commands: List[Command]) -> None:
     ]
     if free_form_answer_commands != commands[: len(free_form_answer_commands)]:
         structlogger.error(
-            "command_processor.validate_state_of_commands.free_form_answer_commands_not_at_beginning",  # noqa: E501
+            "command_processor.validate_state_of_commands.free_form_answer_commands_not_at_beginning",
             commands=commands,
         )
         raise ValueError(
@@ -341,7 +349,6 @@ def clean_up_commands(
     clean_commands: List[Command] = []
 
     for command in commands:
-
         if isinstance(command, SetSlotCommand):
             clean_commands = clean_up_slot_command(
                 clean_commands, command, tracker, all_flows, slots_so_far
@@ -355,6 +362,19 @@ def clean_up_commands(
                 ".skip_command_flow_already_cancelled",
                 command=command,
             )
+
+        # if there is a cannot handle command after the previous step,
+        # we don't want to add another one
+        elif isinstance(command, CannotHandleCommand) and contains_command(
+            clean_commands, CannotHandleCommand
+        ):
+            structlogger.debug(
+                "command_processor"
+                ".clean_up_commands"
+                ".skip_command_already_has_cannot_handle",
+                command=command,
+            )
+
         elif isinstance(command, StartFlowCommand) and command.flow == active_flow:
             # drop a start flow command if the starting flow is equal to the currently
             # active flow
@@ -388,6 +408,13 @@ def clean_up_commands(
         else:
             clean_commands.append(command)
 
+    # when coexistence is enabled, by default there will be a SetSlotCommand
+    # for the ROUTE_TO_CALM_SLOT slot.
+    if tracker.has_coexistence_routing_slot and len(clean_commands) > 2:
+        clean_commands = filter_cannot_handle_command_for_skipped_slots(clean_commands)
+    elif not tracker.has_coexistence_routing_slot and len(clean_commands) > 1:
+        clean_commands = filter_cannot_handle_command_for_skipped_slots(clean_commands)
+
     structlogger.debug(
         "command_processor.clean_up_commands.final_commands",
         command=clean_commands,
@@ -461,6 +488,21 @@ def clean_up_slot_command(
 
     resulting_commands = commands_so_far[:]
     if command.name in slots_so_far and command.name != ROUTE_TO_CALM_SLOT:
+        slot = tracker.slots.get(command.name)
+        if slot is None:
+            structlogger.debug(
+                "command_processor.clean_up_slot_command.skip_command_slot_not_in_domain",
+                command=command,
+            )
+            return resulting_commands
+
+        if not should_slot_be_set(slot, command):
+            cannot_handle = CannotHandleCommand(reason=CANNOT_HANDLE_REASON)
+            if cannot_handle not in resulting_commands:
+                resulting_commands.append(cannot_handle)
+
+            return resulting_commands
+
         current_collect_info = get_current_collect_step(stack, all_flows)
 
         if current_collect_info and current_collect_info.collect == command.name:
@@ -576,3 +618,69 @@ def clean_up_chitchat_command(
         )
 
     return resulting_commands
+
+
+def should_slot_be_set(slot: Slot, command: SetSlotCommand) -> bool:
+    """Check if a slot should be set by a command."""
+    if command.extractor == SetSlotExtractor.COMMAND_PAYLOAD_READER.value:
+        # if the command is issued by the command payload reader, it means the slot
+        # was set deterministically via a response button. In this case,
+        # we can always set it
+        return True
+
+    slot_mappings = slot.mappings
+
+    if not slot_mappings:
+        slot_mappings = [{"type": SlotMappingType.FROM_LLM.value}]
+
+    for mapping in slot_mappings:
+        mapping_type = SlotMappingType(
+            mapping.get("type", SlotMappingType.FROM_LLM.value)
+        )
+
+        should_be_set_by_llm = (
+            command.extractor == SetSlotExtractor.LLM.value
+            and mapping_type == SlotMappingType.FROM_LLM
+        )
+        should_be_set_by_nlu = (
+            command.extractor == SetSlotExtractor.NLU.value
+            and mapping_type.is_predefined_type()
+        )
+
+        if should_be_set_by_llm or should_be_set_by_nlu:
+            # if the extractor matches the mapping type, we can continue
+            # setting the slot
+            break
+
+        structlogger.debug(
+            "command_processor.clean_up_slot_command.skip_command.extractor_"
+            "does_not_match_slot_mapping",
+            extractor=command.extractor,
+            slot_name=slot.name,
+            mapping_type=mapping_type.value,
+        )
+        return False
+
+    return True
+
+
+def filter_cannot_handle_command_for_skipped_slots(
+    clean_commands: List[Command],
+) -> List[Command]:
+    """Filter out a 'cannot handle' command for skipped slots.
+
+    This is used to filter out a 'cannot handle' command for skipped slots
+    in case other commands are present.
+
+    Returns:
+        The filtered commands.
+    """
+    return [
+        command
+        for command in clean_commands
+        if not (
+            isinstance(command, CannotHandleCommand)
+            and command.reason
+            and CANNOT_HANDLE_REASON == command.reason
+        )
+    ]

rasa/e2e_test/constants.py

@@ -8,3 +8,4 @@ KEY_SLOT_SET = "slot_was_set"
 KEY_SLOT_NOT_SET = "slot_was_not_set"
 KEY_STEPS = "steps"
 KEY_TEST_CASE = "test_case"
+KEY_METADATA = "metadata"

rasa/e2e_test/e2e_test_case.py

@@ -8,6 +8,7 @@ from rasa.e2e_test.constants import (
     KEY_BOT_INPUT,
     KEY_BOT_UTTERED,
     KEY_FIXTURES,
+    KEY_METADATA,
     KEY_SLOT_NOT_SET,
     KEY_SLOT_SET,
     KEY_STEPS,
@@ -63,6 +64,7 @@ class TestStep:
     slot_was_not_set: bool = False
     _slot_instance: Optional[Union[Text, Dict[Text, Any]]] = None
     _underlying: Optional[Dict[Text, Any]] = None
+    metadata_name: Optional[Text] = None
 
     @staticmethod
     def from_dict(test_step_dict: Dict[Text, Any]) -> "TestStep":
@@ -71,6 +73,8 @@ class TestStep:
         Example:
             >>> TestStep.from_dict({"user": "hello"})
             TestStep(text="hello", actor="user")
+            >>> TestStep.from_dict({"user": "hello", metadata: "some_metadata"})
+            TestStep(text="hello", actor="user", metadata_name="some_metadata")
             >>> TestStep.from_dict({"bot": "hello world"})
             TestStep(text="hello world", actor="bot")
 
@@ -94,6 +98,7 @@ class TestStep:
             slot_was_not_set=bool(test_step_dict.get(KEY_SLOT_NOT_SET)),
             _slot_instance=slot_instance,
             _underlying=test_step_dict,
+            metadata_name=test_step_dict.get(KEY_METADATA, ""),
         )
 
     @staticmethod
@@ -269,6 +274,7 @@ class TestCase:
     file: Optional[Text] = None
     line: Optional[int] = None
     fixture_names: Optional[List[Text]] = None
+    metadata_name: Optional[Text] = None
 
     @staticmethod
     def from_dict(
@@ -311,6 +317,7 @@ class TestCase:
             if hasattr(input_test_case, "lc")
             else None,
             fixture_names=input_test_case.get(KEY_FIXTURES),
+            metadata_name=input_test_case.get(KEY_METADATA),
         )
 
     def file_with_line(self) -> Text:
@@ -320,3 +327,40 @@ class TestCase:
 
         line = str(self.line) if self.line is not None else ""
         return f"{self.file}:{line}"
+
+
+@dataclass(frozen=True)
+class Metadata:
+    """Class for storing an input metadata."""
+
+    name: Text
+    metadata: Dict[Text, Any]
+
+    @staticmethod
+    def from_dict(metadata_dict: Dict[Text, Any]) -> "Metadata":
+        """Creates a metadata from a dictionary.
+
+        Example:
+            >>> Metadata.from_dict({"some_metadata": {"room": "test_room"}})
+            Metadata(name="some_metadata", metadata={"room": "test_room"})
+
+        Args:
+            metadata_dict: Dictionary containing the metadata.
+        """
+        return Metadata(
+            name=next(iter(metadata_dict.keys())),
+            metadata={
+                metadata_name: metadata_value
+                for metadata in metadata_dict.values()
+                for metadata_name, metadata_value in metadata.items()
+            },
+        )
+
+
+@dataclass(frozen=True)
+class TestSuite:
+    """Class for representing all top level test suite keys."""
+
+    test_cases: List[TestCase]
+    fixtures: List[Fixture]
+    metadata: List[Metadata]