rasa-pro 3.14.1__py3-none-any.whl → 3.14.2__py3-none-any.whl

rasa/constants.py

@@ -33,6 +33,7 @@ ENV_MCP_LOGGING_ENABLED = "MCP_LOGGING_ENABLED"
 ENV_LOG_LEVEL_MATPLOTLIB = "LOG_LEVEL_MATPLOTLIB"
 ENV_LOG_LEVEL_RABBITMQ = "LOG_LEVEL_RABBITMQ"
 ENV_LOG_LEVEL_KAFKA = "LOG_LEVEL_KAFKA"
+ENV_LOG_LEVEL_PYMONGO = "LOG_LEVEL_PYMONGO"
 
 DEFAULT_SANIC_WORKERS = 1
 ENV_SANIC_WORKERS = "SANIC_WORKERS"

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/browser_audio.py

@@ -90,13 +90,13 @@ class BrowserAudioInputChannel(VoiceInputChannel):
         self._wav_file: Optional[wave.Wave_write] = None
 
     def _start_recording(self, call_id: str, user_id: str) -> None:
+        if not self._recording_enabled:
+            return
+
         os.makedirs("recordings", exist_ok=True)
         filename = f"{user_id}_{call_id}.wav"
         file_path = os.path.join("recordings", filename)
 
-        if not self._recording_enabled:
-            return
-
         self._wav_file = wave.open(file_path, "wb")
         self._wav_file.setnchannels(1)  # Mono audio
         self._wav_file.setsampwidth(4)  # 32-bit audio (4 bytes)

rasa/core/channels/voice_stream/voice_channel.py

@@ -192,6 +192,8 @@ class VoiceOutputChannel(OutputChannel):
     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
+        call_state.is_bot_speaking = True
+        VoiceInputChannel._cancel_silence_timeout_watcher()
         await self.send_marker_message(recipient_id)
 
     async def send_intermediate_marker(self, recipient_id: str) -> None:
@@ -268,11 +270,6 @@ class VoiceOutputChannel(OutputChannel):
         # Track TTS start time
         call_state.tts_start_time = time.time()
 
-        cached_audio_bytes = self.tts_cache.get(text)
-        collected_audio_bytes = RasaAudioBytes(b"")
-        seconds_marker = -1
-        last_sent_offset = 0
-        first_audio_sent = False
         logger.debug("voice_channel.sending_audio", text=text)
 
         # Send start marker before first chunk
@@ -285,17 +282,12 @@ class VoiceOutputChannel(OutputChannel):
         allow_interruptions = kwargs.get("allow_interruptions", True)
         call_state.channel_data["allow_interruptions"] = allow_interruptions
 
-        if cached_audio_bytes:
-            audio_stream = self.chunk_audio(cached_audio_bytes)
-        else:
-            # Todo: make kwargs compatible with engine config
-            synth_config = self.tts_engine.config.__class__.from_dict({})
-            try:
-                audio_stream = self.tts_engine.synthesize(text, synth_config)
-            except TTSError:
-                # TODO: add message that works without tts, e.g. loading from disc
-                audio_stream = self.chunk_audio(generate_silence())
+        audio_stream = await self._create_audio_stream(text)
 
+        collected_audio_bytes = RasaAudioBytes(b"")
+        last_sent_offset = 0
+        first_audio_sent = False
+        seconds_marker = -1
         async for audio_bytes in audio_stream:
             collected_audio_bytes = RasaAudioBytes(collected_audio_bytes + audio_bytes)
 
@@ -315,6 +307,8 @@ class VoiceOutputChannel(OutputChannel):
                     await self.send_audio_bytes(recipient_id, new_bytes)
                     last_sent_offset = len(collected_audio_bytes)
 
+                    # seconds of audio rounded down to floor number
+                    # e.g 7 // 2 = 3
                     full_seconds_of_audio = len(collected_audio_bytes) // HERTZ
                     if full_seconds_of_audio > seconds_marker:
                         await self.send_intermediate_marker(recipient_id)
@@ -348,7 +342,7 @@ class VoiceOutputChannel(OutputChannel):
             pass
         call_state.latest_bot_audio_id = self.latest_message_id
 
