rasa-pro 3.11.6__py3-none-any.whl → 3.11.8__py3-none-any.whl

rasa/core/channels/voice_stream/twilio_media_streams.py

@@ -1,31 +1,54 @@
+from __future__ import annotations
+
 import base64
 import json
 import uuid
+from typing import TYPE_CHECKING, Any, Awaitable, Callable, Dict, Optional, Text, Tuple
 
 import structlog
-from typing import Any, Awaitable, Callable, Dict, Optional, Text, Tuple
-
-from sanic import Blueprint, HTTPResponse, Request, response
-from sanic import Websocket  # type: ignore
-
+from sanic import (  # type: ignore[attr-defined]
+    Blueprint,
+    HTTPResponse,
+    Request,
+    Websocket,
+    response,
+)
 
-from rasa.core.channels import UserMessage
+from rasa.core.channels import InputChannel, UserMessage
+from rasa.core.channels.channel import (
+    create_auth_requested_response_provider,
+    requires_basic_auth,
+)
 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.audio_bytes import RasaAudioBytes
 from rasa.core.channels.voice_stream.voice_channel import (
+    ContinueConversationAction,
     EndConversationAction,
     NewAudioAction,
     VoiceChannelAction,
-    ContinueConversationAction,
     VoiceInputChannel,
     VoiceOutputChannel,
 )
+from rasa.shared.exceptions import RasaException
+
+if TYPE_CHECKING:
+    from twilio.twiml.voice_response import VoiceResponse
 
 logger = structlog.get_logger(__name__)
 
 
+TWILIO_MEDIA_STREAMS_WEBHOOK_PATH = "webhooks/twilio_media_streams/webhook"
+TWILIO_MEDIA_STREAMS_WEBSOCKET_PATH = "webhooks/twilio_media_streams/websocket"
+
+
+CALL_SID_REQUEST_KEY = "CallSid"
+FROM_NUMBER_REQUEST_KEY = "From"
+TO_NUMBER_REQUEST_KEY = "To"
+DIRECTION_REQUEST_KEY = "Direction"
+
+
 def map_call_params(data: Dict[Text, Any]) -> CallParameters:
     """Map the twilio stream parameters to the CallParameters dataclass."""
     stream_sid = data["streamSid"]
@@ -74,6 +97,40 @@ class TwilioMediaStreamsOutputChannel(VoiceOutputChannel):
 
 
 class TwilioMediaStreamsInputChannel(VoiceInputChannel):
+    def __init__(
+        self,
+        server_url: str,
+        asr_config: Dict,
+        tts_config: Dict,
+        monitor_silence: bool = False,
+        username: Optional[Text] = None,
+        password: Optional[Text] = None,
+    ):
+        super().__init__(server_url, asr_config, tts_config, monitor_silence)
+        self.username = username
+        self.password = password
+
+    @classmethod
+    def from_credentials(cls, credentials: Optional[Dict[str, Any]]) -> InputChannel:
+        credentials = credentials or {}
+
+        username = credentials.get("username")
+        password = credentials.get("password")
+        if (username is None) != (password is None):
+            raise RasaException(
+                "In TwilioMediaStreams channel, either both username and password "
+                "or neither should be provided. "
+            )
+
+        return cls(
+            credentials["server_url"],
+            credentials["asr"],
+            credentials["tts"],
+            credentials.get("monitor_silence", False),
+            username=username,
+            password=password,
+        )
+
     @classmethod
     def name(cls) -> str:
         return "twilio_media_streams"
@@ -126,16 +183,6 @@ class TwilioMediaStreamsInputChannel(VoiceInputChannel):
             self.tts_cache,
         )
 
-    def websocket_stream_url(self) -> str:
-        """Returns the websocket stream URL."""
-        # depending on the config value, the url might contain http as a
-        # protocol or not - we'll make sure both work
-        if self.server_url.startswith("http"):
-            base_url = self.server_url.replace("http", "ws")
-        else:
-            base_url = f"wss://{self.server_url}"
-        return f"{base_url}/webhooks/twilio_media_streams/websocket"
-
     def blueprint(
         self, on_new_message: Callable[[UserMessage], Awaitable[Any]]
     ) -> Blueprint:
