rasa-pro 3.9.18__py3-none-any.whl

rasa/dialogue_understanding/coexistence/llm_based_router.py

@@ -0,0 +1,260 @@
+from __future__ import annotations
+import importlib
+from typing import Any, Dict, List, Optional
+
+import structlog
+from jinja2 import Template
+
+from rasa.dialogue_understanding.coexistence.constants import (
+    CALM_ENTRY,
+    NLU_ENTRY,
+    STICKY,
+    NON_STICKY,
+)
+from rasa.dialogue_understanding.commands import Command, SetSlotCommand
+from rasa.dialogue_understanding.commands.noop_command import NoopCommand
+from rasa.dialogue_understanding.generator.constants import LLM_CONFIG_KEY
+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.constants import ROUTE_TO_CALM_SLOT
+from rasa.shared.core.trackers import DialogueStateTracker
+from rasa.shared.exceptions import InvalidConfigException, FileIOException
+from rasa.shared.nlu.constants import COMMANDS, TEXT
+from rasa.shared.nlu.training_data.message import Message
+from rasa.shared.nlu.training_data.training_data import TrainingData
+import rasa.shared.utils.io
+from rasa.shared.utils.llm import (
+    DEFAULT_OPENAI_CHAT_MODEL_NAME,
+    get_prompt_template,
+    llm_factory,
+)
+
+LLM_BASED_ROUTER_PROMPT_FILE_NAME = "llm_based_router_prompt.jinja2"
+DEFAULT_COMMAND_PROMPT_TEMPLATE = importlib.resources.read_text(
+    "rasa.dialogue_understanding.coexistence", "router_template.jinja2"
+)
+
+
+# Token ids for gpt 3.5 and gpt 4 corresponding to space + capitalized Letter
+A_TO_C_TOKEN_IDS_CHATGPT = [
+    362,  # " A"
+    426,  # " B"
+    356,  # " C"
+]
+
+DEFAULT_LLM_CONFIG = {
+    "_type": "openai",
+    "request_timeout": 7,
+    "temperature": 0.0,
+    "model_name": DEFAULT_OPENAI_CHAT_MODEL_NAME,
+    "max_tokens": 1,
+    "logit_bias": {str(token_id): 100 for token_id in A_TO_C_TOKEN_IDS_CHATGPT},
+}
+
+structlogger = structlog.get_logger()
+
+
+@DefaultV1Recipe.register(
+    [
+        DefaultV1Recipe.ComponentType.COEXISTENCE_ROUTER,
+    ],
+    is_trainable=True,
+)
+class LLMBasedRouter(GraphComponent):
+    @staticmethod
+    def get_default_config() -> Dict[str, Any]:
+        """The component's default config (see parent class for full docstring)."""
+        return {
+            "prompt": None,
+            CALM_ENTRY: {STICKY: None},
+            NLU_ENTRY: {
+                NON_STICKY: "handles chitchat",
+                STICKY: "handles everything else",
+            },
+            LLM_CONFIG_KEY: None,
+        }
+
+    def __init__(
+        self,
+        config: Dict[str, Any],
+        model_storage: ModelStorage,
+        resource: Resource,
+        prompt_template: Optional[str] = None,
+    ) -> None:
+        self.config = {**self.get_default_config(), **config}
+
+        self.prompt_template = (
+            prompt_template
+            or get_prompt_template(
+                config.get("prompt"),
+                DEFAULT_COMMAND_PROMPT_TEMPLATE,
+            ).strip()
+        )
+
+        self._model_storage = model_storage
+        self._resource = resource
+        self.validate_config()
+
+    def validate_config(self) -> None:
+        """Validate the config of the router."""
+        if (
+            self.config[CALM_ENTRY] is None
+            or not isinstance(self.config[CALM_ENTRY], dict)
+            or STICKY not in self.config[CALM_ENTRY]
+            or self.config[CALM_ENTRY][STICKY] is None
+        ):
+            raise ValueError(
+                "The LLMBasedRouter component needs a proper "
+                "description of the capabilities implemented in the CALM "
+                "part of the bot."
+            )
+
+    def persist(self) -> None:
+        """Persist this component to disk for future loading."""
+        with self._model_storage.write_to(self._resource) as path:
+            rasa.shared.utils.io.write_text_file(
+                self.prompt_template, path / LLM_BASED_ROUTER_PROMPT_FILE_NAME
+            )
+
+    def train(self, training_data: TrainingData) -> Resource:
+        """Train the intent classifier on a data set."""
+        self.persist()
+        return self._resource
+
+    @classmethod
+    def load(
+        cls,
+        config: Dict[str, Any],
+        model_storage: ModelStorage,
+        resource: Resource,
+        execution_context: ExecutionContext,
+        **kwargs: Any,
+    ) -> "LLMBasedRouter":
+        """Loads trained component (see parent class for full docstring)."""
+        prompt_template = None
+        try:
+            with model_storage.read_from(resource) as path:
+                prompt_template = rasa.shared.utils.io.read_file(
+                    path / LLM_BASED_ROUTER_PROMPT_FILE_NAME
+                )
+        except (FileNotFoundError, FileIOException) as e:
+            structlogger.warning(
+                "llm_based_router.load.failed", error=e, resource=resource.name
+            )
+
+        return cls(config, model_storage, resource, prompt_template=prompt_template)
+
+    @classmethod
+    def create(
+        cls,
+        config: Dict[str, Any],
+        model_storage: ModelStorage,
+        resource: Resource,
+        execution_context: ExecutionContext,
+    ) -> LLMBasedRouter:
+        """Creates component (see parent class for full docstring)."""
+        return cls(config, model_storage, resource)
+
+    async def process(
+        self,
+        messages: List[Message],
+        tracker: Optional[DialogueStateTracker] = None,
+    ) -> List[Message]:
+        """Process a list of messages."""
+        if tracker is None:
+            # cannot do anything if there is no tracker (happens during 'rasa test nlu')
+            return messages
+
+        for message in messages:
+            commands = await self.predict_commands(message, tracker)
+            commands_dicts = [command.as_dict() for command in commands]
+            message.set(COMMANDS, commands_dicts, add_to_output=True)
+
+        return messages
+
+    async def predict_commands(
+        self,
+        message: Message,
+        tracker: DialogueStateTracker,
+    ) -> List[Command]:
+        if not tracker.has_coexistence_routing_slot:
+            raise InvalidConfigException(
+                f"Tried to run the LLMBasedRouter component "
+                f"without the slot to track coexistence routing ({ROUTE_TO_CALM_SLOT})."
+            )
+
+        route_session_to_calm = tracker.get_slot(ROUTE_TO_CALM_SLOT)
+        if route_session_to_calm is None:
+            prompt = self.render_template(message)
+            structlogger.info("llm_based_router.prompt_rendered", prompt=prompt)
+            # generating answer
+            answer = await self._generate_answer_using_llm(prompt)
+            structlogger.info("llm_based_router.llm_answer", answer=answer)
+            commands = self.parse_answer(answer)
+            structlogger.info("llm_based_router.predicated_commands", commands=commands)
+            return commands
+        elif route_session_to_calm is True:
+            # don't set any commands so that a `LLMBasedCommandGenerator` is triggered
+            # and can predict the actual commands.
+            return []
+        else:
+            # If the session is assigned to DM1 add a `NoopCommand` to silence
+            # the other command generators.
+            return [NoopCommand()]
+
+    @staticmethod
+    def parse_answer(answer: Optional[str]) -> List[Command]:
+        if answer is None:
+            structlogger.warn(
+                "llm_based_router.parse_answer.invalid_answer", answer=answer
+            )
+            return [SetSlotCommand(ROUTE_TO_CALM_SLOT, False)]
+
+        # removing any whitespaces from the token
+        answer = answer.strip()
+
+        # to calm
+        if answer == "A":
+            return []
+        # to dm1
+        elif answer == "C":
+            return [SetSlotCommand(ROUTE_TO_CALM_SLOT, False)]
+        # to dm1 for a single chitchat turn
+        elif answer == "B":
+            return [NoopCommand()]
+        else:
+            structlogger.warn(
+                "llm_based_router.parse_answer.invalid_answer", answer=answer
+            )
+            return [SetSlotCommand(ROUTE_TO_CALM_SLOT, False)]
+
+    def render_template(self, message: Message) -> str:
+        inputs = {
+            "user_message": message.get(TEXT),
+            f"{CALM_ENTRY}_{STICKY}": self.config[CALM_ENTRY][STICKY],
+            f"{NLU_ENTRY}_{STICKY}": self.config[NLU_ENTRY][STICKY],
+            f"{NLU_ENTRY}_{NON_STICKY}": self.config[NLU_ENTRY][NON_STICKY],
+        }
+
+        return Template(self.prompt_template).render(**inputs)
+
+    async def _generate_answer_using_llm(self, prompt: str) -> Optional[str]:
+        """Use LLM to generate a response.
+
+        Args:
+            prompt: The prompt to send to the LLM.
+
+        Returns:
+            The generated text.
+        """
+        llm = llm_factory(self.config.get(LLM_CONFIG_KEY), DEFAULT_LLM_CONFIG)
+
+        try:
+            return await llm.apredict(prompt)
+        except Exception as e:
+            # unfortunately, langchain does not wrap LLM exceptions which means
+            # we have to catch all exceptions here
+            structlogger.error("llm_based_router.llm.error", error=e)
+            return None

rasa/dialogue_understanding/coexistence/router_template.jinja2

@@ -0,0 +1,12 @@
+You have to forward the user message to the right assistant.
+
+The following assistants are available:
+
+Assistant A: {{ calm_entry_sticky }}
+Assistant B: {{ nlu_entry_non_sticky }}
+Assistant C: {{ nlu_entry_sticky }}
+
+The user said: """{{ user_message }}"""
+
+Answer which assistant needs to get this message:
+The message is for the assistant with the letter

rasa/dialogue_understanding/commands/__init__.py

@@ -0,0 +1,49 @@
+from rasa.dialogue_understanding.commands.command import Command
+from rasa.dialogue_understanding.commands.free_form_answer_command import (
+    FreeFormAnswerCommand,
+)
+from rasa.dialogue_understanding.commands.cancel_flow_command import CancelFlowCommand
+from rasa.dialogue_understanding.commands.knowledge_answer_command import (
+    KnowledgeAnswerCommand,
+)
+from rasa.dialogue_understanding.commands.chit_chat_answer_command import (
+    ChitChatAnswerCommand,
+)
+from rasa.dialogue_understanding.commands.skip_question_command import (
+    SkipQuestionCommand,
+)
+from rasa.dialogue_understanding.commands.can_not_handle_command import (
+    CannotHandleCommand,
+)
+from rasa.dialogue_understanding.commands.clarify_command import ClarifyCommand
+from rasa.dialogue_understanding.commands.error_command import ErrorCommand
+from rasa.dialogue_understanding.commands.set_slot_command import SetSlotCommand
+from rasa.dialogue_understanding.commands.start_flow_command import StartFlowCommand
+from rasa.dialogue_understanding.commands.human_handoff_command import (
+    HumanHandoffCommand,
+)
+from rasa.dialogue_understanding.commands.correct_slots_command import (
+    CorrectSlotsCommand,
+    CorrectedSlot,
+)
+from rasa.dialogue_understanding.commands.noop_command import NoopCommand
+from rasa.dialogue_understanding.commands.change_flow_command import ChangeFlowCommand
+
+__all__ = [
+    "Command",
+    "FreeFormAnswerCommand",
+    "CancelFlowCommand",
+    "KnowledgeAnswerCommand",
+    "ChitChatAnswerCommand",
+    "SkipQuestionCommand",
+    "CannotHandleCommand",
+    "ClarifyCommand",
+    "SetSlotCommand",
+    "StartFlowCommand",
+    "HumanHandoffCommand",
+    "CorrectSlotsCommand",
+    "CorrectedSlot",
+    "ErrorCommand",
+    "NoopCommand",
+    "ChangeFlowCommand",
+]

