rasa-pro 3.12.18.dev1__py3-none-any.whl → 3.12.20__py3-none-any.whl

rasa/__init__.py

@@ -5,11 +5,5 @@ from rasa import version
 # define the version before the other imports since these need it
 __version__ = version.__version__
 
-from litellm.integrations.langfuse.langfuse import LangFuseLogger
-
-from rasa.monkey_patches import litellm_langfuse_logger_init_fixed
-
-# Monkey-patch the init method as early as possible before the class is used
-LangFuseLogger.__init__ = litellm_langfuse_logger_init_fixed  # type: ignore
 
 logging.getLogger(__name__).addHandler(logging.NullHandler())

rasa/core/actions/action.py

@@ -1137,15 +1137,12 @@ class ActionSendText(Action):
         tracker: "DialogueStateTracker",
         domain: "Domain",
         metadata: Optional[Dict[Text, Any]] = None,
-        create_bot_uttered_event: bool = True,
     ) -> List[Event]:
         """Runs action. Please see parent class for the full docstring."""
         fallback = {"text": ""}
         metadata_copy = copy.deepcopy(metadata) if metadata else {}
         message = metadata_copy.get("message", fallback)
-        if create_bot_uttered_event:
-            return [create_bot_utterance(message)]
-        return []
+        return [create_bot_utterance(message)]
 
 
 class ActionExtractSlots(Action):

rasa/core/channels/voice_stream/asr/azure.py

@@ -3,6 +3,8 @@ import os
 from dataclasses import dataclass
 from typing import Any, AsyncIterator, Dict, Optional
 
+import structlog
+
 from rasa.core.channels.voice_stream.asr.asr_engine import ASREngine, ASREngineConfig
 from rasa.core.channels.voice_stream.asr.asr_event import (
     ASREvent,
@@ -13,6 +15,8 @@ from rasa.core.channels.voice_stream.audio_bytes import HERTZ, RasaAudioBytes
 from rasa.shared.constants import AZURE_SPEECH_API_KEY_ENV_VAR
 from rasa.shared.exceptions import ConnectionException
 
+logger = structlog.get_logger(__name__)
+
 
 @dataclass
 class AzureASRConfig(ASREngineConfig):
@@ -61,6 +65,11 @@ class AzureASR(ASREngine[AzureASRConfig]):
             and self.config.speech_endpoint is None
         ):
             self.config.speech_region = "eastus"
+            logger.warning(
+                "voice_channel.asr.azure.no_region",
+                message="No speech region configured, using 'eastus' as default",
+                region="eastus",
+            )
         speech_config = speechsdk.SpeechConfig(
             subscription=os.environ[AZURE_SPEECH_API_KEY_ENV_VAR],
             region=self.config.speech_region,

rasa/core/channels/voice_stream/twilio_media_streams.py

@@ -135,6 +135,13 @@ class TwilioMediaStreamsInputChannel(VoiceInputChannel):
     def name(cls) -> str:
         return "twilio_media_streams"
 
+    def get_sender_id(self, call_parameters: CallParameters) -> str:
+        """Get the sender ID for the channel.
+
+        Twilio Media Streams uses the Stream ID as Sender ID because
+        it is required in OutputChannel.send_text_message to send messages."""
+        return call_parameters.stream_id  # type: ignore[return-value]
+
     def channel_bytes_to_rasa_audio_bytes(self, input_bytes: bytes) -> RasaAudioBytes:
         return RasaAudioBytes(base64.b64decode(input_bytes))
 

rasa/core/channels/voice_stream/voice_channel.py

@@ -288,6 +288,17 @@ class VoiceInputChannel(InputChannel):
         self.monitor_silence = monitor_silence
         self.tts_cache = TTSCache(tts_config.get("cache_size", 1000))
 
+        logger.info(
+            "voice_channel.initialized",
+            server_url=self.server_url,
+            asr_config=self.asr_config,
+            tts_config=self.tts_config,
+        )
+
+    def get_sender_id(self, call_parameters: CallParameters) -> str:
+        """Get the sender ID for the channel."""
+        return call_parameters.call_id
+
     async def monitor_silence_timeout(self, asr_event_queue: asyncio.Queue) -> None:
         timeout = call_state.silence_timeout
         if not timeout:
@@ -334,9 +345,9 @@ class VoiceInputChannel(InputChannel):
     ) -> None:
         output_channel = self.create_output_channel(channel_websocket, tts_engine)
         message = UserMessage(
-            "/session_start",
-            output_channel,
-            call_parameters.stream_id,
+            text="/session_start",
+            output_channel=output_channel,
+            sender_id=self.get_sender_id(call_parameters),
             input_channel=self.name(),
             metadata=asdict(call_parameters),
         )
@@ -393,6 +404,9 @@ class VoiceInputChannel(InputChannel):
                     await asr_engine.send_audio_chunks(channel_action.audio_bytes)
                 elif isinstance(channel_action, EndConversationAction):
                     # end stream event came from the other side
+                    await self.handle_disconnect(
+                        channel_websocket, on_new_message, tts_engine, call_parameters
+                    )
                     break
 
         async def receive_asr_events() -> None:
@@ -449,9 +463,9 @@ class VoiceInputChannel(InputChannel):
             call_state.is_user_speaking = False  # type: ignore[attr-defined]
             output_channel = self.create_output_channel(voice_websocket, tts_engine)
             message = UserMessage(
-                e.text,
-                output_channel,
-                call_parameters.stream_id,
+                text=e.text,
+                output_channel=output_channel,
+                sender_id=self.get_sender_id(call_parameters),
                 input_channel=self.name(),
                 metadata=asdict(call_parameters),
             )
@@ -462,10 +476,27 @@ class VoiceInputChannel(InputChannel):
         elif isinstance(e, UserSilence):
             output_channel = self.create_output_channel(voice_websocket, tts_engine)
             message = UserMessage(
-                "/silence_timeout",
-                output_channel,
-                call_parameters.stream_id,
+                text="/silence_timeout",
+                output_channel=output_channel,
+                sender_id=self.get_sender_id(call_parameters),
                 input_channel=self.name(),
                 metadata=asdict(call_parameters),
             )
             await on_new_message(message)
+
+    async def handle_disconnect(
+        self,
+        channel_websocket: Websocket,
+        on_new_message: Callable[[UserMessage], Awaitable[Any]],
+        tts_engine: TTSEngine,
+        call_parameters: CallParameters,
+    ) -> None:
+        """Handle disconnection from the channel."""
+        output_channel = self.create_output_channel(channel_websocket, tts_engine)
+        message = UserMessage(
+            text="/session_end",
+            output_channel=output_channel,
+            sender_id=self.get_sender_id(call_parameters),
+            input_channel=self.name(),
+        )
+        await on_new_message(message)

rasa/core/policies/intentless_policy.py

@@ -721,9 +721,7 @@ class IntentlessPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Policy):
                 final_response_examples.append(resp)
 
         llm_response = await self.generate_answer(
-            final_response_examples,
-            conversation_samples,
-            history,
+            final_response_examples, conversation_samples, history
         )
         if not llm_response:
             structlogger.debug("intentless_policy.prediction.skip_llm_fail")

rasa/core/processor.py

@@ -34,6 +34,9 @@ from rasa.dialogue_understanding.commands import (
     CannotHandleCommand,
     Command,
     NoopCommand,
+    RestartCommand,
+    SessionEndCommand,
+    SessionStartCommand,
     SetSlotCommand,
 )
 from rasa.dialogue_understanding.commands.utils import (
@@ -880,19 +883,61 @@ class MessageProcessor:
                 tracker.has_coexistence_routing_slot
                 and tracker.get_slot(ROUTE_TO_CALM_SLOT) is None
             ):
-                # if we are currently not routing to either CALM or dm1
-                # we make a sticky routing to CALM if there are any commands
-                # from the trigger intent parsing
-                # or a sticky routing to dm1 if there are no commands
+                # If we are currently not routing to either CALM or DM1:
+                # - Sticky route to CALM if there are any commands
+                #   from the trigger intent parsing
+                # - Sticky route to DM1 if there are no commands present
+                route_to_calm_slot_value = self._determine_route_to_calm_slot_value(
+                    nlu_adapted_commands
+                )
                 commands += [
                     SetSlotCommand(
-                        ROUTE_TO_CALM_SLOT, len(nlu_adapted_commands) > 0
+                        ROUTE_TO_CALM_SLOT, route_to_calm_slot_value
                     ).as_dict()
                 ]
 
         parse_data[COMMANDS] = commands
         return parse_data
 
