rasa-pro 3.10.17__py3-none-any.whl → 3.10.20.dev1__py3-none-any.whl

rasa/core/policies/intentless_policy.py

@@ -1,7 +1,7 @@
 import importlib.resources
 import math
 from dataclasses import dataclass, field
-from typing import Any, Dict, List, Optional, Set, TYPE_CHECKING, Text, Tuple
+from typing import Any, Dict, List, Optional, TYPE_CHECKING, Text, Tuple
 
 import structlog
 import tiktoken
@@ -29,7 +29,6 @@ from rasa.engine.storage.storage import ModelStorage
 from rasa.graph_components.providers.forms_provider import Forms
 from rasa.graph_components.providers.responses_provider import Responses
 from rasa.shared.constants import (
-    REQUIRED_SLOTS_KEY,
     EMBEDDINGS_CONFIG_KEY,
     LLM_CONFIG_KEY,
     MODEL_CONFIG_KEY,
@@ -49,6 +48,7 @@ from rasa.shared.core.events import (
 )
 from rasa.shared.core.flows import FlowsList
 from rasa.shared.core.generator import TrackerWithCachedStates
+from rasa.shared.core.policies.utils import filter_responses_for_intentless_policy
 from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.shared.exceptions import FileIOException, RasaCoreException
 from rasa.shared.nlu.constants import PREDICTED_CONFIDENCE_KEY
@@ -81,8 +81,6 @@ from rasa.utils.ml_utils import (
     persist_faiss_vector_store,
     response_for_template,
 )
-from rasa.dialogue_understanding.patterns.chitchat import FLOW_PATTERN_CHITCHAT
-from rasa.shared.core.constants import ACTION_TRIGGER_CHITCHAT
 from rasa.utils.log_utils import log_llm
 
 if TYPE_CHECKING:
@@ -142,59 +140,6 @@ class Conversation:
     interactions: List[Interaction] = field(default_factory=list)
 
 
-def collect_form_responses(forms: Forms) -> Set[Text]:
-    """Collect responses that belong the requested slots in forms.
-
-    Args:
-        forms: the forms from the domain
-    Returns:
-        all utterances used in forms
-    """
-    form_responses = set()
-    for _, form_info in forms.data.items():
-        for required_slot in form_info.get(REQUIRED_SLOTS_KEY, []):
-            form_responses.add(f"utter_ask_{required_slot}")
-    return form_responses
-
-
-def filter_responses(responses: Responses, forms: Forms, flows: FlowsList) -> Responses:
-    """Filters out responses that are unwanted for the intentless policy.
-
-    This includes utterances used in flows and forms.
-
-    Args:
-        responses: the responses from the domain
-        forms: the forms from the domain
-        flows: all flows
-    Returns:
-        The remaining, relevant responses for the intentless policy.
-    """
-    form_responses = collect_form_responses(forms)
-    flow_responses = flows.utterances
-    combined_responses = form_responses | flow_responses
-    filtered_responses = {
-        name: variants
-        for name, variants in responses.data.items()
-        if name not in combined_responses
-    }
-
-    pattern_chitchat = flows.flow_by_id(FLOW_PATTERN_CHITCHAT)
-
-    # The following condition is highly unlikely, but mypy requires the case
-    # of pattern_chitchat == None to be addressed
-    if not pattern_chitchat:
-        return Responses(data=filtered_responses)
-
-    # if action_trigger_chitchat, filter out "utter_free_chitchat_response"
-    has_action_trigger_chitchat = pattern_chitchat.has_action_step(
-        ACTION_TRIGGER_CHITCHAT
-    )
-    if has_action_trigger_chitchat:
-        filtered_responses.pop("utter_free_chitchat_response", None)
-
-    return Responses(data=filtered_responses)
-
-
 def action_from_response(
     text: Optional[str], responses: Dict[Text, List[Dict[Text, Any]]]
 ) -> Optional[str]:
@@ -495,7 +440,9 @@ class IntentlessPolicy(Policy):
             "IntentlessPolicy",
         )
 
-        responses = filter_responses(responses, forms, flows or FlowsList([]))
+        responses = filter_responses_for_intentless_policy(
+            responses, forms, flows or FlowsList([])
+        )
         telemetry.track_intentless_policy_train()
         response_texts = [r for r in extract_ai_response_examples(responses.data)]
 

