rasa-pro 3.8.16__py3-none-any.whl

rasa/dialogue_understanding/commands/set_slot_command.py

@@ -0,0 +1,125 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Dict, List
+
+import structlog
+from rasa.dialogue_understanding.commands import Command
+from rasa.dialogue_understanding.patterns.collect_information import (
+    CollectInformationPatternFlowStackFrame,
+)
+from rasa.dialogue_understanding.stack.utils import (
+    get_collect_steps_excluding_ask_before_filling_for_active_flow,
+)
+from rasa.shared.constants import ROUTE_TO_CALM_SLOT
+from rasa.shared.core.events import Event, SlotSet
+from rasa.shared.core.flows import FlowsList
+from rasa.shared.core.trackers import DialogueStateTracker
+
+structlogger = structlog.get_logger()
+
+
+def get_flows_predicted_to_start_from_tracker(
+    tracker: DialogueStateTracker,
+) -> List[str]:
+    """Returns the flows that are predicted to start from the current state.
+
+    Args:
+        tracker: The tracker to use.
+
+    Returns:
+        The flows that are predicted to start from the current state.
+    """
+    from rasa.dialogue_understanding.processor.command_processor import (
+        get_commands_from_tracker,
+        filter_start_flow_commands,
+    )
+
+    commands = get_commands_from_tracker(tracker)
+    return filter_start_flow_commands(commands)
+
+
+@dataclass
+class SetSlotCommand(Command):
+    """A command to set a slot."""
+
+    name: str
+    value: Any
+
+    @classmethod
+    def command(cls) -> str:
+        """Returns the command type."""
+        return "set slot"
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> SetSlotCommand:
+        """Converts the dictionary to a command.
+
+        Returns:
+            The converted dictionary.
+        """
+        try:
+            return SetSlotCommand(name=data["name"], value=data["value"])
+        except KeyError as e:
+            raise ValueError(f"Missing key when parsing SetSlotCommand: {e}") from e
+
+    def run_command_on_tracker(
+        self,
+        tracker: DialogueStateTracker,
+        all_flows: FlowsList,
+        original_tracker: DialogueStateTracker,
+    ) -> List[Event]:
+        """Runs the command on the tracker.
+
+        Args:
+            tracker: The tracker to run the command on.
+            all_flows: All flows in the assistant.
+            original_tracker: The tracker before any command was executed.
+
+        Returns:
+            The events to apply to the tracker.
+        """
+        slot = tracker.slots.get(self.name)
+        if slot is None:
+            structlogger.debug(
+                "command_executor.skip_command.slot_not_in_domain", command=self
+            )
+            return []
+
+        if slot.has_same_coerced_value(self.value):
+            # value hasn't changed, skip this one
+            structlogger.debug(
+                "command_executor.skip_command.slot_already_set", command=self
+            )
+            return []
+
+        # Get slots of the active flow
+        slots_of_active_flow = (
+            get_collect_steps_excluding_ask_before_filling_for_active_flow(
+                tracker.stack, all_flows
+            )
+        )
+
+        # Add slots that are asked in the current collect step. This is needed
+        # to include slots that has ask_before_filling set to True.
+        top_frame = tracker.stack.top()
+        if isinstance(top_frame, CollectInformationPatternFlowStackFrame):
+            slots_of_active_flow.add(top_frame.collect)
+
+        if self.name not in slots_of_active_flow and self.name != ROUTE_TO_CALM_SLOT:
+            # Get the other predicted flows from the most recent message on the tracker.
+            predicted_flows = get_flows_predicted_to_start_from_tracker(tracker)
+            use_slot_fill = any(
+                step.collect == self.name and not step.ask_before_filling
+                for flow in all_flows.underlying_flows
+                if flow.id in predicted_flows
+                for step in flow.get_collect_steps()
+            )
+            if not use_slot_fill:
+                structlogger.debug(
+                    "command_executor.skip_command.slot_not_asked_for", command=self
+                )
+                return []
+
+        structlogger.debug("command_executor.set_slot", command=self)
+        return [SlotSet(self.name, slot.coerce_value(self.value))]

