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

rasa/server.py

@@ -44,7 +44,6 @@ import rasa.utils.endpoints
 import rasa.utils.io
 from rasa.constants import MINIMUM_COMPATIBLE_VERSION
 from rasa.core.agent import Agent
-from rasa.core.available_agents import AvailableAgents
 from rasa.core.available_endpoints import AvailableEndpoints
 from rasa.core.channels.channel import (
     CollectingOutputChannel,
@@ -694,7 +693,6 @@ def create_app(
     jwt_private_key: Optional[Text] = None,
     jwt_method: Text = "HS256",
     endpoints: Optional[AvailableEndpoints] = None,
-    sub_agents: Optional[AvailableAgents] = None,
     is_inspector_enabled: bool = False,
 ) -> Sanic:
     """Class representing a Rasa HTTP server."""
@@ -730,7 +728,6 @@ def create_app(
             user_id="username",
         )
 
-    app.ctx.sub_agents = sub_agents
     app.ctx.agent = agent
     # Initialize shared object of type unsigned int for tracking
     # the number of active training processes
@@ -1466,13 +1463,6 @@ def create_app(
         flows = await processor.get_flows()
         return response.json(flows.as_json_list())
 
-    @app.get("/sub-agents")
-    @requires_auth(app, auth_token)
-    async def get_sub_agents(request: Request) -> HTTPResponse:
-        """Get all the sub-agents currently stored by the agent."""
-        sub_agents = app.ctx.sub_agents
-        return response.json(sub_agents.as_json_list())
-
     @app.get("/domain")
     @requires_auth(app, auth_token)
     @ensure_loaded_agent(app)

rasa/shared/constants.py

@@ -345,8 +345,6 @@ PAYLOAD = "payload"
 # Used for LLM command generation
 ROLE_USER = "user"
 ROLE_SYSTEM = "system"
-ROLE_ASSISTANT = "assistant"
-ROLE_TOOL = "tool"
 
 # Used for key values in ValidateSlotPatternFlowStackFrame
 REFILL_UTTER = "refill_utter"
@@ -361,6 +359,3 @@ FAQ_INPUT_DATA_QUESTION_LINE_PREFIX = "Q:"
 FAQ_INPUT_DATA_ANSWER_LINE_PREFIX = "A:"
 FAQ_DOCUMENT_ENTRY_SEPARATOR = "\n\n"
 FAQ_DOCUMENT_LINE_SEPARATOR = "\n"
-
-# Constants for the MCP server
-KEY_TOOL_CALLS = "tool_calls"

rasa/shared/core/constants.py

@@ -30,7 +30,6 @@ LOOP_NAME = "name"
 ACTION_LISTEN_NAME = "action_listen"
 ACTION_RESTART_NAME = "action_restart"
 ACTION_SEND_TEXT_NAME = "action_send_text"
-ACTION_AGENT_REQUEST_USER_INPUT_NAME = "action_agent_request_user_input"
 ACTION_SESSION_START_NAME = "action_session_start"
 ACTION_DEFAULT_FALLBACK_NAME = "action_default_fallback"
 ACTION_DEACTIVATE_LOOP_NAME = "action_deactivate_loop"
@@ -53,16 +52,10 @@ ACTION_TRIGGER_CHITCHAT = "action_trigger_chitchat"
 ACTION_RESET_ROUTING = "action_reset_routing"
 ACTION_HANGUP = "action_hangup"
 ACTION_REPEAT_BOT_MESSAGES = "action_repeat_bot_messages"
-ACTION_CONTINUE_INTERRUPTED_FLOW = "action_continue_interrupted_flow"
-ACTION_SET_INTERRUPTED_FLOWS = "action_set_interrupted_flows"
-ACTION_CANCEL_INTERRUPTED_FLOW = "action_cancel_interrupted_flow"
-ACTION_ASK_INTERRUPTED_FLOW_TO_CONTINUE = "action_ask_interrupted_flow_to_continue"
 
 ACTION_METADATA_EXECUTION_SUCCESS = "execution_success"
 ACTION_METADATA_EXECUTION_ERROR_MESSAGE = "execution_error_message"
 
-ACTION_METADATA_MESSAGE_KEY = "message"
-ACTION_METADATA_TEXT_KEY = "text"
 
 DEFAULT_ACTION_NAMES = [
     ACTION_LISTEN_NAME,
@@ -77,7 +70,6 @@ DEFAULT_ACTION_NAMES = [
     ACTION_UNLIKELY_INTENT_NAME,
     ACTION_BACK_NAME,
     ACTION_SEND_TEXT_NAME,
-    ACTION_AGENT_REQUEST_USER_INPUT_NAME,
     RULE_SNIPPET_ACTION_NAME,
     ACTION_EXTRACT_SLOTS,
     ACTION_CANCEL_FLOW,
@@ -90,10 +82,6 @@ DEFAULT_ACTION_NAMES = [
     ACTION_RESET_ROUTING,
     ACTION_HANGUP,
     ACTION_REPEAT_BOT_MESSAGES,
-    ACTION_CONTINUE_INTERRUPTED_FLOW,
-    ACTION_SET_INTERRUPTED_FLOWS,
-    ACTION_CANCEL_INTERRUPTED_FLOW,
-    ACTION_ASK_INTERRUPTED_FLOW_TO_CONTINUE,
 ]
 
 ACTION_SHOULD_SEND_DOMAIN = "send_domain"
@@ -148,6 +136,7 @@ DEFAULT_SLOT_NAMES = {
     FLOW_HASHES_SLOT,
 }
 
+
 SLOT_MAPPINGS = "mappings"
 MAPPING_CONDITIONS = "conditions"
 KEY_MAPPING_TYPE = "type"

rasa/shared/core/domain.py

@@ -98,6 +98,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 +148,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()
@@ -318,7 +322,7 @@ class Domain:
         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 +472,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
@@ -510,8 +514,8 @@ class Domain:
     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.
+        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.
@@ -545,7 +549,7 @@ class Domain:
     def difference(self, other: Domain) -> Domain:
         """Returns a new Domain containing items in `self` that are NOT in `other`.
 
-        Simple using equality checks for dict/list items.
+        Uses simple equality checks for dict/list items.
 
         Args:
             other: The domain to compare with.
@@ -598,9 +602,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 +948,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 +1722,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

@@ -2646,325 +2646,6 @@ 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,
-    ) -> 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"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/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

@@ -9,7 +9,7 @@ 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_call_steps,
+    validate_called_flows_exists,
     validate_flow,
     validate_link_in_call_restriction,
     validate_linked_flows_exists,
@@ -166,7 +166,7 @@ class FlowsList:
             validate_flow(flow)
         validate_nlu_trigger(self.underlying_flows)
         validate_link_in_call_restriction(self)
-        validate_call_steps(self)
+        validate_called_flows_exists(self)
         validate_linked_flows_exists(self)
         validate_patterns_are_not_called_or_linked(self)
         validate_patterns_are_not_calling_or_linking_other_flows(self)