rasa/dialogue_understanding/commands/can_not_handle_command.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional, Text
+
+from rasa.dialogue_understanding.commands import Command
+from rasa.dialogue_understanding.patterns.cannot_handle import (
+    CannotHandlePatternFlowStackFrame,
+)
+from rasa.shared.constants import RASA_PATTERN_CANNOT_HANDLE_DEFAULT
+from rasa.shared.core.events import Event
+from rasa.shared.core.flows import FlowsList
+from rasa.shared.core.trackers import DialogueStateTracker
+
+
+@dataclass
+class CannotHandleCommand(Command):
+    """A command to indicate that the bot can't handle the user's input."""
+
+    reason: Optional[Text] = RASA_PATTERN_CANNOT_HANDLE_DEFAULT
+    """Reason for cannot handle used in switch-case of the
+    cannot handle pattern flow."""
+
+    @classmethod
+    def command(cls) -> str:
+        """Returns the command type."""
+        return "cannot handle"
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> CannotHandleCommand:
+        """Converts the dictionary to a command.
+
+        Returns:
+            The converted dictionary.
+        """
+        return CannotHandleCommand(
+            data.get("reason", RASA_PATTERN_CANNOT_HANDLE_DEFAULT)
+        )
+
+    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
+        if self.reason is not None:
+            stack.push(CannotHandlePatternFlowStackFrame(reason=self.reason))
+        else:
+            stack.push(CannotHandlePatternFlowStackFrame())
+        return tracker.create_stack_updated_events(stack)
+
+    def __hash__(self) -> int:
+        return hash(self.reason)
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, CannotHandleCommand):
+            return False
+
+        return other.reason == self.reason