@@ -147,22 +194,20 @@ class TwilioMediaStreamsInputChannel(VoiceInputChannel):
             return response.json({"status": "ok"})
 
         @blueprint.route("/webhook", methods=["POST"])
+        @requires_basic_auth(
+            username=self.username,
+            password=self.password,
+            auth_request_provider=create_auth_requested_response_provider(
+                realm=TWILIO_MEDIA_STREAMS_WEBHOOK_PATH
+            ),
+        )
         async def receive(request: Request) -> HTTPResponse:
-            from twilio.twiml.voice_response import Connect, VoiceResponse
-
-            voice_response = VoiceResponse()
-            start = Connect()
-            stream = start.stream(url=self.websocket_stream_url())
-            # pass information about the call to the webhook - so we can
-            # store it in the input channel
-            stream.parameter(name="call_id", value=request.form.get("CallSid", None))
-            stream.parameter(name="user_phone", value=request.form.get("From", None))
-            stream.parameter(name="bot_phone", value=request.form.get("To", None))
-            stream.parameter(
-                name="direction", value=request.form.get("Direction", None)
-            )
+            voice_response = self._build_twilio_response(request)
 
-            voice_response.append(start)
+            logger.debug(
+                "twilio_media_streams.webhook.twilio_response",
+                twilio_response=str(voice_response),
+            )
 
             return response.text(str(voice_response), content_type="text/xml")
 
@@ -171,3 +216,36 @@ class TwilioMediaStreamsInputChannel(VoiceInputChannel):
             await self.run_audio_streaming(on_new_message, ws)
 
         return blueprint
+
+    def _websocket_stream_url(self) -> str:
+        """Returns the websocket stream URL."""
+        # depending on the config value, the url might contain http as a
+        # protocol or not - we'll make sure both work
+        if self.server_url.startswith("http"):
+            base_url = self.server_url.replace("http", "ws")
+        else:
+            base_url = f"wss://{self.server_url}"
+        return f"{base_url}/{TWILIO_MEDIA_STREAMS_WEBSOCKET_PATH}"
+
+    def _build_twilio_response(self, request: Request) -> VoiceResponse:
+        from twilio.twiml.voice_response import Connect, VoiceResponse
+
+        voice_response = VoiceResponse()
+        start = Connect()
+        stream = start.stream(url=self._websocket_stream_url())
+        # pass information about the call to the webhook - so we can
+        # store it in the input channel
+        stream.parameter(
+            name="call_id", value=request.form.get(CALL_SID_REQUEST_KEY, None)
+        )
+        stream.parameter(
+            name="user_phone", value=request.form.get(FROM_NUMBER_REQUEST_KEY, None)
+        )
+        stream.parameter(
+            name="bot_phone", value=request.form.get(TO_NUMBER_REQUEST_KEY, None)
+        )
+        stream.parameter(
+            name="direction", value=request.form.get(DIRECTION_REQUEST_KEY, None)
+        )
+        voice_response.append(start)
+        return voice_response

rasa/core/channels/voice_stream/voice_channel.py

@@ -22,6 +22,7 @@ from rasa.core.channels.voice_stream.asr.asr_event import (
     ASREvent,
     NewTranscript,
     UserIsSpeaking,
+    UserSilence,
 )
 from sanic import Websocket  # type: ignore
 
@@ -244,13 +245,7 @@ class VoiceInputChannel(InputChannel):
         self.monitor_silence = monitor_silence
         self.tts_cache = TTSCache(tts_config.get("cache_size", 1000))
 
-    async def handle_silence_timeout(
-        self,
-        voice_websocket: Websocket,
-        on_new_message: Callable[[UserMessage], Awaitable[Any]],
-        tts_engine: TTSEngine,
-        call_parameters: CallParameters,
-    ) -> None:
+    async def monitor_silence_timeout(self, asr_event_queue: asyncio.Queue) -> None:
         timeout = call_state.silence_timeout
         if not timeout:
             return
