rasa-pro 3.13.12__py3-none-any.whl → 3.14.0__py3-none-any.whl

rasa/shared/core/domain.py

@@ -32,7 +32,6 @@ from ruamel.yaml.scalarstring import DoubleQuotedScalarString
 import rasa.shared.core.slot_mappings
 import rasa.shared.utils.common
 import rasa.shared.utils.io
-from rasa.core.available_endpoints import AvailableEndpoints
 from rasa.shared.constants import (
     DEFAULT_CARRY_OVER_SLOTS_TO_NEW_SESSION,
     DEFAULT_SESSION_EXPIRATION_TIME_IN_MINUTES,
@@ -49,7 +48,6 @@ from rasa.shared.core.constants import (
     ACTION_SHOULD_SEND_DOMAIN,
     KEY_MAPPING_TYPE,
     KNOWLEDGE_BASE_SLOT_NAMES,
-    SILENCE_TIMEOUT_SLOT,
     SLOT_MAPPINGS,
     SlotMappingType,
 )
@@ -98,6 +96,8 @@ IS_RETRIEVAL_INTENT_KEY = "is_retrieval_intent"
 ENTITY_ROLES_KEY = "roles"
 ENTITY_GROUPS_KEY = "groups"
 ENTITY_FEATURIZATION_KEY = "influence_conversation"
+STORE_ENTITIES_AS_SLOTS_KEY = "store_entities_as_slots"
+DOMAIN_CONFIG_KEY = "config"
 
 KEY_SLOTS = "slots"
 KEY_INTENTS = "intents"
@@ -146,6 +146,8 @@ MERGE_FUNC_MAPPING: Dict[Text, Callable[..., Any]] = {
     KEY_FORMS: rasa.shared.utils.common.merge_dicts,
 }
 
+DEFAULT_STORE_ENTITIES_AS_SLOTS = True
+
 DICT_DATA_KEYS = [
     key
     for key, value in MERGE_FUNC_MAPPING.items()
@@ -308,17 +310,12 @@ class Domain:
         responses = data.get(KEY_RESPONSES, {})
 
         domain_slots = data.get(KEY_SLOTS, {})
-        for slot_name, slot in domain_slots.items():
-            if slot_name == SILENCE_TIMEOUT_SLOT:
-                slot["initial_value"] = (
-                    AvailableEndpoints.get_instance().interaction_handling.global_silence_timeout
-                )
         slots = cls.collect_slots(domain_slots)
         domain_actions = data.get(KEY_ACTIONS, [])
         actions = cls._collect_action_names(domain_actions)
 
         additional_arguments = {
-            **data.get("config", {}),
+            **data.get(DOMAIN_CONFIG_KEY, {}),
             "actions_which_explicitly_need_domain": (
                 cls._collect_actions_which_explicitly_need_domain(domain_actions)
             ),
@@ -468,9 +465,9 @@ class Domain:
             return domain_dict
 
         if override:
-            config = domain_dict.get("config", {})
+            config = domain_dict.get(DOMAIN_CONFIG_KEY, {})
             for key, val in config.items():
-                combined["config"][key] = val
+                combined[DOMAIN_CONFIG_KEY][key] = val
 
         if (
             override
@@ -508,10 +505,10 @@ class Domain:
         return combined
 
     def partial_merge(self, other: Domain) -> Domain:
-        """
-        Returns a new Domain with intersection-based merging:
-          - For each domain section only overwrite items that already exist in self.
-          - Brand-new items in `other` are ignored.
+        """Returns a new Domain with intersection-based merging.
+
+        For each domain section only overwrite items that already exist in self.
+        Brand-new items in `other` are ignored.
 
         Args:
             other: The domain to merge with.
@@ -543,9 +540,9 @@ class Domain:
         return Domain.from_dict(updated_self)
 
     def difference(self, other: Domain) -> Domain:
-        """
-        Returns a new Domain containing items in `self` that are NOT in `other`,
-        using simple equality checks for dict/list items.
+        """Returns a new Domain containing items in `self` that are NOT in `other`.
+
+        Uses simple equality checks for dict/list items.
 
         Args:
             other: The domain to compare with.
@@ -598,9 +595,16 @@ class Domain:
     ) -> Dict:
         # add the config, session_config and training data version defaults
         # if not included in the original domain dict
-        if "config" not in data and not store_entities_as_slots:
+        if (
+            DOMAIN_CONFIG_KEY not in data
+            and store_entities_as_slots != DEFAULT_STORE_ENTITIES_AS_SLOTS
+        ):
             data.update(
-                {"config": {"store_entities_as_slots": store_entities_as_slots}}
+                {
+                    DOMAIN_CONFIG_KEY: {
+                        STORE_ENTITIES_AS_SLOTS_KEY: store_entities_as_slots
+                    }
+                }
             )
 
         if SESSION_CONFIG_KEY not in data:
@@ -937,7 +941,7 @@ class Domain:
         forms: Union[Dict[Text, Any], List[Text]],
         data: Dict,
         action_texts: Optional[List[Text]] = None,
-        store_entities_as_slots: bool = True,
+        store_entities_as_slots: bool = DEFAULT_STORE_ENTITIES_AS_SLOTS,
         session_config: SessionConfig = SessionConfig.default(),
         **kwargs: Any,
     ) -> None:
@@ -1711,9 +1715,45 @@ class Domain:
         else:
             return True
 
-    def as_dict(self) -> Dict[Text, Any]:
+    def _uses_custom_session_config(self) -> bool:
+        """Check if the domain uses a custom session config."""
+        return self._data.get(SESSION_CONFIG_KEY) != SessionConfig.default().as_dict()
+
+    def _uses_custom_domain_config(self) -> bool:
+        """Check if the domain uses a custom domain config."""
+        return self._data.get(DOMAIN_CONFIG_KEY) != {
+            STORE_ENTITIES_AS_SLOTS_KEY: DEFAULT_STORE_ENTITIES_AS_SLOTS
+        }
+
+    def _cleaned_json_data(self) -> Dict[Text, Any]:
+        """Remove default values from the domain data.
+
+        Only retains data that was customized by the user.
+
+        Returns:
+            A cleaned dictionary version of the domain.
+        """
+        cleaned_data = copy.deepcopy(self._data)
+
+        # Remove default config if it only contains store_entities_as_slots: False
+        if DOMAIN_CONFIG_KEY in cleaned_data and not self._uses_custom_domain_config():
+            del cleaned_data[DOMAIN_CONFIG_KEY]
+
+        # Remove default session config if it matches the default values
+        if (
+            SESSION_CONFIG_KEY in cleaned_data
+            and not self._uses_custom_session_config()
+        ):
+            del cleaned_data[SESSION_CONFIG_KEY]
+
+        return cleaned_data
+
+    def as_dict(self, should_clean_json: bool = False) -> Dict[Text, Any]:
         """Return serialized `Domain`."""
-        return self._data
+        if should_clean_json:
+            return self._cleaned_json_data()
+        else:
+            return self._data
 
     @staticmethod
     def get_responses_with_multilines(

rasa/shared/core/events.py

@@ -35,6 +35,7 @@ from rasa.shared.core.constants import (
     ACTION_LISTEN_NAME,
     ACTION_METADATA_EXECUTION_ERROR_MESSAGE,
     ACTION_METADATA_EXECUTION_SUCCESS,
+    ACTION_METADATA_EXECUTION_TIME,
     ACTION_NAME_SENDER_ID_CONNECTOR_STR,
     ACTION_SESSION_START_NAME,
     ENTITY_LABEL_SEPARATOR,
@@ -1815,6 +1816,7 @@ class ActionExecuted(Event):
         items_to_ignore = [
             ACTION_METADATA_EXECUTION_SUCCESS,
             ACTION_METADATA_EXECUTION_ERROR_MESSAGE,
+            ACTION_METADATA_EXECUTION_TIME,
         ]
         meta_no_nones = {
             k: v
@@ -2646,6 +2648,333 @@ class FlowCancelled(SkipEventInMDStoryMixin):
             raise ValueError(f"Failed to parse flow_cancelled event. {e}")
 
 
+class AgentCompleted(SkipEventInMDStoryMixin):
+    """Mark the completion of an agent."""
+
+    type_name = "agent_completed"
+
+    def __init__(
+        self,
+        agent_id: str,
+        flow_id: str,
+        status: Optional[str] = None,
+        timestamp: Optional[float] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        self.agent_id = agent_id
+        self.flow_id = flow_id
+        self.status = status
+        super().__init__(timestamp, metadata)
+
+    def __repr__(self) -> Text:
+        """Returns event as string for debugging."""
+        return (
+            f"AgentCompleted(agent: {self.agent_id}, flow: {self.flow_id}, "
+            f"status: {self.status})"
+        )
+
+    def __str__(self) -> str:
+        """Returns event as human-readable string."""
+        return (
+            f"{self.__class__.__name__}({self.agent_id}, {self.flow_id}, {self.status})"
+        )
+
+    def __hash__(self) -> int:
+        """Returns unique hash for event."""
+        return hash((self.agent_id, self.flow_id, self.status))
+
+    def __eq__(self, other: Any) -> bool:
+        """Compares object with other object."""
+        if not isinstance(other, AgentCompleted):
+            return NotImplemented
+        return (self.agent_id, self.flow_id, self.status) == (
+            other.agent_id,
+            other.flow_id,
+            other.status,
+        )
+
+    def as_dict(self) -> Dict[str, Any]:
+        """Returns serialized event."""
+        serialized = super().as_dict()
+        serialized.update(
+            {"agent_id": self.agent_id, "flow_id": self.flow_id, "status": self.status}
+        )
+        return serialized
+
+    @classmethod
+    def _from_parameters(cls, parameters: Dict[str, Any]) -> "AgentCompleted":
+        if "agent_id" not in parameters:
+            raise ValueError(
+                "Failed to parse agent_completed event: agent_id is required"
+            )
+        if "flow_id" not in parameters:
+            raise ValueError(
+                "Failed to parse agent_completed event: flow_id is required"
+            )
+
+        return AgentCompleted(
+            parameters["agent_id"],
+            parameters["flow_id"],
+            parameters.get("status"),
+            parameters.get("timestamp"),
+            parameters.get("metadata"),
+        )
+
+
+class AgentStarted(SkipEventInMDStoryMixin):
+    """Mark the start of an agent."""
+
+    type_name = "agent_started"
+
+    def __init__(
+        self,
+        agent_id: str,
+        flow_id: str,
+        timestamp: Optional[float] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+        context_id: Optional[str] = None,
+    ) -> None:
+        self.agent_id = agent_id
+        self.flow_id = flow_id
+        self.context_id = context_id
+        super().__init__(timestamp, metadata)
+
+    def __repr__(self) -> str:
+        """Returns event as string for debugging."""
+        if self.context_id:
+            return (
+                f"AgentStarted(agent: {self.agent_id}, flow: {self.flow_id}, "
+                f"context_id: {self.context_id})"
+            )
+        else:
+            return f"AgentStarted(agent: {self.agent_id}, flow: {self.flow_id})"
+
+    def __str__(self) -> str:
+        """Returns event as human-readable string."""
+        return f"{self.__class__.__name__}({self.agent_id}, {self.flow_id})"
+
+    def __hash__(self) -> int:
+        """Returns unique hash for event."""
+        return hash((self.agent_id, self.flow_id))
+
+    def __eq__(self, other: Any) -> bool:
+        """Compares object with other object."""
+        if not isinstance(other, AgentStarted):
+            return NotImplemented
+        return (self.agent_id, self.flow_id) == (other.agent_id, other.flow_id)
+
+    def as_dict(self) -> Dict[str, Any]:
+        """Returns serialized event."""
+        serialized = super().as_dict()
+        serialized.update({"agent_id": self.agent_id, "flow_id": self.flow_id})
+        return serialized
+
+    @classmethod
+    def _from_parameters(cls, parameters: Dict[str, Any]) -> "AgentStarted":
+        if "agent_id" not in parameters:
+            raise ValueError(
+                "Failed to parse agent_started event: agent_id is required"
+            )
+        if "flow_id" not in parameters:
+            raise ValueError("Failed to parse agent_started event: flow_id is required")
+
+        return AgentStarted(
+            parameters["agent_id"],
+            parameters["flow_id"],
+            parameters.get("timestamp"),
+            parameters.get("metadata"),
+        )
+
+
+class AgentInterrupted(SkipEventInMDStoryMixin):
+    """Mark the interruption of an agent."""
+
+    type_name = "agent_interrupted"
+
+    def __init__(
+        self,
+        agent_id: str,
+        flow_id: str,
+        timestamp: Optional[float] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        self.agent_id = agent_id
+        self.flow_id = flow_id
+        super().__init__(timestamp, metadata)
+
+    def __repr__(self) -> str:
+        """Returns event as string for debugging."""
+        return f"AgentInterrupted(agent: {self.agent_id}, flow: {self.flow_id})"
+
+    def __str__(self) -> str:
+        """Returns event as human-readable string."""
+        return f"{self.__class__.__name__}({self.agent_id}, {self.flow_id})"
+
+    def __hash__(self) -> int:
+        """Returns unique hash for event."""
+        return hash((self.agent_id, self.flow_id))
+
+    def __eq__(self, other: Any) -> bool:
+        """Compares object with other object."""
+        if not isinstance(other, AgentInterrupted):
+            return NotImplemented
+        return (self.agent_id, self.flow_id) == (other.agent_id, other.flow_id)
+
+    def as_dict(self) -> Dict[str, Any]:
+        """Returns serialized event."""
+        serialized = super().as_dict()
+        serialized.update({"agent_id": self.agent_id, "flow_id": self.flow_id})
+        return serialized
+
+    @classmethod
+    def _from_parameters(cls, parameters: Dict[str, Any]) -> "AgentInterrupted":
+        if "agent_id" not in parameters:
+            raise ValueError(
+                "Failed to parse agent_interrupted event: agent_id is required"
+            )
+        if "flow_id" not in parameters:
+            raise ValueError(
+                "Failed to parse agent_interrupted event: flow_id is required"
+            )
+
+        return AgentInterrupted(
+            parameters["agent_id"],
+            parameters["flow_id"],
+            parameters.get("timestamp"),
+            parameters.get("metadata"),
+        )
+
+
+class AgentCancelled(SkipEventInMDStoryMixin):
+    """Mark the cancellation of an agent."""
+
+    type_name = "agent_cancelled"
+
+    def __init__(
+        self,
+        agent_id: str,
+        flow_id: str,
+        reason: Optional[str] = None,
+        timestamp: Optional[float] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        self.agent_id = agent_id
+        self.flow_id = flow_id
+        self.reason = reason
+        super().__init__(timestamp, metadata)
+
+    def __repr__(self) -> str:
+        """Returns event as string for debugging."""
+        return (
+            f"AgentCancelled(agent: {self.agent_id}, flow: {self.flow_id}, "
+            f"reason: {self.reason})"
+        )
+
+    def __str__(self) -> str:
+        """Returns event as human-readable string."""
+        return (
+            f"{self.__class__.__name__}({self.agent_id}, {self.flow_id}, {self.reason})"
+        )
+
+    def __hash__(self) -> int:
+        """Returns unique hash for event."""
+        return hash((self.agent_id, self.flow_id, self.reason))
+
+    def __eq__(self, other: Any) -> bool:
+        """Compares object with other object."""
+        if not isinstance(other, AgentCancelled):
+            return NotImplemented
+        return (self.agent_id, self.flow_id, self.reason) == (
+            other.agent_id,
+            other.flow_id,
+            other.reason,
+        )
+
+    def as_dict(self) -> Dict[str, Any]:
+        """Returns serialized event."""
+        serialized = super().as_dict()
+        serialized.update(
+            {"agent_id": self.agent_id, "flow_id": self.flow_id, "reason": self.reason}
+        )
+        return serialized
+
+    @classmethod
+    def _from_parameters(cls, parameters: Dict[str, Any]) -> "AgentCancelled":
+        if "agent_id" not in parameters:
+            raise ValueError(
+                "Failed to parse agent_cancelled event: agent_id is required"
+            )
+        if "flow_id" not in parameters:
+            raise ValueError(
+                "Failed to parse agent_cancelled event: flow_id is required"
+            )
+
+        return AgentCancelled(
+            parameters["agent_id"],
+            parameters["flow_id"],
+            parameters.get("reason"),
+            parameters.get("timestamp"),
+            parameters.get("metadata"),
+        )
+
+
+class AgentResumed(SkipEventInMDStoryMixin):
+    """Mark the resumption of an agent."""
+
+    type_name = "agent_resumed"
+
+    def __init__(
+        self,
+        agent_id: str,
+        flow_id: str,
+        timestamp: Optional[float] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        self.agent_id = agent_id
+        self.flow_id = flow_id
+        super().__init__(timestamp, metadata)
+
+    def __repr__(self) -> str:
+        """Returns event as string for debugging."""
+        return f"AgentResumed(agent: {self.agent_id}, flow: {self.flow_id})"
+
+    def __str__(self) -> str:
+        """Returns event as human-readable string."""
+        return f"{self.__class__.__name__}({self.agent_id}, {self.flow_id})"
+
+    def __hash__(self) -> int:
+        """Returns unique hash for event."""
+        return hash((self.agent_id, self.flow_id))
+
+    def __eq__(self, other: Any) -> bool:
+        """Compares object with other object."""
+        if not isinstance(other, AgentResumed):
+            return NotImplemented
+        return (self.agent_id, self.flow_id) == (other.agent_id, other.flow_id)
+
+    def as_dict(self) -> Dict[str, Any]:
+        """Returns serialized event."""
+        serialized = super().as_dict()
+        serialized.update({"agent_id": self.agent_id, "flow_id": self.flow_id})
+        return serialized
+
+    @classmethod
+    def _from_parameters(cls, parameters: Dict[str, Any]) -> "AgentResumed":
+        if "agent_id" not in parameters:
+            raise ValueError(
+                "Failed to parse agent_resumed event: agent_id is required"
+            )
+        if "flow_id" not in parameters:
+            raise ValueError("Failed to parse agent_resumed event: flow_id is required")
+
+        return AgentResumed(
+            parameters["agent_id"],
+            parameters["flow_id"],
+            parameters.get("timestamp"),
+            parameters.get("metadata"),
+        )
+
+
 class SessionEnded(AlwaysEqualEventMixin):
     """Mark the end of a conversation session."""
 

rasa/shared/core/flows/constants.py

@@ -11,3 +11,8 @@ KEY_RUN_PATTERN_COMPLETED = "run_pattern_completed"
 KEY_TRANSLATION = "translation"
 KEY_CALLED_FLOW = "called_flow"
 KEY_LINKED_FLOW = "linked_flow"
+
+# MCP mapping field names
+KEY_MAPPING_INPUT = "input"
+KEY_MAPPING_OUTPUT = "output"
+KEY_MAPPING_SLOT = "slot"

rasa/shared/core/flows/flow.py

@@ -8,7 +8,6 @@ from typing import Any, Dict, List, Optional, Set, Text, Tuple, Union
 
 import structlog
 from pydantic import BaseModel
-from pypred import Predicate
 
 import rasa.shared.utils.io
 from rasa.engine.language import Language
@@ -53,6 +52,7 @@ from rasa.shared.core.flows.steps.constants import (
 )
 from rasa.shared.core.flows.steps.continuation import ContinueFlowStep
 from rasa.shared.core.slots import Slot
+from rasa.utils.pypred import Predicate
 
 structlogger = structlog.get_logger()
 

rasa/shared/core/flows/flow_step.py

@@ -52,7 +52,13 @@ def step_from_json(flow_id: Text, data: Dict[Text, Any]) -> FlowStep:
         return SetSlotsFlowStep.from_json(flow_id, data)
     if "noop" in data:
         return NoOperationFlowStep.from_json(flow_id, data)
-    raise RasaException(f"Failed to parse step from json. Unknown type for {data}.")
+
+    required_properties = ["action", "collect", "link", "call", "set_slots", "noop"]
+    raise RasaException(
+        f"Failed to parse step from json. Unknown type for {data}. "
+        f"At least one of the following properties is required: "
+        f"{', '.join(required_properties)}"
+    )
 
 
 @dataclass

rasa/shared/core/flows/flows_list.py

@@ -2,17 +2,21 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any, Dict, Generator, List, Optional, Set, Text, Union
+from typing import TYPE_CHECKING, Any, Dict, Generator, List, Optional, Set, Text, Union
 
 import rasa.shared.utils.io
 from rasa.shared.core.flows import Flow
 from rasa.shared.core.flows.flow_path import FlowPathsList
 from rasa.shared.core.flows.validation import (
     DuplicatedFlowIdException,
-    validate_called_flows_exists,
+    validate_call_steps,
+    validate_exit_if_conditions,
+    validate_exit_if_exclusivity,
     validate_flow,
     validate_link_in_call_restriction,
     validate_linked_flows_exists,
+    validate_mcp_mapping_slots,
+    validate_mcp_server_references,
     validate_nlu_trigger,
     validate_patterns_are_not_called_or_linked,
     validate_patterns_are_not_calling_or_linking_other_flows,
@@ -20,6 +24,9 @@ from rasa.shared.core.flows.validation import (
 )
 from rasa.shared.core.slots import Slot
 
+if TYPE_CHECKING:
+    from rasa.shared.core.domain import Domain
+
 
 @dataclass
 class FlowsList:
@@ -160,17 +167,26 @@ class FlowsList:
         else:
             return None
 
-    def validate(self) -> None:
-        """Validate the flows."""
+    def validate(self, domain: Optional["Domain"] = None) -> None:
+        """Validate the flows.
+
+        Args:
+            domain: Optional domain containing slot definitions. If provided,
+                   exit_if conditions will be validated against defined slots.
+        """
         for flow in self.underlying_flows:
             validate_flow(flow)
         validate_nlu_trigger(self.underlying_flows)
         validate_link_in_call_restriction(self)
-        validate_called_flows_exists(self)
+        validate_call_steps(self)
+        validate_mcp_server_references(self)
+        validate_mcp_mapping_slots(self, domain)
         validate_linked_flows_exists(self)
         validate_patterns_are_not_called_or_linked(self)
         validate_patterns_are_not_calling_or_linking_other_flows(self)
         validate_step_ids_are_unique(self)
+        validate_exit_if_conditions(self, domain)
+        validate_exit_if_exclusivity(self)
 
     @property
     def user_flow_ids(self) -> Set[str]: