rasa-pro 3.13.6__py3-none-any.whl → 3.14.0.dev1__py3-none-any.whl

rasa/dialogue_understanding/stack/dialogue_stack.py

@@ -8,6 +8,13 @@ from typing import Any, Callable, Dict, List, Optional
 import jsonpatch
 import structlog
 
+from rasa.dialogue_understanding.stack.frames.flow_stack_frame import (
+    AgentStackFrame,
+    AgentState,
+    FlowStackFrameType,
+    UserFlowStackFrame,
+)
+
 if typing.TYPE_CHECKING:
     from rasa.dialogue_understanding.stack.frames import DialogueStackFrame
 
@@ -91,6 +98,42 @@ class DialogueStack:
         """
         return self.frames.pop()
 
+    def move_frames_to_top(self, frames_to_move: List["DialogueStackFrame"]) -> None:
+        """Moves specified frames to top of stack while preserving their relative order.
+
+        Args:
+            frames_to_move: The frames to move to the top of the stack.
+        """
+        # Get frames that are not being moved
+        frames_to_keep = [frame for frame in self.frames if frame not in frames_to_move]
+
+        # Reorder: keep frames first, then moved frames
+        self.frames = frames_to_keep + frames_to_move
+
+        # set all frames to interrupt except for LINK and CALL
+        for frame in self.frames:
+            if (
+                isinstance(frame, UserFlowStackFrame)
+                and frame.frame_type == FlowStackFrameType.LINK
+            ):
+                continue
+            if (
+                isinstance(frame, UserFlowStackFrame)
+                and frame.frame_type == FlowStackFrameType.CALL
+            ):
+                continue
+            if (
+                isinstance(frame, UserFlowStackFrame)
+                and frame.frame_type == FlowStackFrameType.REGULAR
+            ):
+                frame.frame_type = FlowStackFrameType.INTERRUPT
+
+        # set the first frame to regular
+        for frame in self.frames:
+            if isinstance(frame, UserFlowStackFrame):
+                frame.frame_type = FlowStackFrameType.REGULAR
+                return
+
     def current_context(self) -> Dict[str, Any]:
         """Returns the context of the topmost frame.
 
