rasa-pro 3.12.0.dev13__py3-none-any.whl → 3.12.0rc1__py3-none-any.whl

rasa/dialogue_understanding/generator/single_step/single_step_llm_command_generator.py

@@ -1,34 +1,21 @@
 import importlib.resources
-from typing import Any, Dict, List, Optional, Text
+from typing import Any, Dict, Optional, Text
 
 import structlog
 
-import rasa.shared.utils.io
-from rasa.dialogue_understanding.commands import (
-    CannotHandleCommand,
-    Command,
-    ErrorCommand,
-    SetSlotCommand,
-)
-from rasa.dialogue_understanding.generator.command_parser import (
-    parse_commands as parse_commands_using_command_parsers,
+from rasa.dialogue_understanding.commands.command_syntax_manager import (
+    CommandSyntaxManager,
+    CommandSyntaxVersion,
 )
 from rasa.dialogue_understanding.generator.constants import (
-    DEFAULT_LLM_CONFIG,
     FLOW_RETRIEVAL_KEY,
     LLM_CONFIG_KEY,
     USER_INPUT_CONFIG_KEY,
 )
 from rasa.dialogue_understanding.generator.flow_retrieval import FlowRetrieval
-from rasa.dialogue_understanding.generator.llm_based_command_generator import (
-    LLMBasedCommandGenerator,
-)
-from rasa.dialogue_understanding.stack.utils import top_flow_frame
-from rasa.dialogue_understanding.utils import (
-    add_commands_to_message_parse_data,
-    add_prompt_to_message_parse_data,
+from rasa.dialogue_understanding.generator.single_step.compact_llm_command_generator import (  # noqa: E501
+    CompactLLMCommandGenerator,
 )
-from rasa.engine.graph import ExecutionContext
 from rasa.engine.recipes.default_recipe import DefaultV1Recipe
 from rasa.engine.storage.resource import Resource
 from rasa.engine.storage.storage import ModelStorage
@@ -36,30 +23,15 @@ from rasa.shared.constants import (
     EMBEDDINGS_CONFIG_KEY,
     PROMPT_CONFIG_KEY,
     PROMPT_TEMPLATE_CONFIG_KEY,
-    ROUTE_TO_CALM_SLOT,
 )
-from rasa.shared.core.flows import FlowsList
-from rasa.shared.core.trackers import DialogueStateTracker
-from rasa.shared.exceptions import ProviderClientAPIException
-from rasa.shared.nlu.constants import LLM_COMMANDS, LLM_PROMPT, TEXT
-from rasa.shared.nlu.training_data.message import Message
-from rasa.shared.providers.llm.llm_response import LLMResponse
 from rasa.shared.utils.io import deep_container_fingerprint
-from rasa.shared.utils.llm import (
-    get_prompt_template,
-    resolve_model_client_config,
-    sanitize_message_for_prompt,
-    tracker_as_readable_transcript,
-)
-from rasa.utils.log_utils import log_llm
-
-COMMAND_PROMPT_FILE_NAME = "command_prompt.jinja2"
+from rasa.shared.utils.llm import get_prompt_template, resolve_model_client_config
 
 DEFAULT_COMMAND_PROMPT_TEMPLATE = importlib.resources.read_text(
-    "rasa.dialogue_understanding.generator.single_step",
+    "rasa.dialogue_understanding.generator.prompt_templates",
     "command_prompt_template.jinja2",
 )
-SINGLE_STEP_LLM_COMMAND_GENERATOR_CONFIG_FILE = "config.json"
+
 
 structlogger = structlog.get_logger()
 
@@ -70,7 +42,7 @@ structlogger = structlog.get_logger()
     ],
     is_trainable=True,
 )
-class SingleStepLLMCommandGenerator(LLMBasedCommandGenerator):
+class SingleStepLLMCommandGenerator(CompactLLMCommandGenerator):
     """A single step LLM-based command generator."""
 
     def __init__(
@@ -109,9 +81,9 @@ class SingleStepLLMCommandGenerator(LLMBasedCommandGenerator):
             DEFAULT_COMMAND_PROMPT_TEMPLATE,
         )
 
-        self.trace_prompt_tokens = self.config.get("trace_prompt_tokens", False)
+        # Set the command syntax version to v1
+        CommandSyntaxManager.set_syntax_version(CommandSyntaxVersion.v1)
 
