rasa-pro 3.11.0a4.dev2__py3-none-any.whl → 3.11.0rc1__py3-none-any.whl

rasa/dialogue_understanding/generator/multi_step/multi_step_llm_command_generator.py

@@ -24,6 +24,8 @@ from rasa.dialogue_understanding.generator.constants import (
     LLM_CONFIG_KEY,
     USER_INPUT_CONFIG_KEY,
     FLOW_RETRIEVAL_KEY,
+    TRAINED_MODEL_NAME_CONFIG_KEY,
+    DEFAULT_LLM_CONFIG,
 )
 from rasa.dialogue_understanding.generator.flow_retrieval import FlowRetrieval
 from rasa.dialogue_understanding.generator.llm_based_command_generator import (
@@ -39,7 +41,10 @@ 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
+from rasa.shared.constants import (
+    RASA_PATTERN_CANNOT_HANDLE_NOT_SUPPORTED,
+    EMBEDDINGS_CONFIG_KEY,
+)
 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
@@ -53,7 +58,9 @@ from rasa.shared.utils.llm import (
     tracker_as_readable_transcript,
     sanitize_message_for_prompt,
     allowed_values_for_slot,
+    resolve_model_client_config,
 )
+from rasa.shared.utils.health_check import perform_inference_time_llm_health_check
 
 # multistep template keys
 HANDLE_FLOWS_KEY = "handle_flows"
@@ -139,6 +146,14 @@ class MultiStepLLMCommandGenerator(LLMBasedCommandGenerator):
     ) -> "MultiStepLLMCommandGenerator":
         """Loads trained component (see parent class for full docstring)."""
         prompts = cls._load_prompt_templates(model_storage, resource)
+
+        persisted_config = cls.load_config_from_model_storage(model_storage, resource)
+        train_model_name = (
+            persisted_config.get(TRAINED_MODEL_NAME_CONFIG_KEY, None)
+            if persisted_config
+            else None
+        )
+
         # init base command generator
         command_generator = cls(config, model_storage, resource, prompts)
         # load flow retrieval if enabled
@@ -146,10 +161,21 @@ class MultiStepLLMCommandGenerator(LLMBasedCommandGenerator):
             command_generator.flow_retrieval = cls.load_flow_retrival(
                 command_generator.config, model_storage, resource
             )
+
+        perform_inference_time_llm_health_check(
+            command_generator.config.get(LLM_CONFIG_KEY),
+            DEFAULT_LLM_CONFIG,
+            train_model_name,
+            "multi_step_llm_command_generator.load",
+            MultiStepLLMCommandGenerator.__name__,
+        )
+
         return command_generator
 
     def persist(self) -> None:
         """Persist this component to disk for future loading."""
+        super().persist()
+
         # persist prompt template
         self._persist_prompt_templates()
         # persist flow retrieval
@@ -229,9 +255,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\(\)")
@@ -280,9 +306,19 @@ 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 options
+                    for flow in cleaned_options
                     if flow in flows.user_flow_ids
                     and flow not in user_flows_on_the_stack(tracker.stack)
                 ]
@@ -293,6 +329,13 @@ 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
@@ -761,11 +804,17 @@ 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,
-            ]
+            [handle_flows_template, fill_slots_template, llm_config, embedding_config]
         )
 
     @staticmethod

rasa/dialogue_understanding/generator/single_step/single_step_llm_command_generator.py

@@ -22,6 +22,8 @@ from rasa.dialogue_understanding.generator.constants import (
     LLM_CONFIG_KEY,
     USER_INPUT_CONFIG_KEY,
     FLOW_RETRIEVAL_KEY,
+    DEFAULT_LLM_CONFIG,
+    TRAINED_MODEL_NAME_CONFIG_KEY,
 )
 from rasa.dialogue_understanding.generator.flow_retrieval import (
     FlowRetrieval,
@@ -38,6 +40,7 @@ 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
@@ -49,9 +52,11 @@ from rasa.shared.utils.llm import (
     get_prompt_template,
     tracker_as_readable_transcript,
     sanitize_message_for_prompt,
+    resolve_model_client_config,
 )
-from rasa.utils.log_utils import log_llm
+from rasa.shared.utils.health_check import perform_inference_time_llm_health_check
 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"
 
@@ -136,6 +141,7 @@ class SingleStepLLMCommandGenerator(LLMBasedCommandGenerator):
         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
@@ -143,11 +149,28 @@ class SingleStepLLMCommandGenerator(LLMBasedCommandGenerator):
             command_generator.flow_retrieval = cls.load_flow_retrival(
                 command_generator.config, model_storage, resource
             )
+
+        persisted_config = cls.load_config_from_model_storage(model_storage, resource)
+        train_model_name = (
+            persisted_config.get(TRAINED_MODEL_NAME_CONFIG_KEY, None)
+            if persisted_config
+            else None
+        )
+        perform_inference_time_llm_health_check(
+            command_generator.config.get(LLM_CONFIG_KEY),
+            DEFAULT_LLM_CONFIG,
+            train_model_name,
+            "single_step_llm_command_generator.load",
+            SingleStepLLMCommandGenerator.__name__,
+        )
+
         return command_generator
 
     def persist(self) -> None:
         """Persist this component to disk for future loading."""
         # persist prompt template
+        super().persist()
+
         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
@@ -187,6 +210,12 @@ 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:
@@ -287,14 +316,16 @@ 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_, ]+)\)")
+        clarify_re = re.compile(r"Clarify\(([\"\'a-zA-Z0-9_, ]+)\)")
         repeat_re = re.compile(r"RepeatLastBotMessages\(\)")
 
         for action in actions.strip().splitlines():
