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

rasa/core/policies/flows/mcp_tool_executor.py

@@ -0,0 +1,240 @@
+import json
+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
+
+structlogger = structlog.get_logger()
+
+SEPARATOR = "\n###\n"
+
+
+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.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,
+            )
+
+            # Process successful result
+            set_slot_event = _process_tool_result(result, step.mapping["output"])
+            if set_slot_event:
+                initial_events.append(set_slot_event)
+
+        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 _process_tool_result(
+    result: CallToolResult,
+    output_mapping: str,
+) -> Optional[SlotSet]:
+    """Create a SetSlot event for the tool result."""
+    try:
+        content_as_string = [
+            json.dumps(content_part.model_dump()) for content_part in result.content
+        ]
+        return SlotSet(key=output_mapping, value=SEPARATOR.join(content_as_string))
+    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/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,
@@ -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,

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
@@ -141,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,
@@ -169,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,
             )
         )
@@ -233,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,
@@ -273,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,
@@ -292,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",
     )
 
@@ -330,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:
@@ -342,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/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)
+        }
+    )

rasa/dialogue_understanding/commands/__init__.py

@@ -8,6 +8,9 @@ from rasa.dialogue_understanding.commands.chit_chat_answer_command import (
 )
 from rasa.dialogue_understanding.commands.clarify_command import ClarifyCommand
 from rasa.dialogue_understanding.commands.command import Command
