rasa-pro 3.11.3a1.dev2__py3-none-any.whl

rasa/dialogue_understanding/commands/user_silence_command.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Dict, List
+from rasa.dialogue_understanding.commands import Command
+from rasa.dialogue_understanding.patterns.user_silence import (
+    UserSilencePatternFlowStackFrame,
+)
+from rasa.shared.core.events import Event
+from rasa.shared.core.flows import FlowsList
+from rasa.shared.core.trackers import DialogueStateTracker
+
+
+@dataclass
+class UserSilenceCommand(Command):
+    """A command to indicate user silence."""
+
+    @classmethod
+    def command(cls) -> str:
+        """Returns the command type."""
+        return "user silence"
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> UserSilenceCommand:
+        """Converts the dictionary to a command.
+
+        Returns:
+            The converted dictionary.
+        """
+        return UserSilenceCommand()
+
+    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
+        stack.push(UserSilencePatternFlowStackFrame())
+        return tracker.create_stack_updated_events(stack)
+
+    def __hash__(self) -> int:
+        return hash(self.command())
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, UserSilenceCommand):
+            return False
+
+        return True

rasa/dialogue_understanding/commands/utils.py

@@ -0,0 +1,45 @@
+from typing import Dict, Type
+
+from rasa.dialogue_understanding.commands import (
+    CancelFlowCommand,
+    CannotHandleCommand,
+    ChitChatAnswerCommand,
+    Command,
+    HumanHandoffCommand,
+    KnowledgeAnswerCommand,
+    SessionStartCommand,
+    SkipQuestionCommand,
+    RestartCommand,
+)
+from rasa.dialogue_understanding.commands.user_silence_command import UserSilenceCommand
+from rasa.dialogue_understanding.patterns.cancel import CancelPatternFlowStackFrame
+from rasa.dialogue_understanding.patterns.cannot_handle import (
+    CannotHandlePatternFlowStackFrame,
+)
+from rasa.dialogue_understanding.patterns.chitchat import ChitchatPatternFlowStackFrame
+from rasa.dialogue_understanding.patterns.human_handoff import (
+    HumanHandoffPatternFlowStackFrame,
+)
+from rasa.dialogue_understanding.patterns.restart import RestartPatternFlowStackFrame
+from rasa.dialogue_understanding.patterns.search import SearchPatternFlowStackFrame
+from rasa.dialogue_understanding.patterns.session_start import (
+    SessionStartPatternFlowStackFrame,
+)
+from rasa.dialogue_understanding.patterns.skip_question import (
+    SkipQuestionPatternFlowStackFrame,
+)
+from rasa.dialogue_understanding.patterns.user_silence import (
+    UserSilencePatternFlowStackFrame,
+)
+
+triggerable_pattern_to_command_class: Dict[str, Type[Command]] = {
+    SessionStartPatternFlowStackFrame.flow_id: SessionStartCommand,
+    UserSilencePatternFlowStackFrame.flow_id: UserSilenceCommand,
+    CancelPatternFlowStackFrame.flow_id: CancelFlowCommand,
+    ChitchatPatternFlowStackFrame.flow_id: ChitChatAnswerCommand,
+    HumanHandoffPatternFlowStackFrame.flow_id: HumanHandoffCommand,
+    SearchPatternFlowStackFrame.flow_id: KnowledgeAnswerCommand,
+    SkipQuestionPatternFlowStackFrame.flow_id: SkipQuestionCommand,
+    CannotHandlePatternFlowStackFrame.flow_id: CannotHandleCommand,
+    RestartPatternFlowStackFrame.flow_id: RestartCommand,
+}

rasa/dialogue_understanding/generator/__init__.py

@@ -0,0 +1,21 @@
+from rasa.dialogue_understanding.generator.command_generator import CommandGenerator
+from rasa.dialogue_understanding.generator.llm_based_command_generator import (
+    LLMBasedCommandGenerator,
+)
+from rasa.dialogue_understanding.generator.llm_command_generator import (
+    LLMCommandGenerator,
+)
+from rasa.dialogue_understanding.generator.multi_step.multi_step_llm_command_generator import (  # noqa: E501
+    MultiStepLLMCommandGenerator,
+)
+from rasa.dialogue_understanding.generator.single_step.single_step_llm_command_generator import (  # noqa: E501
+    SingleStepLLMCommandGenerator,
+)
+
+__all__ = [
+    "CommandGenerator",
+    "LLMBasedCommandGenerator",
+    "LLMCommandGenerator",
+    "MultiStepLLMCommandGenerator",
+    "SingleStepLLMCommandGenerator",
+]

