rasa-pro 3.12.0.dev1__py3-none-any.whl

rasa/dialogue_understanding/patterns/default_flows_for_patterns.yml

@@ -0,0 +1,301 @@
+version: "3.1"
+responses:
+
+  utter_ask_rephrase:
+    - text: I’m sorry I am unable to understand you, could you please rephrase?
+
+  utter_ask_still_there:
+    - text: "Hello, are you still there?"
+      metadata:
+        rephrase: True
+
+  utter_boolean_slot_rejection:
+    - text: "Sorry, the value you provided, `{{value}}`, is not valid. Please respond with a valid value."
+      metadata:
+        rephrase: True
+        template: jinja
+
+  utter_can_do_something_else:
+    - text: "What else can I help you with?"
+      metadata:
+        rephrase: True
+
+  utter_cannot_handle:
+    - text: I'm sorry, I'm not trained to help with that.
+
+  utter_categorical_slot_rejection:
+    - text: "Sorry, you responded with an invalid value - `{{value}}`. Please select one of the available options."
+      metadata:
+        rephrase: True
+        template: jinja
+
+  utter_clarification_options_rasa:
+    - text: "I can help, but I need more information. Which of these would you like to do: {{context.clarification_options}}?"
+      metadata:
+        rephrase: True
+        template: jinja
+
+  utter_corrected_previous_input:
+    - text: "Ok, I am updating {{ context.corrected_slots.keys()|join(', ') }} to {{ context.corrected_slots.values()|join(', ') }} respectively."
+      metadata:
+        rephrase: True
+        template: jinja
+
+  utter_float_slot_rejection:
+    - text: "Sorry, it seems the value you provided `{{value}}` is not a valid number. Please provide a valid number in your response."
+      metadata:
+        rephrase: True
+        template: jinja
+
+  utter_flow_cancelled_rasa:
+    - text: "Okay, stopping {{ context.canceled_name }}."
+      metadata:
+        rephrase: True
+        template: jinja
+
+  utter_flow_continue_interrupted:
+    - text: "Let's continue with {{ context.previous_flow_name }}."
+      metadata:
+        rephrase: True
+        template: jinja
+
+  utter_free_chitchat_response:
+    - text: "Sorry, I'm not able to answer that right now."
+      metadata:
+        rephrase: True
+        rephrase_prompt: |
+          You are an incredibly friendly assistant. Generate a short
+          response to the user's comment in simple english.
+
+          User: {{current_input}}
+          Response:
+
+  utter_human_handoff_not_available:
+    - text: I understand you want to be connected to a human agent, but that's something I cannot help you with at the moment. Is there something else I can help you with?
+      metadata:
+        rephrase: True
+
+  utter_inform_code_change:
+    - text: There has been an update to my code. I need to wrap up our running dialogue and start from scratch.
+      metadata:
+        rephrase: True
+
+  utter_inform_hangup:
+    - text: It seems you are not there anymore. I will hang up shortly.
+      metadata:
+        rephrase: True
+
+  utter_internal_error_rasa:
+    - text: Sorry, I am having trouble with that. Please try again in a few minutes.
+
+  utter_no_knowledge_base:
+    - text: I am afraid, I don't know the answer. At this point, I don't have access to a knowledge base.
+      metadata:
+        rephrase: True
+
+  utter_skip_question_answer:
+    - text: I'm here to provide you with the best assistance, and in order to do so, I kindly request that we complete this step together. Your input is essential for a seamless experience!
+      metadata:
+        rephrase: True
+
+  utter_user_input_empty_error_rasa:
+    - text: I see an empty message. What can I assist you with?
+
+  utter_user_input_too_long_error_rasa:
+    - text: I'm sorry, but your message is too long for me to process. Please keep your message concise and within {% if context.info.max_characters %}{{context.info.max_characters}} characters.{% else %}a reasonable length.{% endif %}
+      metadata:
+        template: jinja
+
+slots:
+  confirm_correction:
+    type: bool
+    mappings:
+      - type: from_llm
+  silence_timeout:
+    type: float
+    initial_value: 6.0
+    max_value: 1000000
+  consecutive_silence_timeouts:
+    type: float
+    initial_value: 0.0
+    max_value: 1000000
+
+
+flows:
+  pattern_cancel_flow:
+    description: Conversation repair flow that starts when a flow is cancelled
+    name: pattern_cancel_flow
+    steps:
+      - action: action_cancel_flow
+      - action: utter_flow_cancelled_rasa
+
+  pattern_cannot_handle:
+    description: |
+      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'"
+            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
+
+  pattern_chitchat:
+    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: 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: 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 for collecting information from users
+    name: pattern collect information
+    steps:
+      - 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
+        action: "{{context.utter}}"
+      - action: "{{context.collect_action}}"
+      - action: action_listen
+        next: start
+
+  pattern_completed:
+    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: Conversation repair flow for managing when users switch between different flows
+    name: pattern continue interrupted
+    steps:
+      - action: utter_flow_continue_interrupted
+
+  pattern_correction:
+    description: Conversation repair flow for managing user input changes or error corrections
+    name: pattern correction
+    steps:
+      - action: action_correct_flow_slot
+        next:
+          - if: not context.is_reset_only
+            then:
+              - action: utter_corrected_previous_input
+                next: END
+          - else: END
+
+  pattern_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: 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
+
+  pattern_repeat_bot_messages:
+    description: Voice conversation repair pattern to repeat bot messages
+    name: pattern repeat bot messages
+    steps:
+      - action: action_repeat_bot_messages
+
+  pattern_restart:
+    description: Flow for restarting the conversation
+    name: pattern restart
+    nlu_trigger:
+      - intent: restart
+    steps:
+      - action: action_restart
+
+  pattern_search:
+    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 for starting the conversation
+    name: pattern session start
+    nlu_trigger:
+      - intent: session_start
+    steps:
+      - action: action_session_start
+
+  pattern_skip_question:
+    description: Conversation repair flow for managing user intents to skip questions (steps)
+    name: pattern skip question
+    steps:
+      - action: utter_skip_question_answer
+
+  pattern_user_silence:
+    description: Reacting to user silence in voice bots
+    name: pattern react to silence
+    nlu_trigger:
+      - intent: silence_timeout
+    persisted_slots:
+      - consecutive_silence_timeouts
+    steps:
+      - noop: true
+        next:
+          - if: "slots.consecutive_silence_timeouts = 0.0"
+            then:
+              - set_slots:
+                  - consecutive_silence_timeouts: 1.0
+              - action: action_repeat_bot_messages
+                next: END
+          - if: "slots.consecutive_silence_timeouts = 1.0"
+            then:
+              - set_slots:
+                  - consecutive_silence_timeouts: 2.0
+              - action: utter_ask_still_there
+                next: END
+          - if: "slots.consecutive_silence_timeouts > 1.0"
+            then:
+              - action: utter_inform_hangup
+              - action: action_hangup
+                next: END
+          - else: END