+    def _determine_route_to_calm_slot_value(
+        self, nlu_adapted_commands: List[Dict[str, Any]]
+    ) -> Optional[bool]:
+        """Determines what value should be assigned to `ROUTE_TO_CALM_SLOT`.
+
+        Returns:
+            - True: If any command other than:
+                - SessionStartCommand
+                - SessionEndCommand
+                - RestartCommand
+              is present.
+            - None: If only ignored system commands are present.
+            - False If no commands at all.
+        """
+        system_commands_to_ignore = [
+            SessionStartCommand.command(),
+            SessionEndCommand.command(),
+            RestartCommand.command(),
+        ]
+
+        # Exclude the system commands, as it doesn't originate from the user's
+        # input intent and shouldn't influence the decision for setting
+        # ROUTE_TO_CALM_SLOT.
+        intent_triggered_commands = [
+            command
+            for command in nlu_adapted_commands
+            if command.get("command") not in system_commands_to_ignore
+        ]
+
+        if len(intent_triggered_commands) > 0:
+            # There are commands other than system commands present - route to CALM
+            return True
+        elif len(nlu_adapted_commands) > 0:
+            # Only system command is present — defer routing decision
+            return None
+        else:
+            # No commands at all — route to DM1
+            return False
+
     def _update_full_retrieval_intent(self, parse_data: Dict[Text, Any]) -> None:
         """Update the parse data with the full retrieval intent.
 

rasa/core/utils.py

@@ -389,16 +389,25 @@ def should_force_slot_filling(
         and the name of the slot if applicable.
     """
     from rasa.dialogue_understanding.processor.command_processor import (
+        find_updated_flows,
         get_current_collect_step,
     )
 
     if tracker is None:
-        structlogger.error(
-            "slot.force_slot_filling.error",
+        structlogger.debug(
+            "slot.force_slot_filling.no_found_tracker",
             event_info="Tracker is None. Cannot force slot filling.",
         )
         return False, None
 
+    updated_flows = find_updated_flows(tracker, flows)
+    if updated_flows:
+        structlogger.debug(
+            "slot.force_slot_filling.running_flows_were_updated",
+            updated_flow_ids=updated_flows,
+        )
+        return False, None
+
     stack = tracker.stack
     step = get_current_collect_step(stack, flows)
     if step is None or not step.force_slot_filling:

rasa/dialogue_understanding/coexistence/llm_based_router.py

@@ -171,6 +171,7 @@ class LLMBasedRouter(LLMHealthCheckMixin, GraphComponent):
         **kwargs: Any,
     ) -> "LLMBasedRouter":
         """Loads trained component (see parent class for full docstring)."""