@@ -109,7 +152,7 @@ class DialogueStack:
         """Returns the topmost frame from the stack.
 
         Args:
-            ignore_frame: The ID of the flow to ignore. Picks the top most
+            ignore: The ID of the flow to ignore. Picks the top most
                 frame that has a different flow ID.
 
         Returns:
@@ -136,7 +179,8 @@ class DialogueStack:
             patch_dump: The patch to apply to the stack.
 
         Returns:
-            The updated stack."""
+        The updated stack.
+        """
         patch = jsonpatch.JsonPatch.from_string(patch_dump)
         dialogue_stack_dump = patch.apply(self.as_dict())
         return DialogueStack.from_dict(dialogue_stack_dump)
@@ -177,3 +221,80 @@ class DialogueStack:
         if patch:
             return patch.to_string()
         return None
+
+    def _find_agent_frame_by_predicate(
+        self, predicate: Callable[[AgentStackFrame], bool]
+    ) -> List[AgentStackFrame]:
+        stack_frames: List[AgentStackFrame] = []
+        for stack_frame in reversed(self.frames):
+            if isinstance(stack_frame, AgentStackFrame) and predicate(stack_frame):
+                stack_frames.append(stack_frame)
+        return stack_frames
+
+    def find_active_agent_frame(self) -> Optional[AgentStackFrame]:
+        stack_frames = self._find_agent_frame_by_predicate(
+            lambda frame: frame.state == AgentState.WAITING_FOR_INPUT
+        )
+        if stack_frames:
+            return stack_frames[0]
+        return None
+
+    def find_agent_stack_frame_by_agent(
+        self, agent_id: str
+    ) -> Optional[AgentStackFrame]:
+        """Get the agent stack frame for a specific agent ID.
+
+        May also include the agent stack frame in the INTERRUPTED state.
+        """
+        stack_frames = self._find_agent_frame_by_predicate(
+            lambda frame: frame.agent_id == agent_id
+        )
+        if stack_frames:
+            return stack_frames[0]
+        return None
+
+    def find_active_agent_stack_frame_for_flow(
+        self, flow_id: str
+    ) -> Optional[AgentStackFrame]:
+        """Get the agent stack frame of a specific flow."""
+        stack_frames = self._find_agent_frame_by_predicate(
+            lambda frame: frame.flow_id == flow_id
+        )
+        for stack_frame in stack_frames:
+            if stack_frame.state == AgentState.WAITING_FOR_INPUT:
+                return stack_frame
+        return None
+
+    def get_active_agent_id(self) -> Optional[typing.Text]:
+        agent_frame = self.find_active_agent_frame()
+        if agent_frame:
+            return agent_frame.agent_id
+        return None
+
+    def agent_is_active(self) -> bool:
+        return self.find_active_agent_frame() is not None
+
+    def get_all_user_flow_frames(
+        self, ignore_call_and_link_frames: bool = True
+    ) -> List[UserFlowStackFrame]:
+        """Get all user flow frames from the dialogue stack.
+
+        Args:
+            ignore_call_and_link_frames: Whether to ignore user frames of type `call`
+                and `link`. By default, these frames are ignored.
+
+        Returns:
+            A list of all user flow frames in the dialogue stack.
+        """
+        return [
+            frame
+            for frame in self.frames
+            if isinstance(frame, UserFlowStackFrame)
+            and (
+                not ignore_call_and_link_frames
+                or (
+                    frame.frame_type != FlowStackFrameType.CALL
+                    and frame.frame_type != FlowStackFrameType.LINK
+                )
+            )
+        ]

rasa/dialogue_understanding/stack/frames/flow_stack_frame.py

@@ -94,6 +94,18 @@ class InvalidFlowStepIdException(Exception):
         super().__init__(f"Invalid flow step ID '{step_id}' for flow '{flow_id}'.")
 
 
+class InvalidAgentState(RasaException):
+    """Raised if the agent state is invalid."""
+
+    def __init__(self, invalid_state: str) -> None:
+        """Creates a `InvalidAgentState`.
+
+        Args:
+            invalid_state: The invalid agent state.
+        """
+        super().__init__(f"Invalid agent state '{invalid_state}'.")
+
+
 @dataclass
 class BaseFlowStackFrame(DialogueStackFrame):
     flow_id: str = ""  # needed to avoid "default arg before non-default" error
@@ -171,3 +183,48 @@ class UserFlowStackFrame(BaseFlowStackFrame):
             step_id=data["step_id"],
             frame_type=FlowStackFrameType.from_str(data.get("frame_type")),
         )
+
+
+class AgentState(str, Enum):
+    INTERRUPTED = "interrupted"
+    WAITING_FOR_INPUT = "waiting_for_input"
+
+    @staticmethod
+    def from_str(state: Optional[str]) -> AgentState:
+        if state == AgentState.WAITING_FOR_INPUT.value:
+            return AgentState.WAITING_FOR_INPUT
+        elif state == AgentState.INTERRUPTED.value:
+            return AgentState.INTERRUPTED
+        else:
+            raise InvalidAgentState(state)
+
+
+@dataclass
+class AgentStackFrame(BaseFlowStackFrame):
+    agent_id: str = ""
+    state: AgentState = AgentState.WAITING_FOR_INPUT
+    metadata: Optional[Dict[str, Any]] = None
+
+    @classmethod
+    def type(cls) -> str:
+        """Returns the type of the frame."""
+        return "agent"
+
+    @staticmethod
+    def from_dict(data: Dict[str, Any]) -> AgentStackFrame:
+        """Creates a `AgentStackFrame` from a dictionary.
+
+        Args:
+            data: The dictionary to create the `AgentStackFrame` from.
+
+        Returns:
+            The created `AgentStackFrame`.
+        """
+        return AgentStackFrame(
+            frame_id=data["frame_id"],
+            flow_id=data["flow_id"],
+            step_id=data["step_id"],
+            agent_id=data["agent_id"],
+            state=AgentState.from_str(data["state"]),
+            metadata=data.get("metadata"),
+        )

rasa/dialogue_understanding/stack/utils.py

@@ -198,8 +198,9 @@ def end_top_user_flow(stack: DialogueStack) -> DialogueStack:
 def get_collect_steps_excluding_ask_before_filling_for_active_flow(
     dialogue_stack: DialogueStack, all_flows: FlowsList
 ) -> Set[str]:
-    """Get all collect steps that are part of the current flow, without
-    considering the collect steps that has to be asked before filling.
+    """Get all collect steps that are part of the current flow.
+
+    Collect steps that have to be asked before filling are not considered.
 
     Args:
         dialogue_stack: The dialogue stack.

rasa/dialogue_understanding_test/du_test_runner.py

@@ -1,10 +1,12 @@
 import asyncio
 import time
-from typing import Any, Dict, List, Optional, Text
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Union
 
 import structlog
 from tqdm import tqdm
 
+from rasa.core.available_agents import AvailableAgents
 from rasa.core.available_endpoints import AvailableEndpoints
 from rasa.core.channels import CollectingOutputChannel, UserMessage
 from rasa.core.exceptions import AgentNotReady
@@ -52,10 +54,11 @@ class DialogueUnderstandingTestRunner:
 
     def __init__(
         self,
-        model_path: Optional[Text] = None,
+        model_path: Optional[str] = None,
         model_server: Optional[EndpointConfig] = None,
         remote_storage: Optional[StorageType] = None,
         endpoints: Optional[AvailableEndpoints] = None,
+        sub_agents_path: Optional[Union[Path, str]] = None,
     ) -> None:
         """Initializes the Dialogue Understanding test suite runner.
 
