rasa-pro 3.14.0.dev20250922__py3-none-any.whl → 3.14.0rc1__py3-none-any.whl

rasa/shared/core/flows/steps/collect.py

@@ -1,11 +1,13 @@
 from __future__ import annotations
 
+from abc import ABC, abstractmethod
 from dataclasses import dataclass
 from typing import Any, Dict, List, Optional, Set, Text, Union
 
 import structlog
 
 from rasa.shared.constants import ACTION_ASK_PREFIX, UTTER_ASK_PREFIX
+from rasa.shared.core.constants import GLOBAL_SILENCE_TIMEOUT_DEFAULT_VALUE
 from rasa.shared.core.flows.flow_step import FlowStep
 from rasa.shared.core.slots import SlotRejection
 from rasa.shared.exceptions import RasaException
@@ -16,7 +18,93 @@ DEFAULT_FORCE_SLOT_FILLING = False
 
 logger = structlog.get_logger(__name__)
 
-SilenceTimeoutInstructionType = Union[int, float, Dict[str, Any]]
+SilenceTimeoutInstructionType = Union[int, float, Dict[str, float]]
+
+
+class SilenceTimeout(ABC):
+    @abstractmethod
+    def get_silence_for_channel(self, channel_name: str) -> float:
+        pass
+
+    @abstractmethod
+    def to_json(self) -> Dict[str, Any]:
+        pass
+
+
+class SingleSilenceTimeout(SilenceTimeout):
+    def __init__(
+        self,
+        silence_timeout: float,
+    ):
+        SingleSilenceTimeout._validate(silence_timeout)
+        self.silence_timeout = silence_timeout
+
+    def get_silence_for_channel(self, channel_name: str) -> float:
+        return self.silence_timeout
+
+    def to_json(self) -> Dict[str, Any]:
+        return {
+            "silence_timeout": self.silence_timeout,
+        }
+
+    def __eq__(self, other: Any) -> bool:
+        if not isinstance(other, SingleSilenceTimeout):
+            return False
+        return self.silence_timeout == other.silence_timeout
+
+    @staticmethod
+    def _validate(silence_timeout: float) -> None:
+        if silence_timeout and silence_timeout < 0:
+            raise RasaException(
+                f"Invalid silence timeout value: {silence_timeout}. "
+                "Silence timeout must be a non-negative number."
+            )
+
+    @classmethod
+    def from_json(cls, silence_timeout: float) -> SingleSilenceTimeout:
+        SingleSilenceTimeout._validate(silence_timeout)
+        return cls(silence_timeout)
+
+
+class PerChannelSilenceTimeout(SilenceTimeout):
+    def __init__(
+        self,
+        channel_silence_timeouts: Dict[str, float],
+    ):
+        self.silence_timeouts = channel_silence_timeouts
+
+    def get_silence_for_channel(self, channel_name: str) -> float:
+        return self.silence_timeouts.get(
+            channel_name, GLOBAL_SILENCE_TIMEOUT_DEFAULT_VALUE
+        )
+
+    def to_json(self) -> Dict[str, Any]:
+        return {
+            "silence_timeout": self.silence_timeouts,
+        }
+
+    def __eq__(self, other: Any) -> bool:
+        if not isinstance(other, PerChannelSilenceTimeout):
+            return False
+        return self.silence_timeouts == other.silence_timeouts
+
+    @staticmethod
+    def _validate(silence_timeout_json: Dict[str, Any]) -> None:
+        for channel, timeout in silence_timeout_json.items():
+            if not isinstance(timeout, (int, float)) or timeout < 0:
+                raise RasaException(
+                    f"Invalid silence timeout value: {timeout} for "
+                    f"channel '{channel}'. "
+                    "If defined at collect step, silence timeout "
+                    "must be a non-negative number."
+                )
+
+    @classmethod
+    def from_json(
+        cls, channel_silence_timeouts: Dict[str, Any]
+    ) -> PerChannelSilenceTimeout:
+        PerChannelSilenceTimeout._validate(channel_silence_timeouts)
+        return cls(channel_silence_timeouts)
 
 
 @dataclass
@@ -37,7 +125,7 @@ class CollectInformationFlowStep(FlowStep):
     """Whether to reset the slot value at the end of the flow."""
     force_slot_filling: bool = False
     """Whether to keep only the SetSlot command for the collected slot."""
