rasa-pro 3.13.0.dev20250612__py3-none-any.whl → 3.13.0rc1__py3-none-any.whl

rasa/dialogue_understanding/generator/single_step/single_step_llm_command_generator.py

@@ -4,32 +4,21 @@ from typing import Any, Dict, Literal, Optional, Text
 import structlog
 
 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.single_step.compact_llm_command_generator import (  # noqa: E501
-    CompactLLMCommandGenerator,
+from rasa.dialogue_understanding.generator.single_step.single_step_based_llm_command_generator import (  # noqa: E501
+    SingleStepBasedLLMCommandGenerator,
 )
 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 (
-    EMBEDDINGS_CONFIG_KEY,
     PROMPT_CONFIG_KEY,
     PROMPT_TEMPLATE_CONFIG_KEY,
 )
-from rasa.shared.utils.constants import LOG_COMPONENT_SOURCE_METHOD_FINGERPRINT_ADDON
-from rasa.shared.utils.io import deep_container_fingerprint
 from rasa.shared.utils.llm import (
+    check_prompt_config_keys_and_warn_if_deprecated,
     get_prompt_template,
-    resolve_model_client_config,
 )
 
 DEFAULT_COMMAND_PROMPT_TEMPLATE = importlib.resources.read_text(
@@ -47,7 +36,7 @@ structlogger = structlog.get_logger()
     ],
     is_trainable=True,
 )
-class SingleStepLLMCommandGenerator(CompactLLMCommandGenerator):
+class SingleStepLLMCommandGenerator(SingleStepBasedLLMCommandGenerator):
     """A single step LLM-based command generator."""
 
     def __init__(
@@ -66,64 +55,22 @@ class SingleStepLLMCommandGenerator(CompactLLMCommandGenerator):
             **kwargs,
         )
 
-        # Set the prompt template
-        if config.get(PROMPT_CONFIG_KEY):
-            structlogger.warning(
-                "single_step_llm_command_generator.init",
-                event_info=(
-                    "The config parameter 'prompt' is deprecated "
-                    "and will be removed in Rasa 4.0.0. "
-                    "Please use the config parameter 'prompt_template' instead. "
-                ),
-            )
-
-        # Set the command syntax version to v1
-        CommandSyntaxManager.set_syntax_version(
-            self.get_component_command_syntax_version()
-        )
-
-    @staticmethod
-    def get_default_config() -> Dict[str, Any]:
-        """The component's default config (see parent class for full docstring)."""
-        return {
-            PROMPT_CONFIG_KEY: None,  # Legacy
-            PROMPT_TEMPLATE_CONFIG_KEY: None,
-            USER_INPUT_CONFIG_KEY: None,
-            LLM_CONFIG_KEY: None,
-            FLOW_RETRIEVAL_KEY: FlowRetrieval.get_default_config(),
-        }
-
-    @classmethod
-    def fingerprint_addon(cls: Any, config: Dict[str, Any]) -> Optional[str]:
-        """Add a fingerprint for the graph."""
-        prompt_template = cls._resolve_component_prompt_template(
-            config, log_context=LOG_COMPONENT_SOURCE_METHOD_FINGERPRINT_ADDON
-        )
-        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]
+        # Warn if the prompt config key is used to set the prompt template
+        check_prompt_config_keys_and_warn_if_deprecated(
+            config, "single_step_llm_command_generator"
         )
 
-    @staticmethod
-    def get_default_llm_config() -> Dict[str, Any]:
-        """Get the default LLM config for the command generator."""
-        return DEFAULT_LLM_CONFIG
-
     @staticmethod
     def get_component_command_syntax_version() -> CommandSyntaxVersion:
         return CommandSyntaxVersion.v1
 
-    @staticmethod
+    @classmethod
     def _resolve_component_prompt_template(
+        cls: Any,
         config: Dict[str, Any],
         prompt_template: Optional[str] = None,
         log_context: Optional[Literal["init", "fingerprint_addon"]] = None,
+        log_source_component: Optional[str] = "SingleStepLLMCommandGenerator",
     ) -> Optional[str]:
         """Get the prompt template from the config or the default prompt template."""
         # Case when model is being loaded