rasa/dialogue_understanding/patterns/human_handoff.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Any, Dict
+
+from rasa.dialogue_understanding.stack.frames import PatternFlowStackFrame
+from rasa.shared.constants import RASA_DEFAULT_FLOW_PATTERN_PREFIX
+
+
+FLOW_PATTERN_HUMAN_HANDOFF = RASA_DEFAULT_FLOW_PATTERN_PREFIX + "human_handoff"
+
+
+@dataclass
+class HumanHandoffPatternFlowStackFrame(PatternFlowStackFrame):
+    """A pattern flow stack frame which hands off to a human."""
+
+    flow_id: str = FLOW_PATTERN_HUMAN_HANDOFF
+    """The ID of the flow."""
+
+    @classmethod
+    def type(cls) -> str:
+        """Returns the type of the frame."""
+        return FLOW_PATTERN_HUMAN_HANDOFF
+
+    @staticmethod
+    def from_dict(data: Dict[str, Any]) -> HumanHandoffPatternFlowStackFrame:
+        """Creates a `DialogueStackFrame` from a dictionary.
+
+        Args:
+            data: The dictionary to create the `DialogueStackFrame` from.
+
+        Returns:
+            The created `DialogueStackFrame`.
+        """
+        return HumanHandoffPatternFlowStackFrame(
+            frame_id=data["frame_id"],
+            step_id=data["step_id"],
+        )