-    silence_timeout: Optional[float] = None
+    silence_timeout: Optional[SilenceTimeout] = None
     """The silence timeout for the collect information step."""
 
     @classmethod
@@ -79,25 +167,22 @@ class CollectInformationFlowStep(FlowStep):
     @staticmethod
     def _deserialise_silence_timeout(
         silence_timeout_json: Optional[SilenceTimeoutInstructionType],
-    ) -> Optional[float]:
+    ) -> Optional[SilenceTimeout]:
         """Deserialize silence timeout from JSON."""
         if not silence_timeout_json:
             return None
 
-        if not isinstance(silence_timeout_json, (int, float)):
+        if not isinstance(silence_timeout_json, (int, float, dict)):
             raise RasaException(
                 f"Invalid silence timeout value: {silence_timeout_json}. "
-                "If defined at collect step, silence timeout must be a number."
+                "If defined at collect step, silence timeout must be a number "
+                "or a map between channel names and timeout values."
             )
 
-        silence_timeout = silence_timeout_json
+        if isinstance(silence_timeout_json, dict):
+            return PerChannelSilenceTimeout.from_json(silence_timeout_json)
 
-        if silence_timeout and silence_timeout < 0:
-            raise RasaException(
-                f"Invalid silence timeout value: {silence_timeout}. "
-                "Silence timeout must be a non-negative number."
-            )
-        return silence_timeout
+        return SingleSilenceTimeout.from_json(silence_timeout_json)
 
     @staticmethod
     def _default_utter(collect: str) -> str:
@@ -119,7 +204,7 @@ class CollectInformationFlowStep(FlowStep):
         data["rejections"] = [rejection.as_dict() for rejection in self.rejections]
         data["force_slot_filling"] = self.force_slot_filling
         if self.silence_timeout:
-            data["silence_timeout"] = self.silence_timeout
+            data.update(self.silence_timeout.to_json())
 
         return super().as_json(step_properties=data)
 

rasa/shared/core/flows/validation.py

@@ -4,7 +4,9 @@ import re
 import typing
 from collections import defaultdict
 from dataclasses import dataclass