rasa/dialogue_understanding/commands/skip_question_command.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Dict, List
+
+import structlog
+from rasa.dialogue_understanding.commands import Command
+from rasa.dialogue_understanding.patterns.skip_question import (
+    SkipQuestionPatternFlowStackFrame,
+)
+from rasa.dialogue_understanding.stack.utils import top_user_flow_frame
+from rasa.shared.core.events import Event
+from rasa.shared.core.flows.flows_list import FlowsList
+from rasa.shared.core.trackers import DialogueStateTracker
+
+structlogger = structlog.get_logger()
+
+
+@dataclass
+class SkipQuestionCommand(Command):
+    """A command that registers the user intent to skip the current question / step in
+    the flow.
+    """
+
+    @classmethod
+    def command(cls) -> str:
+        """Returns the command type."""
+        return "skip question"
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> SkipQuestionCommand:
+        """Converts the dictionary to a command.
+
+        Returns:
+            The converted dictionary.
+        """
+        return SkipQuestionCommand()
+
+    def run_command_on_tracker(
+        self,
+        tracker: DialogueStateTracker,
+        all_flows: FlowsList,
+        original_tracker: DialogueStateTracker,
+    ) -> List[Event]:
+        """Runs the command on the tracker.
+
+        Args:
+            tracker: The tracker to run the command on.
+            all_flows: All flows in the assistant.
+            original_tracker: The tracker before any command was executed.
+
+        Returns:
+            The events to apply to the tracker.
+        """
+        stack = tracker.stack
+        user_frame = top_user_flow_frame(original_tracker.stack)
+        current_flow = user_frame.flow(all_flows) if user_frame else None
+
+        if not current_flow:
+            structlogger.debug(
+                "command_executor.skip_question.no_active_flow", command=self
+            )
+            return []
+
+        stack.push(SkipQuestionPatternFlowStackFrame())
+        return tracker.create_stack_updated_events(stack)

rasa/dialogue_understanding/commands/start_flow_command.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Dict, List
+
+import structlog
+from rasa.dialogue_understanding.commands import Command
+from rasa.dialogue_understanding.stack.frames.flow_stack_frame import (
+    FlowStackFrameType,
+    UserFlowStackFrame,
+)
+from rasa.dialogue_understanding.stack.utils import (
+    top_user_flow_frame,
+    user_flows_on_the_stack,
+)
+from rasa.shared.core.events import Event, FlowInterrupted
+from rasa.shared.core.flows import FlowsList
+from rasa.shared.core.trackers import DialogueStateTracker
+
+structlogger = structlog.get_logger()
+
+
+@dataclass
+class StartFlowCommand(Command):
+    """A command to start a flow."""
+
+    flow: str
+
+    @classmethod
+    def command(cls) -> str:
+        """Returns the command type."""
+        return "start flow"
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> StartFlowCommand:
+        """Converts the dictionary to a command.
+
+        Returns:
+            The converted dictionary.
+        """
+        try:
+            return StartFlowCommand(flow=data["flow"])
+        except KeyError as e:
+            raise ValueError(
+                f"Missing parameter '{e}' while parsing StartFlowCommand."
+            ) from e
+
+    def run_command_on_tracker(
+        self,
+        tracker: DialogueStateTracker,
+        all_flows: FlowsList,
+        original_tracker: DialogueStateTracker,
+    ) -> List[Event]:
+        """Runs the command on the tracker.
+
+        Args:
+            tracker: The tracker to run the command on.
+            all_flows: All flows in the assistant.
+            original_tracker: The tracker before any command was executed.
+
+        Returns:
+            The events to apply to the tracker.
+        """
+        stack = tracker.stack
+        original_stack = original_tracker.stack
+        applied_events: List[Event] = []
+
+        if self.flow in user_flows_on_the_stack(stack):
+            structlogger.debug(
+                "command_executor.skip_command.already_started_flow", command=self
+            )
+            return []
+        elif self.flow not in all_flows.flow_ids:
+            structlogger.debug(
+                "command_executor.skip_command.start_invalid_flow_id", command=self
+            )
+            return []
+
+        original_user_frame = top_user_flow_frame(original_stack)
+        original_top_flow = (
+            original_user_frame.flow(all_flows) if original_user_frame else None
+        )
+
+        frame_type = FlowStackFrameType.REGULAR
+
+        if original_top_flow:
+            frame_type = FlowStackFrameType.INTERRUPT
+
+            if original_user_frame is not None:
+                applied_events.append(
+                    FlowInterrupted(
+                        original_user_frame.flow_id, original_user_frame.step_id
+                    )
+                )
+
+        structlogger.debug("command_executor.start_flow", command=self)
+        stack.push(UserFlowStackFrame(flow_id=self.flow, frame_type=frame_type))
+        return applied_events + tracker.create_stack_updated_events(stack)

rasa/dialogue_understanding/generator/__init__.py