rasa/dialogue_understanding/patterns/internal_error.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+from dataclasses import dataclass, field
+from typing import Any, Dict, Optional, Text
+
+from rasa.dialogue_understanding.stack.frames import PatternFlowStackFrame
+from rasa.shared.constants import (
+    RASA_DEFAULT_FLOW_PATTERN_PREFIX,
+    RASA_PATTERN_INTERNAL_ERROR_DEFAULT,
+)
+
+FLOW_PATTERN_INTERNAL_ERROR_ID = RASA_DEFAULT_FLOW_PATTERN_PREFIX + "internal_error"
+
+
+@dataclass
+class InternalErrorPatternFlowStackFrame(PatternFlowStackFrame):
+    """A pattern flow stack frame that gets added if an internal error occurs."""
+
+    flow_id: str = FLOW_PATTERN_INTERNAL_ERROR_ID
+    """The ID of the flow."""
+
+    error_type: Optional[Text] = RASA_PATTERN_INTERNAL_ERROR_DEFAULT
+    """Error type used in switch-case of the error pattern flow."""
+
+    info: Dict[Text, Any] = field(default_factory=dict)
+    """Additional info to be provided to the user"""
+
+    @classmethod
+    def type(cls) -> str:
+        """Returns the type of the frame."""
+        return FLOW_PATTERN_INTERNAL_ERROR_ID
+
+    @staticmethod
+    def from_dict(data: Dict[str, Any]) -> InternalErrorPatternFlowStackFrame:
+        """Creates a `DialogueStackFrame` from a dictionary.
+
+        Args:
+            data: The dictionary to create the `DialogueStackFrame` from.
+
+        Returns:
+            The created `DialogueStackFrame`.
+        """
+        return InternalErrorPatternFlowStackFrame(
+            frame_id=data["frame_id"],
+            step_id=data["step_id"],
+            error_type=data.get("error_type", RASA_PATTERN_INTERNAL_ERROR_DEFAULT),
+            info=data.get("info", {}),
+        )

rasa/dialogue_understanding/patterns/repeat.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Dict
+
+from rasa.dialogue_understanding.stack.frames import PatternFlowStackFrame
+from rasa.shared.constants import RASA_DEFAULT_FLOW_PATTERN_PREFIX
+
+FLOW_PATTERN_REPEAT = RASA_DEFAULT_FLOW_PATTERN_PREFIX + "repeat_bot_messages"
+
+
+@dataclass
+class RepeatBotMessagesPatternFlowStackFrame(PatternFlowStackFrame):
+    """A flow stack frame that can get added when bot messages should be repeated"""
+
+    flow_id: str = FLOW_PATTERN_REPEAT
+    """The ID of the flow."""
+
+    @classmethod
+    def type(cls) -> str:
+        """Returns the type of the frame."""
+        return FLOW_PATTERN_REPEAT
+
+    @staticmethod
+    def from_dict(data: Dict[str, Any]) -> RepeatBotMessagesPatternFlowStackFrame:
+        """Creates a `DialogueStackFrame` from a dictionary.
+
+        Args:
+            data: The dictionary to create the `DialogueStackFrame` from.
+
+        Returns:
+            The created `DialogueStackFrame`.
+        """
+        return RepeatBotMessagesPatternFlowStackFrame(
+            frame_id=data["frame_id"],
+            step_id=data["step_id"],
+        )

rasa/dialogue_understanding/patterns/restart.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Dict
+
+from rasa.dialogue_understanding.stack.frames import PatternFlowStackFrame
+from rasa.shared.constants import RASA_DEFAULT_FLOW_PATTERN_PREFIX
+
+FLOW_PATTERN_RESTART = RASA_DEFAULT_FLOW_PATTERN_PREFIX + "restart"
+
+
+@dataclass
+class RestartPatternFlowStackFrame(PatternFlowStackFrame):
+    """A flow stack frame that can get added at the beginning of the conversation."""
+
+    flow_id: str = FLOW_PATTERN_RESTART
+    """The ID of the flow."""
+
+    @classmethod
+    def type(cls) -> str:
+        """Returns the type of the frame."""
+        return FLOW_PATTERN_RESTART
+
+    @staticmethod
+    def from_dict(data: Dict[str, Any]) -> RestartPatternFlowStackFrame:
+        """Creates a `DialogueStackFrame` from a dictionary.
+
+        Args:
+            data: The dictionary to create the `DialogueStackFrame` from.
+
+        Returns:
+            The created `DialogueStackFrame`.
+        """
+        return RestartPatternFlowStackFrame(
+            frame_id=data["frame_id"],
+            step_id=data["step_id"],
+        )

rasa/dialogue_understanding/patterns/search.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Any, Dict
+
+from rasa.dialogue_understanding.stack.frames import PatternFlowStackFrame
+from rasa.shared.constants import RASA_DEFAULT_FLOW_PATTERN_PREFIX
+
+
+FLOW_PATTERN_SEARCH = RASA_DEFAULT_FLOW_PATTERN_PREFIX + "search"
+
+
+@dataclass
+class SearchPatternFlowStackFrame(PatternFlowStackFrame):
+    """A stack frame that gets added to respond to knowledge-oriented questions."""
+
+    flow_id: str = FLOW_PATTERN_SEARCH
+    """The ID of the flow."""
+
+    @classmethod
+    def type(cls) -> str:
+        """Returns the type of the frame."""
+        return FLOW_PATTERN_SEARCH
+
+    @staticmethod
+    def from_dict(data: Dict[str, Any]) -> SearchPatternFlowStackFrame:
+        """Creates a `DialogueStackFrame` from a dictionary.
+
+        Args:
+            data: The dictionary to create the `DialogueStackFrame` from.
+
+        Returns:
+            The created `DialogueStackFrame`.
+        """
+        return SearchPatternFlowStackFrame(
+            frame_id=data["frame_id"],
+            step_id=data["step_id"],
+        )