@@ -143,6 +90,6 @@ class SingleStepLLMCommandGenerator(CompactLLMCommandGenerator):
         return get_prompt_template(
             prompt_template_path,
             DEFAULT_COMMAND_PROMPT_TEMPLATE,
-            log_source_component=SingleStepLLMCommandGenerator.__name__,
+            log_source_component=log_source_component,
             log_source_method=log_context,
         )

rasa/dialogue_understanding/patterns/cancel.py

@@ -90,7 +90,7 @@ class ActionCancelFlow(action.Action):
             return []
 
         if not isinstance(top, CancelPatternFlowStackFrame):
-            structlogger.warning("action.cancel_flow.no_cancel_frame", top=top)
+            structlogger.warning("action.cancel_flow.no_cancel_frame")
             return []
 
         for canceled_frame_id in top.canceled_frames:
@@ -105,7 +105,6 @@ class ActionCancelFlow(action.Action):
             else:
                 structlogger.warning(
                     "action.cancel_flow.frame_not_found",
-                    dialogue_stack=stack,
                     frame_id=canceled_frame_id,
                 )
 

rasa/dialogue_understanding/patterns/clarify.py

@@ -89,7 +89,7 @@ class ActionClarifyFlows(action.Action):
             return []
 
         if not isinstance(top, ClarifyPatternFlowStackFrame):
-            structlogger.warning("action.clarify_flows.no_clarification_frame", top=top)
+            structlogger.warning("action.clarify_flows.no_clarification_frame")
             return []
 
         options_string = self.assemble_options_string(top.names)

rasa/dialogue_understanding/patterns/correction.py

@@ -114,7 +114,8 @@ class ActionCorrectFlowSlot(action.Action):
 
         if not isinstance(top, CorrectionPatternFlowStackFrame):
             structlogger.warning(
-                "action.correct_flow_slot.no_correction_frame", top=top
+                "action.correct_flow_slot.no_correction_frame",
+                top=top,  # no PII
             )
             return []
 
@@ -246,7 +247,6 @@ def reset_stack_on_tracker_to_prior_state(
             "action.correct_flow_slot.no_target_frame_found",
             reset_step_id=reset_step_id,
             reset_flow_id=reset_flow_id,
-            stack_to_reset_to=stack_to_reset_to,
         )
         return tracker.stack
 

rasa/dialogue_understanding/patterns/default_flows_for_patterns.yml

@@ -93,6 +93,11 @@ responses:
       metadata:
         rephrase: True
 
+  utter_no_relevant_answer_found:
+    - text: I’m sorry, I can’t help with that.
+      metadata:
+        rephrase: True
+
   utter_skip_question_answer:
     - text: I'm here to provide you with the best assistance, and in order to do so, I kindly request that we complete this step together. Your input is essential for a seamless experience!
       metadata:
@@ -129,23 +134,28 @@ flows:
       - action: utter_flow_cancelled_rasa
 
   pattern_cannot_handle:
-    description: |
-      Conversation repair flow for addressing failed command generation scenarios
-    name: pattern cannot handle
+    description: Conversation repair flow for addressing failed command generation scenarios
+    name: pattern_cannot_handle
     steps:
       - noop: true
         next:
-          # chitchat fallback
-          - if: "'{{context.reason}}' = 'cannot_handle_chitchat'"
+          # Chitchat fallback
+          - if: context.reason is "cannot_handle_chitchat"
             then:
               - action: utter_cannot_handle
                 next: "END"
-          # fallback for things that are not supported
-          - if: "'{{context.reason}}' = 'cannot_handle_not_supported'"
+          # Fallback for things that are not supported
+          - if: context.reason is "cannot_handle_not_supported"
             then:
               - action: utter_cannot_handle
                 next: END