-    ### Implementations of LLMBasedCommandGenerator parent
     @staticmethod
     def get_default_config() -> Dict[str, Any]:
         """The component's default config (see parent class for full docstring)."""
@@ -123,224 +95,6 @@ class SingleStepLLMCommandGenerator(LLMBasedCommandGenerator):
             FLOW_RETRIEVAL_KEY: FlowRetrieval.get_default_config(),
         }
 
-    @classmethod
-    def load(
-        cls: Any,
-        config: Dict[str, Any],
-        model_storage: ModelStorage,
-        resource: Resource,
-        execution_context: ExecutionContext,
-        **kwargs: Any,
-    ) -> "SingleStepLLMCommandGenerator":
-        """Loads trained component (see parent class for full docstring)."""
-        # Perform health check of the LLM API endpoint
-        llm_config = resolve_model_client_config(config.get(LLM_CONFIG_KEY, {}))
-        cls.perform_llm_health_check(
-            llm_config,
-            DEFAULT_LLM_CONFIG,
-            "single_step_llm_command_generator.load",
-            SingleStepLLMCommandGenerator.__name__,
-        )
-
-        # load prompt template from the model storage.
-        prompt_template = cls.load_prompt_template_from_model_storage(
-            model_storage, resource, COMMAND_PROMPT_FILE_NAME
-        )
-
-        # init base command generator
-        command_generator = cls(config, model_storage, resource, prompt_template)
-        # load flow retrieval if enabled
-        if command_generator.enabled_flow_retrieval:
-            command_generator.flow_retrieval = cls.load_flow_retrival(
-                command_generator.config, model_storage, resource
-            )
-
-        return command_generator
-
-    def persist(self) -> None:
-        """Persist this component to disk for future loading."""
-        self._persist_prompt_template()
-        self._persist_config()
-        if self.flow_retrieval is not None:
-            self.flow_retrieval.persist()
-
-    def _persist_prompt_template(self) -> None:
-        """Persist prompt template for future loading."""
-        with self._model_storage.write_to(self._resource) as path:
-            rasa.shared.utils.io.write_text_file(
-                self.prompt_template, path / COMMAND_PROMPT_FILE_NAME
-            )
-
-    def _persist_config(self) -> None:
-        """Persist config as a source of truth for resolved clients."""
-        with self._model_storage.write_to(self._resource) as path:
-            rasa.shared.utils.io.dump_obj_as_json_to_file(
-                path / SINGLE_STEP_LLM_COMMAND_GENERATOR_CONFIG_FILE, self.config
-            )
-
-    async def predict_commands(
-        self,
-        message: Message,
-        flows: FlowsList,
-        tracker: Optional[DialogueStateTracker] = None,
-        **kwargs: Any,
-    ) -> List[Command]:
-        """Predict commands using the LLM.
-
-        Args:
-            message: The message from the user.
-            flows: The flows available to the user.
-            tracker: The tracker containing the current state of the conversation.
-            **kwargs: Keyword arguments for forward compatibility.
-
-        Returns:
-            The commands generated by the llm.
-        """
-        prior_commands = self._get_prior_commands(message)
-
-        if tracker is None or flows.is_empty():
-            # cannot do anything if there are no flows or no tracker
-            return prior_commands
-
-        if self._should_skip_llm_call(prior_commands, flows, tracker):
-            return prior_commands
-
-        try:
-            commands = await self._predict_commands(message, flows, tracker)
-        except ProviderClientAPIException:
-            # if command predictions resulted in API exception
-            # "predict" the ErrorCommand
-            commands = [ErrorCommand()]
-
-        if not commands and not prior_commands:
-            # no commands are parsed or there's an invalid command
-            structlogger.warning(
-                "single_step_llm_command_generator.predict_commands",
-                message="No commands were predicted as the LLM response could "
-                "not be parsed or the LLM responded with an invalid command."
-                "Returning a CannotHandleCommand instead.",
-            )
-            commands = [CannotHandleCommand()]
-
-        if tracker.has_coexistence_routing_slot:
-            # if coexistence feature is used, set the routing slot
-            commands += [SetSlotCommand(ROUTE_TO_CALM_SLOT, True)]
-
-        log_llm(
-            logger=structlogger,
-            log_module="SingleStepLLMCommandGenerator",
-            log_event="llm_command_generator.predict_commands.finished",
-            commands=commands,
-        )
-
-        domain = kwargs.get("domain")
-        commands = self._check_commands_against_slot_mappings(commands, tracker, domain)
-
-        return self._check_commands_overlap(prior_commands, commands)
-
-    async def _predict_commands(
-        self,
-        message: Message,
-        flows: FlowsList,
-        tracker: Optional[DialogueStateTracker] = None,
-    ) -> List[Command]:
-        """Predict commands using the LLM.
-
-        Args:
-            message: The message from the user.
-            flows: The flows available to the user.
-            tracker: The tracker containing the current state of the conversation.
-
-        Returns:
-            The commands generated by the llm.
-
-        Raises:
-            ProviderClientAPIException: If API calls raised an error.
-        """
-        # retrieve flows
-        filtered_flows = await self.filter_flows(message, flows, tracker)
-
-        flow_prompt = self.render_template(message, tracker, filtered_flows, flows)
-        log_llm(
-            logger=structlogger,
-            log_module="SingleStepLLMCommandGenerator",
-            log_event="llm_command_generator.predict_commands.prompt_rendered",
-            prompt=flow_prompt,
-        )
-
-        response = await self.invoke_llm(flow_prompt)
-        llm_response = LLMResponse.ensure_llm_response(response)
-        # The check for 'None' maintains compatibility with older versions
-        # of LLMCommandGenerator. In previous implementations, 'invoke_llm'
-        # might return 'None' to indicate a failure to generate actions.
-        if llm_response is None or not llm_response.choices:
-            return [ErrorCommand()]
-
-        action_list = llm_response.choices[0]
-
-        log_llm(
-            logger=structlogger,
-            log_module="SingleStepLLMCommandGenerator",
-            log_event="llm_command_generator.predict_commands.actions_generated",
-            action_list=action_list,
-        )
-
-        commands = self.parse_commands(action_list, tracker, flows)
-
-        self._update_message_parse_data_for_fine_tuning(message, commands, flow_prompt)
-        add_commands_to_message_parse_data(
-            message, SingleStepLLMCommandGenerator.__name__, commands
-        )
-        add_prompt_to_message_parse_data(
-            message=message,
-            component_name=SingleStepLLMCommandGenerator.__name__,
-            prompt_name="command_generator_prompt",
-            user_prompt=flow_prompt,
-            llm_response=llm_response,
-        )
-
-        return commands
-
-    @staticmethod
-    def _update_message_parse_data_for_fine_tuning(
-        message: Message, commands: List[Command], prompt: str
-    ) -> None:
-        from rasa.llm_fine_tuning.annotation_module import preparing_fine_tuning_data
-
-        if preparing_fine_tuning_data:
-            # Add commands and prompt to the message object in order to create
-            # prompt -> commands pairs for fine-tuning
-            message.set(
-                LLM_COMMANDS,
-                [command.as_dict() for command in commands],
-                add_to_output=True,
-            )
-            message.set(LLM_PROMPT, prompt, add_to_output=True)
-
-    @classmethod
-    def parse_commands(
-        cls, actions: Optional[str], tracker: DialogueStateTracker, flows: FlowsList
-    ) -> List[Command]:
-        """Parse the actions returned by the llm into intent and entities.
-
-        Args:
-            actions: The actions returned by the llm.
-            tracker: The tracker containing the current state of the conversation.
-            flows: the list of flows
-
-        Returns:
-            The parsed commands.
-        """
-        commands = parse_commands_using_command_parsers(actions, flows)
-        if not commands:
-            structlogger.debug(
-                "single_step_llm_command_generator.parse_commands",
-                message="No commands were parsed from the LLM actions.",
-                actions=actions,
-            )
-
-        return commands
-
     @classmethod
     def fingerprint_addon(cls: Any, config: Dict[str, Any]) -> Optional[str]:
         """Add a fingerprint for the graph."""
