rasa-pro 3.14.0.dev5__py3-none-any.whl → 3.14.0.dev6__py3-none-any.whl

rasa/core/policies/flows/mcp_tool_executor.py

@@ -0,0 +1,277 @@
+import json
+import operator
+from functools import reduce
+from typing import Any, Dict, List, Optional
+
+import structlog
+from mcp.types import CallToolResult
+
+from rasa.core.available_endpoints import AvailableEndpoints
+from rasa.core.policies.flows.flow_step_result import (
+    ContinueFlowWithNextStep,
+    FlowStepResult,
+)
+from rasa.dialogue_understanding.patterns.internal_error import (
+    InternalErrorPatternFlowStackFrame,
+)
+from rasa.dialogue_understanding.stack.dialogue_stack import DialogueStack
+from rasa.shared.core.events import Event, SlotSet
+from rasa.shared.core.flows.steps import CallFlowStep
+from rasa.shared.core.trackers import DialogueStateTracker
+from rasa.shared.utils.mcp.server_connection import MCPServerConnection
+from rasa.utils.common import ensure_jsonified_iterable
+
+structlogger = structlog.get_logger()
+
+CONFIG_RESULT_KEY = "result_key"
+CONFIG_SLOT = "slot"
+
+
+async def call_mcp_tool(
+    initial_events: List[Event],
+    stack: DialogueStack,
+    step: CallFlowStep,
+    tracker: DialogueStateTracker,
+) -> FlowStepResult:
+    """Run an MCP tool call step."""
+    structlogger.debug(
+        "flow.step.call_mcp_tool",
+        tool_id=step.call,
+        mcp_server=step.mcp_server,
+        mapping=step.mapping,
+        step_id=step.id,
+        flow_id=step.flow_id,
+    )
+
+    try:
+        return await _execute_mcp_tool_call(initial_events, stack, step, tracker)
+    except Exception as e:
+        return _handle_mcp_tool_error(
+            stack,
+            initial_events,
+            error_message=f"Failed to execute MCP tool call: {e}.",
+            tool_name=step.call,
+            mcp_server=step.mcp_server,
+        )
+
+
+async def _execute_mcp_tool_call(
+    initial_events: List[Event],
+    stack: DialogueStack,
+    step: CallFlowStep,
+    tracker: DialogueStateTracker,
+) -> FlowStepResult:
+    """Execute the MCP tool call with proper error handling."""
+    mcp_server_connection = None
+    try:
+        # Connect to the MCP server
+        mcp_server_connection = await _connect_to_mcp_server(step.mcp_server)
+
+        if not mcp_server_connection:
+            return _handle_mcp_tool_error(
+                stack,
+                initial_events,
+                f"Cannot connect to MCP server '{step.mcp_server}'.",
+                tool_name=step.call,
+                mcp_server=step.mcp_server,
+            )
+
+        # Validate tool availability
+        if not await _is_tool_available(mcp_server_connection, step.call):
+            return _handle_mcp_tool_error(
+                stack,
+                initial_events,
+                f"Tool '{step.call}' is not available on MCP server "
+                f"'{step.mcp_server}'.",
+                tool_name=step.call,
+                mcp_server=step.mcp_server,
+            )
+
+        # This should not happen, but we need to check for type checking to pass
+        if not step.mapping:
+            return _handle_mcp_tool_error(
+                stack,
+                initial_events,
+                f"No mapping found for tool '{step.call}'.",
+                tool_name=step.call,
+                mcp_server=step.mcp_server,
+            )
+
+        # Prepare arguments for the tool call
+        arguments = _prepare_tool_arguments(step.mapping["input"], tracker)
+
+        # Call the tool with parameters
+        mcp_server = await mcp_server_connection.ensure_active_session()
+        result = await mcp_server.call_tool(step.call, arguments)
+
+        # Handle tool execution result
+        if result is None or result.isError:
+            return _handle_mcp_tool_error(
+                stack,
+                initial_events,
+                f"Tool '{step.call}' execution failed: {result.content}.",
+                tool_name=step.call,
+                mcp_server=step.mcp_server,
+            )
+        elif not result.content:
+            structlogger.warning(
+                "call_mcp_tool.empty_tool_result",
+                tool_name=step.call,
+                mcp_server=step.mcp_server,
+            )
+        else:
+            structlogger.debug(
+                "call_mcp_tool.tool_execution_success",
+                tool_name=step.call,
+                mcp_server=step.mcp_server,
+                result_content=result.content,
+                result_structured_content=result.structuredContent,
+            )
+
+            # Process successful result
+            if set_slot_event := _process_tool_result(result, step.mapping["output"]):
+                initial_events.extend(set_slot_event)
+            else:
+                return _handle_mcp_tool_error(
+                    stack,
+                    initial_events,
+                    f"Failed to process tool result for '{step.call}'.",
+                    tool_name=step.call,
+                    mcp_server=step.mcp_server,
+                )
+
+        return ContinueFlowWithNextStep(events=initial_events)
+
+    finally:
+        # Always clean up the connection to prevent resource leaks
+        if mcp_server_connection:
+            try:
+                await mcp_server_connection.close()
+            except Exception as e:
+                structlogger.warning(
+                    "call_mcp_tool.connection_cleanup_failed",
+                    tool_name=step.call,
+                    mcp_server=step.mcp_server,
+                    error=str(e),
+                )
+
+
+async def _is_tool_available(
+    mcp_server_connection: MCPServerConnection, tool_name: str
+) -> bool:
+    """Check if the specified tool is available on the MCP server."""
+    try:
+        # Get the active session from the connection
+        mcp_server = await mcp_server_connection.ensure_active_session()
+        available_tools = await mcp_server.list_tools()
+        tool_names = [tool.name for tool in available_tools.tools]
+        return tool_name in tool_names
+    except Exception as e:
+        structlogger.warning(
+            "call_mcp_tool.tool_availability_check_failed",
+            tool_name=tool_name,
+            error=str(e),
+        )
+        return False
+
+
+async def _connect_to_mcp_server(
+    mcp_server_name: Optional[str],
+) -> Optional[MCPServerConnection]:
+    """Connect to the MCP server."""
+    if not mcp_server_name:
+        return None
+
+    # get the MCP server config from the available endpoints
+    endpoints = AvailableEndpoints.get_instance()
+    mcp_servers = endpoints.mcp_servers
+    if not mcp_servers:
+        return None
+
+    mcp_server_configs = [
+        mcp_server for mcp_server in mcp_servers if mcp_server.name == mcp_server_name
+    ]
+    if not mcp_server_configs or len(mcp_server_configs) != 1:
+        return None
+
+    mcp_server_config = mcp_server_configs[0]
+    mcp_server_connection = MCPServerConnection(
+        mcp_server_config.name, mcp_server_config.url, mcp_server_config.type
+    )
+
+    # Ensure the connection is established and return the connection object
+    await mcp_server_connection.ensure_active_session()
+    return mcp_server_connection
+
+
+def _prepare_tool_arguments(
+    input_mapping: List[Dict[str, str]], tracker: DialogueStateTracker
+) -> Dict[str, Any]:
+    """Prepare arguments for the tool call from slot values."""
+    arguments = {}
+    for argument in input_mapping:
+        slot_value = tracker.get_slot(argument["slot"])
+        arguments[argument["param"]] = slot_value
+    return arguments
+
+
+def _jsonify_slot_value(value: Any) -> str | int | float | bool | None:
+    """Prepare value for SlotSet: iterables -> JSON string, primitives -> as-is"""
+    if isinstance(value, (list, dict)) and len(value):
+        return json.dumps(ensure_jsonified_iterable(value))
+    return value
+
+
+def _process_tool_result(
+    result: CallToolResult,
+    output_mapping: List[Dict[str, str]],
+) -> Optional[List[SlotSet]]:
+    """Create a SetSlot event for the tool result."""
+    try:
+        _result_as_dict = {"result": result.model_dump()}
+        slots = []
+        for mapping in output_mapping:
+            try:
+                # Use reduce to navigate through nested keys in the result
+                slot_value = reduce(
+                    operator.getitem,
+                    mapping[CONFIG_RESULT_KEY].split("."),
+                    _result_as_dict,
+                )
+                slots.append(
+                    SlotSet(mapping[CONFIG_SLOT], _jsonify_slot_value(slot_value))
+                )
+            except (KeyError, TypeError):
+                structlogger.error(
+                    "call_mcp_tool.result_key_not_found_in_tool_result",
+                    slot=mapping[CONFIG_SLOT],
+                    result_key=mapping[CONFIG_RESULT_KEY],
+                    result=_result_as_dict,
+                )
+                return None
+        return slots
+    except Exception as e:
+        structlogger.error(
+            "call_mcp_tool.result_processing_failed",
+            error=str(e),
+            result=result,
+        )
+        return None
+
+
+def _handle_mcp_tool_error(
+    stack: DialogueStack,
+    events: List[Event],
+    error_message: str,
+    tool_name: str,
+    mcp_server: Optional[str],
+) -> FlowStepResult:
+    """Handle MCP tool errors consistently."""
+    structlogger.error(
+        "call_mcp_tool.error",
+        error_message=error_message,
+        tool_name=tool_name,
+        mcp_server=mcp_server,
+    )
+    stack.push(InternalErrorPatternFlowStackFrame())
+    return ContinueFlowWithNextStep(events=events)