@@ -0,0 +1,6 @@
+from rasa.dialogue_understanding.generator.command_generator import CommandGenerator
+from rasa.dialogue_understanding.generator.llm_command_generator import (
+    LLMCommandGenerator,
+)
+
+__all__ = ["CommandGenerator", "LLMCommandGenerator"]

rasa/dialogue_understanding/generator/command_generator.py

@@ -0,0 +1,257 @@
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional, Text
+
+import structlog
+
+from rasa.dialogue_understanding.commands import Command, StartFlowCommand, ErrorCommand
+from rasa.shared.core.flows import FlowsList
+from rasa.shared.core.trackers import DialogueStateTracker
+from rasa.shared.nlu.training_data.message import Message
+from rasa.shared.nlu.constants import COMMANDS, TEXT
+from rasa.shared.utils.llm import DEFAULT_MAX_USER_INPUT_CHARACTERS
+from rasa.shared.constants import (
+    RASA_PATTERN_INTERNAL_ERROR_USER_INPUT_TOO_LONG,
+    RASA_PATTERN_INTERNAL_ERROR_USER_INPUT_EMPTY,
+)
+
+structlogger = structlog.get_logger()
+
+
+@dataclass
+class UserInputConfig:
+    """Configuration class for user input settings."""
+
+    max_characters: int = DEFAULT_MAX_USER_INPUT_CHARACTERS
+    """The maximum number of characters allowed in the user input."""
+
+    def __post_init__(self) -> None:
+        if self.max_characters is None:
+            self.max_characters = DEFAULT_MAX_USER_INPUT_CHARACTERS
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "UserInputConfig":
+        return cls(
+            max_characters=data.get("max_characters", DEFAULT_MAX_USER_INPUT_CHARACTERS)
+        )
+
+
+class CommandGenerator:
+    """A command generator.
+
+    Parses a message and returns a list of commands. The commands are then
+    executed and will lead to tracker state modifications and action
+    predictions.
+    """
+
+    def __init__(self, config: Dict[Text, Any]):
+        self.user_input_config = UserInputConfig.from_dict(
+            config.get("user_input") or {}
+        )
+
+    async def process(
+        self,
+        messages: List[Message],
+        flows: FlowsList,
+        tracker: Optional[DialogueStateTracker] = None,
+    ) -> List[Message]:
+        """Process a list of messages. For each message predict commands.
+
+        The result of the generation is added to the message as a list of
+        commands.
+
+        Args:
+            messages: The messages to process.
+            tracker: The tracker containing the conversation history up to now.
+            flows: The flows to use for command prediction.
+
+        Returns:
+        The processed messages (usually this is just one during prediction).
+        """
+        # Determines a set of startable flows by evaluating flow guard conditions.
+        startable_flows = self.get_startable_flows(flows, tracker)
+        # Get the currently active and called flow (if present).
+        # If they would be guarded, e.g. if: false, they would not be in the list
+        # of startable flows and not available inside the prompt.
+        active_flows = self.get_active_flows(flows, tracker)
+        available_flows = FlowsList.from_multiple_flows_lists(
+            startable_flows, active_flows
+        )
+
+        for message in messages:
+
+            if message.get(COMMANDS):
+                # do not overwrite commands if they are already present
+                # i.e. another command generator already predicted commands
+                continue
+
+            commands = await self._evaluate_and_predict(
+                message, available_flows, tracker
+            )
+            # Double check commands for guarded flows. Unlikely but the llm could
+            # have predicted a command for a flow that is not in the startable
+            # flow list supplied in the prompt.
+            commands = self._check_commands_against_startable_flows(
+                commands, startable_flows
+            )
+            commands_dicts = [command.as_dict() for command in commands]
+            message.set(COMMANDS, commands_dicts, add_to_output=True)
+
+        return messages
+
+    def get_startable_flows(
+        self, flows: FlowsList, tracker: Optional[DialogueStateTracker] = None
+    ) -> FlowsList:
+        """Determines a set of startable flows by evaluating flow guard conditions.
+
+        Args:
+            flows: Underlying flows.
+            tracker: The tracker containing the conversation history up to now.
+
+        Returns:
+            FlowsList: All flows for which the starting conditions are met.
+        """
+        if tracker is not None:
+            # if tracker is not None, evaluate the flow guard conditions with
+            # the current state of the tracker
+            return tracker.get_startable_flows(flows)
+
+        # else evaluate it without the tracker context
+        return flows.get_startable_flows({})
+
+    def get_active_flows(
+        self, flows: FlowsList, tracker: Optional[DialogueStateTracker]
+    ) -> FlowsList:
+        """Retrieve a list of currently active flows.
+
+        Args:
+            flows: Underlying flows.
+            tracker: The tracker.
+
+        Returns:
+            FlowsList: All currently active flows.
+        """
+        if not tracker:
+            return FlowsList([])
+        return tracker.get_active_flows(flows)
+
+    async def _evaluate_and_predict(
+        self,
+        message: Message,
+        startable_flows: FlowsList,
+        tracker: Optional[DialogueStateTracker] = None,
+    ) -> List[Command]:
+        """Evaluates message for errors and predicts commands if no errors are found.
+
+        Args:
+            message: The message to process.
+            tracker: The tracker containing the conversation history up to now.
+            startable_flows: The startable flows to use for command prediction.
+
+        Returns:
+            Errors or predicted commands
+        """
+        # evaluate message for errors
+        if error_commands := self.evaluate_message(message):
+            return error_commands
+
+        # if no errors, try predicting commands
+        try:
+            return await self.predict_commands(message, startable_flows, tracker)
+        except NotImplementedError:
+            raise
+        except Exception as e:
+            structlogger.error("command_generator.predict.error", error=str(e))
+            return []
+
+    async def predict_commands(
+        self,
+        message: Message,
+        flows: FlowsList,
+        tracker: Optional[DialogueStateTracker] = None,
+    ) -> List[Command]:
+        """Predict commands for a single message.
+
+        Args:
+            message: The message to predict commands for.
+            flows: The flows to use for command prediction.
+            tracker: The tracker containing the conversation history up to now.
+
+        Returns:
+        The predicted commands.
+        """
+        raise NotImplementedError()
+
+    def _check_commands_against_startable_flows(
+        self, commands: List[Command], startable_flows: FlowsList
+    ) -> List[Command]:
+        """Check if the start flow commands are only for startable flows.
+
+        Args:
+            commands: The commands to check.
+            startable_flows: The flows which have their starting conditions statisfied.
+
+        Returns:
+            The commands that are startable.
+        """
+        checked_commands = [
+            command
+            for command in commands
+            if not (
+                isinstance(command, StartFlowCommand)
+                and command.flow not in startable_flows.flow_ids
+            )
+        ]
+
+        if commands and len(checked_commands) != len(commands):
+            structlogger.info(
+                "command_generator.check_commands_against_startable_flows.startable_commands",
+                commands=checked_commands,
+            )
+
+        return checked_commands
+
+    def evaluate_message(self, message: Message) -> List[Command]:
+        """Evaluates the given message.
+
+        Args:
+            message: The message to evaluate.
+
+        Returns:
+            A list of error commands indicating the type of error.
+        """
+        errors: List[Command]
+
+        if self.check_if_message_is_empty(message):
+            # notify the user that the message is empty
+            errors = [
+                ErrorCommand(error_type=RASA_PATTERN_INTERNAL_ERROR_USER_INPUT_EMPTY)
+            ]
+        elif self.check_if_message_exceeds_limit(message):
+            # notify the user about message length
+            errors = [
+                ErrorCommand(
+                    error_type=RASA_PATTERN_INTERNAL_ERROR_USER_INPUT_TOO_LONG,
+                    info={"max_characters": self.user_input_config.max_characters},
+                )
+            ]
+        else:
+            return []
+
+        structlogger.info(
+            "command_generator.evaluate_message.error",
+            event_info="Invalid message",
+            errors=[e.as_dict() for e in errors],
+            message=message.get(TEXT),
+        )
+        return errors
+
+    def check_if_message_exceeds_limit(self, message: Message) -> bool:
+        """Checks if the given message exceeds the predefined number of characters."""
+        # if limit was a negative number, omit it
+        if self.user_input_config.max_characters < 0:
+            return False
+        return len(message.get(TEXT, "")) > self.user_input_config.max_characters
+
+    def check_if_message_is_empty(self, message: Message) -> bool:
+        """Checks if the given message is empty or whitespace-only."""
+        return len(message.get(TEXT, "").strip()) == 0

rasa/dialogue_understanding/generator/command_prompt_template.jinja2

@@ -0,0 +1,57 @@
+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 %}
+
+===
+Here is what happened previously in the conversation:
+{{ current_conversation }}
+
+===
+{% 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()".
+
+===
+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/flow_document_template.jinja2

@@ -0,0 +1,4 @@
+{{ flow.name }}: {{ flow.description }}
+    {% for slot in flow.slots -%}
+    {{ slot.name }}: {% if slot.description %}{{ slot.description }}{% endif %}{% if slot.allowed_values %}, allowed values: {{ slot.allowed_values }}{% endif %}
+    {% endfor %}