@@ -326,19 +357,36 @@ class SingleStepLLMCommandGenerator(LLMBasedCommandGenerator):
                 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 options if flow in flows.user_flow_ids
+                    flow for flow in cleaned_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 of the knowledge base for the graph."""
+        """Add a fingerprint for the graph."""
         config_prompt = (
             config.get(PROMPT_CONFIG_KEY)
             or config.get(PROMPT_TEMPLATE_CONFIG_KEY)
@@ -348,7 +396,16 @@ class SingleStepLLMCommandGenerator(LLMBasedCommandGenerator):
             config_prompt,
             DEFAULT_COMMAND_PROMPT_TEMPLATE,
         )
-        return deep_container_fingerprint(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]
+        )
 
     ### Helper methods
     def render_template(

rasa/dialogue_understanding/patterns/default_flows_for_patterns.yml

@@ -4,6 +4,11 @@ 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:
@@ -75,6 +80,11 @@ 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.
 
@@ -251,3 +261,32 @@ 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/patterns/user_silence.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Any, Dict
+
+from rasa.dialogue_understanding.stack.frames import PatternFlowStackFrame
+from rasa.shared.constants import RASA_DEFAULT_FLOW_PATTERN_PREFIX
+
+
+FLOW_PATTERN_USER_SILENCE = RASA_DEFAULT_FLOW_PATTERN_PREFIX + "user_silence"
+
+
+@dataclass
+class UserSilencePatternFlowStackFrame(PatternFlowStackFrame):
+    """A flow stack frame that can get added when the silence timeout trips."""
+
+    flow_id: str = FLOW_PATTERN_USER_SILENCE
+    """The ID of the flow."""
+
+    @classmethod
+    def type(cls) -> str:
+        """Returns the type of the frame."""
+        return FLOW_PATTERN_USER_SILENCE
+
+    @staticmethod
+    def from_dict(data: Dict[str, Any]) -> UserSilencePatternFlowStackFrame:
+        """Creates a `DialogueStackFrame` from a dictionary.
+
+        Args:
+            data: The dictionary to create the `DialogueStackFrame` from.
+
+        Returns:
+            The created `DialogueStackFrame`.
+        """
+        return UserSilencePatternFlowStackFrame(
+            frame_id=data["frame_id"],
+            step_id=data["step_id"],
+        )

rasa/e2e_test/e2e_test_runner.py

@@ -190,11 +190,11 @@ class E2ETestRunner:
                     error=f"Message handling timed out for user message '{step.text}'.",
                     exc_info=True,
                 )
-            except Exception:
+            except Exception as exc:
                 structlogger.error(
                     "e2e_test_runner.run_prediction_loop",
                     error=f"An exception occurred while handling "
-                    f"user message '{step.text}'.",
+                    f"user message '{step.text}'. Error: {exc}",
                 )
             tracker = await self.agent.tracker_store.retrieve(sender_id)  # type: ignore[assignment]
             turns[position], event_cursor = self.get_actual_step_output(
@@ -1155,6 +1155,8 @@ class E2ETestRunner:
                     flow_paths_stack
                     and self.agent.domain
                     and self.agent.domain.is_custom_action(event.action_name)
+                    and STEP_ID_METADATA_KEY in event.metadata
+                    and ACTIVE_FLOW_METADATA_KEY in event.metadata
                 ):
                     flow_paths_stack[-1].nodes.append(self._create_path_node(event))
 

rasa/e2e_test/utils/io.py

@@ -346,7 +346,7 @@ def read_test_cases(path: str) -> TestSuite:
     beta_flag_verified = False
 
     for test_file in test_files:
-        test_file_content = parse_raw_yaml(Path(test_file).read_text())
+        test_file_content = parse_raw_yaml(Path(test_file).read_text(encoding="utf-8"))
 
         validate_yaml_data_using_schema_with_assertions(
             yaml_data=test_file_content, schema_content=e2e_test_schema