@@ -363,55 +117,3 @@ class SingleStepLLMCommandGenerator(LLMBasedCommandGenerator):
         return deep_container_fingerprint(
             [prompt_template, llm_config, embedding_config]
         )
-
-    ### Helper methods
-    def render_template(
-        self,
-        message: Message,
-        tracker: DialogueStateTracker,
-        startable_flows: FlowsList,
-        all_flows: FlowsList,
-    ) -> str:
-        """Render the jinja template to create the prompt for the LLM.
-
-        Args:
-            message: The current message from the user.
-            tracker: The tracker containing the current state of the conversation.
-            startable_flows: The flows startable at this point in time by the user.
-            all_flows: all flows present in the assistant
-
-        Returns:
-            The rendered prompt template.
-        """
-        # need to make this distinction here because current step of the
-        # top_calling_frame would be the call step, but we need the collect step from
-        # the called frame. If no call is active calling and called frame are the same.
-        top_calling_frame = top_flow_frame(tracker.stack)
-        top_called_frame = top_flow_frame(tracker.stack, ignore_call_frames=False)
-
-        top_flow = top_calling_frame.flow(all_flows) if top_calling_frame else None
-        current_step = top_called_frame.step(all_flows) if top_called_frame else None
-
-        flow_slots = self.prepare_current_flow_slots_for_template(
-            top_flow, current_step, tracker
-        )
-        current_slot, current_slot_description = self.prepare_current_slot_for_template(
-            current_step
-        )
-        current_conversation = tracker_as_readable_transcript(tracker)
-        latest_user_message = sanitize_message_for_prompt(message.get(TEXT))
-        current_conversation += f"\nUSER: {latest_user_message}"
-
-        inputs = {
-            "available_flows": self.prepare_flows_for_template(
-                startable_flows, tracker
-            ),
-            "current_conversation": current_conversation,
-            "flow_slots": flow_slots,
-            "current_flow": top_flow.id if top_flow is not None else None,
-            "current_slot": current_slot,
-            "current_slot_description": current_slot_description,
-            "user_message": latest_user_message,
-        }
-
-        return self.compile_template(self.prompt_template).render(**inputs)