-from typing import List, Optional, Set, Text
+from typing import Iterator, List, Optional, Set, Text, Tuple
+
+from jinja2 import Template
 
 from rasa.shared.constants import (
     RASA_DEFAULT_FLOW_PATTERN_PREFIX,
@@ -12,6 +14,11 @@ from rasa.shared.constants import (
     RASA_PATTERN_HUMAN_HANDOFF,
     RASA_PATTERN_INTERNAL_ERROR,
 )
+from rasa.shared.core.flows.constants import (
+    KEY_MAPPING_INPUT,
+    KEY_MAPPING_OUTPUT,
+    KEY_MAPPING_SLOT,
+)
 from rasa.shared.core.flows.flow import Flow
 from rasa.shared.core.flows.flow_step import (
     FlowStep,
@@ -35,6 +42,7 @@ from rasa.shared.core.flows.utils import (
 from rasa.shared.exceptions import RasaException
 
 if typing.TYPE_CHECKING:
+    from rasa.shared.core.domain import Domain
     from rasa.shared.core.flows.flows_list import FlowsList
 
 FLOW_ID_REGEX = r"""^[a-zA-Z0-9_][a-zA-Z0-9_-]*?$"""
@@ -107,6 +115,47 @@ class DuplicatedStepIdException(RasaException):
         )
 
 
+class InvalidExitIfConditionException(RasaException):
+    """Raised when an exit_if condition is invalid."""
+
+    def __init__(self, step_id: str, flow_id: str, condition: str, reason: str) -> None:
+        """Initializes the exception."""
+        self.step_id = step_id
+        self.flow_id = flow_id
+        self.condition = condition
+        self.reason = reason
+
+    def __str__(self) -> str:
+        """Return a string representation of the exception."""
+        return (
+            f"Invalid exit_if condition '{self.condition}' in step '{self.step_id}' "
+            f"of flow '{self.flow_id}': {self.reason}. "
+            f"Please ensure that exit_if conditions contain at least one slot "
+            f"reference and use only defined slots with valid predicates."
+        )
+
+
+class ExitIfExclusivityException(RasaException):
+    """Raised when a call step with exit_if has other properties."""
+
+    def __init__(
+        self, step_id: str, flow_id: str, conflicting_properties: List[str]
+    ) -> None:
+        """Initializes the exception."""
+        self.step_id = step_id
+        self.flow_id = flow_id
+        self.conflicting_properties = conflicting_properties
+
+    def __str__(self) -> str:
+        """Return a string representation of the exception."""
+        conflicting_properties_str = ", ".join(self.conflicting_properties)
+        return (
+            f"Call step '{self.step_id}' in flow '{self.flow_id}' has an 'exit_if' "
+            f"property but also has other properties: {conflicting_properties_str}. "
+            f"A call step with 'exit_if' cannot have any other properties."
+        )
+
+
 class DuplicatedFlowIdException(RasaException):
     """Raised when a flow is using the same id as another flow."""
 
@@ -261,7 +310,7 @@ class NoLinkAllowedInCalledFlowException(RasaException):
         )
 
 
-class UnresolvedFlowException(RasaException):
+class UnresolvedLinkFlowException(RasaException):
     """Raised when a flow is called or linked from another flow but doesn't exist."""
 
     def __init__(self, flow_id: str, calling_flow_id: str, step_id: str) -> None:
@@ -273,13 +322,91 @@ class UnresolvedFlowException(RasaException):
     def __str__(self) -> str:
         """Return a string representation of the exception."""
         return (
-            f"Flow '{self.flow_id}' is called or linked from flow "
+            f"Flow '{self.flow_id}' is linked from flow "
             f"'{self.calling_flow_id}' in step '{self.step_id}', "
             f"but it doesn't exist. "
             f"Please make sure that a flow with id '{self.flow_id}' exists."
         )
 
 
+class UnresolvedCallStepException(RasaException):
+    """Raised when a call step doesn't have a reference to an existing flow or agent."""
+
+    def __init__(
+        self, call_step_argument: str, calling_flow_id: str, step_id: str
+    ) -> None:
+        """Initializes the exception."""
+        self.call_step_argument = call_step_argument
+        self.calling_flow_id = calling_flow_id
+        self.step_id = step_id
+
+    def __str__(self) -> str:
+        """Return a string representation of the exception."""
+        return (
+            f"The call step '{self.step_id}' in flow '{self.calling_flow_id}' "
+            f"is invalid: there is no flow or agent with the "
+            f"id '{self.call_step_argument}'. "
+            f"Please make sure that the call step argument is a valid flow id "
+            f"or an agent id."
+        )
+
+
+class InvalidMCPServerReferenceException(RasaException):
+    """Raised when a call step references a non-existent MCP server."""
+
+    def __init__(
+        self, mcp_server_name: str, calling_flow_id: str, step_id: str
+    ) -> None:
+        """Initializes the exception."""
+        self.mcp_server_name = mcp_server_name
+        self.calling_flow_id = calling_flow_id
+        self.step_id = step_id
+
+    def __str__(self) -> str:
+        """Return a string representation of the exception."""
+        return (
+            f"Call step '{self.step_id}' in flow '{self.calling_flow_id}' "
+            f"references MCP server '{self.mcp_server_name}' which does not exist "
+            f"in endpoints.yml. Please make sure that the MCP server is properly "
+            f"configured in endpoints.yml."
+        )
+
+
+class InvalidMCPMappingSlotException(RasaException):
+    """Raised when MCP tool mapping references non-existent slots."""
+
+    def __init__(
+        self,
+        step_id: str,
+        flow_id: str,
+        invalid_input_slots: Set[str],
+        invalid_output_slots: Set[str],
+    ) -> None:
+        """Initializes the exception."""
+        self.step_id = step_id
+        self.flow_id = flow_id
+        self.invalid_input_slots = invalid_input_slots
+        self.invalid_output_slots = invalid_output_slots
+
+    def __str__(self) -> str:
+        """Return a string representation of the exception."""
+        error_parts = []
+
+        if self.invalid_input_slots:
+            input_slots_str = ", ".join(sorted(self.invalid_input_slots))
+            error_parts.append(f"input slots: {input_slots_str}")
+
+        if self.invalid_output_slots:
+            output_slots_str = ", ".join(sorted(self.invalid_output_slots))
+            error_parts.append(f"output slots: {output_slots_str}")
+
+        slots_info = " ".join(error_parts)
+        return (
+            f"Call step '{self.step_id}' in flow '{self.flow_id}' has slots not "
+            f"defined in the domain: {slots_info}"
+        )
+
+
 class UnresolvedFlowStepIdException(RasaException):
     """Raised when a flow step is referenced, but its id can not be resolved."""
 
@@ -562,15 +689,201 @@ def validate_link_in_call_restriction(flows: "FlowsList") -> None:
                 raise NoLinkAllowedInCalledFlowException(step.id, flow.id, step.call)
 
 
-def validate_called_flows_exists(flows: "FlowsList") -> None:
-    """Validates that all called flows exist."""
+def validate_call_steps(flows: "FlowsList") -> None:
+    """Validates that all called flows/agents exist and properties are valid."""
     for flow in flows.underlying_flows:
         for step in flow.steps:
             if not isinstance(step, CallFlowStep):
                 continue
 
-            if flows.flow_by_id(step.call) is None:
-                raise UnresolvedFlowException(step.call, flow.id, step.id)
+            _is_step_calling_agent = step.is_calling_agent()
+            _is_step_calling_mcp_tool = step.has_mcp_tool_properties()
+
+            if (
+                not _is_step_calling_agent
+                and flows.flow_by_id(step.call) is None
+                and not _is_step_calling_mcp_tool
+            ):
+                raise UnresolvedCallStepException(step.call, flow.id, step.id)
+
+            if step.exit_if and not _is_step_calling_agent:
+                # exit_if is only allowed for call steps that call an agent
+                raise RasaException(
+                    f"Call step '{step.id}' in flow '{flow.id}' has an 'exit_if' "
+                    f"condition, but it is not calling an agent. "
+                    f"'exit_if' is only allowed for call steps that call an agent."
+                )
+
+
+def validate_mcp_server_references(flows: "FlowsList") -> None:
+    """Validates that MCP server references in call steps are valid."""
+    for flow in flows.underlying_flows:
+        for step in flow.steps:
+            if not isinstance(step, CallFlowStep):
+                continue
+
+            # Only validate call steps that are trying to call MCP tools
+            if step.has_mcp_tool_properties():
+                # Check if the referenced MCP server exists
+                from rasa.shared.utils.mcp.utils import mcp_server_exists
+
+                if not mcp_server_exists(step.mcp_server):
+                    raise InvalidMCPServerReferenceException(
+                        step.mcp_server, flow.id, step.id
+                    )
+
+
+def validate_mcp_mapping_slots(
+    flows: "FlowsList", domain: Optional["Domain"] = None
+) -> None:
+    """Validates that slots referenced in MCP tool mapping are defined in the domain.
+
+    This function validates that all slots referenced in the input and output
+    mapping of MCP tool calls are defined in the domain.
+
+    Args:
+        flows: The flows to validate.
+        domain: The domain with slot definitions. If None, slot validation is skipped.
+
+    Raises:
+        InvalidMCPMappingSlotException: If any MCP mapping references undefined slots.
+    """
+    if domain is None:
+        return
+
+    domain_slots = {slot.name for slot in domain.slots}
+
+    for flow in flows.underlying_flows:
+        for step in flow.steps:
+            if not isinstance(step, CallFlowStep):
+                continue
+
+            # Only validate call steps that are calling MCP tools
+            if not step.has_mcp_tool_properties() or step.mapping is None:
+                continue
+
+            # Extract slot names from input mapping
+            input_slots = set()
+            if KEY_MAPPING_INPUT in step.mapping and isinstance(
+                step.mapping[KEY_MAPPING_INPUT], list
+            ):
+                for input_item in step.mapping[KEY_MAPPING_INPUT]:
+                    input_slots.add(input_item[KEY_MAPPING_SLOT])
+
+            # Extract slot names from output mapping
+            output_slots = set()
+            if KEY_MAPPING_OUTPUT in step.mapping and isinstance(
+                step.mapping[KEY_MAPPING_OUTPUT], list
+            ):
+                for output_item in step.mapping[KEY_MAPPING_OUTPUT]:
+                    output_slots.add(output_item[KEY_MAPPING_SLOT])
+
+            # Check for invalid slots in both input and output
+            invalid_input_slots = input_slots - domain_slots
+            invalid_output_slots = output_slots - domain_slots
+
+            # Raise exception if any invalid slots are found
+            if invalid_input_slots or invalid_output_slots:
+                raise InvalidMCPMappingSlotException(
+                    step.id, flow.id, invalid_input_slots, invalid_output_slots
+                )
+
+
+def _get_call_steps_with_exit_if(
+    flows: "FlowsList",
+) -> Iterator[Tuple["CallFlowStep", "Flow"]]:
+    """Helper function to get all call steps with exit_if properties.
+
+    Args:
+        flows: The flows to search through.
+
+    Yields:
+        Tuples of (call_step, flow) for steps that have exit_if properties.
+    """
+    for flow in flows.underlying_flows:
+        for step in flow.steps:
+            if isinstance(step, CallFlowStep) and step.exit_if:
+                yield step, flow
+
+
+def validate_exit_if_conditions(
+    flows: "FlowsList", domain: Optional["Domain"] = None
+) -> None:
+    """Validates that exit_if conditions are valid.
+
+    This function validates:
+    - Each condition contains at least one slot reference
+    - Only defined slots are used within the conditions
+    - The predicates are valid
+
+    Args:
+        flows: The flows to validate.
+        domain: The domain with slot definitions. If None, slot validation is skipped.
+
+    Raises:
+        InvalidExitIfConditionException: If any exit_if condition is invalid.
+    """
+    for step, flow in _get_call_steps_with_exit_if(flows):
+        for condition in step.exit_if:  # type: ignore[union-attr]
+            if not isinstance(condition, str):
+                raise InvalidExitIfConditionException(
+                    step.id, flow.id, str(condition), "Condition must be a string"
+                )
+
+            # Check if condition contains at least one slot reference
+            slot_references_regex = re.compile(r"\bslots\.\w+")
+            slot_references = slot_references_regex.findall(condition)
+            if not slot_references:
+                raise InvalidExitIfConditionException(
+                    step.id,
+                    flow.id,
+                    condition,
+                    "Condition must contain at least one slot reference "
+                    "(e.g., 'slots.slot_name')",
+                )
+
+            # Validate predicate syntax using pypred (always, regardless of domain)
+            _validate_predicate_syntax_with_pypred(step.id, flow.id, condition)
+
+            # Validate slot names if domain is provided
+            if domain:
+                domain_slots = {slot.name: slot for slot in domain.slots}
+                for slot_ref in slot_references:
+                    slot_name = slot_ref.split(".")[1]
+                    if slot_name not in domain_slots:
+                        raise InvalidExitIfConditionException(
+                            step.id,
+                            flow.id,
+                            condition,
+                            f"Slot '{slot_name}' is not defined in the domain",
+                        )
+
+
+def validate_exit_if_exclusivity(flows: "FlowsList") -> None:
+    """Validates that call steps with exit_if don't have other properties.
+
+    This function validates that call steps with an exit_if property cannot have
+    any other properties besides the required 'call' property and standard flow
+    step properties (id, next, metadata, description).
+
+    Args:
+        flows: The flows to validate.
+
+    Raises:
+        ExitIfExclusivityException: If a call step with exit_if has other properties.
+    """
+    for step, flow in _get_call_steps_with_exit_if(flows):
+        # Check for conflicting properties
+        conflicting_properties = []
+
+        # Check for MCP-related properties
+        if step.mcp_server is not None:
+            conflicting_properties.append("mcp_server")
+        if step.mapping is not None:
+            conflicting_properties.append("mapping")
+
+        if conflicting_properties:
+            raise ExitIfExclusivityException(step.id, flow.id, conflicting_properties)
 
 
 def validate_linked_flows_exists(flows: "FlowsList") -> None:
@@ -594,7 +907,7 @@ def validate_linked_flows_exists(flows: "FlowsList") -> None:
                     flow.is_rasa_default_flow and step.link == RASA_PATTERN_CHITCHAT
                 )
             ):
-                raise UnresolvedFlowException(step.link, flow.id, step.id)
+                raise UnresolvedLinkFlowException(step.link, flow.id, step.id)
 
 
 def validate_patterns_are_not_called_or_linked(flows: "FlowsList") -> None:
@@ -694,6 +1007,7 @@ def validate_slot_names_to_be_collected(flow: Flow) -> None:
 
 def validate_flow_id(flow: Flow) -> None:
     """Validates if the flow id comply with a specified regex.
+
     Flow IDs can start with an alphanumeric character or an underscore.
     Followed by zero or more alphanumeric characters, hyphens, or underscores.
 
@@ -751,3 +1065,53 @@ def validate_slot_persistence_configuration(flow: Flow) -> None:
         result = _is_persist_slots_valid(persist_slots, flow_slots)
         if not result.is_valid:
             raise InvalidPersistSlotsException(flow_id, result.invalid_slots)
+
+
+def _validate_predicate_syntax_with_pypred(
+    step_id: str, flow_id: str, condition: str
+) -> None:
+    """Validates predicate syntax using pypred.
+
+    This function validates that the exit_if condition has valid predicate syntax.
+    Pypred catches syntax errors like double operators, invalid expressions, etc.
+
+    Args:
+        step_id: The ID of the step containing the condition.
+        flow_id: The ID of the flow containing the step.
+        condition: The exit_if condition string.
+
+    Raises:
+        InvalidExitIfConditionException: If pypred detects syntax errors.
+    """
+    try:
+        from rasa.utils.pypred import Predicate
+
+        # Create a simple test context for syntax validation.
+        # This context works with all slot types since it's only used for:
+        # 1. Template rendering: Basic structure for Jinja2 template rendering
+        # 2. Syntax validation: Pypred validates predicate syntax
+        #    without actual slot values
+        test_context = {"slots": {"test_slot": "test_value"}}
+        rendered_template = Template(condition).render(test_context)
+
+        # Let pypred validate the predicate syntax
+        predicate = Predicate(rendered_template)
+        if not predicate.is_valid():
+            raise InvalidExitIfConditionException(
+                step_id,
+                flow_id,
+                condition,
+                "Invalid predicate syntax",
+            )
+
+    except ImportError:
+        # pypred not available, skip validation
+        pass
+    except Exception as e:
+        # Re-raise pypred errors as predicate syntax errors
+        raise InvalidExitIfConditionException(
+            step_id,
+            flow_id,
+            condition,
+            f"Invalid predicate syntax: {e}",
+        )

rasa/shared/core/flows/yaml_flows_io.py

@@ -127,7 +127,7 @@ class YAMLFlowsReader:
             If a schema does not have a `schema_name` set, we will use the
             `type` instead as a fallback.
             """
