rasa-pro 3.12.0.dev12__py3-none-any.whl → 3.12.0rc1__py3-none-any.whl

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

@@ -21,6 +21,7 @@ structlogger = structlog.get_logger()
 @dataclass
 class AzureTTSConfig(TTSEngineConfig):
     speech_region: Optional[str] = None
+    endpoint: Optional[str] = None
 
 
 class AzureTTS(TTSEngine[AzureTTSConfig]):
@@ -76,12 +77,19 @@ class AzureTTS(TTSEngine[AzureTTSConfig]):
 
     @staticmethod
     def get_tts_endpoint(config: AzureTTSConfig) -> str:
-        return f"https://{config.speech_region}.tts.speech.microsoft.com/cognitiveservices/v1"
+        if config.endpoint is not None:
+            return config.endpoint
+        else:
+            return (
+                f"https://{config.speech_region}.tts.speech.microsoft.com/"
+                f"cognitiveservices/v1"
+            )
 
     @staticmethod
     def create_request_body(text: str, conf: AzureTTSConfig) -> str:
         return f"""
-        <speak version='1.0' xml:lang='{conf.language}'>
+        <speak version='1.0' xml:lang='{conf.language}' xmlns:mstts='http://www.w3.org/2001/mstts'
+                xmlns='http://www.w3.org/2001/10/synthesis'>
             <voice xml:lang='{conf.language}' name='{conf.voice}'>
                 {text}
             </voice>
@@ -98,6 +106,7 @@ class AzureTTS(TTSEngine[AzureTTSConfig]):
             voice="en-US-JennyNeural",
             timeout=10,
             speech_region="eastus",
+            endpoint=None,
         )
 
     @classmethod

rasa/core/channels/voice_stream/tts/cartesia.py

@@ -1,3 +1,5 @@
+import base64
+import json
 import os
 from dataclasses import dataclass
 from typing import AsyncIterator, Dict, Optional
@@ -22,6 +24,7 @@ structlogger = structlog.get_logger()
 class CartesiaTTSConfig(TTSEngineConfig):
     model_id: Optional[str] = None
     version: Optional[str] = None
+    endpoint: Optional[str] = None
 
 
 class CartesiaTTS(TTSEngine[CartesiaTTSConfig]):
@@ -36,11 +39,6 @@ class CartesiaTTS(TTSEngine[CartesiaTTSConfig]):
         if self.__class__.session is None or self.__class__.session.closed:
             self.__class__.session = aiohttp.ClientSession(timeout=timeout)
 
-    @staticmethod
-    def get_tts_endpoint() -> str:
-        """Create the endpoint string for cartesia."""
-        return "https://api.cartesia.ai/tts/bytes"
-
     @staticmethod
     def get_request_body(text: str, config: CartesiaTTSConfig) -> Dict:
         """Create the request body for cartesia."""
@@ -77,7 +75,7 @@ class CartesiaTTS(TTSEngine[CartesiaTTSConfig]):
         config = self.config.merge(config)
         payload = self.get_request_body(text, config)
         headers = self.get_request_headers(config)
-        url = self.get_tts_endpoint()
+        url = self.config.endpoint
         if self.session is None:
             raise ConnectionException("Client session is not initialized")
         try:
@@ -85,16 +83,36 @@ class CartesiaTTS(TTSEngine[CartesiaTTSConfig]):
                 url, headers=headers, json=payload, chunked=True
             ) as response:
                 if 200 <= response.status < 300:
-                    async for data in response.content.iter_chunked(1024):
-                        yield self.engine_bytes_to_rasa_audio_bytes(data)
+                    async for chunk in response.content:
+                        # we are looking for chunks in the response that look like
+                        # b"data: {..., data: <base64 encoded audio bytes> ...}"
+                        # and extract the audio bytes from that
+                        if chunk.startswith(b"data: "):
+                            json_bytes = chunk[5:-1]
+                            json_data = json.loads(json_bytes.decode())
+                            if "data" in json_data:
+                                base64_encoded_bytes = json_data["data"]
+                                channel_bytes = base64.b64decode(base64_encoded_bytes)
+                                yield self.engine_bytes_to_rasa_audio_bytes(
+                                    channel_bytes
+                                )
                     return
+                elif response.status == 401:
+                    structlogger.error(
+                        "cartesia.synthesize.rest.unauthorized",
+                        status_code=response.status,
+                    )
+                    raise TTSError(
+                        "Unauthorized. Please make sure you have the correct API key."
+                    )
                 else:
+                    response_text = await response.text()
                     structlogger.error(
                         "cartesia.synthesize.rest.failed",
                         status_code=response.status,
-                        msg=response.text(),
+                        msg=response_text,
                     )
-                    raise TTSError(f"TTS failed: {response.text()}")
+                    raise TTSError(f"TTS failed: {response_text}")
         except ClientConnectorError as e:
             raise TTSError(e)
         except TimeoutError as e:
@@ -112,6 +130,7 @@ class CartesiaTTS(TTSEngine[CartesiaTTSConfig]):
             timeout=10,
             model_id="sonic-english",
             version="2024-06-10",
+            endpoint="https://api.cartesia.ai/tts/sse",
         )
 
     @classmethod

rasa/core/channels/voice_stream/twilio_media_streams.py

@@ -98,6 +98,7 @@ class TwilioMediaStreamsInputChannel(VoiceInputChannel):
     def map_input_message(
         self,
         message: Any,
+        ws: Websocket,
     ) -> VoiceChannelAction:
         data = json.loads(message)
         if data["event"] == "media":
@@ -142,7 +143,7 @@ class TwilioMediaStreamsInputChannel(VoiceInputChannel):
     def blueprint(
         self, on_new_message: Callable[[UserMessage], Awaitable[Any]]
     ) -> Blueprint:
-        """Defines a Sanic bluelogger.debug."""
+        """Defines a Sanic blueprint for the voice input channel."""
         blueprint = Blueprint("twilio_media_streams", __name__)
 
         @blueprint.route("/", methods=["GET"])

rasa/core/channels/voice_stream/voice_channel.py

@@ -148,6 +148,19 @@ class VoiceOutputChannel(OutputChannel):
         await self.voice_websocket.send(marker_message)
         self.latest_message_id = mark_id
 
+    async def send_start_marker(self, recipient_id: str) -> None:
+        """Send a marker message before the first audio chunk."""
+        # Default implementation uses the generic marker message
+        await self.send_marker_message(recipient_id)
+
+    async def send_intermediate_marker(self, recipient_id: str) -> None:
+        """Send a marker message during audio streaming."""
+        await self.send_marker_message(recipient_id)
+
+    async def send_end_marker(self, recipient_id: str) -> None:
+        """Send a marker message after the last audio chunk."""
+        await self.send_marker_message(recipient_id)
+
     def update_silence_timeout(self) -> None:
         """Updates the silence timeout for the session."""
         if self.tracker_state:
@@ -173,6 +186,13 @@ class VoiceOutputChannel(OutputChannel):
         cached_audio_bytes = self.tts_cache.get(text)
         collected_audio_bytes = RasaAudioBytes(b"")
         seconds_marker = -1
+
+        # Send start marker before first chunk
+        try:
+            await self.send_start_marker(recipient_id)
+        except (WebsocketClosed, ServerError):
+            call_state.connection_failed = True  # type: ignore[attr-defined]
+
         if cached_audio_bytes:
             audio_stream = self.chunk_audio(cached_audio_bytes)
         else:
@@ -189,15 +209,16 @@ class VoiceOutputChannel(OutputChannel):
                 await self.send_audio_bytes(recipient_id, audio_bytes)
                 full_seconds_of_audio = len(collected_audio_bytes) // HERTZ
                 if full_seconds_of_audio > seconds_marker:
-                    await self.send_marker_message(recipient_id)
+                    await self.send_intermediate_marker(recipient_id)
                     seconds_marker = full_seconds_of_audio
 
             except (WebsocketClosed, ServerError):
                 # ignore sending error, and keep collecting and caching audio bytes
                 call_state.connection_failed = True  # type: ignore[attr-defined]
             collected_audio_bytes = RasaAudioBytes(collected_audio_bytes + audio_bytes)
+
         try:
-            await self.send_marker_message(recipient_id)
+            await self.send_end_marker(recipient_id)
         except (WebsocketClosed, ServerError):
             # ignore sending error
             pass
@@ -315,6 +336,7 @@ class VoiceInputChannel(InputChannel):
     def map_input_message(
         self,
         message: Any,
+        ws: Websocket,
     ) -> VoiceChannelAction:
         """Map a channel input message to a voice channel action."""
         raise NotImplementedError
@@ -340,7 +362,7 @@ class VoiceInputChannel(InputChannel):
         async def consume_audio_bytes() -> None:
             async for message in channel_websocket:
                 is_bot_speaking_before = call_state.is_bot_speaking
-                channel_action = self.map_input_message(message)
+                channel_action = self.map_input_message(message, channel_websocket)
                 is_bot_speaking_after = call_state.is_bot_speaking
 
                 if not is_bot_speaking_before and is_bot_speaking_after:

rasa/core/constants.py

@@ -110,3 +110,5 @@ UTTER_SOURCE_METADATA_KEY = "utter_source"
 DOMAIN_GROUND_TRUTH_METADATA_KEY = "domain_ground_truth"
 ACTIVE_FLOW_METADATA_KEY = "active_flow"
 STEP_ID_METADATA_KEY = "step_id"
+KEY_IS_CALM_SYSTEM = "is_calm_system"
+KEY_IS_COEXISTENCE_ASSISTANT = "is_coexistence_assistant"

rasa/core/migrate.py

@@ -14,7 +14,7 @@ from rasa.shared.constants import (
 )
 from rasa.shared.core.constants import (
     ACTIVE_LOOP,
-    MAPPING_TYPE,
+    KEY_MAPPING_TYPE,
     REQUESTED_SLOT,
     SLOT_MAPPINGS,
     SlotMappingType,
@@ -43,7 +43,7 @@ def _create_back_up(domain_file: Path, backup_location: Path) -> Dict[Text, Any]
 def _get_updated_mapping_condition(
     condition: Dict[Text, Text], mapping: Dict[Text, Any], slot_name: Text
 ) -> Dict[Text, Text]:
-    if mapping.get(MAPPING_TYPE) not in [
+    if mapping.get(KEY_MAPPING_TYPE) not in [
         str(SlotMappingType.FROM_ENTITY),
         str(SlotMappingType.FROM_TRIGGER_INTENT),
     ]:

rasa/core/nlg/contextual_response_rephraser.py

@@ -64,7 +64,7 @@ DEFAULT_LLM_CONFIG = {
 DEFAULT_RESPONSE_VARIATION_PROMPT_TEMPLATE = """The following is a conversation with
 an AI assistant. The assistant is helpful, creative, clever, and very friendly.
 Rephrase the suggested AI response staying close to the original message and retaining