+
         # Perform health check on the resolved LLM client config
         llm_config = resolve_model_client_config(config.get(LLM_CONFIG_KEY, {}))
         cls.perform_llm_health_check(

rasa/dialogue_understanding/commands/__init__.py

@@ -16,6 +16,9 @@ from rasa.dialogue_understanding.commands.error_command import ErrorCommand
 from rasa.dialogue_understanding.commands.free_form_answer_command import (
     FreeFormAnswerCommand,
 )
+from rasa.dialogue_understanding.commands.handle_code_change_command import (
+    HandleCodeChangeCommand,
+)
 from rasa.dialogue_understanding.commands.human_handoff_command import (
     HumanHandoffCommand,
 )
@@ -49,6 +52,7 @@ __all__ = [
     "SetSlotCommand",
     "StartFlowCommand",
     "HumanHandoffCommand",
+    "HandleCodeChangeCommand",
     "CorrectSlotsCommand",
     "CorrectedSlot",
     "ErrorCommand",

rasa/dialogue_understanding/commands/cancel_flow_command.py

@@ -95,7 +95,9 @@ class CancelFlowCommand(Command):
         original_stack = original_tracker.stack
 
         applied_events: List[Event] = []
-        user_frame = top_user_flow_frame(original_stack)
+        user_frame = top_user_flow_frame(
+            original_stack, ignore_call_and_link_frames=False
+        )
         current_flow = user_frame.flow(all_flows) if user_frame else None
 
         if not current_flow:

rasa/dialogue_understanding/commands/set_slot_command.py

@@ -13,6 +13,7 @@ from rasa.dialogue_understanding.commands.command_syntax_manager import (
 )
 from rasa.dialogue_understanding.commands.utils import (
     clean_extracted_value,
+    find_default_flows_collecting_slot,
     get_nullable_slot_value,
 )
 from rasa.dialogue_understanding.patterns.collect_information import (
@@ -136,6 +137,11 @@ class SetSlotCommand(Command):
         ):
             # Get the other predicted flows from the most recent message on the tracker.
             predicted_flows = get_flows_predicted_to_start_from_tracker(tracker)
+            if not predicted_flows:
+                # If no predicted flows, check for default flows collecting the slot.
+                predicted_flows = find_default_flows_collecting_slot(
+                    self.name, all_flows
+                )
             use_slot_fill = any(
                 step.collect == self.name and not step.ask_before_filling
                 for flow in all_flows.underlying_flows

rasa/dialogue_understanding/commands/utils.py

@@ -7,18 +7,18 @@ from rasa.dialogue_understanding.patterns.validate_slot import (
 )
 from rasa.shared.constants import ACTION_ASK_PREFIX, UTTER_ASK_PREFIX
 from rasa.shared.core.events import Event, SlotSet
+from rasa.shared.core.flows import FlowsList
 from rasa.shared.core.slots import Slot
 from rasa.shared.core.trackers import DialogueStateTracker
 
 if TYPE_CHECKING:
     from rasa.dialogue_understanding.commands import StartFlowCommand
-    from rasa.shared.core.flows import FlowsList
 
 structlogger = structlog.get_logger()
 
 
 def start_flow_by_name(
-    flow_name: str, flows: "FlowsList"
+    flow_name: str, flows: FlowsList
 ) -> Optional["StartFlowCommand"]:
     from rasa.dialogue_understanding.commands import StartFlowCommand
 
@@ -126,3 +126,27 @@ def create_validate_frames_from_slot_set_events(
             validate_frames.append(frame)
 
     return tracker, validate_frames
+
+
+def find_default_flows_collecting_slot(
+    slot_name: str, all_flows: FlowsList
+) -> List[str]:
+    """Find default flows that have collect steps matching the specified slot name.
+
+    Args:
+        slot_name: The name of the slot to search for.
+        all_flows: All flows in the assistant.
+
+    Returns:
+        List of flow IDs for default flows that collect the specified slot
+        without asking before filling.
+    """
+    return [
+        flow.id
+        for flow in all_flows.underlying_flows
+        if flow.is_rasa_default_flow
+        and any(
+            step.collect == slot_name and not step.ask_before_filling
+            for step in flow.get_collect_steps()
+        )
+    ]

rasa/dialogue_understanding/generator/command_generator.py

@@ -8,6 +8,7 @@ from rasa.dialogue_understanding.commands import (
     Command,
     CorrectSlotsCommand,
     ErrorCommand,
+    HandleCodeChangeCommand,
     SetSlotCommand,
     StartFlowCommand,
 )
@@ -396,15 +397,24 @@ class CommandGenerator:
             The filtered commands.
         """
         from rasa.dialogue_understanding.processor.command_processor import (
+            find_updated_flows,
             get_current_collect_step,
         )
 
         if tracker is None:
-            structlogger.error(
+            structlogger.debug(
                 "command_generator.filter_commands_during_force_slot_filling.tracker_not_found",
             )
             return commands
 
+        updated_flows = find_updated_flows(tracker, available_flows)
+        if updated_flows:
+            structlogger.debug(
+                "command_generator.filter_commands_during_force_slot_filling.running_flows_were_updated",
+                updated_flow_ids=updated_flows,
+            )
+            return [HandleCodeChangeCommand()]
+
         stack = tracker.stack
         step = get_current_collect_step(stack, available_flows)
 

rasa/dialogue_understanding/generator/llm_based_command_generator.py

@@ -1,8 +1,6 @@
 from abc import ABC, abstractmethod
-from asyncio import Lock
 from functools import lru_cache
 from typing import Any, Dict, List, Optional, Set, Text, Tuple, Union
-from uuid import UUID, uuid4
 
 import structlog
 from jinja2 import Environment, Template, select_autoescape
@@ -91,9 +89,6 @@ class LLMBasedCommandGenerator(
         else:
             self.flow_retrieval = None
 
-        self.sender_id_to_session_id_mapping: Dict[str, UUID] = {}
-        self._lock = Lock()
-
     ### Abstract methods
     @staticmethod
     @abstractmethod
@@ -230,7 +225,8 @@ class LLMBasedCommandGenerator(
 
     @lru_cache
     def compile_template(self, template: str) -> Template:
-        """Compile the prompt template and register custom filters.
+        """
+        Compile the prompt template and register custom filters.
         Compiling the template is an expensive operation,
         so we cache the result.
         """
@@ -332,9 +328,7 @@ class LLMBasedCommandGenerator(
 
     @measure_llm_latency
     async def invoke_llm(
-        self,
-        prompt: Union[List[dict], List[str], str],
-        metadata: Optional[Dict[str, Any]] = None,
+        self, prompt: Union[List[dict], List[str], str]
     ) -> Optional[LLMResponse]:
         """Use LLM to generate a response.
 
@@ -347,7 +341,6 @@ class LLMBasedCommandGenerator(
                 - a list of messages. Each message is a string and will be formatted
                     as a user message.
                 - a single message as a string which will be formatted as user message.
-            metadata: Optional metadata to be passed to the LLM call.
 
         Returns:
             An LLMResponse object.
@@ -359,7 +352,7 @@ class LLMBasedCommandGenerator(
             self.config.get(LLM_CONFIG_KEY), self.get_default_llm_config()
         )
         try:
-            return await llm.acompletion(prompt, metadata)
+            return await llm.acompletion(prompt)
         except Exception as e:
             # unfortunately, langchain does not wrap LLM exceptions which means
             # we have to catch all exceptions here
@@ -662,7 +655,3 @@ class LLMBasedCommandGenerator(
     def get_default_llm_config() -> Dict[str, Any]:
         """Get the default LLM config for the command generator."""
         return DEFAULT_LLM_CONFIG
-
-    async def _get_or_create_session_id(self, sender_id: str) -> UUID:
-        async with self._lock:
-            return self.sender_id_to_session_id_mapping.setdefault(sender_id, uuid4())

rasa/dialogue_understanding/generator/llm_command_generator.py

@@ -55,9 +55,7 @@ class LLMCommandGenerator(SingleStepLLMCommandGenerator):
         )
 
     async def invoke_llm(
-        self,
-        prompt: Union[List[dict], List[str], str],
-        metadata: Optional[Dict[str, Any]] = None,
+        self, prompt: Union[List[dict], List[str], str]
     ) -> Optional[LLMResponse]:
         try:
             return await super().invoke_llm(prompt)

rasa/dialogue_understanding/generator/multi_step/multi_step_llm_command_generator.py

@@ -42,9 +42,6 @@ from rasa.engine.storage.resource import Resource
 from rasa.engine.storage.storage import ModelStorage
 from rasa.shared.constants import (
     EMBEDDINGS_CONFIG_KEY,
-    LANGFUSE_CUSTOM_METADATA_DICT,
-    LANGFUSE_METADATA_SESSION_ID,
-    LANGFUSE_TAGS,
     RASA_PATTERN_CANNOT_HANDLE_NOT_SUPPORTED,
     ROUTE_TO_CALM_SLOT,
 )
@@ -110,7 +107,7 @@ structlogger = structlog.get_logger()
 )
 @deprecated(
     reason=(
-        "The MultiStepLLMCommandGenerator is  deprecated and will be removed in "
+        "The MultiStepLLMCommandGenerator is deprecated and will be removed in "
         "Rasa `4.0.0`."
     )
 )
@@ -495,20 +492,7 @@ class MultiStepLLMCommandGenerator(LLMBasedCommandGenerator):
             prompt=prompt,
         )
 
-        if tracker:
-            session_id = str(await self._get_or_create_session_id(tracker.sender_id))
-        else:
-            session_id = "unknown"
-        metadata = {
-            LANGFUSE_METADATA_SESSION_ID: session_id,
-            LANGFUSE_CUSTOM_METADATA_DICT: {
-                "component": self.__class__.__name__,
-                "function": "_predict_commands_for_active_flow",
-            },
-            LANGFUSE_TAGS: [self.__class__.__name__],
-        }
-
-        response = await self.invoke_llm(prompt, metadata)
+        response = await self.invoke_llm(prompt)
         llm_response = LLMResponse.ensure_llm_response(response)
         actions = None
         if llm_response and llm_response.choices:
@@ -562,20 +546,8 @@ class MultiStepLLMCommandGenerator(LLMBasedCommandGenerator):
             ".prompt_rendered",
             prompt=prompt,
         )
-        if tracker:
-            session_id = str(await self._get_or_create_session_id(tracker.sender_id))
-        else:
-            session_id = "unknown"
-        metadata = {
-            LANGFUSE_METADATA_SESSION_ID: session_id,
-            LANGFUSE_CUSTOM_METADATA_DICT: {
-                "component": self.__class__.__name__,
-                "function": "_predict_commands_for_handling_flows",
-            },
-            LANGFUSE_TAGS: [self.__class__.__name__],
-        }
 
-        response = await self.invoke_llm(prompt, metadata)
+        response = await self.invoke_llm(prompt)
         llm_response = LLMResponse.ensure_llm_response(response)
         actions = None
         if llm_response and llm_response.choices:
@@ -664,20 +636,8 @@ class MultiStepLLMCommandGenerator(LLMBasedCommandGenerator):
             flow=newly_started_flow.id,
             prompt=prompt,
         )
-        if tracker:
-            session_id = str(await self._get_or_create_session_id(tracker.sender_id))
-        else:
-            session_id = "unknown"
-        metadata = {
-            LANGFUSE_METADATA_SESSION_ID: session_id,
-            LANGFUSE_CUSTOM_METADATA_DICT: {
-                "component": self.__class__.__name__,
-                "function": "_predict_commands_for_newly_started_flow",
-            },
-            LANGFUSE_TAGS: [self.__class__.__name__],
-        }
 
-        response = await self.invoke_llm(prompt, metadata)
+        response = await self.invoke_llm(prompt)
         llm_response = LLMResponse.ensure_llm_response(response)
         actions = None
         if llm_response and llm_response.choices:

rasa/dialogue_understanding/generator/single_step/compact_llm_command_generator.py

@@ -47,9 +47,6 @@ from rasa.shared.constants import (
     AWS_BEDROCK_PROVIDER,
     AZURE_OPENAI_PROVIDER,
     EMBEDDINGS_CONFIG_KEY,
-    LANGFUSE_CUSTOM_METADATA_DICT,
-    LANGFUSE_METADATA_SESSION_ID,
-    LANGFUSE_TAGS,
     MAX_COMPLETION_TOKENS_CONFIG_KEY,
     PROMPT_TEMPLATE_CONFIG_KEY,
     ROUTE_TO_CALM_SLOT,
@@ -369,17 +366,7 @@ class CompactLLMCommandGenerator(LLMBasedCommandGenerator):
             prompt=flow_prompt,
         )
 
-        if tracker:
-            session_id = str(await self._get_or_create_session_id(tracker.sender_id))
-        else:
-            session_id = "unknown"
-        metadata = {
-            LANGFUSE_METADATA_SESSION_ID: session_id,
-            LANGFUSE_CUSTOM_METADATA_DICT: {"component": self.__class__.__name__},
-            LANGFUSE_TAGS: [self.__class__.__name__],
-        }
-
-        response = await self.invoke_llm(flow_prompt, metadata)
+        response = await self.invoke_llm(flow_prompt)
         llm_response = LLMResponse.ensure_llm_response(response)
         # The check for 'None' maintains compatibility with older versions
         # of LLMCommandGenerator. In previous implementations, 'invoke_llm'

rasa/dialogue_understanding/processor/command_processor.py

@@ -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)