rasa/dialogue_understanding/patterns/collect_information.py

@@ -8,7 +8,7 @@ from rasa.dialogue_understanding.stack.frames import (
     PatternFlowStackFrame,
 )
 from rasa.shared.constants import RASA_DEFAULT_FLOW_PATTERN_PREFIX
-from rasa.shared.core.flows.steps.collect import SlotRejection
+from rasa.shared.core.slots import SlotRejection
 
 FLOW_PATTERN_COLLECT_INFORMATION = (
     RASA_DEFAULT_FLOW_PATTERN_PREFIX + "collect_information"

rasa/dialogue_understanding/patterns/default_flows_for_patterns.yml

@@ -359,3 +359,19 @@ flows:
               - action: action_hangup
                 next: END
           - else: END
+
+  pattern_validate_slot:
+    description: Flow for running validations on slots
+    name: pattern validate slot
+    steps:
+      - id: start
+        action: action_run_slot_rejections
+        next:
+          - if: "slots.{{context.validate}} is not null"
+            then: END
+          - else: ask_refill
+      - id: ask_refill
+        action: "{{context.refill_utter}}"
+      - action: "{{context.refill_action}}"
+      - action: action_listen
+        next: start

rasa/dialogue_understanding/patterns/validate_slot.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Dict, List
+
+from rasa.dialogue_understanding.stack.frames import (
+    PatternFlowStackFrame,
+)
+from rasa.shared.constants import (
+    RASA_DEFAULT_FLOW_PATTERN_PREFIX,
+    REFILL_UTTER,
+    REJECTIONS,
+)
+from rasa.shared.core.slots import SlotRejection
+
+FLOW_PATTERN_VALIDATE_SLOT = RASA_DEFAULT_FLOW_PATTERN_PREFIX + "validate_slot"
+
+
+@dataclass
+class ValidateSlotPatternFlowStackFrame(PatternFlowStackFrame):
+    """A pattern flow stack frame to validate slots."""
+
+    flow_id: str = FLOW_PATTERN_VALIDATE_SLOT
+    """The ID of the flow."""
+    validate: str = ""
+    """The slot that should be validated."""
+    refill_utter: str = ""
+    """The utter action that should be executed to ask the user to refill the
+    information."""
+    refill_action: str = ""
+    """The action that should be executed to ask the user to refill the
+    information."""
+    rejections: List[SlotRejection] = field(default_factory=list)
+    """The predicate check that should be applied to the filled slot.
+    If a predicate check fails, its `utter` action indicated under rejections
+    will be executed.
+    """
+
+    @classmethod
+    def type(cls) -> str:
+        """Returns the type of the frame."""
+        return FLOW_PATTERN_VALIDATE_SLOT
+
+    @staticmethod
+    def from_dict(data: Dict[str, Any]) -> ValidateSlotPatternFlowStackFrame:
+        """Creates a `DialogueStackFrame` from a dictionary.
+
+        Args:
+            data: The dictionary to create the `DialogueStackFrame` from.
+
+        Returns:
+            The created `DialogueStackFrame`.
+        """
+        rejections = [
+            SlotRejection.from_dict(rejection) for rejection in data.get(REJECTIONS, [])
+        ]
+
+        return ValidateSlotPatternFlowStackFrame(
+            frame_id=data["frame_id"],
+            step_id=data["step_id"],
+            validate=data["validate"],
+            refill_action=data["refill_action"],
+            refill_utter=data[REFILL_UTTER],
+            rejections=rejections,
+        )

rasa/dialogue_understanding/processor/command_processor.py

@@ -22,6 +22,9 @@ from rasa.dialogue_understanding.commands.handle_digressions_command import (
     HandleDigressionsCommand,
 )
 from rasa.dialogue_understanding.commands.set_slot_command import SetSlotExtractor
+from rasa.dialogue_understanding.commands.utils import (
+    create_validate_frames_from_slot_set_events,
+)
 from rasa.dialogue_understanding.patterns.chitchat import FLOW_PATTERN_CHITCHAT
 from rasa.dialogue_understanding.patterns.collect_information import (
     CollectInformationPatternFlowStackFrame,
@@ -29,6 +32,9 @@ from rasa.dialogue_understanding.patterns.collect_information import (
 from rasa.dialogue_understanding.patterns.correction import (
     CorrectionPatternFlowStackFrame,
 )
+from rasa.dialogue_understanding.patterns.validate_slot import (
+    ValidateSlotPatternFlowStackFrame,
+)
 from rasa.dialogue_understanding.stack.dialogue_stack import DialogueStack
 from rasa.dialogue_understanding.stack.frames import (
     BaseFlowStackFrame,
@@ -234,18 +240,51 @@ def execute_commands(
     # and then pushing the commands onto the stack in the reversed order.
     reversed_commands = list(reversed(commands))
 
+    # we need to keep track of the ValidateSlotPatternFlowStackFrame that
+    # should be pushed onto the stack before executing the StartFlowCommands.
+    # This is necessary to make sure that slots filled before the start of a
+    # flow can be immediately validated without waiting till the flow is started
+    # and completed.
+    stack_frames_to_follow_commands: List[ValidateSlotPatternFlowStackFrame] = []
+
     validate_state_of_commands(commands)
 
     for command in reversed_commands:
         new_events = command.run_command_on_tracker(
             tracker, all_flows, original_tracker
         )
+
+        _, stack_frames_to_follow_commands = (
+            create_validate_frames_from_slot_set_events(
+                tracker, new_events, stack_frames_to_follow_commands
+            )
+        )
+
         events.extend(new_events)
         tracker.update_with_events(new_events)
 
+        new_events = push_stack_frames_to_follow_commands(
+            tracker, stack_frames_to_follow_commands
+        )
+        events.extend(new_events)
+
     return remove_duplicated_set_slots(events)
 
 
+def push_stack_frames_to_follow_commands(
+    tracker: DialogueStateTracker, stack_frames: List
+) -> List[Event]:
+    """Push stack frames to follow commands."""
+    new_events = []
+
+    for frame in stack_frames:
+        stack = tracker.stack
+        stack.push(frame)
+        new_events.extend(tracker.create_stack_updated_events(stack))
+    tracker.update_with_events(new_events)
+    return new_events
+
+
 def remove_duplicated_set_slots(events: List[Event]) -> List[Event]:
     """Removes duplicated set slot events.
 

rasa/dialogue_understanding_test/du_test_case.py

@@ -2,7 +2,7 @@ from typing import Any, Dict, Iterator, List, Optional, Tuple
 
 from pydantic import BaseModel, Field
 
-from rasa.dialogue_understanding.commands import Command
+from rasa.dialogue_understanding.commands.prompt_command import PromptCommand
 from rasa.dialogue_understanding.generator.command_parser import parse_commands
 from rasa.dialogue_understanding_test.command_comparison import are_command_lists_equal
 from rasa.dialogue_understanding_test.constants import (
@@ -30,6 +30,7 @@ from rasa.shared.nlu.constants import (
 KEY_USAGE = "usage"
 KEY_PROMPT_TOKENS = "prompt_tokens"
 KEY_COMPLETION_TOKENS = "completion_tokens"
+KEY_CHOICES = "choices"
 
 
 class DialogueUnderstandingOutput(BaseModel):
@@ -65,11 +66,18 @@ class DialogueUnderstandingOutput(BaseModel):
     """
 
     # Dict with component name as key and list of commands as value
-    commands: Dict[str, List[Command]]
+    commands: Dict[str, List[PromptCommand]]
     # List of prompts
     prompts: Optional[List[Dict[str, Any]]] = None
 
-    def get_predicted_commands(self) -> List[Command]:
+    class Config:
+        """Skip validation for PromptCommand protocol as pydantic does not know how to
+        serialize or handle instances of a protocol.
+        """
+
+        arbitrary_types_allowed = True
+
+    def get_predicted_commands(self) -> List[PromptCommand]:
         """Get all commands from the output."""
         return [
             command
@@ -144,6 +152,11 @@ class DialogueUnderstandingOutput(BaseModel):
                         KEY_COMPLETION_TOKENS
                     )
 
+            choices = prompt_data.get(KEY_LLM_RESPONSE_METADATA, {}).get(KEY_CHOICES)
+            if choices and len(choices) > 0:
+                # Add the action list returned by the LLM to the prompt_info
+                prompt_info[KEY_CHOICES] = choices[0]
+
             data[component_name].append(prompt_info)
 
         return data
@@ -155,9 +168,16 @@ class DialogueUnderstandingTestStep(BaseModel):
     template: Optional[str] = None
     line: Optional[int] = None
     metadata_name: Optional[str] = None
-    commands: Optional[List[Command]] = None
+    commands: Optional[List[PromptCommand]] = None
     dialogue_understanding_output: Optional[DialogueUnderstandingOutput] = None
 
+    class Config:
+        """Skip validation for PromptCommand protocol as pydantic does not know how to
+        serialize or handle instances of a protocol.
+        """
+
+        arbitrary_types_allowed = True
+
     def as_dict(self) -> Dict[str, Any]:
         if self.actor == ACTOR_USER:
             if self.commands:
@@ -178,7 +198,7 @@ class DialogueUnderstandingTestStep(BaseModel):
     def from_dict(
         step: Dict[str, Any],
         flows: FlowsList,
-        custom_command_classes: List[Command] = [],
+        custom_command_classes: List[PromptCommand] = [],
         remove_default_commands: List[str] = [],
     ) -> "DialogueUnderstandingTestStep":
         """Creates a DialogueUnderstandingTestStep from a dictionary.
@@ -224,7 +244,7 @@ class DialogueUnderstandingTestStep(BaseModel):
             commands=commands,
         )
 
-    def get_predicted_commands(self) -> List[Command]:
+    def get_predicted_commands(self) -> List[PromptCommand]:
         """Get all predicted commands from the test case."""
         if self.dialogue_understanding_output is None:
             return []
@@ -314,7 +334,7 @@ class DialogueUnderstandingTestCase(BaseModel):
         input_test_case: Dict[str, Any],
         flows: FlowsList,
         file: Optional[str] = None,
-        custom_command_classes: List[Command] = [],
+        custom_command_classes: List[PromptCommand] = [],
         remove_default_commands: List[str] = [],
     ) -> "DialogueUnderstandingTestCase":
         """Creates a DialogueUnderstandingTestCase from a dictionary.
@@ -361,7 +381,7 @@ class DialogueUnderstandingTestCase(BaseModel):
 
         return [step.to_str() for step in steps]
 
-    def get_expected_commands(self) -> List[Command]:
+    def get_expected_commands(self) -> List[PromptCommand]:
         """Get all commands from the test steps."""
         return [
             command