-its meaning. Use simple english.
+its meaning. Use simple {{language}}.
 
 Context / previous conversation with the user:
 {{history}}
@@ -164,6 +164,22 @@ class ContextualResponseRephraser(
         response[PROMPTS] = prompts
         return response
 
+    @staticmethod
+    def get_language_label(tracker: DialogueStateTracker) -> str:
+        """Fetches the label of the language to be used for the rephraser.
+
+        Args:
+            tracker: The tracker to get the language from.
+
+        Returns:
+            The label of the current language, or "English" if no language is set.
+        """
+        return (
+            tracker.current_language.label
+            if tracker.current_language
+            else tracker.default_language.label
+        )
+
     def _last_message_if_human(self, tracker: DialogueStateTracker) -> Optional[str]:
         """Returns the latest message from the tracker.
 
@@ -281,6 +297,7 @@ class ContextualResponseRephraser(
             suggested_response=response_text,
             current_input=current_input,
             slots=tracker.current_slot_values(),
+            language=self.get_language_label(tracker),
         )
         log_llm(
             logger=structlogger,

rasa/core/nlg/generator.py

@@ -1,6 +1,9 @@
-import logging
 from typing import Any, Dict, List, Optional, Text, Union
 
+import structlog
+from jinja2 import Template
+from pypred import Predicate
+
 import rasa.shared.utils.common
 import rasa.shared.utils.io
 from rasa.shared.constants import CHANNEL, RESPONSE_CONDITION
@@ -8,7 +11,7 @@ from rasa.shared.core.domain import Domain
 from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.utils.endpoints import EndpointConfig
 
-logger = logging.getLogger(__name__)
+structlogger = structlog.get_logger()
 
 
 class NaturalLanguageGenerator:
@@ -74,7 +77,11 @@ def _create_from_endpoint_config(
     else:
         nlg = _load_from_module_name_in_endpoint_config(endpoint_config, domain)
 
-    logger.debug(f"Instantiated NLG to '{nlg.__class__.__name__}'.")
+    structlogger.debug(
+        "rasa.core.nlg.generator.create",
+        nlg_class_name=nlg.__class__.__name__,
+        event_info=f"Instantiated NLG to '{nlg.__class__.__name__}'.",
+    )
     return nlg
 
 
@@ -112,18 +119,15 @@ class ResponseVariationFilter:
     ) -> bool:
         """Checks if the conditional response variation matches the filled slots."""
         constraints = response.get(RESPONSE_CONDITION, [])
-        for constraint in constraints:
-            name = constraint["name"]
-            value = constraint["value"]
-            filled_slots_value = filled_slots.get(name)
-            if isinstance(filled_slots_value, str) and isinstance(value, str):
-                if filled_slots_value.casefold() != value.casefold():
+        if isinstance(constraints, str) and not _evaluate_predicate(
+            constraints, filled_slots
+        ):
+            return False
+
+        elif isinstance(constraints, list):
+            for constraint in constraints:
+                if not _evaluate_and_deprecate_condition(constraint, filled_slots):
                     return False
-            # slot values can be of different data types
-            # such as int, float, bool, etc. hence, this check
-            # executes when slot values are not strings
-            elif filled_slots_value != value:
-                return False
 
         return True
 
@@ -180,7 +184,21 @@ class ResponseVariationFilter:
         if conditional_no_channel:
             return conditional_no_channel
 
-        return default_no_channel
+        if default_no_channel:
+            return default_no_channel
+
+        # if there is no response variation selected,
+        # return the internal error response to prevent
+        # the bot from staying silent
+        structlogger.error(
+            "rasa.core.nlg.generator.responses_for_utter_action.no_response",
+            utter_action=utter_action,
+            event_info=f"No response variation selected for the predicted "
+            f"utterance {utter_action}. Please check you have provided "
+            f"a default variation and that all the conditions are valid. "
+            f"Returning the internal error response.",
+        )
+        return self.responses.get("utter_internal_error_rasa", [])
 
     def get_response_variation_id(
         self,
@@ -228,3 +246,53 @@ class ResponseVariationFilter:
             response_ids.add(response_variation_id)
 
         return True
+
+
+def _evaluate_and_deprecate_condition(
+    constraint: Dict[Text, Any], filled_slots: Dict[Text, Any]
+) -> bool:
+    """Evaluates the condition of a response variation."""
+    rasa.shared.utils.io.raise_deprecation_warning(
+        "Using a dictionary as a condition in a response variation is deprecated. "
+        "Please use a pypred string predicate instead. "
+        "Dictionary conditions will be removed in Rasa Open Source 4.0.0 .",
+        warn_until_version="4.0.0",
+    )
+
+    name = constraint["name"]
+    value = constraint["value"]
+    filled_slots_value = filled_slots.get(name)
+    if isinstance(filled_slots_value, str) and isinstance(value, str):
+        if filled_slots_value.casefold() != value.casefold():
+            return False
+    # slot values can be of different data types
+    # such as int, float, bool, etc. hence, this check
+    # executes when slot values are not strings
+    elif filled_slots_value != value:
+        return False
+
+    return True
+
+
+def _evaluate_predicate(constraint: str, filled_slots: Dict[Text, Any]) -> bool:
+    """Evaluates the condition of a response variation."""
+    context = {"slots": filled_slots}
+    document = context.copy()
+    try:
+        rendered_template = Template(constraint).render(context)
+        predicate = Predicate(rendered_template)
+        result = predicate.evaluate(document)
+        structlogger.debug(
+            "rasa.core.nlg.generator.evaluate_conditional_response_predicate",
+            predicate=predicate.description(),
+            result=result,
+        )
+        return result
+    except (TypeError, Exception) as e:
+        structlogger.error(
+            "rasa.core.nlg.generator.evaluate_conditional_response_predicate.error",
+            predicate=constraint,
+            document=document,
+            error=str(e),
+        )
+        return False

rasa/core/nlg/response.py

@@ -49,9 +49,12 @@ class TemplatedNaturalLanguageGenerator(NaturalLanguageGenerator):
                 selected_response = np.random.choice(suitable_responses)
                 condition = selected_response.get(RESPONSE_CONDITION)
                 if condition:
-                    formatted_response_conditions = self._format_response_conditions(
-                        condition
-                    )
+                    if isinstance(condition, list):
+                        formatted_response_conditions = (
+                            self._format_response_conditions(condition)
+                        )
+                    else:
+                        formatted_response_conditions = condition
                     logger.debug(
                         "Selecting response variation with conditions:"
                         f"{formatted_response_conditions}"

rasa/core/nlg/translate.py

@@ -0,0 +1,55 @@
+from typing import Any, Dict, List, Optional, Text
+
+from rasa.engine.language import Language
+from rasa.shared.core.flows.constants import KEY_TRANSLATION
+
+
+def get_translated_text(
+    text: Optional[Text],
+    translation: Dict[Text, Any],
+    language: Optional[Language] = None,
+) -> Optional[Text]:
+    """Get the translated text from the message.
+
+    Args:
+        text: The default text to use if no translation is found.
+        translation: The translations for the text.
+        language: The language to use for the translation.
+
+    Returns:
+        The translated text if found, otherwise the default text.
+    """
+    language_code = language.code if language else None
+    return translation.get(language_code, text)
+
+
+def get_translated_buttons(
+    buttons: Optional[List[Dict[Text, Any]]], language: Optional[Language] = None
+) -> Optional[List[Dict[Text, Any]]]:
+    """Get the translated buttons from the message.
+
+    Args:
+        buttons: The default buttons to use if no translation is found.
+        language: The language to use for the translation.
+
+    Returns:
+        The translated buttons if found; otherwise, the default buttons.
+    """
+    if buttons is None:
+        return None
+
+    language_code = language.code if language else None
+    translated_buttons = []
+    for button in buttons:
+        translation = button.get(KEY_TRANSLATION, {})
+        language_translation = translation.get(language_code, {})
+
+        # Maintain the original key order to ensure
+        # accurate comparisons of BotUtter events.
+        translated_button = {
+            key: language_translation.get(key, button.get(key))
+            for key, value in button.items()
+            if key != KEY_TRANSLATION
+        }
+        translated_buttons.append(translated_button)
+    return translated_buttons

rasa/core/policies/enterprise_search_prompt_with_citation_template.jinja2

@@ -4,7 +4,7 @@ If the answer is not known or cannot be determined from the provided documents o
 Use the following documents to answer the question:
 {% for doc in docs %}
 {{ loop.cycle("*")}}. {{ doc.metadata }}
-{{ doc.page_content }}
+{{ doc.text }}
 {% endfor %}
 
 {% if citation_enabled %}

rasa/core/policies/flows/flow_executor.py

@@ -23,6 +23,7 @@ from rasa.core.policies.flows.flow_step_result import (
 )
 from rasa.dialogue_understanding.commands import CancelFlowCommand
 from rasa.dialogue_understanding.patterns.cancel import CancelPatternFlowStackFrame
+from rasa.dialogue_understanding.patterns.clarify import ClarifyPatternFlowStackFrame
 from rasa.dialogue_understanding.patterns.collect_information import (
     CollectInformationPatternFlowStackFrame,
 )
@@ -50,9 +51,12 @@ from rasa.dialogue_understanding.stack.frames.flow_stack_frame import (
 )
 from rasa.dialogue_understanding.stack.utils import (
     top_user_flow_frame,
+    user_flows_on_the_stack,
 )
 from rasa.shared.constants import RASA_PATTERN_HUMAN_HANDOFF
-from rasa.shared.core.constants import ACTION_LISTEN_NAME, SlotMappingType
+from rasa.shared.core.constants import (
+    ACTION_LISTEN_NAME,
+)
 from rasa.shared.core.events import (
     Event,
     FlowCompleted,
@@ -81,9 +85,8 @@ from rasa.shared.core.flows.steps import (
     NoOperationFlowStep,
     SetSlotsFlowStep,
 )
-from rasa.shared.core.flows.steps.collect import SlotRejection
 from rasa.shared.core.flows.steps.constants import START_STEP
-from rasa.shared.core.slots import Slot
+from rasa.shared.core.slots import Slot, SlotRejection
 from rasa.shared.core.trackers import (
     DialogueStateTracker,
 )
@@ -239,7 +242,10 @@ def events_for_collect_step_execution(
 
 
 def trigger_pattern_continue_interrupted(
-    current_frame: DialogueStackFrame, stack: DialogueStack, flows: FlowsList
+    current_frame: DialogueStackFrame,
+    stack: DialogueStack,
+    flows: FlowsList,
+    tracker: DialogueStateTracker,
 ) -> List[Event]:
     """Trigger the pattern to continue an interrupted flow if needed."""
     events: List[Event] = []
@@ -262,7 +268,9 @@ def trigger_pattern_continue_interrupted(
     ):
         stack.push(
             ContinueInterruptedPatternFlowStackFrame(
-                previous_flow_name=interrupted_user_flow.readable_name(),
+                previous_flow_name=interrupted_user_flow.readable_name(
+                    language=tracker.current_language
+                ),
             )
         )
         events.append(
@@ -272,6 +280,28 @@ def trigger_pattern_continue_interrupted(
     return events
 
 
+def trigger_pattern_clarification(
+    current_frame: DialogueStackFrame, stack: DialogueStack, flows: FlowsList
+) -> None:
+    """Trigger the pattern to clarify which topic to continue if needed."""
+    if not isinstance(current_frame, UserFlowStackFrame):
+        return None
+
+    if current_frame.frame_type == FlowStackFrameType.CALL:
+        # we want to return to the flow that called the current flow
+        return None
+
+    pending_flows = [
+        flows.flow_by_id(frame.flow_id)
+        for frame in stack.frames
+        if isinstance(frame, UserFlowStackFrame)
+        and frame.flow_id != current_frame.flow_id
+    ]
+
+    flow_names = [flow.readable_name() for flow in pending_flows if flow is not None]
+    stack.push(ClarifyPatternFlowStackFrame(names=flow_names))
+
+
 def trigger_pattern_completed(
     current_frame: DialogueStackFrame, stack: DialogueStack, flows: FlowsList
 ) -> None:
@@ -283,6 +313,9 @@ def trigger_pattern_completed(
         or isinstance(current_frame, SearchPatternFlowStackFrame)
     ):
         completed_flow = current_frame.flow(flows)
+        if not completed_flow.run_pattern_completed:
+            return
+
         completed_flow_name = completed_flow.readable_name() if completed_flow else None
         stack.push(
             CompletedPatternFlowStackFrame(
@@ -540,38 +573,6 @@ def cancel_flow_and_push_internal_error(stack: DialogueStack, flow_name: str) ->
     stack.push(InternalErrorPatternFlowStackFrame())
 
 
-def validate_custom_slot_mappings(
-    step: CollectInformationFlowStep,
-    stack: DialogueStack,
-    tracker: DialogueStateTracker,
-    available_actions: List[str],
-    flow_name: str,
-) -> bool:
-    """Validate a slot with custom mappings.
-
-    If invalid, trigger pattern_internal_error and return False.
-    """
-    slot = tracker.slots.get(step.collect, None)
-    slot_mappings = slot.mappings if slot else []
-    for mapping in slot_mappings:
-        if (
-            mapping.get("type") == SlotMappingType.CUSTOM.value
-            and mapping.get("action") is None
-        ):
-            # this is a slot that must be filled by a custom action
-            # check if collect_action exists
-            if step.collect_action not in available_actions:
-                structlogger.error(
-                    "flow.step.run.collect_action_not_found_for_custom_slot_mapping",
-                    action=step.collect_action,
-                    collect=step.collect,
-                )
-                cancel_flow_and_push_internal_error(stack, flow_name)
-                return False
-
-    return True
-
-
 def attach_stack_metadata_to_events(
     step_id: str,
     flow_id: str,
@@ -669,7 +670,15 @@ def _run_end_step(
     structlogger.debug("flow.step.run.flow_end")
     current_frame = stack.pop()
     trigger_pattern_completed(current_frame, stack, flows)
-    resumed_events = trigger_pattern_continue_interrupted(current_frame, stack, flows)
+    resumed_events = []
+    if len(user_flows_on_the_stack(stack)) > 1:
+        # if there are more user flows on the stack,
+        # we need to trigger the pattern clarify
+        trigger_pattern_clarification(current_frame, stack, flows)
+    else:
+        resumed_events = trigger_pattern_continue_interrupted(
+            current_frame, stack, flows, tracker
+        )
     reset_events: List[Event] = reset_scoped_slots(current_frame, flow, tracker)
     return ContinueFlowWithNextStep(
         events=initial_events + reset_events + resumed_events, has_flow_ended=True
@@ -760,14 +769,6 @@ def _run_collect_information_step(
         # if we return any other FlowStepResult, the assistant will stay silent
         # instead of triggering the internal error pattern
         return ContinueFlowWithNextStep(events=initial_events)
-    is_mapping_valid = validate_custom_slot_mappings(
-        step, stack, tracker, available_actions, flow_name
-    )
-
-    if not is_mapping_valid:
-        # if we return any other FlowStepResult, the assistant will stay silent
-        # instead of triggering the internal error pattern
-        return ContinueFlowWithNextStep(events=initial_events)
 
     structlogger.debug("flow.step.run.collect")
     trigger_pattern_ask_collect_information(