rasa/dialogue_understanding/generator/nlu_command_adapter.py

@@ -139,7 +139,7 @@ class NLUCommandAdapter(GraphComponent, CommandGenerator):
 
         if commands:
             commands = clean_up_commands(
-                commands, tracker, flows, self._execution_context
+                commands, tracker, flows, self._execution_context, domain
             )
             log_llm(
                 logger=structlogger,

rasa/dialogue_understanding/processor/command_processor.py

@@ -1,6 +1,8 @@
 from typing import List, Optional, Type, Set, Dict
 
 import structlog
+
+from rasa.shared.core.domain import Domain
 from rasa.shared.core.training_data.structures import StoryGraph
 from rasa.dialogue_understanding.commands import (
     CancelFlowCommand,
@@ -43,6 +45,7 @@ from rasa.shared.core.constants import FLOW_HASHES_SLOT
 from rasa.shared.core.events import Event, SlotSet
 from rasa.shared.core.flows import FlowsList
 from rasa.shared.core.flows.steps.collect import CollectInformationFlowStep
+from rasa.shared.core.policies.utils import contains_intentless_policy_responses
 from rasa.shared.core.slots import Slot
 from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.shared.nlu.constants import COMMANDS
@@ -181,6 +184,7 @@ def execute_commands(
     all_flows: FlowsList,
     execution_context: ExecutionContext,
     story_graph: Optional[StoryGraph] = None,
+    domain: Optional[Domain] = None,
 ) -> List[Event]:
     """Executes a list of commands.
 
@@ -190,6 +194,7 @@ def execute_commands(
         all_flows: All flows.
         execution_context: Information about the single graph run.
         story_graph: StoryGraph object with stories available for training.
+        domain: The domain of the bot.
 
     Returns:
         A list of the events that were created.
@@ -198,7 +203,7 @@ def execute_commands(
     original_tracker = tracker.copy()
 
     commands = clean_up_commands(
-        commands, tracker, all_flows, execution_context, story_graph
+        commands, tracker, all_flows, execution_context, story_graph, domain
     )
 
     updated_flows = find_updated_flows(tracker, all_flows)
@@ -332,6 +337,7 @@ def clean_up_commands(
     all_flows: FlowsList,
     execution_context: ExecutionContext,
     story_graph: Optional[StoryGraph] = None,
+    domain: Optional[Domain] = None,
 ) -> List[Command]:
     """Clean up a list of commands.
 
@@ -347,10 +353,13 @@ def clean_up_commands(
         all_flows: All flows.
         execution_context: Information about a single graph run.
         story_graph: StoryGraph object with stories available for training.
+        domain: The domain of the bot.
 
     Returns:
     The cleaned up commands.
     """
+    domain = domain if domain else Domain.empty()
+
     slots_so_far, active_flow = filled_slots_for_active_flow(tracker, all_flows)
 
     clean_commands: List[Command] = []
@@ -393,7 +402,12 @@ def clean_up_commands(
         # handle chitchat command differently from other free-form answer commands
         elif isinstance(command, ChitChatAnswerCommand):
             clean_commands = clean_up_chitchat_command(
-                clean_commands, command, all_flows, execution_context, story_graph
+                clean_commands,
+                command,
+                all_flows,
+                execution_context,
+                domain,
+                story_graph,
             )
 
         elif isinstance(command, FreeFormAnswerCommand):
@@ -570,6 +584,7 @@ def clean_up_chitchat_command(
     command: ChitChatAnswerCommand,
     flows: FlowsList,
     execution_context: ExecutionContext,
+    domain: Domain,
     story_graph: Optional[StoryGraph] = None,
 ) -> List[Command]:
     """Clean up a chitchat answer command.
@@ -583,6 +598,8 @@ def clean_up_chitchat_command(
         flows: All flows.
         execution_context: Information about a single graph run.
         story_graph: StoryGraph object with stories available for training.
+        domain: The domain of the bot.
+
     Returns:
         The cleaned up commands.
     """
@@ -608,10 +625,9 @@ def clean_up_chitchat_command(
     )
     defines_intentless_policy = execution_context.has_node(IntentlessPolicy)
 
-    has_e2e_stories = True if (story_graph and story_graph.has_e2e_stories()) else False
-
     if (has_action_trigger_chitchat and not defines_intentless_policy) or (
-        defines_intentless_policy and not has_e2e_stories
+        defines_intentless_policy
+        and not contains_intentless_policy_responses(flows, domain, story_graph)
     ):
         resulting_commands.insert(
             0, CannotHandleCommand(RASA_PATTERN_CANNOT_HANDLE_CHITCHAT)

rasa/dialogue_understanding/processor/command_processor_component.py

@@ -6,6 +6,7 @@ import rasa.dialogue_understanding.processor.command_processor
 from rasa.engine.graph import ExecutionContext, GraphComponent
 from rasa.engine.storage.resource import Resource
 from rasa.engine.storage.storage import ModelStorage
+from rasa.shared.core.domain import Domain
 from rasa.shared.core.events import Event
 from rasa.shared.core.flows import FlowsList
 from rasa.shared.core.trackers import DialogueStateTracker
@@ -15,7 +16,8 @@ from rasa.shared.core.training_data.structures import StoryGraph
 class CommandProcessorComponent(GraphComponent):
     """Processes commands by issuing events to modify a tracker.
 
-    Minimal component that applies commands to a tracker."""
+    Minimal component that applies commands to a tracker.
+    """
 
     def __init__(self, execution_context: ExecutionContext):
         self._execution_context = execution_context
@@ -36,8 +38,9 @@ class CommandProcessorComponent(GraphComponent):
         tracker: DialogueStateTracker,
         flows: FlowsList,
         story_graph: StoryGraph,
+        domain: Domain,
     ) -> List[Event]:
         """Execute commands to update tracker state."""
         return rasa.dialogue_understanding.processor.command_processor.execute_commands(
-            tracker, flows, self._execution_context, story_graph
+            tracker, flows, self._execution_context, story_graph, domain
         )

rasa/engine/validation.py

@@ -5,18 +5,18 @@ import logging
 import sys
 import typing
 from typing import (
-    Optional,
+    Any,
     Callable,
+    Dict,
+    List,
+    Literal,
+    Optional,
+    Set,
     Text,
     Tuple,
-    Dict,
     Type,
-    Any,
-    Set,
-    Union,
     TypeVar,
-    List,
-    Literal,
+    Union,
 )
 
 import structlog
@@ -60,8 +60,10 @@ from rasa.shared.constants import (
 )
 from rasa.shared.core.constants import ACTION_RESET_ROUTING, ACTION_TRIGGER_CHITCHAT
 from rasa.shared.core.domain import Domain
-from rasa.shared.core.flows import FlowsList, Flow
+from rasa.shared.core.flows import Flow, FlowsList
+from rasa.shared.core.policies.utils import contains_intentless_policy_responses
 from rasa.shared.core.slots import Slot
+from rasa.shared.core.training_data.structures import StoryGraph
 from rasa.shared.exceptions import RasaException
 from rasa.shared.nlu.training_data.message import Message
 
@@ -621,11 +623,18 @@ def _recursively_check_required_components(
 
 
 def validate_flow_component_dependencies(
-    flows: FlowsList, model_configuration: GraphModelConfiguration
+    flows: FlowsList,
+    domain: Domain,
+    story_graph: StoryGraph,
+    model_configuration: GraphModelConfiguration,
 ) -> None:
     if (pattern_chitchat := flows.flow_by_id(FLOW_PATTERN_CHITCHAT)) is not None:
         _validate_chitchat_dependencies(pattern_chitchat, model_configuration)
 
+    _validate_intentless_policy_responses(
+        flows, domain, story_graph, model_configuration
+    )
+
 
 def _validate_chitchat_dependencies(
     pattern_chitchat: Flow, model_configuration: GraphModelConfiguration
@@ -653,6 +662,32 @@ def _validate_chitchat_dependencies(
         )
 
 
+def _validate_intentless_policy_responses(
+    flows: FlowsList,
+    domain: Domain,
+    story_graph: StoryGraph,
+    model_configuration: GraphModelConfiguration,
+) -> None:
+    """If IntentlessPolicy is configured, validate that it has responses to use:
+    either responses from the domain that are not part of any flow, or from
+    end-to-end stories.
+    """
+    if not model_configuration.predict_schema.has_node(IntentlessPolicy):
+        return
+
+    if not contains_intentless_policy_responses(flows, domain, story_graph):
+        structlogger.error(
+            "validation.intentless_policy.no_applicable_responses_found",
+            event_info=(
+                "IntentlessPolicy is configured, but no applicable responses are "
+                "found. Please make sure that there are responses defined in the "
+                "domain that are not part of any flow, or that there are "
+                "end-to-end stories in the training data."
+            ),
+        )
+        sys.exit(1)
+
+
 def get_component_index(schema: GraphSchema, component_class: Type) -> Optional[int]:
     """Extracts the index of a component of the given class in the schema.
     This function assumes that each component's node name is stored in a way

rasa/llm_fine_tuning/conversations.py

@@ -45,7 +45,7 @@ class ConversationStep:
             elif isinstance(command, SetSlotCommand):
                 output.append(f"SetSlot({command.name}, {command.value})")
             elif isinstance(command, ClarifyCommand):
-                output.append(f"Clarify({command.options})")
+                output.append(f"Clarify({', '.join(command.options)})")
             elif isinstance(command, CancelFlowCommand):
                 output.append("CancelFlow()")
             elif isinstance(command, ChitChatAnswerCommand):

rasa/model_training.py

@@ -302,6 +302,7 @@ async def _train_graph(
     )
     flows = file_importer.get_flows()
     domain = file_importer.get_domain()
+    story_graph = file_importer.get_stories()
     model_configuration = recipe.graph_config_for_recipe(
         config,
         kwargs,
@@ -314,7 +315,7 @@ async def _train_graph(
     )
     rasa.engine.validation.validate_model_client_configuration_setup(config)
     rasa.engine.validation.validate_flow_component_dependencies(
-        flows, model_configuration
+        flows, domain, story_graph, model_configuration
     )
     rasa.engine.validation.validate_command_generator_setup(model_configuration)
 

rasa/shared/constants.py

@@ -97,6 +97,8 @@ UTTER_ASK_PREFIX = "utter_ask_"
 ACTION_ASK_PREFIX = "action_ask_"
 FLOW_PREFIX = "flow_"
 
+UTTER_FREE_CHITCHAT_RESPONSE = "utter_free_chitchat_response"
+
 ASSISTANT_ID_KEY = "assistant_id"
 ASSISTANT_ID_DEFAULT_VALUE = "placeholder_default"
 
@@ -115,6 +117,7 @@ CONFIG_MANDATORY_KEYS_NLU = ["language"] + CONFIG_MANDATORY_COMMON_KEYS
 CONFIG_MANDATORY_KEYS = list(
     set(CONFIG_MANDATORY_KEYS_CORE + CONFIG_MANDATORY_KEYS_NLU)
 )
+CONFIG_RECIPE_KEY = "recipe"
 
 # Keys related to Forms (in the Domain)
 REQUIRED_SLOTS_KEY = "required_slots"

rasa/shared/core/constants.py

@@ -165,3 +165,5 @@ POLICY_NAME_RULE = "RulePolicy"
 CLASSIFIER_NAME_FALLBACK = "FallbackClassifier"
 
 POLICIES_THAT_EXTRACT_ENTITIES = {"TEDPolicy"}
+
+ERROR_CODE_KEY = "error_code"

rasa/shared/core/domain.py

@@ -1651,6 +1651,14 @@ class Domain:
         """Write domain to a file."""
         as_yaml = self.as_yaml()
         rasa.shared.utils.io.write_text_file(as_yaml, filename)
+        # run the check again on the written domain to catch any errors
+        # that may have been missed in the user defined domain files
+        structlogger.info(
+            "domain.persist.domain_written_to_file",
+            event_info="The entire domain content has been written to file.",
+            filename=filename,
+        )
+        Domain.is_domain_file(filename)
 
     def as_yaml(self) -> Text:
         """Dump the `Domain` object as a YAML string.
@@ -1945,17 +1953,18 @@ class Domain:
 
         try:
             content = read_yaml_file(filename)
-        except (RasaException, YamlSyntaxException):
-            structlogger.warning(
+        except (RasaException, YamlSyntaxException) as error:
+            structlogger.error(
                 "domain.cannot_load_domain_file",
                 file=filename,
+                error=error,
                 event_info=(
                     f"The file {filename} could not be loaded as domain file. "
                     f"You can use https://yamlchecker.com/ to validate "
                     f"the YAML syntax of your file."
                 ),
             )
-            return False
+            raise RasaException(f"Domain could not be loaded: {error}")
 
         return any(key in content for key in ALL_DOMAIN_KEYS)
 

rasa/shared/core/events.py

@@ -31,15 +31,16 @@ from typing import Union
 
 from rasa.shared.constants import DOCS_URL_TRAINING_DATA
 from rasa.shared.core.constants import (
-    LOOP_NAME,
-    EXTERNAL_MESSAGE_PREFIX,
+    ACTION_LISTEN_NAME,
     ACTION_NAME_SENDER_ID_CONNECTOR_STR,
+    ACTION_SESSION_START_NAME,
+    ENTITY_LABEL_SEPARATOR,
+    ERROR_CODE_KEY,
+    EXTERNAL_MESSAGE_PREFIX,
     IS_EXTERNAL,
-    USE_TEXT_FOR_FEATURIZATION,
     LOOP_INTERRUPTED,
-    ENTITY_LABEL_SEPARATOR,
-    ACTION_SESSION_START_NAME,
-    ACTION_LISTEN_NAME,
+    USE_TEXT_FOR_FEATURIZATION,
+    LOOP_NAME,
 )
 from rasa.shared.exceptions import UnsupportedFeatureException
 from rasa.shared.nlu.constants import (
@@ -2528,3 +2529,69 @@ class FlowCancelled(SkipEventInMDStoryMixin):
             )
         except KeyError as e:
             raise ValueError(f"Failed to parse flow_cancelled event. {e}")
+
+
+class ErrorHandled(Event):
+    """An error occurred during the conversation.
+
+    The error message is stored in the metadata of the event.
+    """
+
+    type_name = "error"
+
+    def __init__(
+        self,
+        error_code: int,
+        timestamp: Optional[float] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        """Creates event for an error.
+
+        Args:
+            error_code: Error int code.
+            timestamp: When the event was created.
+            metadata: Additional event metadata.
+        """
+        self.error_code = error_code
+        super().__init__(timestamp, metadata)
+
+    def __str__(self) -> Text:
+        """Returns text representation of event."""
+        return f"ErrorHandled({self.error_code})"
+
+    def __repr__(self) -> Text:
+        """Returns event as string for debugging."""
+        return f"ErrorHandled({self.error_code}, {self.timestamp}, {self.metadata})"
+
+    def __hash__(self) -> int:
+        """Returns unique hash for event."""
+        return hash(self.error_code)
+
+    def __eq__(self, other: Any) -> bool:
+        """Compares object with other object."""
+        if not isinstance(other, ErrorHandled):
+            return NotImplemented
+
+        return self.error_code == other.error_code
+
+    def as_story_string(self) -> Text:
+        """Returns text representation of event."""
+        props = json.dumps({ERROR_CODE_KEY: self.error_code})
+        return f"{ErrorHandled.type_name}{props}"
+
+    @classmethod
+    def _from_story_string(cls, parameters: Dict[Text, Any]) -> List["ErrorHandled"]:
+        """Called to convert a parsed story line into an event."""
+        return [
+            ErrorHandled(
+                parameters.get(ERROR_CODE_KEY),
+                parameters.get("timestamp"),
+                parameters.get("metadata"),
+            )
+        ]
+
+    def as_dict(self) -> Dict[Text, Any]:
+        """Returns serialized event."""
+        serialized = super().as_dict()
+        serialized.update({ERROR_CODE_KEY: self.error_code})
+        return serialized

rasa/shared/core/policies/utils.py

@@ -0,0 +1,87 @@
+from typing import Set, Text
+
+from rasa.dialogue_understanding.patterns.chitchat import FLOW_PATTERN_CHITCHAT
+from rasa.graph_components.providers.forms_provider import Forms
+from rasa.graph_components.providers.responses_provider import Responses
+from rasa.shared.constants import (
+    REQUIRED_SLOTS_KEY,
+    UTTER_ASK_PREFIX,
+    UTTER_FREE_CHITCHAT_RESPONSE,
+)
+from rasa.shared.core.constants import ACTION_TRIGGER_CHITCHAT
+from rasa.shared.core.domain import Domain
+from rasa.shared.core.flows import FlowsList
+from rasa.shared.core.training_data.structures import StoryGraph
+
+
+def collect_form_responses(forms: Forms) -> Set[Text]:
+    """Collect responses that belong the requested slots in forms.
+
+    Args:
+        forms: the forms from the domain
+    Returns:
+        all utterances used in forms
+    """
+    form_responses = set()
+    for _, form_info in forms.data.items():
+        for required_slot in form_info.get(REQUIRED_SLOTS_KEY, []):
+            form_responses.add(f"{UTTER_ASK_PREFIX}{required_slot}")
+    return form_responses
+
+
+def filter_responses_for_intentless_policy(
+    responses: Responses, forms: Forms, flows: FlowsList
+) -> Responses:
+    """Filters out responses that are unwanted for the intentless policy.
+
+    This includes utterances used in flows and forms.
+
+    Args:
+        responses: the responses from the domain
+        forms: the forms from the domain
+        flows: all flows
+    Returns:
+        The remaining, relevant responses for the intentless policy.
+    """
+    form_responses = collect_form_responses(forms)
+    flow_responses = flows.utterances
+    combined_responses = form_responses | flow_responses
+    filtered_responses = {
+        name: variants
+        for name, variants in responses.data.items()
+        if name not in combined_responses
+    }
+
+    pattern_chitchat = flows.flow_by_id(FLOW_PATTERN_CHITCHAT)
+
+    # The following condition is highly unlikely, but mypy requires the case
+    # of pattern_chitchat == None to be addressed
+    if not pattern_chitchat:
+        return Responses(data=filtered_responses)
+
+    # if action_trigger_chitchat, filter out "utter_free_chitchat_response"
+    has_action_trigger_chitchat = pattern_chitchat.has_action_step(
+        ACTION_TRIGGER_CHITCHAT
+    )
+    if has_action_trigger_chitchat:
+        filtered_responses.pop(UTTER_FREE_CHITCHAT_RESPONSE, None)
+
+    return Responses(data=filtered_responses)
+
+
+def contains_intentless_policy_responses(
+    flows: FlowsList, domain: Domain, story_graph: StoryGraph
+) -> bool:
+    """Checks if IntentlessPolicy has applicable responses: either responses in the
+    domain that are not part of any flow, or if there are e2e stories.
+    """
+    responses = filter_responses_for_intentless_policy(
+        Responses(data=domain.responses), Forms(data=domain.forms), flows
+    )
+
+    has_applicable_responses = bool(
+        responses and responses.data and len(responses.data) > 0
+    )
+    has_e2e_stories = bool(story_graph and story_graph.has_e2e_stories())
+
+    return has_applicable_responses or has_e2e_stories

rasa/shared/utils/schemas/events.py

@@ -164,8 +164,7 @@ DIALOGUE_STACK_UPDATED = {
 }
 ROUTING_SESSION_ENDED = {"properties": {"event": {"const": "routing_session_ended"}}}
 
-
-ROUTING_SESSION_ENDED = {"properties": {"event": {"const": "routing_session_ended"}}}
+ERROR_HANDLED = {"properties": {"event": {"const": "error"}}}
 
 EVENT_SCHEMA = {
     "type": "object",
@@ -206,6 +205,7 @@ EVENT_SCHEMA = {
         FLOW_CANCELLED,
         DIALOGUE_STACK_UPDATED,
         ROUTING_SESSION_ENDED,
+        ERROR_HANDLED,
     ],
 }
 

rasa/tracing/instrumentation/attribute_extractors.py

@@ -376,6 +376,7 @@ def extract_attrs_for_execute_commands(
     all_flows: FlowsList,
     execution_context: ExecutionContext,
     story_graph: Optional[StoryGraph] = None,
+    domain: Optional[Domain] = None,
 ) -> Dict[str, Any]:
     return {
         "number_of_events": len(tracker.events),
@@ -419,6 +420,7 @@ def extract_attrs_for_clean_up_commands(
     all_flows: FlowsList,
     execution_context: ExecutionContext,
     story_graph: Optional[StoryGraph] = None,
+    domain: Optional[Domain] = None,
 ) -> Dict[str, Any]:
     commands_list = []
 

rasa/version.py

@@ -1,3 +1,3 @@
 # this file will automatically be changed,
 # do not add anything but the version number here!
-__version__ = "3.10.17"
+__version__ = "3.10.20.dev1"