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

rasa/dialogue_understanding/generator/single_step/single_step_llm_command_generator.py

@@ -4,33 +4,19 @@ 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 (
-    get_prompt_template,
-    resolve_model_client_config,
-)
+from rasa.shared.utils.llm import get_prompt_template
 
 DEFAULT_COMMAND_PROMPT_TEMPLATE = importlib.resources.read_text(
     "rasa.dialogue_understanding.generator.prompt_templates",
@@ -47,7 +33,7 @@ structlogger = structlog.get_logger()
     ],
     is_trainable=True,
 )
-class SingleStepLLMCommandGenerator(CompactLLMCommandGenerator):
+class SingleStepLLMCommandGenerator(SingleStepBasedLLMCommandGenerator):
     """A single step LLM-based command generator."""
 
     def __init__(
@@ -77,53 +63,17 @@ class SingleStepLLMCommandGenerator(CompactLLMCommandGenerator):
                 ),
             )
 
-        # 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]
-        )
-
-    @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 +93,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/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.")
 

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/utils.py

@@ -1,7 +1,9 @@
 from contextlib import contextmanager
 from typing import Any, Dict, Generator, List, Optional, Text
 
-from rasa.dialogue_understanding.commands import Command
+import structlog
+
+from rasa.dialogue_understanding.commands import Command, NoopCommand, SetSlotCommand
 from rasa.dialogue_understanding.constants import (
     RASA_RECORD_COMMANDS_AND_PROMPTS_ENV_VAR_NAME,
 )
@@ -16,7 +18,6 @@ from rasa.shared.nlu.constants import (
     KEY_USER_PROMPT,
     PREDICTED_COMMANDS,
     PROMPTS,
-    SET_SLOT_COMMAND,
 )
 from rasa.shared.nlu.training_data.message import Message
 from rasa.shared.providers.llm.llm_response import LLMResponse
@@ -26,6 +27,8 @@ record_commands_and_prompts = get_bool_env_variable(
     RASA_RECORD_COMMANDS_AND_PROMPTS_ENV_VAR_NAME, False
 )
 
+structlogger = structlog.get_logger()
+
 
 @contextmanager
 def set_record_commands_and_prompts() -> Generator:
@@ -144,21 +147,74 @@ def _handle_via_nlu_in_coexistence(
     if not tracker:
         return False
 
+    commands = message.get(COMMANDS, [])
+
+    # If coexistence routing slot is not active, this setup doesn't
+    # support dual routing -> default to CALM
     if not tracker.has_coexistence_routing_slot:
+        structlogger.debug(
+            "utils.handle_via_nlu_in_coexistence"
+            ".tracker_missing_route_session_to_calm_slot",
+            event_info=(
+                f"Tracker doesn't have the '{ROUTE_TO_CALM_SLOT}' slot."
+                f"Routing to CALM."
+            ),
+            route_session_to_calm=commands,
+        )
         return False
 
+    # Check if the routing decision is stored in the tracker slot
+    # If slot is true -> route to CALM
+    # If slot is false -> route to DM1
     value = tracker.get_slot(ROUTE_TO_CALM_SLOT)
     if value is not None:
+        structlogger.debug(
+            "utils.handle_via_nlu_in_coexistence"
+            ".tracker_route_session_to_calm_slot_value",
+            event_info=(
+                f"Tracker slot '{ROUTE_TO_CALM_SLOT}' set to '{value}'. "
+                f"Routing to "
+                f"{'CALM' if value else 'NLU system'}."
+            ),
+            route_session_to_calm_value_in_tracker=value,
+        )
         return not value
 
-    # routing slot has been reset so we need to check
-    # the command issued by the Router component
-    if message.get(COMMANDS):
-        for command in message.get(COMMANDS):
-            if (
-                command.get("command") == SET_SLOT_COMMAND
-                and command.get("name") == ROUTE_TO_CALM_SLOT
-            ):
-                return not command.get("value")
-
+    # Non-sticky routing to DM1 is only allowed if NoopCommand is the sole predicted
+    # command. In that case, route to DM1
+    if len(commands) == 1 and commands[0].get("command") == NoopCommand.command():
+        structlogger.debug(
+            "utils.handle_via_nlu_in_coexistence.noop_command_detected",
+            event_info="NoopCommand found. Routing to NLU system non-sticky.",
+            commands=commands,
+        )
+        return True
+
+    # If the slot was reset (e.g. new session), try to infer routing from
+    # attached commands. Look for a SetSlotCommand targeting the ROUTE_TO_CALM_SLOT
+    for command in message.get(COMMANDS, []):
+        # If slot is true -> route to CALM
+        # If slot is false -> route to DM1
+        if (
+            command.get("command") == SetSlotCommand.command()
+            and command.get("name") == ROUTE_TO_CALM_SLOT
+        ):
+            structlogger.debug(
+                "utils.handle_via_nlu_in_coexistence.set_slot_command_detected",
+                event_info=(
+                    f"SetSlotCommand setting the '{ROUTE_TO_CALM_SLOT}' to "
+                    f"'{command.get('value')}'. "
+                    f"Routing to "
+                    f"{'CALM' if command.get('value') else 'NLU system'}."
+                ),
+                commands=commands,
+            )
+            return not command.get("value")
+
+    # If no routing info is available -> default to CALM
+    structlogger.debug(
+        "utils.handle_via_nlu_in_coexistence.no_routing_info_available",
+        event_info="No routing info available. Routing to CALM.",
+        commands=commands,
+    )
     return False

rasa/dialogue_understanding_test/du_test_case.py

@@ -3,9 +3,9 @@ from typing import Any, Dict, Iterator, List, Optional, Tuple
 
 from pydantic import BaseModel, Field
 
-from rasa.core import IntentlessPolicy
 from rasa.core.nlg.contextual_response_rephraser import ContextualResponseRephraser
 from rasa.core.policies.enterprise_search_policy import EnterpriseSearchPolicy
+from rasa.core.policies.intentless_policy import IntentlessPolicy
 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

rasa/dialogue_understanding_test/du_test_runner.py

@@ -5,10 +5,10 @@ from typing import Any, Dict, List, Optional, Text
 import structlog
 from tqdm import tqdm
 
+from rasa.core.available_endpoints import AvailableEndpoints
 from rasa.core.channels import CollectingOutputChannel, UserMessage
 from rasa.core.exceptions import AgentNotReady
 from rasa.core.persistor import StorageType
-from rasa.core.utils import AvailableEndpoints
 from rasa.dialogue_understanding.commands import Command
 from rasa.dialogue_understanding.utils import set_record_commands_and_prompts
 from rasa.dialogue_understanding_test.du_test_case import (
@@ -34,6 +34,7 @@ from rasa.e2e_test.e2e_test_runner import E2ETestRunner
 from rasa.shared.core.events import UserUttered
 from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.shared.nlu.constants import PREDICTED_COMMANDS, PROMPTS
+from rasa.shared.utils.llm import create_tracker_for_user_step
 from rasa.utils.endpoints import EndpointConfig
 
 structlogger = structlog.get_logger()
@@ -179,8 +180,9 @@ class DialogueUnderstandingTestRunner:
             # create and save the tracker at the time just
             # before the user message was sent
             step_sender_id = f"{sender_id}_{user_step_index}"
-            await self._create_tracker_for_user_step(
+            await create_tracker_for_user_step(
                 step_sender_id,
+                self.agent,
                 test_case_tracker,
                 user_uttered_event_indices[user_step_index],
             )
@@ -289,26 +291,6 @@ class DialogueUnderstandingTestRunner:
 
         return user_uttered_event
 
-    async def _create_tracker_for_user_step(
-        self,
-        step_sender_id: str,
-        test_case_tracker: DialogueStateTracker,
-        index_user_uttered_event: int,
-    ) -> None:
-        """Creates a tracker for the user step."""
-        tracker = test_case_tracker.copy()
-        # modify the sender id so that the test case tracker is not overwritten
-        tracker.sender_id = step_sender_id
-
-        if tracker.events:
-            # get timestamp of the event just before the user uttered event
-            timestamp = tracker.events[index_user_uttered_event - 1].timestamp
-            # revert the tracker to the event just before the user uttered event
-            tracker = tracker.travel_back_in_time(timestamp)
-
-        # store the tracker with the unique sender id
-        await self.agent.tracker_store.save(tracker)
-
     async def _send_user_message(
         self,
         sender_id: str,