-            return schema.get("schema_name", schema.get("type"))
+            return str(schema.get("schema_name", schema.get("type") or "unknown"))
 
         def schema_names(schemas: List[Dict[str, Any]]) -> List[str]:
             """Get the names of the schemas.
@@ -415,7 +415,8 @@ def process_yaml_content(yaml_content: Dict[str, Any]) -> Dict[str, Any]:
 
     # Under the "flows" key certain keys cannot have metadata
     _process_keys_recursively(
-        yaml_content["flows"], ["nlu_trigger", "set_slots", "metadata"]
+        yaml_content["flows"],
+        ["nlu_trigger", "set_slots", "metadata", "mapping", "exit_if"],
     )
 
     return yaml_content

rasa/shared/core/slots.py

@@ -68,9 +68,9 @@ class SlotRejection:
 
 
 class SlotValidation(BaseModel):
-    rejections: List[SlotRejection] = Field(alias=REJECTIONS)
+    rejections: List[SlotRejection] = Field(alias=REJECTIONS)  # type: ignore[literal-required]
     """how the slot value is validated using predicate evaluation."""
-    refill_utter: str = Field(alias=REFILL_UTTER)
+    refill_utter: str = Field(alias=REFILL_UTTER)  # type: ignore[literal-required]
     """The utterance that the assistant uses to ask for the slot."""
 
     @staticmethod

rasa/shared/core/trackers.py

@@ -849,7 +849,7 @@ class DialogueStateTracker:
         action_names_to_exclude: Optional[List[Text]] = None,
         skip: int = 0,
         event_verbosity: EventVerbosity = EventVerbosity.APPLIED,
-    ) -> Optional["EventTypeAlias"]:
+    ) -> Optional[Event]:
         """Gets the last event of a given type which was actually applied.
 
         Args:
@@ -889,9 +889,12 @@ class DialogueStateTracker:
         Returns:
             `True` if last executed action had name `name`, otherwise `False`.
         """
-        last: Optional[ActionExecuted] = self.get_last_event_for(
+        last_event = self.get_last_event_for(
             ActionExecuted, action_names_to_exclude=[ACTION_LISTEN_NAME], skip=skip
         )
+        last: Optional[ActionExecuted] = (
+            last_event if isinstance(last_event, ActionExecuted) else None
+        )
         return last is not None and last.action_name == name
 
     ###