@@ -68,6 +71,7 @@ class DialogueUnderstandingTestRunner:
         import rasa.core.agent
 
         self._check_action_server(endpoints)
+        sub_agents = AvailableAgents.get_instance(sub_agents_path)
 
         self.agent = asyncio.run(
             rasa.core.agent.load_agent(
@@ -75,6 +79,7 @@ class DialogueUnderstandingTestRunner:
                 model_server=model_server,
                 remote_storage=remote_storage,
                 endpoints=endpoints,
+                sub_agents=sub_agents,
             )
         )
         if not self.agent.is_ready():

rasa/dialogue_understanding_test/du_test_schema.yml

@@ -5,12 +5,12 @@ mapping:
     sequence:
       - type: map
         mapping:
-          regex;(^[a-zA-Z_]+[a-zA-Z0-9_]*$):
+          regex;(^[a-zA-Z_]+[a-zA-Z0-9_\-]*$):
             type: "seq"
             sequence:
               - type: map
                 mapping:
-                  regex;(^[a-zA-Z_]+[a-zA-Z0-9_]*$):
+                  regex;(^[a-zA-Z_]+[a-zA-Z0-9_\-]*$):
                     type: any
 
   metadata:
@@ -129,7 +129,7 @@ mapping:
             type: "seq"
             sequence:
               - type: "str"
-                pattern: ^[a-zA-Z_]+[a-zA-Z0-9_]*$
+                pattern: ^[a-zA-Z_]+[a-zA-Z0-9_\-]*$
           metadata:
             type: "str"
             pattern: ^[a-zA-Z_]+[a-zA-Z0-9_]*$

rasa/e2e_test/e2e_test_runner.py

@@ -13,6 +13,7 @@ import structlog
 from tqdm import tqdm
 
 import rasa.shared.utils.io
+from rasa.core.available_agents import AvailableAgents
 from rasa.core.available_endpoints import AvailableEndpoints
 from rasa.core.channels import CollectingOutputChannel, UserMessage
 from rasa.core.constants import ACTIVE_FLOW_METADATA_KEY, STEP_ID_METADATA_KEY
@@ -65,6 +66,7 @@ class E2ETestRunner:
         model_server: Optional[EndpointConfig] = None,
         remote_storage: Optional[StorageType] = None,
         endpoints: Optional[AvailableEndpoints] = None,
