rasa-pro 3.11.0__py3-none-any.whl → 3.11.0a1__py3-none-any.whl

rasa/dialogue_understanding/generator/multi_step/multi_step_llm_command_generator.py

@@ -24,7 +24,6 @@ from rasa.dialogue_understanding.generator.constants import (
     LLM_CONFIG_KEY,
     USER_INPUT_CONFIG_KEY,
     FLOW_RETRIEVAL_KEY,
-    DEFAULT_LLM_CONFIG,
 )
 from rasa.dialogue_understanding.generator.flow_retrieval import FlowRetrieval
 from rasa.dialogue_understanding.generator.llm_based_command_generator import (
@@ -40,10 +39,7 @@ 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
-from rasa.shared.constants import (
-    RASA_PATTERN_CANNOT_HANDLE_NOT_SUPPORTED,
-    EMBEDDINGS_CONFIG_KEY,
-)
+from rasa.shared.constants import RASA_PATTERN_CANNOT_HANDLE_NOT_SUPPORTED
 from rasa.shared.constants import ROUTE_TO_CALM_SLOT
 from rasa.shared.core.flows import FlowStep, Flow, FlowsList
 from rasa.shared.core.flows.steps.collect import CollectInformationFlowStep
@@ -57,7 +53,6 @@ from rasa.shared.utils.llm import (
     tracker_as_readable_transcript,
     sanitize_message_for_prompt,
     allowed_values_for_slot,
-    resolve_model_client_config,
 )
 
 # multistep template keys
@@ -75,7 +70,6 @@ DEFAULT_HANDLE_FLOWS_TEMPLATE = importlib.resources.read_text(
 DEFAULT_FILL_SLOTS_TEMPLATE = importlib.resources.read_text(
     "rasa.dialogue_understanding.generator.multi_step", "fill_slots_prompt.jinja2"
 ).strip()
-MULTI_STEP_LLM_COMMAND_GENERATOR_CONFIG_FILE = "config.json"
 
 # dictionary of template names and associated file names and default values
 PROMPT_TEMPLATES = {
@@ -144,18 +138,7 @@ class MultiStepLLMCommandGenerator(LLMBasedCommandGenerator):
         **kwargs: Any,
     ) -> "MultiStepLLMCommandGenerator":
         """Loads trained component (see parent class for full docstring)."""
-
-        # Perform health check of the LLM client config
-        llm_config = resolve_model_client_config(config.get(LLM_CONFIG_KEY, {}))
-        cls.perform_llm_health_check(
-            llm_config,
-            DEFAULT_LLM_CONFIG,
-            "multi_step_llm_command_generator.load",
-            MultiStepLLMCommandGenerator.__name__,
-        )
-
         prompts = cls._load_prompt_templates(model_storage, resource)
-
         # init base command generator
         command_generator = cls(config, model_storage, resource, prompts)
         # load flow retrieval if enabled
@@ -163,13 +146,13 @@ class MultiStepLLMCommandGenerator(LLMBasedCommandGenerator):
             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."""
+        # persist prompt template
         self._persist_prompt_templates()
-        self._persist_config()
+        # persist flow retrieval
         if self.flow_retrieval is not None:
             self.flow_retrieval.persist()
 
@@ -246,9 +229,9 @@ class MultiStepLLMCommandGenerator(LLMBasedCommandGenerator):
         commands: List[Command] = []
 
         slot_set_re = re.compile(
-            r"""SetSlot\(['"]?([a-zA-Z_][a-zA-Z0-9_-]*)['"]?, ?['"]?(.*)['"]?\)"""
+            r"""SetSlot\((\"?[a-zA-Z_][a-zA-Z0-9_-]*?\"?), ?(.*)\)"""
         )
-        start_flow_re = re.compile(r"StartFlow\(['\"]?([a-zA-Z0-9_-]+)['\"]?\)")
+        start_flow_re = re.compile(r"StartFlow\(([a-zA-Z0-9_-]+?)\)")
         change_flow_re = re.compile(r"ChangeFlow\(\)")
         cancel_flow_re = re.compile(r"CancelFlow\(\)")
         chitchat_re = re.compile(r"ChitChat\(\)")
@@ -297,19 +280,9 @@ class MultiStepLLMCommandGenerator(LLMBasedCommandGenerator):
                 commands.append(HumanHandoffCommand())
             elif match := clarify_re.search(action):
                 options = sorted([opt.strip() for opt in match.group(1).split(",")])
-                # Remove surrounding quotes if present
-                cleaned_options = []
-                for flow in options:
-                    if (flow.startswith('"') and flow.endswith('"')) or (
-                        flow.startswith("'") and flow.endswith("'")
-                    ):
-                        cleaned_options.append(flow[1:-1])
-                    else:
-                        cleaned_options.append(flow)
-                # check if flow is valid
                 valid_options = [
                     flow
-                    for flow in cleaned_options
+                    for flow in options
                     if flow in flows.user_flow_ids
                     and flow not in user_flows_on_the_stack(tracker.stack)
                 ]
@@ -320,13 +293,6 @@ class MultiStepLLMCommandGenerator(LLMBasedCommandGenerator):
             elif change_flow_re.search(action):
                 commands.append(ChangeFlowCommand())
 
-        if not commands:
-            structlogger.debug(
-                "multi_step_llm_command_generator.parse_commands",
-                message="No commands were parsed from the LLM actions.",
-                actions=actions,
-            )
-
         return commands
 
     ### Helper methods
@@ -402,13 +368,6 @@ class MultiStepLLMCommandGenerator(LLMBasedCommandGenerator):
                 file_path = path / file_name
                 rasa.shared.utils.io.write_text_file(template, file_path)
 
-    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 / MULTI_STEP_LLM_COMMAND_GENERATOR_CONFIG_FILE, self.config
-            )
-
     async def _predict_commands_with_multi_step(
         self,
         message: Message,
@@ -802,17 +761,11 @@ class MultiStepLLMCommandGenerator(LLMBasedCommandGenerator):
             .get(FILE_PATH_KEY),
             DEFAULT_FILL_SLOTS_TEMPLATE,
         )
-
-        llm_config = resolve_model_client_config(
-            config.get(LLM_CONFIG_KEY), MultiStepLLMCommandGenerator.__name__
-        )
-        embedding_config = resolve_model_client_config(
-            config.get(FLOW_RETRIEVAL_KEY, {}).get(EMBEDDINGS_CONFIG_KEY),
-            FlowRetrieval.__name__,
-        )
-
         return deep_container_fingerprint(
-            [handle_flows_template, fill_slots_template, llm_config, embedding_config]
+            [
+                handle_flows_template,
+                fill_slots_template,
+            ]
         )
 
     @staticmethod

rasa/dialogue_understanding/generator/nlu_command_adapter.py

@@ -19,7 +19,6 @@ from rasa.engine.storage.storage import ModelStorage
 from rasa.shared.constants import ROUTE_TO_CALM_SLOT
 from rasa.shared.core.domain import Domain
 from rasa.shared.core.flows.flows_list import FlowsList
-from rasa.shared.core.flows.steps import CollectInformationFlowStep
 from rasa.shared.core.slot_mappings import (
     SlotFillingManager,
     extract_slot_value,
@@ -218,24 +217,7 @@ def _issue_set_slot_commands(
     commands: List[Command] = []
     domain = domain if domain else Domain.empty()
     slot_filling_manager = SlotFillingManager(domain, tracker, message)
-
-    # only use slots that don't have ask_before_filling set to True
-    available_slot_names = flows.available_slot_names(ask_before_filling=False)
-
-    # check if the current step is a CollectInformationFlowStep
-    # in case it has ask_before_filling set to True, we need to add the
-    # slot to the available_slot_names
-    if tracker.active_flow:
-        flow = flows.flow_by_id(tracker.active_flow)
-        step_id = tracker.current_step_id
-        if flow is not None:
-            current_step = flow.step_by_id(step_id)
-            if (
-                current_step
-                and isinstance(current_step, CollectInformationFlowStep)
-                and current_step.ask_before_filling
-            ):
-                available_slot_names.add(current_step.collect)
+    available_slot_names = flows.available_slot_names()
 
     for _, slot in tracker.slots.items():
         # if a slot is not collected in available flows,

rasa/dialogue_understanding/generator/single_step/command_prompt_template.jinja2

@@ -41,9 +41,6 @@ Based on this information generate a list of actions you want to take. Your job
 * 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()".
-{% if is_repeat_command_enabled %}
-* Repeat the last bot messages, described by "RepeatLastBotMessages()". This is useful when the user asks to repeat the last bot messages.
-{% endif %}
 
 ===
 Write out the actions you want to take, one per line, in the order they should take place.

rasa/dialogue_understanding/generator/single_step/single_step_llm_command_generator.py

@@ -16,13 +16,11 @@ from rasa.dialogue_understanding.commands import (
     KnowledgeAnswerCommand,
     ClarifyCommand,
     CannotHandleCommand,
-    RepeatBotMessagesCommand,
 )
 from rasa.dialogue_understanding.generator.constants import (
     LLM_CONFIG_KEY,
     USER_INPUT_CONFIG_KEY,
     FLOW_RETRIEVAL_KEY,
-    DEFAULT_LLM_CONFIG,
 )
 from rasa.dialogue_understanding.generator.flow_retrieval import (
     FlowRetrieval,
@@ -39,7 +37,6 @@ from rasa.shared.constants import (
     ROUTE_TO_CALM_SLOT,
     PROMPT_CONFIG_KEY,
     PROMPT_TEMPLATE_CONFIG_KEY,
-    EMBEDDINGS_CONFIG_KEY,
 )
 from rasa.shared.core.flows import FlowsList
 from rasa.shared.core.trackers import DialogueStateTracker
@@ -51,9 +48,7 @@ from rasa.shared.utils.llm import (
     get_prompt_template,
     tracker_as_readable_transcript,
     sanitize_message_for_prompt,
-    resolve_model_client_config,
 )
-from rasa.utils.beta import ensure_beta_feature_is_enabled, BetaNotEnabledException
 from rasa.utils.log_utils import log_llm
 
 COMMAND_PROMPT_FILE_NAME = "command_prompt.jinja2"
@@ -62,7 +57,6 @@ DEFAULT_COMMAND_PROMPT_TEMPLATE = importlib.resources.read_text(
     "rasa.dialogue_understanding.generator.single_step",
     "command_prompt_template.jinja2",
 )
-SINGLE_STEP_LLM_COMMAND_GENERATOR_CONFIG_FILE = "config.json"
 
 structlogger = structlog.get_logger()
 
@@ -113,7 +107,6 @@ class SingleStepLLMCommandGenerator(LLMBasedCommandGenerator):
         )
 
         self.trace_prompt_tokens = self.config.get("trace_prompt_tokens", False)
-        self.repeat_command_enabled = self.is_repeat_command_enabled()
 
     ### Implementations of LLMBasedCommandGenerator parent
     @staticmethod
@@ -137,21 +130,10 @@ class SingleStepLLMCommandGenerator(LLMBasedCommandGenerator):
         **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
@@ -159,29 +141,18 @@ class SingleStepLLMCommandGenerator(LLMBasedCommandGenerator):
             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."""
+        # persist prompt template
         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
-            )
+        # persist flow retrieval
+        if self.flow_retrieval is not None:
+            self.flow_retrieval.persist()
 
     async def predict_commands(
         self,
@@ -214,12 +185,6 @@ class SingleStepLLMCommandGenerator(LLMBasedCommandGenerator):
 
         if not 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:
@@ -320,17 +285,14 @@ class SingleStepLLMCommandGenerator(LLMBasedCommandGenerator):
 
         commands: List[Command] = []
 
-        slot_set_re = re.compile(
-            r"""SetSlot\(['"]?([a-zA-Z_][a-zA-Z0-9_-]*)['"]?, ?['"]?(.*)['"]?\)"""
-        )
-        start_flow_re = re.compile(r"StartFlow\(['\"]?([a-zA-Z0-9_-]+)['\"]?\)")
+        slot_set_re = re.compile(r"""SetSlot\(([a-zA-Z_][a-zA-Z0-9_-]*?), ?(.*)\)""")
+        start_flow_re = re.compile(r"StartFlow\(([a-zA-Z0-9_-]+?)\)")
         cancel_flow_re = re.compile(r"CancelFlow\(\)")
         chitchat_re = re.compile(r"ChitChat\(\)")
         skip_question_re = re.compile(r"SkipQuestion\(\)")
         knowledge_re = re.compile(r"SearchAndReply\(\)")
         humand_handoff_re = re.compile(r"HumanHandoff\(\)")
-        clarify_re = re.compile(r"Clarify\(([\"\'a-zA-Z0-9_, ]+)\)")
-        repeat_re = re.compile(r"RepeatLastBotMessages\(\)")
+        clarify_re = re.compile(r"Clarify\(([a-zA-Z0-9_, ]+)\)")
 
         for action in actions.strip().splitlines():
             if match := slot_set_re.search(action):
@@ -357,40 +319,21 @@ class SingleStepLLMCommandGenerator(LLMBasedCommandGenerator):
                 commands.append(KnowledgeAnswerCommand())
             elif humand_handoff_re.search(action):
                 commands.append(HumanHandoffCommand())
-            elif repeat_re.search(action):
-                commands.append(RepeatBotMessagesCommand())
             elif match := clarify_re.search(action):
                 options = sorted([opt.strip() for opt in match.group(1).split(",")])
-                # Remove surrounding quotes if present
-                cleaned_options = []
-                for flow in options:
-                    if (flow.startswith('"') and flow.endswith('"')) or (
-                        flow.startswith("'") and flow.endswith("'")
-                    ):
-                        cleaned_options.append(flow[1:-1])
-                    else:
-                        cleaned_options.append(flow)
-                # check if flow is valid
                 valid_options = [
-                    flow for flow in cleaned_options if flow in flows.user_flow_ids
+                    flow for flow in options if flow in flows.user_flow_ids
                 ]
                 if len(set(valid_options)) == 1:
                     commands.extend(cls.start_flow_by_name(valid_options[0], flows))
                 elif len(valid_options) > 1:
                     commands.append(ClarifyCommand(valid_options))
 
-        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."""
+        """Add a fingerprint of the knowledge base for the graph."""
         config_prompt = (
             config.get(PROMPT_CONFIG_KEY)
             or config.get(PROMPT_TEMPLATE_CONFIG_KEY)
@@ -400,16 +343,7 @@ class SingleStepLLMCommandGenerator(LLMBasedCommandGenerator):
             config_prompt,
             DEFAULT_COMMAND_PROMPT_TEMPLATE,
         )
-        llm_config = resolve_model_client_config(
-            config.get(LLM_CONFIG_KEY), SingleStepLLMCommandGenerator.__name__
-        )
-        embedding_config = resolve_model_client_config(
-            config.get(FLOW_RETRIEVAL_KEY, {}).get(EMBEDDINGS_CONFIG_KEY),
-            FlowRetrieval.__name__,
-        )
-        return deep_container_fingerprint(
-            [prompt_template, llm_config, embedding_config]
-        )
+        return deep_container_fingerprint(prompt_template)
 
     ### Helper methods
     def render_template(
@@ -459,20 +393,6 @@ class SingleStepLLMCommandGenerator(LLMBasedCommandGenerator):
             "current_slot": current_slot,
             "current_slot_description": current_slot_description,
             "user_message": latest_user_message,
-            "is_repeat_command_enabled": self.repeat_command_enabled,
         }
 
         return self.compile_template(self.prompt_template).render(**inputs)
-
-    def is_repeat_command_enabled(self) -> bool:
-        """Check for feature flag"""
-        RASA_PRO_BETA_REPEAT_COMMAND_ENV_VAR_NAME = "RASA_PRO_BETA_REPEAT_COMMAND"
-        try:
-            ensure_beta_feature_is_enabled(
-                "Repeat Command",
-                env_flag=RASA_PRO_BETA_REPEAT_COMMAND_ENV_VAR_NAME,
-            )
-        except BetaNotEnabledException:
-            return False
-
-        return True

rasa/dialogue_understanding/patterns/default_flows_for_patterns.yml

@@ -4,11 +4,6 @@ responses:
   utter_ask_rephrase:
     - text: I’m sorry I am unable to understand you, could you please rephrase?
 
-  utter_ask_still_there:
-    - text: "Hello, are you still there?"
-      metadata:
-        rephrase: True
-
   utter_boolean_slot_rejection:
     - text: "Sorry, the value you provided, `{{value}}`, is not valid. Please respond with a valid value."
       metadata:
@@ -80,11 +75,6 @@ responses:
       metadata:
         rephrase: True
 
-  utter_inform_hangup:
-    - text: It seems you are not there anymore. I will hang up shortly.
-      metadata:
-        rephrase: True
-
   utter_internal_error_rasa:
     - text: Sorry, I am having trouble with that. Please try again in a few minutes.
 
@@ -111,15 +101,6 @@ slots:
     type: bool
     mappings:
       - type: from_llm
-  silence_timeout:
-    type: float
-    initial_value: 6.0
-    max_value: 1000000
-  consecutive_silence_timeouts:
-    type: float
-    initial_value: 0.0
-    max_value: 1000000
-
 
 flows:
   pattern_cancel_flow:
@@ -236,11 +217,6 @@ flows:
               - action: utter_internal_error_rasa
                 next: END
 
-  pattern_repeat_bot_messages:
-    description: Voice conversation repair pattern to repeat bot messages
-    name: pattern repeat bot messages
-    steps:
-      - action: action_repeat_bot_messages
 
   pattern_restart:
     description: Flow for restarting the conversation
@@ -270,32 +246,3 @@ flows:
     name: pattern skip question
     steps:
       - action: utter_skip_question_answer
-
-  pattern_user_silence:
-    description: Reacting to user silence in voice bots
-    name: pattern react to silence
-    nlu_trigger:
-      - intent: silence_timeout
-    persisted_slots:
-      - consecutive_silence_timeouts
-    steps:
-      - noop: true
-        next:
-          - if: "slots.consecutive_silence_timeouts = 0.0"
-            then:
-              - set_slots:
-                  - consecutive_silence_timeouts: 1.0
-              - action: action_repeat_bot_messages
-                next: END
-          - if: "slots.consecutive_silence_timeouts = 1.0"
-            then:
-              - set_slots:
-                  - consecutive_silence_timeouts: 2.0
-              - action: utter_ask_still_there
-                next: END
-          - if: "slots.consecutive_silence_timeouts > 1.0"
-            then:
-              - action: utter_inform_hangup
-              - action: action_hangup
-                next: END
-          - else: END

rasa/dialogue_understanding/processor/command_processor.py

@@ -8,7 +8,6 @@ from rasa.dialogue_understanding.commands import (
     Command,
     CorrectSlotsCommand,
     CorrectedSlot,
-    RepeatBotMessagesCommand,
     SetSlotCommand,
     StartFlowCommand,
     FreeFormAnswerCommand,
@@ -423,9 +422,6 @@ def clean_up_commands(
     elif not tracker.has_coexistence_routing_slot and len(clean_commands) > 1:
         clean_commands = filter_cannot_handle_command_for_skipped_slots(clean_commands)
 
-    clean_commands = ensure_max_number_of_command_type(
-        clean_commands, RepeatBotMessagesCommand, 1
-    )
     structlogger.debug(
         "command_processor.clean_up_commands.final_commands",
         command=clean_commands,
@@ -434,22 +430,6 @@ def clean_up_commands(
     return clean_commands
 
 
-def ensure_max_number_of_command_type(
-    commands: List[Command], command_type: Type[Command], n: int
-) -> List[Command]:
-    """Ensures that for a given command type only the first n stay in the list."""
-    filtered: List[Command] = []
-    count = 0
-    for c in commands:
-        if isinstance(c, command_type):
-            if count >= n:
-                continue
-            else:
-                count += 1
-        filtered.append(c)
-    return filtered
-
-
 def clean_up_clarify_command(
     commands_so_far: List[Command],
     all_commands: List[Command],
@@ -472,7 +452,7 @@ def clean_up_clarify_command(
         if not (isinstance(c, SetSlotCommand) and c.name == ROUTE_TO_CALM_SLOT)
     ]
 
-    # if all commands are clarify commands, add the first one only, otherwise add none
+    # if there are multiple clarify commands, do add the first one
     if all(
         isinstance(c, ClarifyCommand) for c in commands_without_route_to_calm_set_slot
     ):