rasa-pro 3.15.0a1__py3-none-any.whl → 3.15.0a3__py3-none-any.whl

rasa/builder/training_service.py

@@ -99,10 +99,16 @@ async def try_load_existing_agent(project_folder: str) -> Optional[Agent]:
         available_endpoints = Configuration.initialise_endpoints(
             endpoints_path=Path(project_folder) / DEFAULT_ENDPOINTS_PATH
         ).endpoints
+        # Get available sub agents for agent loading
+        _sub_agents = Configuration.initialise_sub_agents(
+            sub_agents_path=None
+        ).available_agents
 
         # Load the agent
         agent = await load_agent(
-            model_path=latest_model_path, endpoints=available_endpoints
+            model_path=latest_model_path,
+            endpoints=available_endpoints,
+            sub_agents=_sub_agents,
         )
 
         if agent and agent.is_ready():
@@ -133,6 +139,9 @@ async def _train_model(
     try:
         structlogger.info("training.started")
 
+        # init sub agents using the default path
+        Configuration.initialise_sub_agents(sub_agents_path=None)
+
         training_result = await train(
             domain="",
             config=str(config_file),
@@ -160,6 +169,8 @@ async def _load_agent(model_path: str, endpoints_file: Path) -> Agent:
         available_endpoints = Configuration.initialise_endpoints(
             endpoints_path=endpoints_file
         ).endpoints
+        _sub_agents = Configuration.get_instance().available_agents
+
         if available_endpoints is None:
             raise AgentLoadError("No endpoints available for agent loading")
 
@@ -173,6 +184,7 @@ async def _load_agent(model_path: str, endpoints_file: Path) -> Agent:
             model_path=model_path,
             remote_storage=None,
             endpoints=available_endpoints,
+            sub_agents=_sub_agents,
         )
 
         if agent_instance is None:

rasa/builder/validation_service.py

@@ -24,7 +24,7 @@ def _mock_sys_exit() -> Generator[Dict[str, bool], Any, None]:
         was_sys_exit_called["value"] = True
 
     original_exit = sys.exit
-    sys.exit = sys_exit_mock  # type: ignore[assignment]
+    sys.exit = sys_exit_mock  # type: ignore
 
     try:
         yield was_sys_exit_called
@@ -50,6 +50,7 @@ async def validate_project(importer: TrainingDataImporter) -> Optional[str]:
                 from rasa.core.config.configuration import Configuration
 
                 Configuration.initialise_empty()
+                Configuration.initialise_sub_agents(sub_agents_path=None)
 
                 validate_files(
                     fail_on_warnings=config.VALIDATION_FAIL_ON_WARNINGS,

rasa/core/actions/action_clean_stack.py

@@ -4,9 +4,11 @@ from typing import Any, Dict, List, Optional
 
 import structlog
 
+import rasa.dialogue_understanding.stack.utils
 from rasa.core.actions.action import Action
 from rasa.core.channels import OutputChannel
 from rasa.core.nlg import NaturalLanguageGenerator
+from rasa.dialogue_understanding.patterns.code_change import FLOW_PATTERN_CODE_CHANGE_ID
 from rasa.dialogue_understanding.stack.dialogue_stack import DialogueStack
 from rasa.dialogue_understanding.stack.frames import (
     BaseFlowStackFrame,
@@ -41,6 +43,15 @@ class ActionCleanStack(Action):
         """Clean the stack."""
         structlogger.debug("action_clean_stack.run")
         new_frames = []
+        top_flow_frame = rasa.dialogue_understanding.stack.utils.top_flow_frame(
+            tracker.stack, ignore_call_frames=False
+        )
+        top_user_flow_frame = (
+            rasa.dialogue_understanding.stack.utils.top_user_flow_frame(
+                tracker.stack, ignore_call_and_link_frames=False
+            )
+        )
+
         # Set all frames to their end step, filter out any non-BaseFlowStackFrames
         for frame in tracker.stack.frames:
             if isinstance(frame, BaseFlowStackFrame):
@@ -56,4 +67,25 @@ class ActionCleanStack(Action):
                 new_frames.append(frame)
         new_stack = DialogueStack.from_dict([frame.as_dict() for frame in new_frames])
 
+        # Check if the action is being called from within a user flow
+        if (
+            top_flow_frame
+            and top_flow_frame.flow_id != FLOW_PATTERN_CODE_CHANGE_ID
+            and top_user_flow_frame
+            and top_user_flow_frame.flow_id == top_flow_frame.flow_id
+        ):
+            # The action is being called from within a user flow on the stack.
+            # If there are other frames on the stack, we need to make sure
+            # the last executed frame is the end step of the current user flow so
+            # that we can trigger pattern_completed for this user flow.
+            new_stack.pop()
+            structlogger.debug(
+                "action_clean_stack.pushing_user_frame_at_the_bottom_of_stack",
+                flow_id=top_user_flow_frame.flow_id,
+            )
+            new_stack.push(
+                top_user_flow_frame,
+                index=0,
+            )
+
         return tracker.create_stack_updated_events(new_stack)

rasa/core/actions/constants.py

@@ -3,3 +3,7 @@ SELECTIVE_DOMAIN = "enable_selective_domain"
 
 SSL_CLIENT_CERT_FIELD = "ssl_client_cert"
 SSL_CLIENT_KEY_FIELD = "ssl_client_key"
+
+# Special marker key used by EndpointConfig to indicate 449 status
+# without raising an exception
+MISSING_DOMAIN_MARKER = "missing_domain"

rasa/core/actions/custom_action_executor.py

@@ -2,7 +2,10 @@ from __future__ import annotations
 
 import abc
 import logging
-from typing import TYPE_CHECKING, Any, Dict, Text
+from enum import Enum
+from typing import TYPE_CHECKING, Any, Dict, Optional, Text
+
+from pydantic import BaseModel
 
 import rasa
 from rasa.core.actions.action_exceptions import DomainNotFound
@@ -19,6 +22,23 @@ if TYPE_CHECKING:
 logger = logging.getLogger(__name__)
 
 
+class ActionResultType(Enum):
+    SUCCESS = "success"
+    RETRY_WITH_DOMAIN = "retry_with_domain"
+
+
+class ActionResult(BaseModel):
+    """Result of custom action execution.
+
+    This is used to avoid raising exceptions for expected conditions
+    like missing domain (449 status code), which would otherwise be
+    captured by tracing as errors.
+    """
+
+    result_type: ActionResultType
+    response: Optional[Dict[Text, Any]] = None
+
+
 class CustomActionExecutor(abc.ABC):
     """Interface for custom action executors.
 
@@ -45,6 +65,34 @@ class CustomActionExecutor(abc.ABC):
         """
         pass
 
+    async def run_with_result(
+        self,
+        tracker: "DialogueStateTracker",
+        domain: "Domain",
+        include_domain: bool = False,
+    ) -> ActionResult:
+        """Executes the custom action and returns a result.
+
+        This method is used to avoid raising exceptions for expected conditions
+        like missing domain, which would otherwise be captured by tracing as errors.
+
+        By default, this method calls the run method and wraps the response
+        for backward compatibility.
+
+        Args:
+            tracker: The current state of the dialogue.
+            domain: The domain object containing domain-specific information.
+            include_domain: If True, the domain is included in the request.
+
+        Returns:
+            ActionResult containing the response and result type.
+        """
+        try:
+            response = await self.run(tracker, domain, include_domain)
+            return ActionResult(result_type=ActionResultType.SUCCESS, response=response)
+        except DomainNotFound:
+            return ActionResult(result_type=ActionResultType.RETRY_WITH_DOMAIN)
+
 
 class NoEndpointCustomActionExecutor(CustomActionExecutor):
     """Implementation of a custom action executor when endpoint is not set.
@@ -163,13 +211,13 @@ class RetryCustomActionExecutor(CustomActionExecutor):
         domain: "Domain",
         include_domain: bool = False,
     ) -> Dict[Text, Any]:
-        """Runs the wrapped custom action executor.
+        """Runs the wrapped custom action executor with retry logic.
 
         First request to the action server is made with/without the domain
         as specified by the `include_domain` parameter.
 
-        If the action server responds with a `DomainNotFound` error, by running the
-        custom action executor again with the domain information.
+        If the action server responds with a missing domain indication,
+        retries the request with the domain included.
 
         Args:
             tracker: The current state of the dialogue.
@@ -178,14 +226,24 @@ class RetryCustomActionExecutor(CustomActionExecutor):
 
         Returns:
             The response from the execution of the custom action.
+
+        Raises:
+            DomainNotFound: If the action server still requires domain after retry.
         """
-        try:
-            return await self._custom_action_executor.run(
-                tracker,
-                domain,
-                include_domain=include_domain,
-            )
-        except DomainNotFound:
-            return await self._custom_action_executor.run(
+        result = await self._custom_action_executor.run_with_result(
+            tracker,
+            domain,
+            include_domain=include_domain,
+        )
+
+        if result.result_type == ActionResultType.RETRY_WITH_DOMAIN:
+            # Retry with domain included
+            result = await self._custom_action_executor.run_with_result(
                 tracker, domain, include_domain=True
             )
+
+            # If still missing domain after retry, raise error
+            if result.result_type == ActionResultType.RETRY_WITH_DOMAIN:
+                raise DomainNotFound()
+
+        return result.response if result.response is not None else {}

rasa/core/actions/grpc_custom_action_executor.py

@@ -11,6 +11,8 @@ from rasa_sdk.grpc_py import action_webhook_pb2, action_webhook_pb2_grpc
 from rasa.core.actions.action_exceptions import DomainNotFound
 from rasa.core.actions.constants import SSL_CLIENT_CERT_FIELD, SSL_CLIENT_KEY_FIELD
 from rasa.core.actions.custom_action_executor import (
+    ActionResult,
+    ActionResultType,
     CustomActionExecutor,
     CustomActionRequestWriter,
 )
@@ -101,13 +103,51 @@ class GRPCCustomActionExecutor(CustomActionExecutor):
 
         Returns:
             Response from the action server.
+            Returns empty dict if domain is missing.
+
+        Raises:
+            RasaException: If an error occurs while making the gRPC request
+                (other than missing domain).
         """
+        result = await self.run_with_result(tracker, domain, include_domain)
+
+        # Return empty dict for retry cases to avoid raising exceptions
+        # RetryCustomActionExecutor will handle the retry logic
+        if result.result_type == ActionResultType.RETRY_WITH_DOMAIN:
+            return {}
+
+        return result.response if result.response is not None else {}
+
+    async def run_with_result(
+        self,
+        tracker: "DialogueStateTracker",
+        domain: "Domain",
+        include_domain: bool = False,
+    ) -> ActionResult:
+        """Execute the custom action and return an ActionResult.
+
+        This method avoids raising DomainNotFound exception for missing domain,
+        instead returning an ActionResult with RETRY_WITH_DOMAIN type.
+        This prevents tracing from capturing this expected condition as an error.
 
+        Args:
+            tracker: Tracker for the current conversation.
+            domain: Domain of the assistant.
+            include_domain: If True, the domain is included in the request.
+
+        Returns:
+            ActionResult containing the response and result type.
+        """
         request = self._create_payload(
             tracker=tracker, domain=domain, include_domain=include_domain
         )
 
-        return self._request(request)
+        try:
+            response = self._request(request)
+            return ActionResult(result_type=ActionResultType.SUCCESS, response=response)
+        except DomainNotFound:
+            # Return retry result instead of raising DomainNotFound
+            return ActionResult(result_type=ActionResultType.RETRY_WITH_DOMAIN)
 
     def _request(
         self,
@@ -121,7 +161,6 @@ class GRPCCustomActionExecutor(CustomActionExecutor):
         Returns:
             Response from the action server.
         """
-
         client = self._create_grpc_client()
         metadata = self._build_metadata()
         try:

rasa/core/actions/http_custom_action_executor.py

@@ -4,8 +4,11 @@ from typing import TYPE_CHECKING, Any, Dict, Optional
 
 import aiohttp
 
-from rasa.core.actions.action_exceptions import ActionExecutionRejection, DomainNotFound
+from rasa.core.actions.action_exceptions import ActionExecutionRejection
+from rasa.core.actions.constants import MISSING_DOMAIN_MARKER
 from rasa.core.actions.custom_action_executor import (
+    ActionResult,
+    ActionResultType,
     CustomActionExecutor,
     CustomActionRequestWriter,
 )
@@ -18,12 +21,12 @@ from rasa.shared.core.domain import Domain
 from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.shared.exceptions import RasaException
 from rasa.utils.common import get_bool_env_variable
+from rasa.utils.endpoints import ClientResponseError, EndpointConfig
 
 if TYPE_CHECKING:
     from rasa.shared.core.domain import Domain
     from rasa.shared.core.trackers import DialogueStateTracker
 
-from rasa.utils.endpoints import ClientResponseError, EndpointConfig
 
 logger = logging.getLogger(__name__)
 
@@ -62,9 +65,40 @@ class HTTPCustomActionExecutor(CustomActionExecutor):
 
         Returns:
             A dictionary containing the response from the custom action endpoint.
+            Returns empty dict if domain is missing (449 status).
 
         Raises:
-            RasaException: If an error occurs while making the HTTP request.
+            RasaException: If an error occurs while making the HTTP request
+                (other than missing domain).
+        """
+        result = await self.run_with_result(tracker, domain, include_domain)
+
+        # Return empty dict for retry cases to avoid raising exceptions
+        # RetryCustomActionExecutor will handle the retry logic
+        if result.result_type == ActionResultType.RETRY_WITH_DOMAIN:
+            return {}
+
+        return result.response if result.response is not None else {}
+
+    async def run_with_result(
+        self,
+        tracker: "DialogueStateTracker",
+        domain: Optional["Domain"] = None,
+        include_domain: bool = False,
+    ) -> ActionResult:
+        """Execute the custom action and return an ActionResult.
+
+        This method avoids raising DomainNotFound exception for 449 status code,
+        instead returning an ActionResult with RETRY_WITH_DOMAIN type.
+        This prevents tracing from capturing this expected condition as an error.
+
+        Args:
+            tracker: The current state of the dialogue.
+            domain: The domain object containing domain-specific information.
+            include_domain: If True, the domain is included in the request.
+
+        Returns:
+            ActionResult containing the response and result type.
         """
         from rasa.core.actions.action import RemoteActionJSONValidator
 
@@ -77,14 +111,23 @@ class HTTPCustomActionExecutor(CustomActionExecutor):
                 tracker=tracker, domain=domain, include_domain=include_domain
             )
 
-            response = await self._perform_request_with_retries(json_body)
+            assert self.action_endpoint is not None
+            response = await self.action_endpoint.request(
+                json=json_body,
+                method="post",
+                timeout=DEFAULT_REQUEST_TIMEOUT,
+                compress=self.should_compress,
+            )
+
+            # Check if we got the special marker for 449 status (missing domain)
+            if isinstance(response, dict) and response.get(MISSING_DOMAIN_MARKER):
+                return ActionResult(result_type=ActionResultType.RETRY_WITH_DOMAIN)
 
             if response is None:
                 response = {}
 
             RemoteActionJSONValidator.validate(response)
-
-            return response
+            return ActionResult(result_type=ActionResultType.SUCCESS, response=response)
 
         except ClientResponseError as e:
             if e.status == 400:
@@ -131,22 +174,3 @@ class HTTPCustomActionExecutor(CustomActionExecutor):
                 "and returns a 200 once the action is executed. "
                 "Error: {}".format(self.action_name, status, e)
             )
-
-    async def _perform_request_with_retries(
-        self,
-        json_body: Dict[str, Any],
-    ) -> Any:
-        """Attempts to perform the request with retries if necessary."""
-        assert self.action_endpoint is not None
-        try:
-            return await self.action_endpoint.request(
-                json=json_body,
-                method="post",
-                timeout=DEFAULT_REQUEST_TIMEOUT,
-                compress=self.should_compress,
-            )
-        except ClientResponseError as e:
-            # Repeat the request because Domain was not in the payload
-            if e.status == 449:
-                raise DomainNotFound()
-            raise e

rasa/core/channels/voice_stream/voice_channel.py

@@ -373,6 +373,14 @@ class VoiceOutputChannel(OutputChannel):
     async def hangup(self, recipient_id: str, **kwargs: Any) -> None:
         call_state.should_hangup = True
 
+    async def send_turn_end_marker(self, recipient_id: str) -> None:
+        """Send a marker to indicate the bot has finished its turn.
+
+        Used internally by Rasa during conversation simulations.
+        This is called after all bot messages in a turn have been sent.
+        """
+        pass
+
 
 class VoiceInputChannel(InputChannel):
     # All children of this class require a voice license to be used.
@@ -471,14 +479,16 @@ class VoiceInputChannel(InputChannel):
         call_parameters: CallParameters,
     ) -> None:
         output_channel = self.create_output_channel(channel_websocket, tts_engine)
+        sender_id = self.get_sender_id(call_parameters)
         message = UserMessage(
             text=USER_CONVERSATION_SESSION_START,
             output_channel=output_channel,
-            sender_id=self.get_sender_id(call_parameters),
+            sender_id=sender_id,
             input_channel=self.name(),
             metadata=asdict(call_parameters),
         )
         await on_new_message(message)
+        await output_channel.send_turn_end_marker(sender_id)
 
     def map_input_message(
         self,
@@ -646,14 +656,16 @@ class VoiceInputChannel(InputChannel):
             call_state.rasa_processing_start_time = time.time()
 
             output_channel = self.create_output_channel(voice_websocket, tts_engine)
+            sender_id = self.get_sender_id(call_parameters)
             message = UserMessage(
                 text=e.text,
                 output_channel=output_channel,
-                sender_id=self.get_sender_id(call_parameters),
+                sender_id=sender_id,
                 input_channel=self.name(),
                 metadata=asdict(call_parameters),
             )
             await on_new_message(message)
+            await output_channel.send_turn_end_marker(sender_id)
         elif isinstance(e, UserIsSpeaking):
             # Track when user starts speaking for ASR latency calculation
             if not call_state.is_user_speaking:

rasa/dialogue_understanding/generator/llm_based_command_generator.py

@@ -62,7 +62,9 @@ structlogger = structlog.get_logger()
 class LLMBasedCommandGenerator(
     LLMHealthCheckMixin, GraphComponent, CommandGenerator, ABC
 ):
-    """An abstract class defining interface and common functionality
+    """This class provides common functionality for all LLM-based command generators.
+
+    An abstract class defining interface and common functionality
     of an LLM-based command generators.
     """
 
@@ -174,8 +176,9 @@ class LLMBasedCommandGenerator(
     def train(
         self, training_data: TrainingData, flows: FlowsList, domain: Domain
     ) -> Resource:
-        """Train the llm based command generator. Stores all flows into a vector
-        store.
+        """Trains the LLM-based command generator and prepares flow retrieval data.
+
+        Stores all flows into a vector store.
         """
         self.perform_llm_health_check(
             self.config.get(LLM_CONFIG_KEY),

rasa/dialogue_understanding/generator/single_step/compact_llm_command_generator.py

@@ -168,6 +168,20 @@ class CompactLLMCommandGenerator(SingleStepBasedLLMCommandGenerator):
         if prompt_template is not None:
             return prompt_template
 
+        # Try to load the template from the given path or fallback to the default for
+        # the component.
+        custom_prompt_template_path = config.get(PROMPT_TEMPLATE_CONFIG_KEY)
+        if custom_prompt_template_path is not None:
+            custom_prompt_template = get_prompt_template(
+                custom_prompt_template_path,
+                None,  # Default will be based on the model
+                log_source_component=log_source_component,
+                log_source_method=log_context,
+            )
+            if custom_prompt_template is not None:
+                return custom_prompt_template
+
+        # Fallback to the default prompt template based on the model.
         default_command_prompt_template = get_default_prompt_template_based_on_model(
             llm_config=config.get(LLM_CONFIG_KEY, {}) or {},
             model_prompt_mapping=cls.get_model_prompt_mapper(),
@@ -177,10 +191,4 @@ class CompactLLMCommandGenerator(SingleStepBasedLLMCommandGenerator):
             log_source_method=log_context,
         )
 
-        # Return the prompt template either from the config or the default prompt.
-        return get_prompt_template(
-            config.get(PROMPT_TEMPLATE_CONFIG_KEY),
-            default_command_prompt_template,
-            log_source_component=log_source_component,
-            log_source_method=log_context,
-        )
+        return default_command_prompt_template

rasa/dialogue_understanding/generator/single_step/search_ready_llm_command_generator.py

@@ -165,7 +165,20 @@ class SearchReadyLLMCommandGenerator(SingleStepBasedLLMCommandGenerator):
         if prompt_template is not None:
             return prompt_template
 
-        # Get the default prompt template based on the model name.
+        # Try to load the template from the given path or fallback to the default for
+        # the component.
+        custom_prompt_template_path = config.get(PROMPT_TEMPLATE_CONFIG_KEY)
+        if custom_prompt_template_path is not None:
+            custom_prompt_template = get_prompt_template(
+                custom_prompt_template_path,
+                None,  # Default will be based on the model
+                log_source_component=log_source_component,
+                log_source_method=log_context,
+            )
+            if custom_prompt_template is not None:
+                return custom_prompt_template
+
+        # Fallback to the default prompt template based on the model.
         default_command_prompt_template = get_default_prompt_template_based_on_model(
             llm_config=config.get(LLM_CONFIG_KEY, {}) or {},
             model_prompt_mapping=cls.get_model_prompt_mapper(),
@@ -175,10 +188,4 @@ class SearchReadyLLMCommandGenerator(SingleStepBasedLLMCommandGenerator):
             log_source_method=log_context,
         )
 
-        # Return the prompt template either from the config or the default prompt.
-        return get_prompt_template(
-            config.get(PROMPT_TEMPLATE_CONFIG_KEY),
-            default_command_prompt_template,
-            log_source_component=log_source_component,
-            log_source_method=log_context,
-        )
+        return default_command_prompt_template

rasa/dialogue_understanding/processor/command_processor.py

@@ -1,3 +1,4 @@
+import os
 from typing import Dict, List, Optional, Set, Type
 
 import structlog
@@ -70,6 +71,8 @@ from rasa.shared.nlu.constants import COMMANDS
 
 structlogger = structlog.get_logger()
 
+CLARIFY_ON_MULTIPLE_START_FLOWS_ENV_VAR_NAME = "CLARIFY_ON_MULTIPLE_START_FLOWS"
+
 
 def contains_command(commands: List[Command], typ: Type[Command]) -> bool:
     """Check if a list of commands contains a command of a given type.
@@ -499,10 +502,24 @@ def clean_up_commands(
         else:
             clean_commands.append(command)
 
+    clean_commands = _process_multiple_start_flow_commands(clean_commands, tracker)
+
+    # ensure that there is only one command of a certain command type
+    clean_commands = ensure_max_number_of_command_type(
+        clean_commands, CannotHandleCommand, 1
+    )
+    clean_commands = ensure_max_number_of_command_type(
+        clean_commands, RepeatBotMessagesCommand, 1
+    )
+    clean_commands = ensure_max_number_of_command_type(
+        clean_commands, ChitChatAnswerCommand, 1
+    )
+
     # Replace CannotHandleCommands with ContinueAgentCommand when an agent is active
     # to keep the agent running, but preserve chitchat
     clean_commands = _replace_cannot_handle_with_continue_agent(clean_commands, tracker)
 
+    # filter out cannot handle commands if there are other commands present
     # when coexistence is enabled, by default there will be a SetSlotCommand
     # for the ROUTE_TO_CALM_SLOT slot.
     if tracker.has_coexistence_routing_slot and len(clean_commands) > 2:
@@ -510,12 +527,6 @@ def clean_up_commands(
     elif not tracker.has_coexistence_routing_slot and len(clean_commands) > 1:
         clean_commands = filter_cannot_handle_command(clean_commands)
 
-    clean_commands = ensure_max_number_of_command_type(
-        clean_commands, RepeatBotMessagesCommand, 1
-    )
-    clean_commands = ensure_max_number_of_command_type(
-        clean_commands, ContinueAgentCommand, 1
-    )
     structlogger.debug(
         "command_processor.clean_up_commands.final_commands",
         command=clean_commands,
@@ -526,6 +537,37 @@ def clean_up_commands(
     return clean_commands
 
 
+def _process_multiple_start_flow_commands(
+    commands: List[Command],
+    tracker: DialogueStateTracker,
+) -> List[Command]:
+    """Process multiple start flow commands.
+
+    If there are multiple start flow commands, no active flows and the
+    CLARIFY_ON_MULTIPLE_START_FLOWS env var is enabled, we replace the
+    start flow commands with a clarify command.
+    """
+    start_flow_candidates = filter_start_flow_commands(commands)
+    clarify_enabled = (
+        os.getenv("CLARIFY_ON_MULTIPLE_START_FLOWS", "false").lower() == "true"
+    )
+
+    if clarify_enabled and len(start_flow_candidates) > 1 and tracker.stack.is_empty():
+        # replace the start flow commands with a clarify command
+        commands = [
+            command for command in commands if not isinstance(command, StartFlowCommand)
+        ]
+        # avoid adding duplicate clarify commands
+        if not any(isinstance(c, ClarifyCommand) for c in commands):
+            structlogger.debug(
+                "command_processor.clean_up_commands.trigger_clarify_for_multiple_start_flows",
+                candidate_flows=start_flow_candidates,
+            )
+            commands.append(ClarifyCommand(options=start_flow_candidates))
+
+    return commands
+
+
 def _get_slots_eligible_for_correction(tracker: DialogueStateTracker) -> Set[str]:
     """Get all slots that are eligible for correction.
 
@@ -580,7 +622,7 @@ def clean_up_start_flow_command(
         # drop a start flow command if the starting flow is equal
         # to the currently active flow
         structlogger.debug(
-            "command_processor.clean_up_commands." "skip_command_flow_already_active",
+            "command_processor.clean_up_commands.skip_command_flow_already_active",
             command=command,
         )
         return clean_commands