rasa/core/policies/intentless_policy.py

@@ -5,7 +5,7 @@ from typing import TYPE_CHECKING, Any, Dict, List, Optional, Text, Tuple
 
 import structlog
 import tiktoken
-from deprecated import deprecated  # type: ignore[import]
+from deprecated import deprecated  # type: ignore[import-untyped]
 from jinja2 import Template
 from langchain.docstore.document import Document
 from langchain.schema.embeddings import Embeddings

rasa/core/policies/unexpected_intent_policy.py

@@ -624,6 +624,7 @@ class UnexpecTEDIntentPolicy(TEDPolicy):
         query_intent = (
             last_user_uttered_event.intent_name
             if last_user_uttered_event is not None
+            and isinstance(last_user_uttered_event, UserUttered)
             else ""
         )
         is_unlikely_intent = self._check_unlikely_intent(

rasa/core/processor.py

@@ -69,6 +69,7 @@ from rasa.shared.constants import (
     UTTER_PREFIX,
 )
 from rasa.shared.core.constants import (
+    ACTION_AGENT_REQUEST_USER_INPUT_NAME,
     ACTION_CORRECT_FLOW_SLOT,
     ACTION_EXTRACT_SLOTS,
     ACTION_LISTEN_NAME,
@@ -729,7 +730,7 @@ class MessageProcessor:
         if not self.domain or self.domain.is_empty():
             return
 
-        intent = parse_data["intent"][INTENT_NAME_KEY]
+        intent = parse_data[INTENT][INTENT_NAME_KEY]
         if intent and intent not in self.domain.intents:
             rasa.shared.utils.io.raise_warning(
                 f"Parsed an intent '{intent}' "
@@ -738,7 +739,7 @@ class MessageProcessor:
                 docs=DOCS_URL_DOMAINS,
             )
 
-        entities = parse_data["entities"] or []
+        entities = parse_data[ENTITIES] or []
         for element in entities:
             entity = element["entity"]
             if entity and entity not in self.domain.entities:
@@ -822,9 +823,9 @@ class MessageProcessor:
         self._update_full_retrieval_intent(parse_data)
         structlogger.debug(
             "processor.message.parse",
-            parse_data_text=copy.deepcopy(parse_data["text"]),
-            parse_data_intent=parse_data["intent"],
-            parse_data_entities=copy.deepcopy(parse_data["entities"]),
+            parse_data_text=copy.deepcopy(parse_data[TEXT]),
+            parse_data_intent=parse_data[INTENT],
+            parse_data_entities=copy.deepcopy(parse_data[ENTITIES]),
         )
 
         self._check_for_unseen_features(parse_data)
@@ -973,7 +974,7 @@ class MessageProcessor:
                     f"invalid intent: {parse_data[INTENT]['name']}. "
                     f"Returning CannotHandleCommand() as a fallback."
                 ),
-                invalid_intent=parse_data[INTENT]["name"],
+                invalid_intent=parse_data[INTENT][INTENT_NAME_KEY],
             )
             commands.append(
                 CannotHandleCommand(RASA_PATTERN_CANNOT_HANDLE_INVALID_INTENT)
@@ -983,7 +984,7 @@ class MessageProcessor:
 
     def _contains_undefined_intent(self, message: Message) -> bool:
         """Checks if the message contains an undefined intent."""
-        intent_name = message.get(INTENT, {}).get("name")
+        intent_name = message.get(INTENT, {}).get(INTENT_NAME_KEY)
         return intent_name is not None and intent_name not in self.domain.intents
 
     async def _parse_message_with_graph(
@@ -1033,8 +1034,8 @@ class MessageProcessor:
         tracker.update(
             UserUttered(
                 message.text,
-                parse_data["intent"],
-                parse_data["entities"],
+                parse_data[INTENT],
+                parse_data[ENTITIES],
                 parse_data,
                 input_channel=message.input_channel,
                 message_id=message.message_id,
@@ -1043,7 +1044,7 @@ class MessageProcessor:
             self.domain,
         )
 
-        if parse_data["entities"]:
+        if parse_data[ENTITIES]:
             self._log_slots(tracker)
 
         plugin_manager().hook.after_new_user_message(tracker=tracker)
@@ -1194,7 +1195,11 @@ class MessageProcessor:
             `False` if `action_name` is `ACTION_LISTEN_NAME` or
             `ACTION_SESSION_START_NAME`, otherwise `True`.
         """
-        return action_name not in (ACTION_LISTEN_NAME, ACTION_SESSION_START_NAME)
+        return action_name not in (
+            ACTION_LISTEN_NAME,
+            ACTION_SESSION_START_NAME,
+            ACTION_AGENT_REQUEST_USER_INPUT_NAME,
+        )
 
     async def execute_side_effects(
         self,
@@ -1467,11 +1472,9 @@ class MessageProcessor:
             # tracker has never expired if sessions are disabled
             return False
 
-        user_uttered_event: Optional[UserUttered] = tracker.get_last_event_for(
-            UserUttered
-        )
+        user_uttered_event = tracker.get_last_event_for(UserUttered)
 
-        if not user_uttered_event:
+        if not user_uttered_event or not isinstance(user_uttered_event, UserUttered):
             # there is no user event so far so the session should not be considered
             # expired
             return False

rasa/core/run.py

@@ -30,6 +30,7 @@ from rasa import server, telemetry
 from rasa.constants import ENV_SANIC_BACKLOG
 from rasa.core import agent, channels, constants
 from rasa.core.agent import Agent
+from rasa.core.available_agents import AvailableAgents
 from rasa.core.available_endpoints import AvailableEndpoints
 from rasa.core.channels import console
 from rasa.core.channels.channel import InputChannel
@@ -42,20 +43,10 @@ from rasa.utils import licensing
 logger = logging.getLogger()  # get the root logger
 
 
-def create_input_channels(
+def create_http_input_channels(
     channel: Optional[Text], credentials_file: Optional[Text]
 ) -> List[InputChannel]:
-    """Instantiate the chosen input channel.
-
-    Args:
-        channel (optional): The name of the specific input channel to create.
-        credentials_file: Path to the credentials file containing channel credentials.
-
-    Returns:
-        A list of instantiated input channels. If a specific channel is provided,
-        it returns a list with that single channel. If no channel is specified,
-        it returns a list of all channels defined in the credentials file.
-    """
+    """Instantiate the chosen input channel."""
     if credentials_file:
         all_credentials = read_config_file(credentials_file)
     else:
@@ -151,6 +142,7 @@ def configure_app(
     route: Optional[Text] = "/webhooks/",
     port: int = constants.DEFAULT_SERVER_PORT,
     endpoints: Optional[AvailableEndpoints] = None,
+    sub_agents: Optional[AvailableAgents] = None,
     log_file: Optional[Text] = None,
     conversation_id: Optional[Text] = uuid.uuid4().hex,
     use_syslog: bool = False,
@@ -179,6 +171,7 @@ def configure_app(
                 jwt_private_key=jwt_private_key,
                 jwt_method=jwt_method,
                 endpoints=endpoints,
+                sub_agents=sub_agents,
                 is_inspector_enabled=is_inspector_enabled,
             )
         )
@@ -243,6 +236,7 @@ def serve_application(
     jwt_private_key: Optional[Text] = None,
     jwt_method: Optional[Text] = None,
     endpoints: Optional[AvailableEndpoints] = None,
+    sub_agents: Optional[AvailableAgents] = None,
     remote_storage: Optional[StorageType] = None,
     log_file: Optional[Text] = None,
     ssl_certificate: Optional[Text] = None,
@@ -263,7 +257,7 @@ def serve_application(
     if not channel and not credentials:
         channel = "cmdline"
 
-    input_channels = create_input_channels(channel, credentials)
+    input_channels = create_http_input_channels(channel, credentials)
 
     if inspect:
         logger.info("Starting development inspector.")
@@ -283,6 +277,7 @@ def serve_application(
         jwt_method,
         port=port,
         endpoints=endpoints,
+        sub_agents=sub_agents,
         log_file=log_file,
         conversation_id=conversation_id,
         use_syslog=use_syslog,
@@ -302,7 +297,7 @@ 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),
+        partial(load_agent_on_start, model_path, endpoints, remote_storage, sub_agents),
         "before_server_start",
     )
 
@@ -340,6 +335,7 @@ async def load_agent_on_start(
     model_path: Text,
     endpoints: AvailableEndpoints,
     remote_storage: Optional[StorageType],
+    sub_agents: Optional[AvailableAgents],
     app: Sanic,
     loop: AbstractEventLoop,
 ) -> Agent:
@@ -352,6 +348,7 @@ async def load_agent_on_start(
         model_path=model_path,
         remote_storage=remote_storage,
         endpoints=endpoints,
+        sub_agents=sub_agents,
         loop=loop,
     )
 

rasa/core/tracker_stores/tracker_store.py

@@ -542,7 +542,7 @@ class FailSafeTrackerStore(TrackerStore):
         return self._tracker_store.domain
 
     @domain.setter
-    def domain(self, domain: Domain) -> None:
+    def domain(self, domain: Optional[Domain]) -> None:
         self._tracker_store.domain = domain
 
         if self._fallback_tracker_store:
@@ -805,9 +805,7 @@ class AwaitableTrackerStore(TrackerStore):
     async def retrieve(self, sender_id: Text) -> Optional[DialogueStateTracker]:
         """Wrapper to call `retrieve` method of primary tracker store."""
         result = self._tracker_store.retrieve(sender_id)
-        return (
-            await result if isawaitable(result) else result  # type: ignore[return-value, misc]
-        )
+        return await result if isawaitable(result) else result
 
     async def keys(self) -> Iterable[Text]:
         """Wrapper to call `keys` method of primary tracker store."""
@@ -834,6 +832,4 @@ class AwaitableTrackerStore(TrackerStore):
     ) -> Optional[DialogueStateTracker]:
         """Wrapper to call `retrieve_full_tracker` method of primary tracker store."""
         result = self._tracker_store.retrieve_full_tracker(conversation_id)
-        return (
-            await result if isawaitable(result) else result  # type: ignore[return-value, misc]
-        )
+        return await result if isawaitable(result) else result

rasa/core/train.py

@@ -46,7 +46,7 @@ async def train_comparison_models(
                     output=str(Path(output_path, f"run_{r +1}")),
                     fixed_model_name=config_name + PERCENTAGE_KEY + str(percentage),
                     additional_arguments={
-                        **additional_arguments,
+                        **(additional_arguments or {}),
                         "exclusion_percentage": percentage,
                     },
                 )

rasa/core/training/interactive.py

@@ -91,7 +91,7 @@ from rasa.shared.core.training_data.visualization import (
 )
 from rasa.shared.exceptions import InvalidConfigException
 from rasa.shared.importers.rasa import TrainingDataImporter
-from rasa.shared.nlu.constants import INTENT_NAME_KEY, TEXT
+from rasa.shared.nlu.constants import ENTITIES, INTENT, INTENT_NAME_KEY, TEXT
 
 # noinspection PyProtectedMember
 from rasa.shared.nlu.training_data import loading
@@ -789,7 +789,7 @@ def _collect_messages(events: List[Dict[Text, Any]]) -> List[Message]:
             data = event.get("parse_data", {})
             rasa_nlu_training_data_utils.remove_untrainable_entities_from(data)
             msg = Message.build(
-                data["text"], data["intent"][INTENT_NAME_KEY], data["entities"]
+                data[TEXT], data[INTENT][INTENT_NAME_KEY], data[ENTITIES]
             )
             messages.append(msg)
         elif event.get("event") == UserUtteranceReverted.type_name and messages:
@@ -901,13 +901,13 @@ def _get_nlu_target_format(export_path: Text) -> Text:
 
 def _entities_from_messages(messages: List[Message]) -> List[Text]:
     """Return all entities that occur in at least one of the messages."""
-    return list({e["entity"] for m in messages for e in m.data.get("entities", [])})
+    return list({e["entity"] for m in messages for e in m.data.get(ENTITIES, [])})
 
 
 def _intents_from_messages(messages: List[Message]) -> Set[Text]:
     """Return all intents that occur in at least one of the messages."""
     # set of distinct intents
-    distinct_intents = {m.data["intent"] for m in messages if "intent" in m.data}
+    distinct_intents = {m.data[INTENT] for m in messages if INTENT in m.data}
 
     return distinct_intents
 
@@ -1191,11 +1191,11 @@ def _as_md_message(parse_data: Dict[Text, Any]) -> Text:
     """Display the parse data of a message in markdown format."""
     from rasa.shared.nlu.training_data.formats.readerwriter import TrainingDataWriter
 
-    if parse_data.get("text", "").startswith(INTENT_MESSAGE_PREFIX):
-        return parse_data["text"]
+    if parse_data.get(TEXT, "").startswith(INTENT_MESSAGE_PREFIX):
+        return parse_data[TEXT]
 
-    if not parse_data.get("entities"):
-        parse_data["entities"] = []
+    if not parse_data.get(ENTITIES):
+        parse_data[ENTITIES] = []
 
     return TrainingDataWriter.generate_message(parse_data)
 
@@ -1207,7 +1207,7 @@ def _validate_user_regex(latest_message: Dict[Text, Any], intents: List[Text]) -
     `/greet`. Return `True` if the intent is a known one.
     """
     parse_data = latest_message.get("parse_data", {})
-    intent = parse_data.get("intent", {}).get(INTENT_NAME_KEY)
+    intent = parse_data.get(INTENT, {}).get(INTENT_NAME_KEY)
 
     if intent in intents:
         return True
@@ -1224,8 +1224,8 @@ async def _validate_user_text(
     """
     parse_data = latest_message.get("parse_data", {})
     text = _as_md_message(parse_data)
-    intent = parse_data.get("intent", {}).get(INTENT_NAME_KEY)
-    entities = parse_data.get("entities", [])
+    intent = parse_data.get(INTENT, {}).get(INTENT_NAME_KEY)
+    entities = parse_data.get(ENTITIES, [])
     if entities:
         message = (
             f"Is the intent '{intent}' correct for '{text}' and are "
@@ -1276,9 +1276,9 @@ async def _validate_nlu(
 
         entities = await _correct_entities(latest_message, endpoint, conversation_id)
         corrected_nlu = {
-            "intent": corrected_intent,
-            "entities": entities,
-            "text": latest_message.get("text"),
+            INTENT: corrected_intent,
+            ENTITIES: entities,
+            TEXT: latest_message.get("text"),
         }
 
         await _correct_wrong_nlu(corrected_nlu, events, endpoint, conversation_id)
@@ -1315,9 +1315,9 @@ def _merge_annotated_and_original_entities(
     # overwrite entities which have already been
     # annotated in the original annotation to preserve
     # additional entity parser information
-    entities = parse_annotated.get("entities", [])[:]
+    entities = parse_annotated.get(ENTITIES, [])[:]
     for i, entity in enumerate(entities):
-        for original_entity in parse_original.get("entities", []):
+        for original_entity in parse_original.get(ENTITIES, []):
             if _is_same_entity_annotation(entity, original_entity):
                 entities[i] = original_entity
                 break

rasa/core/training/story_conflict.py

@@ -14,7 +14,7 @@ from rasa.shared.core.constants import (
 from rasa.shared.core.domain import Domain, State
 from rasa.shared.core.events import ActionExecuted, Event
 from rasa.shared.core.generator import TrackerWithCachedStates
-from rasa.shared.nlu.constants import TEXT
+from rasa.shared.nlu.constants import INTENT, TEXT
 from rasa.shared.nlu.training_data.message import Message
 
 logger = logging.getLogger(__name__)
@@ -362,12 +362,12 @@ def _get_previous_event(
         previous_event_type = "bot utterance"
         previous_event_name = state[PREVIOUS_ACTION]["action_text"]
     elif USER in state.keys():
-        if "intent" in state[USER]:
+        if INTENT in state[USER]:
             previous_event_type = "intent"
-            previous_event_name = state[USER]["intent"]
-        elif "text" in state[USER]:
+            previous_event_name = state[USER][INTENT]
+        elif TEXT in state[USER]:
             previous_event_type = "user utterance"
-            previous_event_name = state[USER]["text"]
+            previous_event_name = state[USER][TEXT]
 
     if not isinstance(previous_event_name, (str, type(None))):
         # While the Substate type doesn't restrict the value of `action_text` /

rasa/core/utils.py

@@ -1,8 +1,9 @@
 import logging
 import os
+import re
 from pathlib import Path
 from socket import SOCK_DGRAM, SOCK_STREAM
-from typing import TYPE_CHECKING, Any, Dict, Optional, Set, Text, Tuple, Union
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Set, Text, Tuple, Union
 
 import numpy as np
 import structlog
@@ -359,3 +360,22 @@ def should_force_slot_filling(
             return True, slot_name
 
     return False, None
+
+
+def get_slot_names_from_exit_conditions(exit_conditions: List[str]) -> List[str]:
+    """Extract slot names from exit conditions.
+
+    Args:
+        exit_conditions: The exit conditions to extract slot names from.
+
+    Returns:
+        A list of slot names.
+    """
+    # Find all unique names matching "slots.<name>"
+    return list(
+        {
+            name
+            for condition in exit_conditions
+            for name in re.findall(r"\bslots\.(\w+)", condition)
+        }
+    )