-          # default
+          # Fallback when no relevant answer to the user query has been found.
+          # This is used by the EnterpriseSearchPolicy.
+          - if: context.reason is "cannot_handle_no_relevant_answer"
+            then:
+              - action: utter_no_relevant_answer_found
+                next: END
+          # Default
           - else:
               - action: utter_ask_rephrase
                 next: END
@@ -219,15 +229,15 @@ flows:
 
   pattern_internal_error:
     description: Conversation repair flow for informing users about internal errors
-    name: pattern internal error
+    name: pattern_internal_error
     steps:
       - noop: true
         next:
-          - if: "'{{context.error_type}}' = 'rasa_internal_error_user_input_too_long'"
+          - if: context.error_type is "rasa_internal_error_user_input_too_long"
             then:
               - action: utter_user_input_too_long_error_rasa
                 next: END
-          - if: "'{{context.error_type}}' = 'rasa_internal_error_user_input_empty'"
+          - if: context.error_type is "rasa_internal_error_user_input_empty"
             then:
               - action: utter_user_input_empty_error_rasa
                 next: END
@@ -281,23 +291,25 @@ flows:
       - 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
+            then: set_slots_consecutive_silence_timeouts
           - if: "slots.consecutive_silence_timeouts = 1.0"
-            then:
-              - set_slots:
-                  - consecutive_silence_timeouts: 2.0
-              - action: utter_ask_still_there
-                next: END
+            then: set_slots_consecutive_silence_timeouts_2
           - if: "slots.consecutive_silence_timeouts > 1.0"
-            then:
-              - action: utter_inform_hangup
-              - action: action_hangup
-                next: END
+            then: message_utter_inform_hangup
           - else: END
+      - id: set_slots_consecutive_silence_timeouts
+        set_slots:
+          - consecutive_silence_timeouts: 1.0
+      - action: action_repeat_bot_messages
+        next: END
+      - id: set_slots_consecutive_silence_timeouts_2
+        set_slots:
+          - consecutive_silence_timeouts: 2.0
+      - action: utter_ask_still_there
+        next: END
+      - id: message_utter_inform_hangup
+        action: utter_inform_hangup
+      - action: action_hangup
 
   pattern_validate_slot:
     description: Flow for running validations on slots

rasa/dialogue_understanding/patterns/domain_for_patterns.py