+        sub_agents_path: Optional[Text] = None,
         **kwargs: Any,
     ) -> None:
         """Initializes the E2E test suite runner.
@@ -94,12 +96,15 @@ class E2ETestRunner:
         if endpoints and not are_custom_actions_stubbed:
             self._action_server_is_reachable(endpoints)
 
+        sub_agents = AvailableAgents.get_instance(sub_agents_path)
+
         self.agent = asyncio.run(
             rasa.core.agent.load_agent(
                 model_path=model_path,
                 model_server=model_server,
                 remote_storage=remote_storage,
                 endpoints=endpoints,
+                sub_agents=sub_agents,
             )
         )
 

rasa/e2e_test/e2e_test_schema.yml

@@ -5,12 +5,12 @@ mapping:
     sequence:
       - type: map
         mapping:
-          regex;(^[a-zA-Z_]+[a-zA-Z0-9_]*$):
+          regex;(^[a-zA-Z_]+[a-zA-Z0-9_\-]*$):
             type: "seq"
             sequence:
               - type: map
                 mapping:
-                  regex;(^[a-zA-Z_]+[a-zA-Z0-9_]*$):
+                  regex;(^[a-zA-Z_]+[a-zA-Z0-9_\-]*$):
                     type: any
 
   metadata:
@@ -129,7 +129,7 @@ mapping:
             type: "seq"
             sequence:
               - type: "str"
-                pattern: ^[a-zA-Z_]+[a-zA-Z0-9_]*$
+                pattern: ^[a-zA-Z_]+[a-zA-Z0-9_\-]*$
           metadata:
             type: "str"
             pattern: ^[a-zA-Z_]+[a-zA-Z0-9_]*$

rasa/model_manager/model_api.py

@@ -571,7 +571,7 @@ def external_blueprint() -> Blueprint:
     """Create a blueprint for the model manager API."""
     from rasa.core.channels.socketio import SocketBlueprint
 
-    sio = AsyncServer(async_mode="sanic", cors_allowed_origins=[])
+    sio = AsyncServer(async_mode="sanic", cors_allowed_origins="*")
     bp = SocketBlueprint(sio, "", "model_api_external")
 
     create_bridge_server(sio, running_bots)

rasa/model_manager/socket_bridge.py

@@ -2,8 +2,7 @@ import json
 from typing import Any, Dict, Optional
 
 import structlog
-from socketio import AsyncServer
-from socketio.asyncio_client import AsyncClient
+from socketio import AsyncClient, AsyncServer  # type: ignore[attr-defined]
 from socketio.exceptions import ConnectionRefusedError
 
 from rasa.model_manager.runner_service import BotSession
@@ -131,6 +130,13 @@ async def create_bridge_client(
         structlogger.debug("model_runner.bot_message", deployment_id=deployment_id)
         await sio.emit("bot_message", data, room=sid)
 
+    @client.event  # type: ignore[misc]
+    async def error(data: Dict[str, Any]) -> None:
+        structlogger.debug(
+            "model_runner.bot_error", deployment_id=deployment_id, data=data
+        )
+        await sio.emit("error", data, room=sid)
+
     @client.event  # type: ignore[misc]
     async def tracker(data: Dict[str, Any]) -> None:
         await sio.emit("tracker", json.loads(data), room=sid)

rasa/server.py

@@ -44,6 +44,7 @@ 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,
@@ -693,6 +694,7 @@ 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."""
@@ -728,6 +730,7 @@ 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
@@ -1463,6 +1466,13 @@ 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/agents/utils.py

@@ -0,0 +1,35 @@
+from typing import Optional
+
+from rasa.agents.core.types import AgentIdentifier, ProtocolType
+from rasa.core.available_agents import AgentConfig, ProtocolConfig
+from rasa.shared.core.flows.steps import CallFlowStep
+
+
+def make_agent_identifier(
+    agent_name: str, protocol_type: ProtocolType
+) -> AgentIdentifier:
+    """Make an agent identifier."""
+    return AgentIdentifier(agent_name, protocol_type)
+
+
+def get_protocol_type(
+    step: CallFlowStep, agent_config: Optional[AgentConfig]
+) -> ProtocolType:
+    """Get the protocol type for an agent.
+
+    Args:
+        step: The step that is calling the agent.
+        agent_config: The agent configuration.
+
+    Returns:
+        The protocol type for the agent.
+    """
+    if step.exit_if:
+        protocol_type = ProtocolType.MCP_TASK
+    else:
+        protocol_type = (
+            ProtocolType.A2A
+            if agent_config and agent_config.agent.protocol == ProtocolConfig.A2A
+            else ProtocolType.MCP_OPEN
+        )
+    return protocol_type

rasa/shared/constants.py

@@ -345,6 +345,8 @@ 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"
@@ -359,3 +361,6 @@ 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,6 +30,7 @@ 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"
@@ -52,10 +53,16 @@ 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,
@@ -70,6 +77,7 @@ 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,
@@ -82,6 +90,10 @@ 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"
@@ -136,7 +148,6 @@ DEFAULT_SLOT_NAMES = {
     FLOW_HASHES_SLOT,
 }
 
-
 SLOT_MAPPINGS = "mappings"
 MAPPING_CONDITIONS = "conditions"
 KEY_MAPPING_TYPE = "type"

rasa/shared/core/domain.py

@@ -508,8 +508,8 @@ class Domain:
         return combined
 
     def partial_merge(self, other: Domain) -> Domain:
-        """
-        Returns a new Domain with intersection-based merging:
+        """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.
 
@@ -543,9 +543,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`.
+
+        Simple using equality checks for dict/list items.
 
         Args:
             other: The domain to compare with.