rasa/dialogue_understanding/generator/command_generator.py

@@ -0,0 +1,472 @@
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional, Text
+
+import structlog
+
+from rasa.dialogue_understanding.commands import (
+    Command,
+    SetSlotCommand,
+    StartFlowCommand,
+    ErrorCommand,
+)
+from rasa.dialogue_understanding.commands.set_slot_command import SetSlotExtractor
+from rasa.shared.constants import (
+    RASA_PATTERN_INTERNAL_ERROR_USER_INPUT_TOO_LONG,
+    RASA_PATTERN_INTERNAL_ERROR_USER_INPUT_EMPTY,
+)
+from rasa.shared.core.constants import SlotMappingType
+from rasa.shared.core.domain import Domain
+from rasa.shared.core.flows import FlowsList
+from rasa.shared.core.slot_mappings import SlotFillingManager
+from rasa.shared.core.trackers import DialogueStateTracker
+from rasa.shared.nlu.constants import (
+    COMMANDS,
+    TEXT,
+    PREDICTED_COMMANDS,
+    PROMPTS,
+    KEY_USER_PROMPT,
+    KEY_SYSTEM_PROMPT,
+    KEY_LLM_RESPONSE_METADATA,
+)
+from rasa.shared.nlu.training_data.message import Message
+from rasa.shared.providers.llm.llm_response import LLMResponse
+from rasa.shared.utils.llm import DEFAULT_MAX_USER_INPUT_CHARACTERS
+
+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,
+        domain: Optional[Domain] = 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.
+            domain: The domain.
+
+        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, domain
+            )
+            # 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 = self._check_commands_against_slot_mappings(
+                commands, tracker, domain
+            )
+            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,
+        domain: Optional[Domain] = 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, domain=domain
+            )
+        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,
+        **kwargs: Any,
+    ) -> 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.
+            **kwargs: Keyword arguments for forward compatibility.
+
+        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 satisfied.
+
+        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
+
+    @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.
+        """
+        if not domain:
+            return commands
+
+        llm_fillable_slot_names = [
+            command.name
+            for command in commands
+            if isinstance(command, SetSlotCommand)
+            and command.extractor == SetSlotExtractor.LLM.value
+        ]
+
+        if not llm_fillable_slot_names:
+            return commands
+
+        llm_fillable_slots = [
+            slot for slot in domain.slots if slot.name in llm_fillable_slot_names
+        ]
+
+        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:
+                mapping_type = SlotMappingType(mapping.get("type"))
+
+                should_fill_slot = slot_filling_manager.should_fill_slot(
+                    slot.name, mapping_type, 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,
+                )
+                slots_to_be_removed.append(slot.name)
+
+        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
+
+    @staticmethod
+    def _add_commands_to_message_parse_data(
+        message: Message, component_name: str, commands: List[Command]
+    ) -> None:
+        """Add commands to the message parse data.
+
+        Commands are only added in case the flag 'record_commands_and_prompts' is set.
+        Example of predicted commands in the message parse data:
+            Message(data={
+              PREDICTED_COMMANDS: {
+                "MultiStepLLMCommandGenerator": [
+                    {"command": "set_slot", "name": "slot_name", "value": "slot_value"},
+                ],
+                "NLUCommandAdapter": [
+                    {"command": "start_flow", "name": "test_flow"},
+                ]
+              }
+            })
+        """
+        from rasa.dialogue_understanding.utils import record_commands_and_prompts
+
+        # only set commands if the flag "record_commands_and_prompts" is set to True
+        if not record_commands_and_prompts:
+            return
+
+        commands_as_dict = [command.as_dict() for command in commands]
+
+        if message.get(PREDICTED_COMMANDS) is not None:
+            predicted_commands = message.get(PREDICTED_COMMANDS)
+            if component_name in predicted_commands:
+                predicted_commands[component_name].extend(commands_as_dict)
+            else:
+                predicted_commands[component_name] = commands_as_dict
+        else:
+            predicted_commands = {component_name: commands_as_dict}
+
+        message.set(
+            PREDICTED_COMMANDS,
+            predicted_commands,
+            add_to_output=True,
+        )
+
+    @staticmethod
+    def _add_prompt_to_message_parse_data(
+        message: Message,
+        component_name: str,
+        prompt_name: str,
+        user_prompt: str,
+        system_prompt: Optional[str] = None,
+        llm_response: Optional[LLMResponse] = None,
+    ) -> None:
+        """Add prompt to the message parse data.
+
+        Prompt is only added in case the flag 'record_commands_and_prompts' is set.
+        Example of prompts in the message parse data:
+            Message(data={
+              PROMPTS: {
+                "MultiStepLLMCommandGenerator": [
+                    (
+                        "fill_slots_prompt",
+                        {
+                            "user_prompt": <prompt content>",
+                            "system_prompt": <prompt content>",
+                            "llm_response_metadata": <metadata dict from LLMResponse>
+                        }
+                    ),
+                    (
+                        "handle_flows_prompt",
+                        {
+                            "user_prompt": <prompt content>",
+                            "system_prompt": <prompt content>",
+                            "llm_response_metadata": <metadata dict from LLMResponse>
+                        }
+                    ),
+                ],
+                "SingleStepLLMCommandGenerator": [
+                    (
+                        "prompt_template",
+                        {
+                            "user_prompt": <prompt content>",
+                            "system_prompt": <prompt content>",
+                            "llm_response_metadata": <metadata dict from LLMResponse>
+                        }
+                    ),
+                ]
+              }
+            })
+        """
+        from rasa.dialogue_understanding.utils import record_commands_and_prompts
+
+        # only set prompt if the flag "record_commands_and_prompts" is set to True
+        if not record_commands_and_prompts:
+            return
+
+        prompt_data: Dict[Text, Any] = {
+            KEY_USER_PROMPT: user_prompt,
+            **({KEY_SYSTEM_PROMPT: system_prompt} if system_prompt else {}),
+        }
+
+        if llm_response is not None:
+            prompt_data[KEY_LLM_RESPONSE_METADATA] = llm_response.to_dict()
+
+        prompt_tuple = (prompt_name, prompt_data)
+
+        if message.get(PROMPTS) is not None:
+            prompts = message.get(PROMPTS)
+            if component_name in prompts:
+                prompts[component_name].append(prompt_tuple)
+            else:
+                prompts[component_name] = [prompt_tuple]
+        else:
+            prompts = {component_name: [prompt_tuple]}
+
+        message.set(
+            PROMPTS,
+            prompts,
+            add_to_output=True,
+        )

rasa/dialogue_understanding/generator/constants.py

@@ -0,0 +1,27 @@
+from rasa.shared.constants import (
+    PROVIDER_CONFIG_KEY,
+    OPENAI_PROVIDER,
+    MODEL_CONFIG_KEY,
+    TIMEOUT_CONFIG_KEY,
+)
+from rasa.shared.utils.llm import (
+    DEFAULT_OPENAI_CHAT_MODEL_NAME_ADVANCED,
+    DEFAULT_OPENAI_MAX_GENERATED_TOKENS,
+)
+
+DEFAULT_LLM_CONFIG = {
+    PROVIDER_CONFIG_KEY: OPENAI_PROVIDER,
+    MODEL_CONFIG_KEY: DEFAULT_OPENAI_CHAT_MODEL_NAME_ADVANCED,
+    "temperature": 0.0,
+    "max_tokens": DEFAULT_OPENAI_MAX_GENERATED_TOKENS,
+    TIMEOUT_CONFIG_KEY: 7,
+}
+
+LLM_CONFIG_KEY = "llm"
+USER_INPUT_CONFIG_KEY = "user_input"
+
+FLOW_RETRIEVAL_KEY = "flow_retrieval"
+FLOW_RETRIEVAL_ACTIVE_KEY = "active"
+FLOW_RETRIEVAL_EMBEDDINGS_CONFIG_KEY = "embeddings"
+
+FLOW_RETRIEVAL_FLOW_THRESHOLD = 20

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 %}