@@ -0,0 +1,190 @@
+from __future__ import annotations
+
+import importlib
+import inspect
+import os
+from dataclasses import fields, is_dataclass
+from typing import Any, Dict, List, Optional, Set, Text
+
+import importlib_resources
+from pydantic import BaseModel, Field, ValidationInfo, field_validator
+
+from rasa.dialogue_understanding.stack.frames.pattern_frame import PatternFlowStackFrame
+from rasa.shared.core.constants import (
+    DEFAULT_ACTION_NAMES,
+    DEFAULT_INTENTS,
+    RULE_SNIPPET_ACTION_NAME,
+)
+from rasa.shared.core.slots import AnySlot, BooleanSlot, CategoricalSlot, TextSlot
+
+ACTIONS: List[Text] = [
+    *DEFAULT_ACTION_NAMES,
+    "validate_{{context.collect}}",
+]
+EXCLUDED_ACTIONS: Set[Text] = {RULE_SNIPPET_ACTION_NAME}
+
+INTENTS: List[Text] = [*DEFAULT_INTENTS]
+
+CONTEXT_FIELD_TYPES: Dict[Text, Text] = {
+    "canceled_name": CategoricalSlot.type_name,
+    "names": CategoricalSlot.type_name,
+    "collect": CategoricalSlot.type_name,
+    "utter": CategoricalSlot.type_name,
+    "collect_action": CategoricalSlot.type_name,
+    "previous_flow_name": CategoricalSlot.type_name,
+    "reset_flow_id": CategoricalSlot.type_name,
+    "is_reset_only": BooleanSlot.type_name,
+    "canceled_frames": AnySlot.type_name,
+    "corrected_slots": AnySlot.type_name,
+    "rejections": AnySlot.type_name,
+    "info": AnySlot.type_name,
+    "reason": TextSlot.type_name,
+    "error_type": TextSlot.type_name,
+}
+
+FLOW_NAME_VALUES = "FLOW_NAME"
+FLOW_ID_VALUES = "FLOW_ID"
+SLOT_NAME_VALUES = "SLOT_NAME"
+RESPONSE_NAME_VALUES = "RESPONSE_NAME"
+ACTION_NAME_VALUES = "ACTION_NAME"
+
+CONTEXT_FIELD_VALUES: Dict[Text, Text] = {
+    "canceled_name": FLOW_NAME_VALUES,
+    "names": FLOW_NAME_VALUES,
+    "previous_flow_name": FLOW_NAME_VALUES,
+    "reset_flow_id": FLOW_ID_VALUES,
+    "collect": SLOT_NAME_VALUES,
+    "utter": RESPONSE_NAME_VALUES,
+    "collect_action": ACTION_NAME_VALUES,
+}
+
+PATTERNS_MODULE_BASE = "rasa.dialogue_understanding.patterns"
+
+
+class ContextField(BaseModel):
+    """Element in the `contexts` mapping of the domain."""
+
+    patterns: List[Text] = Field(
+        ..., description="Patterns that reference this context field."
+    )
+    type: Text = Field(
+        ..., description="Slot type (categorical, text, boolean, any …)."
+    )
+    values: Optional[List[Text]] = Field(
+        None,
+        description="Optional placeholder that restricts which values a slot can take "
+        "(FLOW_NAME, SLOT_NAME, …).",
+    )
+
+    @field_validator("type")
+    def _validate_slot_type(cls, v: str) -> str:
+        allowed_types = list(set(CONTEXT_FIELD_TYPES.values()))
+        if v not in allowed_types:
+            raise ValueError(
+                f"Unsupported type '{v}'. "
+                f"Must be one of: {', '.join(allowed_types)}."
+            )
+        return v
+
+    @field_validator("values")
+    def _validate_values_placeholder(
+        cls, v: Optional[str], values: ValidationInfo
+    ) -> Optional[str]:
+        if v is None:
+            return v
+
+        allowed_values = set(CONTEXT_FIELD_VALUES.values())
+        if not set(v).issubset(allowed_values):
+            raise ValueError(
+                f"Unsupported values placeholder '{v}'. "
+                f"Must be one of {', '.join(allowed_values)}."
+            )
+
+        slot_type = values.data.get("type")
+        if slot_type != CategoricalSlot.type_name:
+            raise ValueError(
+                "`values` can only be specified for categorical slots "
+                f"(got slot type '{slot_type}')."
+            )
+
+        return v
+
+
+class PatternDomain(BaseModel):
+    """Complete domain that is generated for the default patterns."""
+
+    actions: List[Text]
+    intents: List[Text]
+    contexts: Dict[Text, ContextField]
+
+
+def build_contexts_from_patterns() -> Dict[str, Dict[str, Any]]:
+    """Builds a dictionary of contexts from the pattern classes.
+
+    Returns:
+        A dictionary where each key is a field name and the value is a dictionary
+    """
+    patterns_folder = str(importlib_resources.files(PATTERNS_MODULE_BASE))
+    contexts_map: Dict[str, Dict[str, Any]] = {}
+
+    # Dynamically gather all .py files
+    for root, _, files in os.walk(patterns_folder):
+        for file in files:
+            if not file.endswith(".py"):
+                continue
+
+            try:
+                module_name = f"{PATTERNS_MODULE_BASE}.{file[:-3]}"
+                module = importlib.import_module(module_name)
+            except ImportError:
+                continue
+
+            # Inspect classes in that module
+            for _, cls in inspect.getmembers(module, inspect.isclass):
+                if not is_dataclass(cls):
+                    continue
+
+                # The cls has to be a subclass of PatternFlowStackFrame
+                if cls == PatternFlowStackFrame or not issubclass(
+                    cls, PatternFlowStackFrame
+                ):
+                    continue
+
+                for f in fields(cls):
+                    field_name = f.name
+                    if field_name not in contexts_map:
+                        field_type = CONTEXT_FIELD_TYPES.get(
+                            field_name, TextSlot.type_name
+                        )
+                        contexts_map[field_name] = {
+                            "patterns": set(),
+                            "type": field_type,
+                        }
+                        values: Optional[Text] = CONTEXT_FIELD_VALUES.get(field_name)
+                        if values:
+                            contexts_map[field_name]["values"] = [values]
+
+                    # Add the pattern name to the set
+                    pattern_name = cls.type()
+                    contexts_map[field_name]["patterns"].add(pattern_name)
+
+    # Convert "patterns" from set to list, for a clean final structure
+    for field_name, details in contexts_map.items():
+        details["patterns"] = sorted(list(details["patterns"]))
+
+    return contexts_map
+
+
+def generate_domain_for_default_patterns() -> PatternDomain:
+    """
+    Generate the domain for pattern-based flows as a strongly-typed object.
+
+    Returns: PatternDomain Pydantic model containing actions, intents and contexts.
+    """
+    actions = [action for action in ACTIONS if action not in EXCLUDED_ACTIONS]
+    raw_contexts = build_contexts_from_patterns()
+    contexts = {
+        field_name: ContextField(**details)
+        for field_name, details in raw_contexts.items()
+    }
+    return PatternDomain(actions=actions, intents=INTENTS, contexts=contexts)