+from rasa.dialogue_understanding.commands.continue_agent_command import (
+    ContinueAgentCommand,
+)
 from rasa.dialogue_understanding.commands.correct_slots_command import (
     CorrectedSlot,
     CorrectSlotsCommand,
@@ -29,6 +32,9 @@ from rasa.dialogue_understanding.commands.noop_command import NoopCommand
 from rasa.dialogue_understanding.commands.repeat_bot_messages_command import (
     RepeatBotMessagesCommand,
 )
+from rasa.dialogue_understanding.commands.restart_agent_command import (
+    RestartAgentCommand,
+)
 from rasa.dialogue_understanding.commands.restart_command import RestartCommand
 from rasa.dialogue_understanding.commands.session_end_command import SessionEndCommand
 from rasa.dialogue_understanding.commands.session_start_command import (
@@ -62,4 +68,6 @@ __all__ = [
     "SessionEndCommand",
     "RepeatBotMessagesCommand",
     "RestartCommand",
+    "ContinueAgentCommand",
+    "RestartAgentCommand",
 ]

rasa/dialogue_understanding/commands/cancel_flow_command.py

@@ -2,10 +2,13 @@ from __future__ import annotations
 
 import re
 from dataclasses import dataclass
-from typing import Any, Dict, List
+from typing import Any, Dict, List, Optional, Tuple
 
 import structlog
 
+from rasa.core.policies.flows.flow_executor import (
+    remove_agent_stack_frame,
+)
 from rasa.dialogue_understanding.commands.command import Command
 from rasa.dialogue_understanding.commands.command_syntax_manager import (
     CommandSyntaxManager,
@@ -13,12 +16,13 @@ from rasa.dialogue_understanding.commands.command_syntax_manager import (
 )
 from rasa.dialogue_understanding.patterns.cancel import CancelPatternFlowStackFrame
 from rasa.dialogue_understanding.stack.dialogue_stack import DialogueStack
+from rasa.dialogue_understanding.stack.frames import DialogueStackFrame
 from rasa.dialogue_understanding.stack.frames.flow_stack_frame import (
     FlowStackFrameType,
     UserFlowStackFrame,
 )
 from rasa.dialogue_understanding.stack.utils import top_user_flow_frame
-from rasa.shared.core.events import Event, FlowCancelled
+from rasa.shared.core.events import AgentCancelled, Event, FlowCancelled
 from rasa.shared.core.flows import FlowsList
 from rasa.shared.core.trackers import DialogueStateTracker
 
@@ -48,8 +52,7 @@ class CancelFlowCommand(Command):
         """Selects the frames that were canceled.
 
         Args:
-            dialogue_stack: The dialogue stack.
-            current_flow: The current flow.
+            stack: The dialogue stack.
 
         Returns:
         The frames that were canceled.
@@ -106,6 +109,19 @@ class CancelFlowCommand(Command):
             )
             return []
 
+        if agent_frame := original_tracker.stack.find_active_agent_stack_frame_for_flow(
+            current_flow.id
+        ):
+            structlogger.debug(
+                "cancel_command.remove_agent_stack_frame",
+                command=self,
+                frame=agent_frame,
+            )
+            remove_agent_stack_frame(stack, agent_frame.agent_id)
+            applied_events.append(
+                AgentCancelled(agent_id=agent_frame.agent_id, flow_id=current_flow.id)
+            )
+
         # we pass in the original dialogue stack (before any of the currently
         # predicted commands were applied) to make sure we don't cancel any
         # frames that were added by the currently predicted commands.
@@ -159,3 +175,80 @@ class CancelFlowCommand(Command):
             CommandSyntaxManager.get_syntax_version(),
             mapper[CommandSyntaxManager.get_default_syntax_version()],
         )
+
+    def cancel_flow(
+        self,
+        tracker: DialogueStateTracker,
+        stack: DialogueStack,
+        flow_id: str,
+    ) -> List[Event]:
+        """Cancels a flow by flow id."""
+        applied_events: List[Event] = []
+
+        frames_to_cancel, user_frame_to_cancel = self._collect_frames_to_cancel(
+            stack, flow_id
+        )
+
+        # if the flow is not on the stack, do nothing
+        if user_frame_to_cancel is None:
+            structlogger.error(
+                "cancel_flow_command.cancel_flow.no_user_frame_to_cancel",
+                command=self,
+            )
+            return []
+
+        frames_ids_to_cancel = [frame.frame_id for frame in frames_to_cancel]
+
+        stack.push(
+            CancelPatternFlowStackFrame(
+                canceled_name=flow_id,
+                canceled_frames=frames_ids_to_cancel,
+            )
+        )
+
+        # create flow cancelled event
+        applied_events.extend(
+            [
+                FlowCancelled(
+                    user_frame_to_cancel.flow_id, user_frame_to_cancel.step_id
+                ),
+            ]
+        )
+
+        update_stack_events = tracker.create_stack_updated_events(stack)
+
+        return applied_events + update_stack_events
+
+    def _collect_frames_to_cancel(
+        self, stack: DialogueStack, target_flow_id: str
+    ) -> Tuple[List[DialogueStackFrame], Optional[UserFlowStackFrame]]:
+        """Collect frames that need to be cancelled.
+
+        Args:
+            stack: The stack to collect frames from.
+            target_flow_id: The ID of the flow to cancel.
+
+        Returns:
+            A tuple containing (frames_to_cancel, frame_to_cancel).
+        """
+        frames_to_cancel: List[DialogueStackFrame] = []
+        frame_found = False
+        frame_to_cancel = None
+
+        for frame in stack.frames:
+            if isinstance(frame, UserFlowStackFrame) and (
+                frame.frame_type == FlowStackFrameType.REGULAR
+                or frame.frame_type == FlowStackFrameType.INTERRUPT
+            ):
+                if frame.flow_id == target_flow_id:
+                    frames_to_cancel.append(frame)
+                    frame_to_cancel = frame
+                    frame_found = True
+                    continue
+                elif frame_found:
+                    break
+
+            if frame_found:
+                frames_to_cancel.append(frame)
+
+        return list(frames_to_cancel), frame_to_cancel

rasa/dialogue_understanding/commands/chit_chat_answer_command.py

@@ -12,6 +12,10 @@ from rasa.dialogue_understanding.commands.free_form_answer_command import (
     FreeFormAnswerCommand,
 )
 from rasa.dialogue_understanding.patterns.chitchat import ChitchatPatternFlowStackFrame
+from rasa.dialogue_understanding.stack.frames.flow_stack_frame import (
+    AgentStackFrame,
+    AgentState,
+)
 from rasa.shared.core.events import Event
 from rasa.shared.core.flows import FlowsList
 from rasa.shared.core.trackers import DialogueStateTracker
@@ -52,6 +56,13 @@ class ChitChatAnswerCommand(FreeFormAnswerCommand):
             The events to apply to the tracker.
         """
         stack = tracker.stack
+
+        # if the top stack frame is an agent stack frame, we need to
+        # update the state to INTERRUPTED
+        if top_stack_frame := stack.top():
+            if isinstance(top_stack_frame, AgentStackFrame):
+                top_stack_frame.state = AgentState.INTERRUPTED
+
         stack.push(ChitchatPatternFlowStackFrame())
         return tracker.create_stack_updated_events(stack)
 

rasa/dialogue_understanding/commands/continue_agent_command.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from typing import Any, Dict, List
+
+import structlog
+
+from rasa.dialogue_understanding.commands.command import Command
+from rasa.dialogue_understanding.commands.command_syntax_manager import (
+    CommandSyntaxManager,
+    CommandSyntaxVersion,
+)
+from rasa.shared.core.events import Event
+from rasa.shared.core.flows import FlowsList
+from rasa.shared.core.trackers import DialogueStateTracker
+
+structlogger = structlog.get_logger()
+
+
+@dataclass
+class ContinueAgentCommand(Command):
+    """A command to continue the currently active agent's execution."""
+
+    @classmethod
+    def command(cls) -> str:
+        """Returns the command type."""
+        return "continue agent"
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> ContinueAgentCommand:
+        """Converts the dictionary to a command.
+
+        Returns:
+            The converted dictionary.
+        """
+        return ContinueAgentCommand()
+
+    def run_command_on_tracker(
+        self,
+        tracker: DialogueStateTracker,
+        all_flows: FlowsList,
+        original_tracker: DialogueStateTracker,
+    ) -> List[Event]:
+        """Runs the command on the tracker.
+
+        Args:
+            tracker: The tracker to run the command on.
+            all_flows: All flows in the assistant.
+            original_tracker: The tracker before any command was executed.
+
+        Returns:
+            The events to apply to the tracker.
+        """
+        # do nothing
+        return []
+
+    def __hash__(self) -> int:
+        return hash(self.command())
+
+    def __eq__(self, other: object) -> bool:
+        return isinstance(other, ContinueAgentCommand)
+
+    def to_dsl(self) -> str:
+        """Converts the command to a DSL string."""
+        mapper = {
+            CommandSyntaxVersion.v1: "ContinueAgent()",
+            CommandSyntaxVersion.v2: "continue agent",
+            CommandSyntaxVersion.v3: "continue agent",
+        }
+        return mapper.get(
+            CommandSyntaxManager.get_syntax_version(),
+            mapper[CommandSyntaxManager.get_default_syntax_version()],
+        )
+
+    @classmethod
+    def from_dsl(cls, match: re.Match, **kwargs: Any) -> ContinueAgentCommand:
+        """Converts a DSL string to a command."""
+        return ContinueAgentCommand()
+
+    @staticmethod
+    def regex_pattern() -> str:
+        mapper = {
+            CommandSyntaxVersion.v1: r"ContinueAgent\(\)",
+            CommandSyntaxVersion.v2: r"""^[\s\W\d]*continue agent['"`]*$""",
+            CommandSyntaxVersion.v3: r"""^[\s\W\d]*continue agent['"`]*$""",
+        }
+        return mapper.get(
+            CommandSyntaxManager.get_syntax_version(),
+            mapper[CommandSyntaxManager.get_default_syntax_version()],
+        )

rasa/dialogue_understanding/commands/knowledge_answer_command.py

@@ -12,6 +12,10 @@ from rasa.dialogue_understanding.commands.free_form_answer_command import (
     FreeFormAnswerCommand,
 )
 from rasa.dialogue_understanding.patterns.search import SearchPatternFlowStackFrame
+from rasa.dialogue_understanding.stack.frames.flow_stack_frame import (
+    AgentStackFrame,
+    AgentState,
+)
 from rasa.shared.core.events import Event
 from rasa.shared.core.flows import FlowsList
 from rasa.shared.core.trackers import DialogueStateTracker
@@ -52,6 +56,13 @@ class KnowledgeAnswerCommand(FreeFormAnswerCommand):
             The events to apply to the tracker.
         """
         stack = tracker.stack
+
+        # if the top stack frame is an agent stack frame, we need to
+        # update the state to INTERRUPTED
+        if top_stack_frame := stack.top():
+            if isinstance(top_stack_frame, AgentStackFrame):
+                top_stack_frame.state = AgentState.INTERRUPTED
+
         stack.push(SearchPatternFlowStackFrame())
         return tracker.create_stack_updated_events(stack)