rasa/dialogue_understanding/commands/cancel_flow_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.cancel import CancelPatternFlowStackFrame
+from rasa.dialogue_understanding.stack.dialogue_stack import DialogueStack
+from rasa.dialogue_understanding.stack.frames import UserFlowStackFrame
+from rasa.dialogue_understanding.stack.frames.flow_stack_frame import FlowStackFrameType
+from rasa.shared.core.events import Event, FlowCancelled
+from rasa.shared.core.flows import FlowsList
+from rasa.shared.core.trackers import DialogueStateTracker
+from rasa.dialogue_understanding.stack.utils import top_user_flow_frame
+
+structlogger = structlog.get_logger()
+
+
+@dataclass
+class CancelFlowCommand(Command):
+    """A command to cancel the current flow."""
+
+    @classmethod
+    def command(cls) -> str:
+        """Returns the command type."""
+        return "cancel flow"
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> CancelFlowCommand:
+        """Converts the dictionary to a command.
+
+        Returns:
+            The converted dictionary.
+        """
+        return CancelFlowCommand()
+
+    @staticmethod
+    def select_canceled_frames(stack: DialogueStack) -> List[str]:
+        """Selects the frames that were canceled.
+
+        Args:
+            dialogue_stack: The dialogue stack.
+            current_flow: The current flow.
+
+        Returns:
+            The frames that were canceled."""
+        canceled_frames = []
+        # we need to go through the original stack dump in reverse order
+        # to find the frames that were canceled. we cancel everything from
+        # the top of the stack until we hit the user flow that was canceled.
+        # this will also cancel any patterns put on top of that user flow,
+        # e.g. corrections.
+        for frame in reversed(stack.frames):
+            canceled_frames.append(frame.frame_id)
+            if (
+                isinstance(frame, UserFlowStackFrame)
+                and frame.frame_type != FlowStackFrameType.CALL
+            ):
+                return canceled_frames
+        else:
+            # we should never get here as we should always find the user flow
+            # that was canceled.
+            raise ValueError(
+                f"Could not find a user flow frame to cancel. "
+                f"Current stack: {stack}."
+            )
+
+    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] = []
+
+        user_frame = top_user_flow_frame(original_stack)
+        current_flow = user_frame.flow(all_flows) if user_frame else None
+
+        if not current_flow:
+            structlogger.debug(
+                "command_executor.skip_cancel_flow.no_active_flow", command=self
+            )
+            return []
+
+        # we pass in the original dialogue stack (before any of the currently
+        # predicted commands were applied) to make sure we don't cancel any
+        # frames that were added by the currently predicted commands.
+        canceled_frames = self.select_canceled_frames(original_stack)
+
+        stack.push(
+            CancelPatternFlowStackFrame(
+                canceled_name=current_flow.readable_name(),
+                canceled_frames=canceled_frames,
+            )
+        )
+
+        if user_frame:
+            applied_events.append(FlowCancelled(user_frame.flow_id, user_frame.step_id))
+
+        return applied_events + tracker.create_stack_updated_events(stack)
+
+    def __hash__(self) -> int:
+        return hash(self.command())
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, CancelFlowCommand):
+            return False
+
+        return True