@@ -258,16 +253,8 @@ class VoiceInputChannel(InputChannel):
             return
         logger.debug("voice_channel.silence_timeout_watch_started", timeout=timeout)
         await asyncio.sleep(timeout)
+        await asr_event_queue.put(UserSilence())
         logger.debug("voice_channel.silence_timeout_tripped")
-        output_channel = self.create_output_channel(voice_websocket, tts_engine)
-        message = UserMessage(
-            "/silence_timeout",
-            output_channel,
-            call_parameters.stream_id,
-            input_channel=self.name(),
-            metadata=asdict(call_parameters),
-        )
-        await on_new_message(message)
 
     @staticmethod
     def _cancel_silence_timeout_watcher() -> None:
@@ -328,6 +315,7 @@ class VoiceInputChannel(InputChannel):
         _call_state.set(CallState())
         asr_engine = asr_engine_from_config(self.asr_config)
         tts_engine = tts_engine_from_config(self.tts_config)
+        asr_event_queue: asyncio.Queue = asyncio.Queue()
         await asr_engine.connect()
 
         call_parameters = await self.collect_call_parameters(channel_websocket)
@@ -354,12 +342,7 @@ class VoiceInputChannel(InputChannel):
                     self._cancel_silence_timeout_watcher()
                     call_state.silence_timeout_watcher = (  # type: ignore[attr-defined]
                         asyncio.create_task(
-                            self.handle_silence_timeout(
-                                channel_websocket,
-                                on_new_message,
-                                tts_engine,
-                                call_parameters,
-                            )
+                            self.monitor_silence_timeout(asr_event_queue)
                         )
                     )
                 if isinstance(channel_action, NewAudioAction):
@@ -368,8 +351,13 @@ class VoiceInputChannel(InputChannel):
                     # end stream event came from the other side
                     break
 
-        async def consume_asr_events() -> None:
+        async def receive_asr_events() -> None:
             async for event in asr_engine.stream_asr_events():
+                await asr_event_queue.put(event)
+
+        async def handle_asr_events() -> None:
+            while True:
+                event = await asr_event_queue.get()
                 await self.handle_asr_event(
                     event,
                     channel_websocket,
@@ -378,16 +366,18 @@ class VoiceInputChannel(InputChannel):
                     call_parameters,
                 )
 
-        audio_forwarding_task = asyncio.create_task(consume_audio_bytes())
-        asr_event_task = asyncio.create_task(consume_asr_events())
+        tasks = [
+            asyncio.create_task(consume_audio_bytes()),
+            asyncio.create_task(receive_asr_events()),
+            asyncio.create_task(handle_asr_events()),
+        ]
         await asyncio.wait(
-            [audio_forwarding_task, asr_event_task],
+            tasks,
             return_when=asyncio.FIRST_COMPLETED,
         )
-        if not audio_forwarding_task.done():
-            audio_forwarding_task.cancel()
-        if not asr_event_task.done():
-            asr_event_task.cancel()
+        for task in tasks:
+            if not task.done():
+                task.cancel()
         await tts_engine.close_connection()
         await asr_engine.close_connection()
         await channel_websocket.close()
@@ -425,3 +415,13 @@ class VoiceInputChannel(InputChannel):
         elif isinstance(e, UserIsSpeaking):
             self._cancel_silence_timeout_watcher()
             call_state.is_user_speaking = True  # type: ignore[attr-defined]
+        elif isinstance(e, UserSilence):
+            output_channel = self.create_output_channel(voice_websocket, tts_engine)
+            message = UserMessage(
+                "/silence_timeout",
+                output_channel,
+                call_parameters.stream_id,
+                input_channel=self.name(),
+                metadata=asdict(call_parameters),
+            )
+            await on_new_message(message)

rasa/core/policies/intentless_policy.py

@@ -1,7 +1,7 @@
 import importlib.resources
 import math
 from dataclasses import dataclass, field