rasa/dialogue_understanding/patterns/session_start.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Any, Dict
+
+from rasa.dialogue_understanding.stack.frames import PatternFlowStackFrame
+from rasa.shared.constants import RASA_DEFAULT_FLOW_PATTERN_PREFIX
+
+
+FLOW_PATTERN_SESSION_START = RASA_DEFAULT_FLOW_PATTERN_PREFIX + "session_start"
+
+
+@dataclass
+class SessionStartPatternFlowStackFrame(PatternFlowStackFrame):
+    """A flow stack frame that can get added at the beginning of the conversation."""
+
+    flow_id: str = FLOW_PATTERN_SESSION_START
+    """The ID of the flow."""
+
+    @classmethod
+    def type(cls) -> str:
+        """Returns the type of the frame."""
+        return FLOW_PATTERN_SESSION_START
+
+    @staticmethod
+    def from_dict(data: Dict[str, Any]) -> SessionStartPatternFlowStackFrame:
+        """Creates a `DialogueStackFrame` from a dictionary.
+
+        Args:
+            data: The dictionary to create the `DialogueStackFrame` from.
+
+        Returns:
+            The created `DialogueStackFrame`.
+        """
+        return SessionStartPatternFlowStackFrame(
+            frame_id=data["frame_id"],
+            step_id=data["step_id"],
+        )

rasa/dialogue_understanding/patterns/skip_question.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Any, Dict
+
+from rasa.dialogue_understanding.stack.frames import PatternFlowStackFrame
+from rasa.shared.constants import RASA_DEFAULT_FLOW_PATTERN_PREFIX
+
+FLOW_PATTERN_SKIP_QUESTION = RASA_DEFAULT_FLOW_PATTERN_PREFIX + "skip_question"
+
+
+@dataclass
+class SkipQuestionPatternFlowStackFrame(PatternFlowStackFrame):
+    """A pattern flow stack frame that gets added if user interrupts the current flow by
+    trying to bypass the collect information step.
+    """
+
+    flow_id: str = FLOW_PATTERN_SKIP_QUESTION
+    """The ID of the flow."""
+
+    @classmethod
+    def type(cls) -> str:
+        """Returns the type of the frame."""
+        return FLOW_PATTERN_SKIP_QUESTION
+
+    @staticmethod
+    def from_dict(data: Dict[str, Any]) -> SkipQuestionPatternFlowStackFrame:
+        """Creates a `DialogueStackFrame` from a dictionary.
+
+        Args:
+            data: The dictionary to create the `DialogueStackFrame` from.
+
+        Returns:
+            The created `DialogueStackFrame`.
+        """
+        return SkipQuestionPatternFlowStackFrame(
+            frame_id=data["frame_id"],
+            step_id=data["step_id"],
+        )

rasa/dialogue_understanding/patterns/user_silence.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Any, Dict
+
+from rasa.dialogue_understanding.stack.frames import PatternFlowStackFrame
+from rasa.shared.constants import RASA_DEFAULT_FLOW_PATTERN_PREFIX
+
+
+FLOW_PATTERN_USER_SILENCE = RASA_DEFAULT_FLOW_PATTERN_PREFIX + "user_silence"
+
+
+@dataclass
+class UserSilencePatternFlowStackFrame(PatternFlowStackFrame):
+    """A flow stack frame that can get added when the silence timeout trips."""
+
+    flow_id: str = FLOW_PATTERN_USER_SILENCE
+    """The ID of the flow."""
+
+    @classmethod
+    def type(cls) -> str:
+        """Returns the type of the frame."""
+        return FLOW_PATTERN_USER_SILENCE
+
+    @staticmethod
+    def from_dict(data: Dict[str, Any]) -> UserSilencePatternFlowStackFrame:
+        """Creates a `DialogueStackFrame` from a dictionary.
+
+        Args:
+            data: The dictionary to create the `DialogueStackFrame` from.
+
+        Returns:
+            The created `DialogueStackFrame`.
+        """
+        return UserSilencePatternFlowStackFrame(
+            frame_id=data["frame_id"],
+            step_id=data["step_id"],
+        )