rasa/dialogue_understanding/processor/command_processor.py

@@ -132,7 +132,7 @@ def validate_state_of_commands(commands: List[Command]) -> None:
     if sum(isinstance(c, CancelFlowCommand) for c in commands) > 1:
         structlogger.error(
             "command_processor.validate_state_of_commands.multiple_cancel_flow_commands",
-            commands=commands,
+            commands=[command.__class__.__name__ for command in commands],
         )
         raise ValueError("There can only be one cancel flow command.")
 
@@ -143,7 +143,7 @@ def validate_state_of_commands(commands: List[Command]) -> None:
     if free_form_answer_commands != commands[: len(free_form_answer_commands)]:
         structlogger.error(
             "command_processor.validate_state_of_commands.free_form_answer_commands_not_at_beginning",
-            commands=commands,
+            commands=[command.__class__.__name__ for command in commands],
         )
         raise ValueError(
             "Free form answer commands must be at start of the predicted command list."
@@ -153,7 +153,7 @@ def validate_state_of_commands(commands: List[Command]) -> None:
     if sum(isinstance(c, CorrectSlotsCommand) for c in commands) > 1:
         structlogger.error(
             "command_processor.validate_state_of_commands.multiple_correct_slots_commands",
-            commands=commands,
+            commands=[command.__class__.__name__ for command in commands],
         )
         raise ValueError("There can only be one correct slots command.")
 
@@ -214,18 +214,18 @@ def execute_commands(
     commands: List[Command] = get_commands_from_tracker(tracker)
     original_tracker = tracker.copy()
 
-    commands = clean_up_commands(
-        commands, tracker, all_flows, execution_context, story_graph, domain
-    )
-
     updated_flows = find_updated_flows(tracker, all_flows)
     if updated_flows:
-        # Override commands
+        # if there are updated flows, we need to handle the code change
         structlogger.debug(
             "command_processor.execute_commands.running_flows_were_updated",
             updated_flow_ids=updated_flows,
         )
         commands = [HandleCodeChangeCommand()]
+    else:
+        commands = clean_up_commands(
+            commands, tracker, all_flows, execution_context, story_graph, domain
+        )
 
     # store current flow hashes if they changed
     new_hashes = calculate_flow_fingerprints(all_flows)
@@ -348,7 +348,6 @@ def get_current_collect_step(
         # but no flow that triggered it. this should never happen.
         structlogger.warning(
             "command_processor.get_current_collect_step.no_flow_on_stack",
-            stack=dialogue_stack,
         )
         return None
 
@@ -358,7 +357,7 @@ def get_current_collect_step(
         # step from it
         structlogger.warning(
             "command_processor.get_current_collect_step.no_step_for_frame",
-            frame=frame_that_triggered_collect_infos,
+            frame=frame_that_triggered_collect_infos.frame_id,
         )
         return None
 
@@ -724,7 +723,7 @@ def clean_up_chitchat_command(
         )
         structlogger.warn(
             "command_processor.clean_up_chitchat_command.pattern_chitchat_not_found",
-            command=resulting_commands[0],
+            command=resulting_commands[0],  # no PII
         )
         return resulting_commands
 
@@ -742,7 +741,7 @@ def clean_up_chitchat_command(
         )
         structlogger.warn(
             "command_processor.clean_up_chitchat_command.replace_chitchat_answer_with_cannot_handle",
-            command=resulting_commands[0],
+            command=resulting_commands[0],  # no PII
             pattern_chitchat_uses_action_trigger_chitchat=has_action_trigger_chitchat,
             defined_intentless_policy_in_config=defines_intentless_policy,
         )

rasa/dialogue_understanding/processor/command_processor_component.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Any, Dict, List, Text
+from typing import Any, Dict, List, Optional, Text
 
 import rasa.dialogue_understanding.processor.command_processor
 from rasa.engine.graph import ExecutionContext, GraphComponent
@@ -37,8 +37,8 @@ class CommandProcessorComponent(GraphComponent):
         self,
         tracker: DialogueStateTracker,
         flows: FlowsList,
-        story_graph: StoryGraph,
-        domain: Domain,
+        domain: Optional[Domain] = None,
+        story_graph: Optional[StoryGraph] = None,
     ) -> List[Event]:
         """Execute commands to update tracker state."""
         return rasa.dialogue_understanding.processor.command_processor.execute_commands(

rasa/dialogue_understanding/stack/frames/flow_stack_frame.py

@@ -53,7 +53,8 @@ class FlowStackFrameType(str, Enum):
             typ: The string to create the `FlowStackFrameType` from.
 
         Returns:
-            The created `FlowStackFrameType`."""
+        The created `FlowStackFrameType`.
+        """
         if typ is None:
             return FlowStackFrameType.REGULAR
         elif typ == FlowStackFrameType.INTERRUPT.value:
@@ -107,7 +108,8 @@ class BaseFlowStackFrame(DialogueStackFrame):
             all_flows: All flows in the assistant.
 
         Returns:
-            The current flow."""
+        The current flow.
+        """
         flow = all_flows.flow_by_id(self.flow_id)
         if not flow:
             # we shouldn't ever end up with a frame that belongs to a non
@@ -122,9 +124,20 @@ class BaseFlowStackFrame(DialogueStackFrame):
             all_flows: All flows in the assistant.
 
         Returns:
-            The current flow step."""
+            The current flow step.
+        """
         flow = self.flow(all_flows)
-        step = flow.step_by_id(self.step_id)
+
+        step_id = self.step_id
+        # in 3.11.4 we added the flow_id as a prefix to the step_id
+        # this causes issues when loading old dialogues as the prefix is missing
+        # (see https://rasahq.atlassian.net/jira/software/c/projects/ENG/boards/43?selectedIssue=ENG-1939)
+        # so we try to find the step by adding the flow prefix to old step_ids as well
+        # TODO: remove this in 4.0.0
+        alternative_step_id = f"{self.flow_id}_{self.step_id}"
+
+        step = flow.step_by_id(step_id) or flow.step_by_id(alternative_step_id)
+
         if not step:
             # we shouldn't ever end up with a frame that belongs to a non
             # existing step, but if we do, we should raise an error

rasa/dialogue_understanding/stack/utils.py

@@ -209,7 +209,9 @@ def get_collect_steps_excluding_ask_before_filling_for_active_flow(
         All collect steps that are part of the current active flow,
         excluding the collect steps that have to be asked before filling.
     """
-    active_frame = top_user_flow_frame(dialogue_stack)
+    active_frame = top_user_flow_frame(
+        dialogue_stack, ignore_call_and_link_frames=False
+    )
     if active_frame is None:
         return set()
     active_flow = active_frame.flow(all_flows)