-from typing import Any, Dict, List, Optional, Set, TYPE_CHECKING, Text, Tuple
+from typing import Any, Dict, List, Optional, TYPE_CHECKING, Text, Tuple
 
 import structlog
 import tiktoken
@@ -18,7 +18,6 @@ from rasa.core.constants import (
     UTTER_SOURCE_METADATA_KEY,
 )
 from rasa.core.policies.policy import Policy, PolicyPrediction, SupportedData
-from rasa.dialogue_understanding.patterns.chitchat import FLOW_PATTERN_CHITCHAT
 from rasa.dialogue_understanding.stack.frames import (
     ChitChatStackFrame,
     DialogueStackFrame,
@@ -30,7 +29,6 @@ from rasa.engine.storage.storage import ModelStorage
 from rasa.graph_components.providers.forms_provider import Forms
 from rasa.graph_components.providers.responses_provider import Responses
 from rasa.shared.constants import (
-    REQUIRED_SLOTS_KEY,
     EMBEDDINGS_CONFIG_KEY,
     LLM_CONFIG_KEY,
     MODEL_CONFIG_KEY,
@@ -42,7 +40,6 @@ from rasa.shared.constants import (
     MODEL_GROUP_ID_CONFIG_KEY,
 )
 from rasa.shared.core.constants import ACTION_LISTEN_NAME
-from rasa.shared.core.constants import ACTION_TRIGGER_CHITCHAT
 from rasa.shared.core.domain import KEY_RESPONSES_TEXT, Domain
 from rasa.shared.core.events import (
     ActionExecuted,
@@ -52,6 +49,7 @@ from rasa.shared.core.events import (
 )
 from rasa.shared.core.flows import FlowsList
 from rasa.shared.core.generator import TrackerWithCachedStates
+from rasa.shared.core.policies.utils import filter_responses_for_intentless_policy
 from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.shared.exceptions import FileIOException, RasaCoreException
 from rasa.shared.nlu.constants import PREDICTED_CONFIDENCE_KEY
@@ -147,59 +145,6 @@ class Conversation:
     interactions: List[Interaction] = field(default_factory=list)
 
 
-def collect_form_responses(forms: Forms) -> Set[Text]:
-    """Collect responses that belong the requested slots in forms.
-
-    Args:
-        forms: the forms from the domain
-    Returns:
-        all utterances used in forms
-    """
-    form_responses = set()
-    for _, form_info in forms.data.items():
-        for required_slot in form_info.get(REQUIRED_SLOTS_KEY, []):
-            form_responses.add(f"utter_ask_{required_slot}")
-    return form_responses
-
-
-def filter_responses(responses: Responses, forms: Forms, flows: FlowsList) -> Responses:
-    """Filters out responses that are unwanted for the intentless policy.
-
-    This includes utterances used in flows and forms.
-
-    Args:
-        responses: the responses from the domain
-        forms: the forms from the domain
-        flows: all flows
-    Returns:
-        The remaining, relevant responses for the intentless policy.
-    """
-    form_responses = collect_form_responses(forms)
-    flow_responses = flows.utterances
-    combined_responses = form_responses | flow_responses
-    filtered_responses = {
-        name: variants
-        for name, variants in responses.data.items()
-        if name not in combined_responses
-    }
-
-    pattern_chitchat = flows.flow_by_id(FLOW_PATTERN_CHITCHAT)
-
-    # The following condition is highly unlikely, but mypy requires the case
-    # of pattern_chitchat == None to be addressed
-    if not pattern_chitchat:
-        return Responses(data=filtered_responses)
-
-    # if action_trigger_chitchat, filter out "utter_free_chitchat_response"
-    has_action_trigger_chitchat = pattern_chitchat.has_action_step(
-        ACTION_TRIGGER_CHITCHAT
-    )
-    if has_action_trigger_chitchat:
-        filtered_responses.pop("utter_free_chitchat_response", None)
-
-    return Responses(data=filtered_responses)
-
-
 def action_from_response(
     text: Optional[str], responses: Dict[Text, List[Dict[Text, Any]]]
 ) -> Optional[str]:
@@ -513,7 +458,9 @@ class IntentlessPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Policy):
         # Perform health checks of both LLM and embeddings client configs
         self._perform_health_checks(self.config, "intentless_policy.train")
 
-        responses = filter_responses(responses, forms, flows or FlowsList([]))
+        responses = filter_responses_for_intentless_policy(
+            responses, forms, flows or FlowsList([])
+        )
         telemetry.track_intentless_policy_train()
         response_texts = [r for r in extract_ai_response_examples(responses.data)]
 
@@ -948,7 +895,6 @@ class IntentlessPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Policy):
         **kwargs: Any,
     ) -> "IntentlessPolicy":
         """Loads a trained policy (see parent class for full docstring)."""