-        if not cached_audio_bytes:
+        if not self.tts_cache.get(text):
             self.tts_cache.put(text, collected_audio_bytes)
 
     async def send_audio_bytes(
@@ -373,6 +367,22 @@ class VoiceOutputChannel(OutputChannel):
     async def hangup(self, recipient_id: str, **kwargs: Any) -> None:
         call_state.should_hangup = True
 
+    async def _create_audio_stream(self, text: str) -> AsyncIterator[RasaAudioBytes]:
+        cached_audio_bytes = self.tts_cache.get(text)
+
+        if cached_audio_bytes:
+            audio_stream = self.chunk_audio(cached_audio_bytes)
+        else:
+            # Todo: make kwargs compatible with engine config
+            synth_config = self.tts_engine.config.__class__.from_dict({})
+            try:
+                audio_stream = self.tts_engine.synthesize(text, synth_config)
+            except TTSError:
+                # TODO: add message that works without tts, e.g. loading from disc
+                audio_stream = self.chunk_audio(generate_silence())
+
+        return audio_stream
+
 
 class VoiceInputChannel(InputChannel):
     # All children of this class require a voice license to be used.
@@ -555,7 +565,7 @@ class VoiceInputChannel(InputChannel):
                     # relevant when the bot speaks multiple messages in one turn
                     self._cancel_silence_timeout_watcher()
 
-                # we just stopped speaking, starting a watcher for silence timeout
+                # bot just stopped speaking, starting a watcher for silence timeout
                 if was_bot_speaking_before and not is_bot_speaking_after:
                     logger.debug("voice_channel.bot_stopped_speaking")
                     self._cancel_silence_timeout_watcher()

rasa/core/config/credentials.py

@@ -5,11 +5,11 @@ from typing import Any, Dict
 
 from rasa.shared.utils.yaml import read_config_file
 
+ChannelsType = Dict[str, Dict[str, Any]]
+
 
 class CredentialsConfig:
-    def __init__(
-        self, channels: Dict[str, Dict[str, Any]], config_file_path: Path
-    ) -> None:
+    def __init__(self, channels: ChannelsType, config_file_path: Path) -> None:
         self.channels = channels
         self.config_file_path = config_file_path
 

rasa/core/policies/flows/flow_executor.py

@@ -357,6 +357,10 @@ def reset_scoped_slots(
     flow_persistable_slots = current_flow.persisted_slots
 
     for step in current_flow.steps_with_calls_resolved:
+        # take persisted slots from called flows into consideration
+        # before resetting slots
+        if isinstance(step, CallFlowStep) and step.called_flow_reference:
+            flow_persistable_slots.extend(step.called_flow_reference.persisted_slots)
         if isinstance(step, CollectInformationFlowStep):
             # reset all slots scoped to the flow
             slot_name = step.collect
@@ -368,7 +372,22 @@ def reset_scoped_slots(
     # slots set by the set slots step should be reset after the flow ends
     # unless they are also used in a collect step where `reset_after_flow_ends`
     # is set to `False` or set in the `persisted_slots` list.
-    resettable_set_slots = [
+    resettable_set_slots = _get_resettable_set_slots(
+        current_flow, not_resettable_slot_names, flow_persistable_slots
+    )
+    for name in resettable_set_slots:
+        _reset_slot(name, tracker)
+
+    return events
+
+
+def _get_resettable_set_slots(
+    current_flow: Flow,
+    not_resettable_slot_names: set[Text],
+    flow_persistable_slots: List[Text],
+) -> List[Text]:
+    """Get list of slot names from SetSlotsFlowStep that should be reset."""
+    return [
         slot["key"]
         for step in current_flow.steps_with_calls_resolved
         if isinstance(step, SetSlotsFlowStep)
@@ -377,11 +396,6 @@ def reset_scoped_slots(
         and slot["key"] not in flow_persistable_slots
     ]
 
-    for name in resettable_set_slots:
-        _reset_slot(name, tracker)
-
-    return events
-
 
 async def advance_flows(
     tracker: DialogueStateTracker,
@@ -853,25 +867,7 @@ def _silence_timeout_events_for_collect_step(
             input_channel_name
         )
     else:
-        input_channel_name = tracker.get_latest_input_channel()
-        credentials_config = Configuration.get_instance().credentials
-
-        if credentials_config:
-            channel_config = (
-                credentials_config.channels.get(input_channel_name)
-                if input_channel_name
-                else None
-            )
-
-            silence_timeout = (
-                channel_config.get(
-                    SILENCE_TIMEOUT_CHANNEL_KEY, GLOBAL_SILENCE_TIMEOUT_DEFAULT_VALUE
-                )
-                if channel_config
-                else GLOBAL_SILENCE_TIMEOUT_DEFAULT_VALUE
-            )
-        else:
-            silence_timeout = GLOBAL_SILENCE_TIMEOUT_DEFAULT_VALUE
+        silence_timeout = _get_default_silence_timeout(tracker)
 
         structlogger.debug(
             "flow.step.run.use_channel_silence_timeout",
@@ -891,13 +887,37 @@ def _append_global_silence_timeout_event(
     events: List[Event], tracker: DialogueStateTracker
 ) -> None:
     current_silence_timeout = tracker.get_slot(SILENCE_TIMEOUT_SLOT)
-    endpoints = Configuration.get_instance().endpoints
-    global_silence_timeout = endpoints.interaction_handling.global_silence_timeout
+    default_silence_timeout = _get_default_silence_timeout(tracker)
 
-    if current_silence_timeout != global_silence_timeout:
+    if current_silence_timeout != default_silence_timeout:
         events.append(
             SlotSet(
                 SILENCE_TIMEOUT_SLOT,
-                global_silence_timeout,
+                default_silence_timeout,
+            )
+        )
+
+
+def _get_default_silence_timeout(tracker: DialogueStateTracker) -> float:
+    """Get the default silence timeout for the tracker."""
+    input_channel_name = tracker.get_latest_input_channel()
+    credentials_config = Configuration.get_instance().credentials
+
+    if credentials_config:
+        channel_config = (
+            credentials_config.channels.get(input_channel_name)
+            if input_channel_name
+            else None
+        )
+
+        silence_timeout = (
+            channel_config.get(
+                SILENCE_TIMEOUT_CHANNEL_KEY, GLOBAL_SILENCE_TIMEOUT_DEFAULT_VALUE
             )
+            if channel_config
+            else GLOBAL_SILENCE_TIMEOUT_DEFAULT_VALUE
         )
+    else:
+        silence_timeout = GLOBAL_SILENCE_TIMEOUT_DEFAULT_VALUE
+
+    return silence_timeout

rasa/core/run.py

@@ -5,6 +5,7 @@ import platform
 import uuid
 import warnings
 from asyncio import AbstractEventLoop
+from copy import deepcopy
 from functools import partial
 from typing import (
     Any,
@@ -112,7 +113,11 @@ def _create_single_channel(
     if channel in BUILTIN_CHANNELS:
         channel_class = BUILTIN_CHANNELS[channel]
 
-        return channel_class.from_credentials(credentials)
+        channel_credentials = deepcopy(credentials)
+        channel_credentials.pop(
+            "silence_timeout", None
+        ) if channel_credentials else None
+        return channel_class.from_credentials(channel_credentials)
     elif channel in channels_with_optional_deps:
         # Channel is known but not available due to missing dependency
         dependency = channels_with_optional_deps[channel]
@@ -328,10 +333,21 @@ def serve_application(
 
     logger.info(f"Starting Rasa server on {protocol}://{interface}:{port}")
 
-    app.register_listener(
-        partial(load_agent_on_start, model_path, endpoints, remote_storage, sub_agents),
-        "before_server_start",
-    )
+    async def load_agent_and_check_failure(app: Sanic, loop: AbstractEventLoop) -> None:
+        """Load agent and exit if it fails in non-debug mode."""
+        try:
+            await load_agent_on_start(
+                model_path, endpoints, remote_storage, sub_agents, app, loop
+            )
+        except Exception as e:
+            is_debug = logger.isEnabledFor(logging.DEBUG)
+            if is_debug:
+                raise e  # show traceback in debug
+            # non-debug: log and exit without starting server
+            logger.error(f"Failed to load agent: {e}")
+            os._exit(1)  # Any other exit method would show a traceback.
+
+    app.register_listener(load_agent_and_check_failure, "before_server_start")
 
     app.register_listener(
         licensing.validate_limited_server_license, "after_server_start"