rasa-pro 3.12.0.dev10__py3-none-any.whl → 3.12.0.dev11__py3-none-any.whl

rasa/cli/inspect.py

@@ -9,6 +9,10 @@ from rasa import telemetry
 from rasa.cli import SubParsersAction
 from rasa.cli.arguments import shell as arguments
 from rasa.core import constants
+from rasa.engine.storage.local_model_storage import LocalModelStorage
+from rasa.exceptions import ModelNotFound
+from rasa.model import get_local_model
+from rasa.shared.utils.cli import print_error
 from rasa.utils.cli import remove_argument_from_parser
 
 
@@ -55,6 +59,8 @@ async def open_inspector_in_browser(server_url: Text, voice: bool = False) -> No
 def inspect(args: argparse.Namespace) -> None:
     """Inspect the bot using the most recent model."""
     import rasa.cli.run
+    from rasa.cli.utils import get_validated_path
+    from rasa.shared.constants import DEFAULT_MODELS_PATH
 
     async def after_start_hook_open_inspector(_: Sanic, __: AbstractEventLoop) -> None:
         """Hook to open the browser on server start."""
@@ -71,5 +77,18 @@ def inspect(args: argparse.Namespace) -> None:
     args.credentials = None
     args.server_listeners = [(after_start_hook_open_inspector, "after_server_start")]
 
-    telemetry.track_inspect_started(args.connector)
+    model = get_validated_path(args.model, "model", DEFAULT_MODELS_PATH)
+
+    try:
+        model = get_local_model(model)
+    except ModelNotFound:
+        print_error(
+            "No model found. Train a model before running the "
+            "server using `rasa train`."
+        )
+        return
+
+    metadata = LocalModelStorage.metadata_from_archive(model)
+
+    telemetry.track_inspect_started(args.connector, metadata.assistant_id)
     rasa.cli.run.run(args)

rasa/cli/shell.py

@@ -95,7 +95,7 @@ def shell_nlu(args: argparse.Namespace) -> None:
         )
         return
 
-    telemetry.track_shell_started("nlu")
+    telemetry.track_shell_started("nlu", metadata.assistant_id)
     rasa.nlu.run.run_cmdline(model)
 
 
@@ -129,12 +129,12 @@ def shell(args: argparse.Namespace) -> None:
     if metadata.training_type == TrainingType.NLU:
         import rasa.nlu.run
 
-        telemetry.track_shell_started("nlu")
+        telemetry.track_shell_started("nlu", metadata.assistant_id)
 
         rasa.nlu.run.run_cmdline(model)
     else:
         import rasa.cli.run
 
-        telemetry.track_shell_started("rasa")
+        telemetry.track_shell_started("rasa", metadata.assistant_id)
 
         rasa.cli.run.run(args)

rasa/core/actions/action.py