-
         # Perform health checks of both LLM and embeddings client configs
         cls._perform_health_checks(config, "intentless_policy.load")
 

rasa/dialogue_understanding/generator/nlu_command_adapter.py

@@ -139,7 +139,7 @@ class NLUCommandAdapter(GraphComponent, CommandGenerator):
 
         if commands:
             commands = clean_up_commands(
-                commands, tracker, flows, self._execution_context
+                commands, tracker, flows, self._execution_context, domain
             )
             log_llm(
                 logger=structlogger,

rasa/dialogue_understanding/processor/command_processor.py

@@ -41,9 +41,11 @@ from rasa.shared.constants import (
 )
 from rasa.shared.core.constants import ACTION_TRIGGER_CHITCHAT, SlotMappingType
 from rasa.shared.core.constants import FLOW_HASHES_SLOT
+from rasa.shared.core.domain import Domain
 from rasa.shared.core.events import Event, SlotSet
 from rasa.shared.core.flows import FlowsList
 from rasa.shared.core.flows.steps.collect import CollectInformationFlowStep
+from rasa.shared.core.policies.utils import contains_intentless_policy_responses
 from rasa.shared.core.slots import Slot
 from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.shared.nlu.constants import COMMANDS
@@ -182,6 +184,7 @@ def execute_commands(
     all_flows: FlowsList,
     execution_context: ExecutionContext,
     story_graph: Optional[StoryGraph] = None,
+    domain: Optional[Domain] = None,
 ) -> List[Event]:
     """Executes a list of commands.
 
@@ -191,6 +194,7 @@ def execute_commands(
         all_flows: All flows.
         execution_context: Information about the single graph run.
         story_graph: StoryGraph object with stories available for training.
+        domain: The domain of the bot.
 
     Returns:
         A list of the events that were created.
@@ -199,7 +203,7 @@ def execute_commands(
     original_tracker = tracker.copy()
 
     commands = clean_up_commands(
-        commands, tracker, all_flows, execution_context, story_graph
+        commands, tracker, all_flows, execution_context, story_graph, domain
     )
 
     updated_flows = find_updated_flows(tracker, all_flows)
@@ -333,6 +337,7 @@ def clean_up_commands(
     all_flows: FlowsList,
     execution_context: ExecutionContext,
     story_graph: Optional[StoryGraph] = None,
+    domain: Optional[Domain] = None,
 ) -> List[Command]:
     """Clean up a list of commands.
 
@@ -348,10 +353,13 @@ def clean_up_commands(
         all_flows: All flows.
         execution_context: Information about a single graph run.
         story_graph: StoryGraph object with stories available for training.
+        domain: The domain of the bot.
 
     Returns:
     The cleaned up commands.
     """
+    domain = domain if domain else Domain.empty()
+
     slots_so_far, active_flow = filled_slots_for_active_flow(tracker, all_flows)
 
     clean_commands: List[Command] = []
@@ -394,7 +402,12 @@ def clean_up_commands(
         # handle chitchat command differently from other free-form answer commands
         elif isinstance(command, ChitChatAnswerCommand):
             clean_commands = clean_up_chitchat_command(
-                clean_commands, command, all_flows, execution_context, story_graph
+                clean_commands,
+                command,
+                all_flows,
+                execution_context,
+                domain,
+                story_graph,
             )
 
         elif isinstance(command, FreeFormAnswerCommand):
@@ -590,6 +603,7 @@ def clean_up_chitchat_command(
     command: ChitChatAnswerCommand,
     flows: FlowsList,
     execution_context: ExecutionContext,
+    domain: Domain,
     story_graph: Optional[StoryGraph] = None,
 ) -> List[Command]:
     """Clean up a chitchat answer command.
@@ -603,6 +617,8 @@ def clean_up_chitchat_command(
         flows: All flows.
         execution_context: Information about a single graph run.
         story_graph: StoryGraph object with stories available for training.
+        domain: The domain of the bot.
+
     Returns:
         The cleaned up commands.
     """
@@ -628,10 +644,9 @@ def clean_up_chitchat_command(
     )
     defines_intentless_policy = execution_context.has_node(IntentlessPolicy)
 
-    has_e2e_stories = True if (story_graph and story_graph.has_e2e_stories()) else False
-
     if (has_action_trigger_chitchat and not defines_intentless_policy) or (
-        defines_intentless_policy and not has_e2e_stories
+        defines_intentless_policy
+        and not contains_intentless_policy_responses(flows, domain, story_graph)
     ):
         resulting_commands.insert(
             0, CannotHandleCommand(RASA_PATTERN_CANNOT_HANDLE_CHITCHAT)

rasa/dialogue_understanding/processor/command_processor_component.py

@@ -6,6 +6,7 @@ import rasa.dialogue_understanding.processor.command_processor
 from rasa.engine.graph import ExecutionContext, GraphComponent
 from rasa.engine.storage.resource import Resource
 from rasa.engine.storage.storage import ModelStorage
+from rasa.shared.core.domain import Domain
 from rasa.shared.core.events import Event
 from rasa.shared.core.flows import FlowsList
 from rasa.shared.core.trackers import DialogueStateTracker
@@ -15,7 +16,8 @@ from rasa.shared.core.training_data.structures import StoryGraph
 class CommandProcessorComponent(GraphComponent):
     """Processes commands by issuing events to modify a tracker.
 
-    Minimal component that applies commands to a tracker."""
+    Minimal component that applies commands to a tracker.
+    """
 
     def __init__(self, execution_context: ExecutionContext):
         self._execution_context = execution_context
@@ -36,8 +38,9 @@ class CommandProcessorComponent(GraphComponent):
         tracker: DialogueStateTracker,
         flows: FlowsList,
         story_graph: StoryGraph,
+        domain: Domain,
     ) -> List[Event]:
         """Execute commands to update tracker state."""
         return rasa.dialogue_understanding.processor.command_processor.execute_commands(
-            tracker, flows, self._execution_context, story_graph
+            tracker, flows, self._execution_context, story_graph, domain
         )

rasa/e2e_test/utils/validation.py

@@ -6,6 +6,7 @@ import structlog
 
 import rasa.shared.utils.io
 from rasa.e2e_test.constants import SCHEMA_FILE_PATH
+from rasa.exceptions import ModelNotFound
 from rasa.shared.utils.yaml import read_schema_file
 
 if TYPE_CHECKING:
@@ -54,10 +55,9 @@ def validate_model_path(model_path: Optional[str], parameter: str, default: str)
         return model_path
 
     if model_path and not Path(model_path).exists():
-        rasa.shared.utils.io.raise_warning(
+        raise ModelNotFound(
             f"The provided model path '{model_path}' could not be found. "
-            f"Using default location '{default}' instead.",
-            UserWarning,
+            "Provide an existing model path."
         )
 
     elif model_path is None:

rasa/engine/validation.py

@@ -84,8 +84,10 @@ from rasa.shared.constants import (
 )
 from rasa.shared.core.constants import ACTION_RESET_ROUTING, ACTION_TRIGGER_CHITCHAT
 from rasa.shared.core.domain import Domain
-from rasa.shared.core.flows import FlowsList, Flow
+from rasa.shared.core.flows import Flow, FlowsList
+from rasa.shared.core.policies.utils import contains_intentless_policy_responses
 from rasa.shared.core.slots import Slot
+from rasa.shared.core.training_data.structures import StoryGraph
 from rasa.shared.exceptions import RasaException
 from rasa.shared.nlu.training_data.message import Message
 
@@ -640,11 +642,18 @@ def _recursively_check_required_components(
 
 
 def validate_flow_component_dependencies(
-    flows: FlowsList, model_configuration: GraphModelConfiguration
+    flows: FlowsList,
+    domain: Domain,
+    story_graph: StoryGraph,
+    model_configuration: GraphModelConfiguration,
 ) -> None:
     if (pattern_chitchat := flows.flow_by_id(FLOW_PATTERN_CHITCHAT)) is not None:
         _validate_chitchat_dependencies(pattern_chitchat, model_configuration)
 
+    _validate_intentless_policy_responses(
+        flows, domain, story_graph, model_configuration
+    )
+
 
 def _validate_chitchat_dependencies(
     pattern_chitchat: Flow, model_configuration: GraphModelConfiguration
@@ -672,6 +681,32 @@ def _validate_chitchat_dependencies(
         )
 
 
+def _validate_intentless_policy_responses(
+    flows: FlowsList,
+    domain: Domain,
+    story_graph: StoryGraph,
+    model_configuration: GraphModelConfiguration,
+) -> None:
+    """If IntentlessPolicy is configured, validate that it has responses to use:
+    either responses from the domain that are not part of any flow, or from
+    end-to-end stories.
+    """
+    if not model_configuration.predict_schema.has_node(IntentlessPolicy):
+        return
+
+    if not contains_intentless_policy_responses(flows, domain, story_graph):
+        structlogger.error(
+            "validation.intentless_policy.no_applicable_responses_found",
+            event_info=(
+                "IntentlessPolicy is configured, but no applicable responses are "
+                "found. Please make sure that there are responses defined in the "
+                "domain that are not part of any flow, or that there are "
+                "end-to-end stories in the training data."
+            ),
+        )
+        sys.exit(1)
+
+
 def get_component_index(schema: GraphSchema, component_class: Type) -> Optional[int]:
     """Extracts the index of a component of the given class in the schema.
     This function assumes that each component's node name is stored in a way

rasa/model_training.py

@@ -312,6 +312,7 @@ async def _train_graph(
     )
     flows = file_importer.get_flows()
     domain = file_importer.get_domain()
+    story_graph = file_importer.get_stories()
     model_configuration = recipe.graph_config_for_recipe(
         config,
         kwargs,
@@ -327,7 +328,7 @@ async def _train_graph(
         config
     )
     rasa.engine.validation.validate_flow_component_dependencies(
-        flows, model_configuration
+        flows, domain, story_graph, model_configuration
     )
     rasa.engine.validation.validate_command_generator_setup(model_configuration)
 

rasa/shared/constants.py

@@ -98,6 +98,8 @@ UTTER_ASK_PREFIX = "utter_ask_"
 ACTION_ASK_PREFIX = "action_ask_"
 FLOW_PREFIX = "flow_"
 
+UTTER_FREE_CHITCHAT_RESPONSE = "utter_free_chitchat_response"
+
 ASSISTANT_ID_KEY = "assistant_id"
 ASSISTANT_ID_DEFAULT_VALUE = "placeholder_default"
 
@@ -113,6 +115,7 @@ CONFIG_KEYS = CONFIG_KEYS_CORE + CONFIG_KEYS_NLU
 CONFIG_MANDATORY_KEYS_CORE: List[Text] = [] + CONFIG_MANDATORY_COMMON_KEYS
 CONFIG_MANDATORY_KEYS_NLU = ["language"] + CONFIG_MANDATORY_COMMON_KEYS
 CONFIG_MANDATORY_KEYS = CONFIG_MANDATORY_KEYS_CORE + CONFIG_MANDATORY_KEYS_NLU
+CONFIG_RECIPE_KEY = "recipe"
 
 # Keys related to Forms (in the Domain)
 REQUIRED_SLOTS_KEY = "required_slots"