rasa/dialogue_understanding/commands/change_flow_command.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Dict, List
+from rasa.dialogue_understanding.commands import Command
+from rasa.shared.core.events import Event
+from rasa.shared.core.flows import FlowsList
+from rasa.shared.core.trackers import DialogueStateTracker
+
+
+@dataclass
+class ChangeFlowCommand(Command):
+    """A command to indicate a change of flows was requested by the command
+    generator."""
+
+    @classmethod
+    def command(cls) -> str:
+        """Returns the command type."""
+        return "change_flow"
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> ChangeFlowCommand:
+        """Converts the dictionary to a command.
+
+        Returns:
+            The converted dictionary.
+        """
+        return ChangeFlowCommand()
+
+    def run_command_on_tracker(
+        self,
+        tracker: DialogueStateTracker,
+        all_flows: FlowsList,
+        original_tracker: DialogueStateTracker,
+    ) -> List[Event]:
+        # the change flow command is not actually pushing anything to the tracker,
+        # but it is predicted by the MultiStepLLMCommandGenerator and used internally
+        return []
+
+    def __eq__(self, other: Any) -> bool:
+        return isinstance(other, ChangeFlowCommand)
+
+    def __hash__(self) -> int:
+        return hash(self.command())

rasa/dialogue_understanding/commands/chit_chat_answer_command.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Dict, List
+from rasa.dialogue_understanding.commands import FreeFormAnswerCommand
+from rasa.dialogue_understanding.patterns.chitchat import ChitchatPatternFlowStackFrame
+from rasa.shared.core.events import Event
+from rasa.shared.core.flows import FlowsList
+from rasa.shared.core.trackers import DialogueStateTracker
+
+
+@dataclass
+class ChitChatAnswerCommand(FreeFormAnswerCommand):
+    """A command to indicate a chitchat style free-form answer by the bot."""
+
+    @classmethod
+    def command(cls) -> str:
+        """Returns the command type."""
+        return "chitchat"
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> ChitChatAnswerCommand:
+        """Converts the dictionary to a command.
+
+        Returns:
+            The converted dictionary.
+        """
+        return ChitChatAnswerCommand()
+
+    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(ChitchatPatternFlowStackFrame())
+        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, ChitChatAnswerCommand):
+            return False
+
+        return True