@@ -72,7 +72,6 @@ from rasa.shared.core.constants import (
     ACTION_UNLIKELY_INTENT_NAME,
     ACTION_VALIDATE_SLOT_MAPPINGS,
     DEFAULT_SLOT_NAMES,
-    KEY_MAPPING_TYPE,
     KNOWLEDGE_BASE_SLOT_NAMES,
     REQUESTED_SLOT,
     USER_INTENT_OUT_OF_SCOPE,
@@ -112,6 +111,7 @@ if TYPE_CHECKING:
     from rasa.core.channels.channel import OutputChannel
     from rasa.core.nlg import NaturalLanguageGenerator
     from rasa.shared.core.events import IntentPrediction
+    from rasa.shared.core.slot_mappings import SlotMapping
 
 logger = logging.getLogger(__name__)
 
@@ -1222,7 +1222,7 @@ class ActionExtractSlots(Action):
 
     async def _execute_custom_action(
         self,
-        mapping: Dict[Text, Any],
+        mapping: "SlotMapping",
         executed_custom_actions: Set[Text],
         output_channel: "OutputChannel",
         nlg: "NaturalLanguageGenerator",
@@ -1230,7 +1230,7 @@ class ActionExtractSlots(Action):
         domain: "Domain",
         calm_custom_action_names: Optional[Set[str]] = None,
     ) -> Tuple[List[Event], Set[Text]]:
-        custom_action = mapping.get("action")
+        custom_action = mapping.run_action_every_turn
 
         if not custom_action or custom_action in executed_custom_actions:
             return [], executed_custom_actions
@@ -1331,10 +1331,9 @@ class ActionExtractSlots(Action):
                 slot_events.append(SlotSet(slot.name, slot_value))
 
             for mapping in slot.mappings:
-                mapping_type = SlotMappingType(mapping.get(KEY_MAPPING_TYPE))
-                should_fill_custom_slot = mapping_type == SlotMappingType.CUSTOM
+                should_fill_controlled_slot = mapping.type == SlotMappingType.CONTROLLED
 
-                if should_fill_custom_slot:
+                if should_fill_controlled_slot:
                     (
                         custom_evts,
                         executed_custom_actions,

rasa/core/actions/forms.py

@@ -2,7 +2,7 @@ import copy
 import itertools
 import json
 import logging
-from typing import Any, Dict, List, Optional, Set, Text, Union
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Set, Text, Union
 
 import structlog
 
@@ -35,6 +35,9 @@ from rasa.shared.core.slots import ListSlot
 from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.utils.endpoints import EndpointConfig
 
+if TYPE_CHECKING:
+    from rasa.shared.core.slot_mappings import SlotMapping
+
 logger = logging.getLogger(__name__)
 structlogger = structlog.get_logger()
 
@@ -171,7 +174,7 @@ class FormAction(LoopAction):
         return unique_entity_slot_mappings
 
     def entity_mapping_is_unique(
-        self, slot_mapping: Dict[Text, Any], domain: Domain
+        self, slot_mapping: "SlotMapping", domain: Domain
     ) -> bool:
         """Verifies if the from_entity mapping is unique."""
         if not self._have_unique_entity_mappings_been_initialized:
@@ -179,7 +182,7 @@ class FormAction(LoopAction):
             self._unique_entity_mappings = self._create_unique_entity_mappings(domain)
             self._have_unique_entity_mappings_been_initialized = True
 
-        mapping_as_string = json.dumps(slot_mapping, sort_keys=True)
+        mapping_as_string = json.dumps(slot_mapping.as_dict(), sort_keys=True)
         return mapping_as_string in self._unique_entity_mappings
 
     @staticmethod

rasa/core/channels/__init__.py

@@ -32,6 +32,7 @@ from rasa.core.channels.vier_cvg import CVGInput
 from rasa.core.channels.voice_stream.twilio_media_streams import (
     TwilioMediaStreamsInputChannel,
 )
+from rasa.core.channels.voice_stream.genesys import GenesysInputChannel
 from rasa.core.channels.studio_chat import StudioChatInput
 
 input_channel_classes: List[Type[InputChannel]] = [
@@ -55,6 +56,7 @@ input_channel_classes: List[Type[InputChannel]] = [
     JambonzVoiceReadyInput,
     TwilioMediaStreamsInputChannel,
     BrowserAudioInputChannel,
+    GenesysInputChannel,
     StudioChatInput,
 ]
 

rasa/core/channels/voice_stream/browser_audio.py

@@ -65,6 +65,7 @@ class BrowserAudioInputChannel(VoiceInputChannel):
     def map_input_message(
         self,
         message: Any,
+        ws: Websocket,
     ) -> VoiceChannelAction:
         data = json.loads(message)
         if "audio" in data:

rasa/core/channels/voice_stream/call_state.py

@@ -1,6 +1,6 @@
 import asyncio
 from contextvars import ContextVar
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import Optional
 
 from werkzeug.local import LocalProxy
@@ -19,6 +19,12 @@ class CallState:
     should_hangup: bool = False
     connection_failed: bool = False
 
+    # Genesys requires the server and client each maintain a
+    # monotonically increasing message sequence number.
+    client_sequence_number: int = 0
+    server_sequence_number: int = 0
+    audio_buffer: bytearray = field(default_factory=bytearray)
+
 
 _call_state: ContextVar[CallState] = ContextVar("call_state")
 call_state = LocalProxy(_call_state)

rasa/core/channels/voice_stream/genesys.py

@@ -0,0 +1,331 @@
+import asyncio
+import json
+from typing import Any, Awaitable, Callable, Dict, Optional, Text
+
+import structlog
+from sanic import (  # type: ignore[attr-defined]
+    Blueprint,
+    HTTPResponse,
+    Request,
+    Websocket,
+    response,
+)
+
+from rasa.core.channels import UserMessage
+from rasa.core.channels.voice_ready.utils import CallParameters
+from rasa.core.channels.voice_stream.audio_bytes import RasaAudioBytes
+from rasa.core.channels.voice_stream.call_state import (
+    call_state,
+)
+from rasa.core.channels.voice_stream.tts.tts_engine import TTSEngine
+from rasa.core.channels.voice_stream.voice_channel import (
+    ContinueConversationAction,
+    EndConversationAction,
+    NewAudioAction,
+    VoiceChannelAction,
+    VoiceInputChannel,
+    VoiceOutputChannel,
+)
+
+# Not mentioned in the documentation but observed in Geneys's example
+# https://github.com/GenesysCloudBlueprints/audioconnector-server-reference-implementation
+MAXIMUM_BINARY_MESSAGE_SIZE = 64000  # 64KB
+logger = structlog.get_logger(__name__)
+
+
+def map_call_params(data: Dict[Text, Any]) -> CallParameters:
+    """Map the twilio stream parameters to the CallParameters dataclass."""
+    parameters = data["parameters"]
+    participant = parameters["participant"]
+    # sent as {"ani": "tel:+491604697810"}
+    ani = participant.get("ani", "")
+    user_phone = ani.split(":")[-1] if ani else ""
+
+    return CallParameters(
+        call_id=parameters.get("conversationId", ""),
+        user_phone=user_phone,
+        bot_phone=participant.get("dnis", ""),
+    )
+
+
+class GenesysOutputChannel(VoiceOutputChannel):
+    @classmethod
+    def name(cls) -> str:
+        return "genesys"
+
+    async def send_audio_bytes(
+        self, recipient_id: str, audio_bytes: RasaAudioBytes
+    ) -> None:
+        """
+        Send audio bytes to the recipient with buffering.
+
+        Genesys throws a rate limit error with too many audio messages.
+        To avoid this, we buffer the audio messages and send them in chunks.
+
+        - global.inbound.binary.average.rate.per.second: 5
+        The allowed average rate per second of inbound binary data
+
+        - global.inbound.binary.max: 25
+        The maximum number of inbound binary data messages
+        that can be sent instantaneously
+
+        https://developer.genesys.cloud/organization/organization/limits#audiohook
+        """
+        call_state.audio_buffer.extend(audio_bytes)
+
+        # If we receive a non-standard chunk size, assume it's the end of a sequence
+        # or buffer is more than 32KB (this is half of genesys's max audio message size)
+        if len(audio_bytes) != 1024 or len(call_state.audio_buffer) >= (
+            MAXIMUM_BINARY_MESSAGE_SIZE / 2
+        ):
+            # TODO: we should send the buffer when we receive a synthesis complete event
+            # from TTS. This will ensure that the last audio chunk is always sent.
+            await self._send_audio_buffer(self.voice_websocket)
+
+    async def _send_audio_buffer(self, ws: Websocket) -> None:
+        """Send the audio buffer to the recipient if it's not empty."""
+        if call_state.audio_buffer:
+            buffer_bytes = bytes(call_state.audio_buffer)
+            await self._send_bytes_to_ws(ws, buffer_bytes)
+            call_state.audio_buffer.clear()
+
+    async def _send_bytes_to_ws(self, ws: Websocket, data: bytes) -> None:
+        """Send audio bytes to the recipient as a binary websocket message."""
+        if len(data) <= MAXIMUM_BINARY_MESSAGE_SIZE:
+            await self.voice_websocket.send(data)
+        else:
+            # split the audio into chunks
+            current_position = 0
+            while current_position < len(data):
+                end_position = min(
+                    current_position + MAXIMUM_BINARY_MESSAGE_SIZE, len(data)
+                )
+                await self.voice_websocket.send(data[current_position:end_position])
+                current_position = end_position
+
+    async def send_marker_message(self, recipient_id: str) -> None:
+        """Send a message that marks positions in the audio stream."""
+        pass
+
+
+class GenesysInputChannel(VoiceInputChannel):
+    @classmethod
+    def name(cls) -> str:
+        return "genesys"
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+
+    def _get_next_sequence(self) -> int:
+        """
+        Get the next message sequence number
+        Rasa == Server
+        Genesys == Client
+
+        Genesys requires the server and client each maintain a
+        monotonically increasing message sequence number.
+        """
+        cs = call_state
+        cs.server_sequence_number += 1  # type: ignore[attr-defined]
+        return cs.server_sequence_number
+
+    def _get_last_client_sequence(self) -> int:
+        """Get the last client(Genesys) sequence number."""
+        return call_state.client_sequence_number
+
+    def _update_client_sequence(self, seq: int) -> None:
+        """Update the client(Genesys) sequence number."""
+        if seq - call_state.client_sequence_number != 1:
+            logger.warning(
+                "genesys.update_client_sequence.sequence_gap",
+                received_seq=seq,
+                last_seq=call_state.client_sequence_number,
+            )
+        call_state.client_sequence_number = seq  # type: ignore[attr-defined]
+
+    def channel_bytes_to_rasa_audio_bytes(self, input_bytes: bytes) -> RasaAudioBytes:
+        return RasaAudioBytes(input_bytes)
+
+    async def collect_call_parameters(
+        self, channel_websocket: Websocket
+    ) -> Optional[CallParameters]:
+        """Call Parameters are collected during the open event."""
+        async for message in channel_websocket:
+            data = json.loads(message)
+            self._update_client_sequence(data["seq"])
+            if data.get("type") == "open":
+                call_params = await self.handle_open(channel_websocket, data)
+                return call_params
+            else:
+                logger.error("genesys.receive.unexpected_initial_message", message=data)
+
+        return None
+
+    def map_input_message(
+        self,
+        message: Any,
+        ws: Websocket,
+    ) -> VoiceChannelAction:
+        # if message is binary, it's audio
+        if isinstance(message, bytes):
+            return NewAudioAction(self.channel_bytes_to_rasa_audio_bytes(message))
+        else:
+            # process text message
+            data = json.loads(message)
+            self._update_client_sequence(data["seq"])
+            msg_type = data.get("type")
+            if msg_type == "close":
+                logger.info("genesys.handle_close", message=data)
+                self.handle_close(ws, data)
+                return EndConversationAction()
+            elif msg_type == "ping":
+                logger.info("genesys.handle_ping", message=data)
+                self.handle_ping(ws, data)
+            elif msg_type == "playback_started":
+                logger.debug("genesys.handle_playback_started", message=data)
+                call_state.is_bot_speaking = True  # type: ignore[attr-defined]
+            elif msg_type == "playback_completed":
+                logger.debug("genesys.handle_playback_completed", message=data)
+                call_state.is_bot_speaking = False  # type: ignore[attr-defined]
+                if call_state.should_hangup:
+                    logger.info("genesys.hangup")
+                    self.disconnect(ws, data)
+            elif msg_type == "dtmf":
+                logger.info("genesys.handle_dtmf", message=data)
+            elif msg_type == "error":
+                logger.warning("genesys.handle_error", message=data)
+            else:
+                logger.warning("genesys.map_input_message.unknown_type", message=data)
+
+        return ContinueConversationAction()
+
+    def create_output_channel(
+        self, voice_websocket: Websocket, tts_engine: TTSEngine
+    ) -> VoiceOutputChannel:
+        return GenesysOutputChannel(
+            voice_websocket,
+            tts_engine,
+            self.tts_cache,
+        )
+
+    async def handle_open(self, ws: Websocket, message: dict) -> CallParameters:
+        """Handle initial open transaction from Genesys."""
+        call_parameters = map_call_params(message)
+        params = message["parameters"]
+        media_options = params.get("media", [])
+
+        # Send opened response
+        if media_options:
+            logger.info("genesys.handle_open", media_parameter=media_options[0])
+            response = {
+                "version": "2",
+                "type": "opened",
+                "seq": self._get_next_sequence(),
+                "clientseq": self._get_last_client_sequence(),
+                "id": message.get("id"),
+                "parameters": {"startPaused": False, "media": [media_options[0]]},
+            }
+            logger.debug("genesys.handle_open.opened", response=response)
+            await ws.send(json.dumps(response))
+        else:
+            logger.warning(
+                "genesys.handle_open.no_media_formats", client_message=message
+            )
+        return call_parameters
+
+    def handle_ping(self, ws: Websocket, message: dict) -> None:
+        """Handle ping message from Genesys."""
+        response = {
+            "version": "2",
+            "type": "pong",
+            "seq": self._get_next_sequence(),
+            "clientseq": message.get("seq"),
+            "id": message.get("id"),
+            "parameters": {},
+        }
+        logger.debug("genesys.handle_ping.pong", response=response)
+        _schedule_ws_task(ws.send(json.dumps(response)))
+
+    def handle_close(self, ws: Websocket, message: dict) -> None:
+        """Handle close message from Genesys."""
+        response = {
+            "version": "2",
+            "type": "closed",
+            "seq": self._get_next_sequence(),
+            "clientseq": self._get_last_client_sequence(),
+            "id": message.get("id"),
+            "parameters": message.get("parameters", {}),
+        }
+        logger.debug("genesys.handle_close.closed", response=response)
+
+        _schedule_ws_task(ws.send(json.dumps(response)))
+        _schedule_ws_task(ws.close())
+
+    def disconnect(self, ws: Websocket, data: dict) -> None:
+        """
+        Send disconnect message to Genesys.
+
+        https://developer.genesys.cloud/devapps/audiohook/protocol-reference#disconnect
+        It should be used to hangup the call.
+        Genesys will respond with a "close" message to us
+        that is handled by the handle_close method.
+        """
+        message = {
+            "version": "2",
+            "type": "disconnect",
+            "seq": self._get_next_sequence(),
+            "clientseq": self._get_last_client_sequence(),
+            "id": data.get("id"),
+            "parameters": {
+                "reason": "completed",
+                # arbitrary values can be sent here
+            },
+        }
+        logger.debug("genesys.disconnect", message=message)
+        _schedule_ws_task(ws.send(json.dumps(message)))
+
+    def blueprint(
+        self, on_new_message: Callable[[UserMessage], Awaitable[Any]]
+    ) -> Blueprint:
+        """Defines a Sanic blueprint for the voice input channel."""
+        blueprint = Blueprint("genesys", __name__)
+
+        @blueprint.route("/", methods=["GET"])
+        async def health(_: Request) -> HTTPResponse:
+            return response.json({"status": "ok"})
+
+        @blueprint.websocket("/websocket")  # type: ignore[misc]
+        async def receive(request: Request, ws: Websocket) -> None:
+            logger.debug(
+                "genesys.receive",
+                audiohook_session_id=request.headers.get("audiohook-session-id"),
+            )
+            # validate required headers
+            required_headers = [
+                "audiohook-organization-id",
+                "audiohook-correlation-id",
+                "audiohook-session-id",
+                "x-api-key",
+            ]
+
+            for header in required_headers:
+                if header not in request.headers:
+                    await ws.close(1008, f"Missing required header: {header}")
+                    return
+
+            # TODO: validate API key header
+            # process audio streaming
+            logger.info("genesys.receive", message="Starting audio streaming")
+            await self.run_audio_streaming(on_new_message, ws)
+
+        return blueprint
+
+
+def _schedule_ws_task(coro: Awaitable[Any]) -> None:
+    """Helper function to schedule a coroutine in the event loop.
+
+    Args:
+        coro: The coroutine to schedule
+    """
+    loop = asyncio.get_running_loop()
+    loop.call_soon_threadsafe(lambda: loop.create_task(coro))

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
@@ -39,7 +41,7 @@ class CartesiaTTS(TTSEngine[CartesiaTTSConfig]):
     @staticmethod
     def get_tts_endpoint() -> str:
         """Create the endpoint string for cartesia."""
-        return "https://api.cartesia.ai/tts/bytes"
+        return "https://api.cartesia.ai/tts/sse"
 
     @staticmethod
     def get_request_body(text: str, config: CartesiaTTSConfig) -> Dict:
@@ -85,8 +87,19 @@ 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
                 else:
                     structlogger.error(

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

@@ -315,6 +315,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 +341,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/policies/flows/flow_executor.py

@@ -54,7 +54,9 @@ from rasa.dialogue_understanding.stack.utils import (
     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,
@@ -564,38 +566,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,
@@ -792,14 +762,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(

rasa/core/run.py

@@ -283,9 +283,10 @@ def serve_application(
         endpoints.lock_store if endpoints else None
     )
 
-    telemetry.track_server_start(
-        input_channels, endpoints, model_path, number_of_workers, enable_api
-    )
+    if not inspect:
+        telemetry.track_server_start(
+            input_channels, endpoints, model_path, number_of_workers, enable_api
+        )
 
     rasa.utils.common.update_sanic_log_level(
         log_file, use_syslog, syslog_address, syslog_port, syslog_protocol