rasa-pro 3.14.0.dev6__py3-none-any.whl → 3.14.0.dev8__py3-none-any.whl

rasa/agents/protocol/mcp/mcp_base_agent.py

@@ -10,7 +10,7 @@ from mcp import ListToolsResult
 from rasa.agents.constants import (
     AGENT_DEFAULT_MAX_RETRIES,
     AGENT_DEFAULT_TIMEOUT_SECONDS,
-    AGENT_METADATA_TOOL_RESULTS_KEY,
+    AGENT_METADATA_STRUCTURED_RESULTS_KEY,
     KEY_ARGUMENTS,
     KEY_CONTENT,
     KEY_FUNCTION,
@@ -45,7 +45,7 @@ from rasa.shared.constants import (
     TIMEOUT_CONFIG_KEY,
 )
 from rasa.shared.core.events import BotUttered, UserUttered
-from rasa.shared.exceptions import AgentInitializationException
+from rasa.shared.exceptions import AgentInitializationException, AuthenticationError
 from rasa.shared.providers.llm.llm_response import LLMResponse, LLMToolCall
 from rasa.shared.utils.constants import LOG_COMPONENT_SOURCE_METHOD_INIT
 from rasa.shared.utils.llm import (
@@ -253,7 +253,8 @@ class MCPBaseAgent(AgentProtocol):
             except ConnectionError as ce:
                 structlogger.warning(
                     "mcp_agent.connect.connection_error",
-                    event_info=f"Connection attempt {attempt} failed: {ce}",
+                    event_info=f"Connection attempt {attempt} failed.",
+                    error=str(ce),
                     attempt=attempt,
                     max_retries=self._max_retries,
                 )
@@ -266,10 +267,14 @@ class MCPBaseAgent(AgentProtocol):
                         f"Failed to connect to MCP servers after {self._max_retries} "
                         f"attempts. Agent `{self._name}` failed to initialize."
                     ) from ce
-            except Exception as e:
+            except (Exception, AuthenticationError) as e:
+                if isinstance(e, AuthenticationError):
+                    event_info = "Authentication error during agent initialization."
+                else:
+                    event_info = "Unexpected error during agent initialization."
                 structlogger.error(
                     "mcp_agent.connect.unexpected_exception",
-                    event_info="Unexpected error during agent initialization.",
+                    event_info=event_info,
                     error=str(e),
                     agent_name=self._name,
                     agent_id=str(make_agent_identifier(self._name, self.protocol_type)),
@@ -296,7 +301,7 @@ class MCPBaseAgent(AgentProtocol):
         except Exception as e:
             event_info = (
                 f"Agent `{self._name}` failed to connect to MCP server - "
-                f"{server_name} @ {server_config.url}: {e}"
+                f"`{server_name}` @ `{server_config.url}`: {e!s}"
             )
             structlogger.error(
                 "mcp_agent.connect.failed_to_connect",
@@ -306,7 +311,7 @@ class MCPBaseAgent(AgentProtocol):
                 agent_name=self._name,
                 agent_id=str(make_agent_identifier(self._name, self.protocol_type)),
             )
-            raise ConnectionError(e)
+            raise e
 
     async def connect_to_servers(self) -> None:
         """Connect to MCP servers."""
@@ -333,7 +338,7 @@ class MCPBaseAgent(AgentProtocol):
         except Exception as e:
             structlogger.error(
                 "mcp_agent.disconnect_server.error",
-                event_info=f"Failed to disconnect from server `{server_name}`: {e}",
+                event_info=f"Failed to disconnect from server `{server_name}`: {e!s}",
                 server_name=server_name,
                 agent_name=self._name,
                 agent_id=str(make_agent_identifier(self._name, self.protocol_type)),
@@ -548,6 +553,19 @@ class MCPBaseAgent(AgentProtocol):
             KEY_CONTENT: tool_response.response_message,
         }
 
+    def _get_system_message_for_malformed_tool_response(self) -> Dict[str, Any]:
+        """Get the system message for a malformed tool response."""
+        system_message = (
+            "The previous tool response contained invalid or incomplete JSON and could"
+            "not be parsed. Retry by generating a tool response in STRICT JSON string "
+            "format only. Ensure the JSON is fully well-formed and corresponds exactly "
+            "to the user's last request."
+        )
+        return {
+            KEY_ROLE: ROLE_SYSTEM,
+            KEY_CONTENT: system_message,
+        }
+
     # ============================================================================
     # Tool Execution
     # ============================================================================
@@ -566,8 +584,8 @@ class MCPBaseAgent(AgentProtocol):
 
         server_id = self._tool_to_server_mapper[tool_name]
         connection = self._server_connections[server_id]
-        session = await connection.ensure_active_session()
         try:
+            session = await connection.ensure_active_session()
             result = await session.call_tool(tool_name, arguments)
             return AgentToolResult.from_mcp_tool_result(tool_name, result)
         except Exception as e:
@@ -577,7 +595,7 @@ class MCPBaseAgent(AgentProtocol):
                 is_error=True,
                 error_message=(
                     f"Failed to execute tool `{tool_name}` via MCP server `{server_id}`"
-                    f"@ {connection.server_url}: {e}"
+                    f" @ `{connection.server_url}`: {e!s}"
                 ),
             )
 
@@ -606,7 +624,7 @@ class MCPBaseAgent(AgentProtocol):
                 tool_name=tool_name,
                 result=None,
                 is_error=True,
-                error_message=f"Failed to execute built-in tool `{tool_name}`: {e}",
+                error_message=f"Failed to execute built-in tool `{tool_name}`: {e!s}",
             )
         return await self._execute_mcp_tool(tool_name, arguments)
 
@@ -639,24 +657,24 @@ class MCPBaseAgent(AgentProtocol):
                 error_message=tool_output.error_message,
             )
 
-    def _get_tool_results_for_agent_output(
+    def _get_structured_results_for_agent_output(
         self,
         agent_input: AgentInput,
         current_tool_results: Dict[str, AgentToolResult],
     ) -> List[List[Dict[str, Any]]]:
         """Get the tool results for the agent output."""
-        tool_results_of_current_iteration: List[Dict[str, Any]] = []
+        structured_results_of_current_iteration: List[Dict[str, Any]] = []
         for tool_result in current_tool_results.values():
-            tool_results_of_current_iteration.append(
-                {"tool_name": tool_result.tool_name, "result": tool_result.result}
+            structured_results_of_current_iteration.append(
+                {"name": tool_result.tool_name, "result": tool_result.result}
             )
 
-        previous_tool_results: List[List[Dict[str, Any]]] = (
-            agent_input.metadata.get(AGENT_METADATA_TOOL_RESULTS_KEY, []) or []
+        previous_structured_results: List[List[Dict[str, Any]]] = (
+            agent_input.metadata.get(AGENT_METADATA_STRUCTURED_RESULTS_KEY, []) or []
         )
-        previous_tool_results.append(tool_results_of_current_iteration)
+        previous_structured_results.append(structured_results_of_current_iteration)
 
-        return previous_tool_results
+        return previous_structured_results
 
     # ============================================================================
     # Core Protocol Methods

rasa/agents/protocol/mcp/mcp_open_agent.py

@@ -31,6 +31,10 @@ from rasa.shared.agents.utils import make_agent_identifier
 from rasa.shared.constants import (
     ROLE_TOOL,
 )
+from rasa.shared.exceptions import (
+    LLMToolResponseDecodeError,
+    ProviderClientAPIException,
+)
 from rasa.shared.providers.llm.llm_response import LLMResponse, LLMToolCall
 
 DEFAULT_OPEN_AGENT_PROMPT_TEMPLATE = importlib.resources.read_text(
@@ -130,7 +134,7 @@ class MCPOpenAgent(MCPBaseAgent):
             id=agent_input.id,
             status=AgentStatus.COMPLETED,
             response_message=tool_result.result,
-            tool_results=self._get_tool_results_for_agent_output(
+            structured_results=self._get_structured_results_for_agent_output(
                 agent_input, tool_results
             ),
         )
@@ -178,7 +182,7 @@ class MCPOpenAgent(MCPBaseAgent):
                         id=agent_input.id,
                         status=AgentStatus.RECOVERABLE_ERROR,
                         error_message=event_info,
-                        tool_results=self._get_tool_results_for_agent_output(
+                        structured_results=self._get_structured_results_for_agent_output(
                             agent_input, tool_results
                         ),
                     )
@@ -189,7 +193,7 @@ class MCPOpenAgent(MCPBaseAgent):
                         id=agent_input.id,
                         status=AgentStatus.INPUT_REQUIRED,
                         response_message=llm_response.choices[0],
-                        tool_results=self._get_tool_results_for_agent_output(
+                        structured_results=self._get_structured_results_for_agent_output(
                             agent_input, tool_results
                         ),
                     )
@@ -258,9 +262,28 @@ class MCPOpenAgent(MCPBaseAgent):
                             )
 
             except Exception as e:
-                # TODO: To log the ProviderClientAPIException separately, so that
-                # malformed tool responses automatically trigger a retry, and are
-                # not cached.
+                if isinstance(e, ProviderClientAPIException) and isinstance(
+                    e.original_exception, LLMToolResponseDecodeError
+                ):
+                    structlogger.debug(
+                        "mcp_open_agent.send_message.malformed_tool_response_error",
+                        event_info=(
+                            "Malformed tool response received from LLM "
+                            "(JSON decode error). Retrying the LLM call."
+                        ),
+                        user_message=agent_input.user_message,
+                        agent_name=self._name,
+                        agent_id=str(
+                            make_agent_identifier(self._name, self.protocol_type)
+                        ),
+                        original_exception=str(e.original_exception),
+                    )
+                    # Continue to make another LLM call by breaking out of the current
+                    # iteration and letting the loop continue with a fresh LLM request
+                    messages.append(
+                        self._get_system_message_for_malformed_tool_response()
+                    )
+                    continue
                 structlogger.error(
                     "mcp_open_agent.send_message.error_in_agent_loop",
                     event_info=f"Failed to send message: {e}",
@@ -272,7 +295,7 @@ class MCPOpenAgent(MCPBaseAgent):
                     id=agent_input.id,
                     status=AgentStatus.FATAL_ERROR,
                     response_message=f"I encountered an error: {e!s}",
-                    tool_results=self._get_tool_results_for_agent_output(
+                    structured_results=self._get_structured_results_for_agent_output(
                         agent_input, tool_results
                     ),
                     error_message=str(e),
@@ -284,7 +307,7 @@ class MCPOpenAgent(MCPBaseAgent):
                 "I've completed my research but couldn't provide a final answer within"
                 "the allowed steps."
             ),
-            tool_results=self._get_tool_results_for_agent_output(
+            structured_results=self._get_structured_results_for_agent_output(
                 agent_input, tool_results
             ),
         )

rasa/agents/protocol/mcp/mcp_task_agent.py

@@ -27,6 +27,10 @@ from rasa.shared.constants import (
     ROLE_TOOL,
 )
 from rasa.shared.core.events import SlotSet
+from rasa.shared.exceptions import (
+    LLMToolResponseDecodeError,
+    ProviderClientAPIException,
+)
 from rasa.shared.providers.llm.llm_response import LLMResponse
 
 DEFAULT_TASK_AGENT_PROMPT_TEMPLATE = importlib.resources.read_text(
@@ -98,7 +102,7 @@ class MCPTaskAgent(MCPBaseAgent):
             for name in re.findall(r"\bslots\.(\w+)", condition)
         }
 
-        slot_names = agent_input.slot_names
+        slot_names = [slot.name for slot in agent_input.slots]
 
         # Keep only slots that actually exist in agent_input.slots
         valid_slot_names = [
@@ -241,7 +245,7 @@ class MCPTaskAgent(MCPBaseAgent):
                 for slot_name, slot_value in slots.items()
                 if slot_name in _slot_names_to_be_filled
             ],
-            tool_results=self._get_tool_results_for_agent_output(
+            structured_results=self._get_structured_results_for_agent_output(
                 agent_input, tool_results
             ),
         )
@@ -303,7 +307,7 @@ class MCPTaskAgent(MCPBaseAgent):
                         id=agent_input.id,
                         status=AgentStatus.RECOVERABLE_ERROR,
                         error_message=event_info,
-                        tool_results=self._get_tool_results_for_agent_output(
+                        structured_results=self._get_structured_results_for_agent_output(
                             agent_input, tool_results
                         ),
                     )
@@ -314,7 +318,7 @@ class MCPTaskAgent(MCPBaseAgent):
                         id=agent_input.id,
                         status=AgentStatus.INPUT_REQUIRED,
                         response_message=llm_response.choices[0],
-                        tool_results=self._get_tool_results_for_agent_output(
+                        structured_results=self._get_structured_results_for_agent_output(
                             agent_input, tool_results
                         ),
                     )
@@ -445,16 +449,35 @@ class MCPTaskAgent(MCPBaseAgent):
                                     "An internal error occurred while checking the "
                                     "exit conditions."
                                 ),
-                                tool_results=self._get_tool_results_for_agent_output(
+                                structured_results=self._get_structured_results_for_agent_output(
                                     agent_input, tool_results
                                 ),
                                 error_message=internal_error,
                             )
 
             except Exception as e:
-                # TODO: To log the ProviderClientAPIException separately, so that
-                # malformed tool responses automatically trigger a retry, and are
-                # not cached.
+                if isinstance(e, ProviderClientAPIException) and isinstance(
+                    e.original_exception, LLMToolResponseDecodeError
+                ):
+                    structlogger.debug(
+                        "mcp_task_agent.send_message.malformed_tool_response_error",
+                        event_info=(
+                            "Malformed tool response received from LLM "
+                            "(JSON decode error). Retrying the LLM call."
+                        ),
+                        user_message=agent_input.user_message,
+                        agent_name=self._name,
+                        agent_id=str(
+                            make_agent_identifier(self._name, self.protocol_type)
+                        ),
+                        original_exception=str(e.original_exception),
+                    )
+                    # Continue to make another LLM call by breaking out of the current
+                    # iteration and letting the loop continue with a fresh LLM request
+                    messages.append(
+                        self._get_system_message_for_malformed_tool_response()
+                    )
+                    continue
                 structlogger.error(
                     "mcp_task_agent.send_message.error_in_agent_loop",
                     event_info=f"Failed to send message: {e}",
@@ -466,7 +489,7 @@ class MCPTaskAgent(MCPBaseAgent):
                     id=agent_input.id,
                     status=AgentStatus.FATAL_ERROR,
                     response_message=f"I encountered an error: {e!s}",
-                    tool_results=self._get_tool_results_for_agent_output(
+                    structured_results=self._get_structured_results_for_agent_output(
                         agent_input, tool_results
                     ),
                     error_message=str(e),
@@ -478,7 +501,7 @@ class MCPTaskAgent(MCPBaseAgent):
                 "I've completed my research but couldn't provide a final answer within"
                 "the allowed steps."
             ),
-            tool_results=self._get_tool_results_for_agent_output(
+            structured_results=self._get_structured_results_for_agent_output(
                 agent_input, tool_results
             ),
         )

rasa/agents/schemas/agent_output.py

@@ -13,7 +13,7 @@ class AgentOutput(BaseModel):
     status: AgentStatus
     response_message: Optional[str] = None
     events: Optional[List[SlotSet]] = None
-    tool_results: Optional[List[List[Dict[str, Any]]]] = None
+    structured_results: Optional[List[List[Dict[str, Any]]]] = None
     metadata: Optional[Dict[str, Any]] = None
     timestamp: Optional[str] = None
     error_message: Optional[str] = None

rasa/agents/utils.py

@@ -1,7 +1,8 @@
-from typing import List, Optional
+from typing import Dict, List, Optional
 
 from rasa.agents.agent_manager import AgentManager
 from rasa.agents.exceptions import AgentNotFoundException
+from rasa.agents.validation import validate_agent_names_not_conflicting_with_flows
 from rasa.core.available_agents import (
     AgentConfig,
     AgentMCPServerConfig,
@@ -10,8 +11,10 @@ from rasa.core.available_agents import (
 from rasa.core.available_endpoints import AvailableEndpoints
 from rasa.shared.agents.utils import get_protocol_type
 from rasa.shared.core.domain import Domain
+from rasa.shared.core.events import AgentCompleted
 from rasa.shared.core.flows import FlowsList
 from rasa.shared.core.flows.steps import CallFlowStep
+from rasa.shared.core.trackers import DialogueStateTracker
 
 
 def resolve_agent_config(
@@ -33,6 +36,7 @@ def resolve_agent_config(
             if mcp_server_endpoint.name == mcp_server.name:
                 mcp_server.url = mcp_server_endpoint.url
                 mcp_server.type = mcp_server_endpoint.type
+                mcp_server.additional_params = mcp_server_endpoint.additional_params
 
     return agent_config
 
@@ -46,6 +50,10 @@ async def initialize_agents(
     agent_manager: AgentManager = AgentManager()
     endpoints = AvailableEndpoints.get_instance()
 
+    # Validate agent names don't conflict with flow names
+    flow_names = {flow.id for flow in flows.underlying_flows}
+    validate_agent_names_not_conflicting_with_flows(sub_agents.agents, flow_names)
+
     for flow in flows.underlying_flows:
         for step in flow.steps:
             if isinstance(step, CallFlowStep):
@@ -70,3 +78,89 @@ async def initialize_agents(
                     protocol_type,
                     resolved_agent_config,
                 )
+
+
+def is_agent_valid(agent_id: str) -> bool:
+    """Check if an agent ID references a valid agent.
+
+    Args:
+        agent_id: The agent ID to validate.
+
+    Returns:
+        True if the agent exists, False otherwise.
+    """
+    agent_config = AvailableAgents.get_agent_config(agent_id)
+    return agent_config is not None
+
+
+def is_agent_completed(tracker: DialogueStateTracker, agent_id: str) -> bool:
+    """Check if an agent has been completed.
+
+    Args:
+        tracker: The dialogue state tracker.
+        agent_id: The agent ID to check.
+
+    Returns:
+        True if the agent has been completed, False otherwise.
+    """
+    # Look for AgentCompleted events for this agent
+    for event in reversed(tracker.events):
+        if isinstance(event, AgentCompleted) and event.agent_id == agent_id:
+            return True
+    return False
+
+
+def get_agent_info(agent_id: str) -> Optional[Dict[str, str]]:
+    """Get basic agent information (name and description).
+
+    Args:
+        agent_id: The agent ID to get information for.
+
+    Returns:
+        Dictionary with agent name and description if found, None otherwise.
+    """
+    agent_config = AvailableAgents.get_agent_config(agent_id)
+    if agent_config is None:
+        return None
+
+    return {
+        "name": agent_config.agent.name,
+        "description": agent_config.agent.description,
+    }
+
+
+def get_completed_agents_info(tracker: DialogueStateTracker) -> List[Dict[str, str]]:
+    """Get information for all completed agents.
+
+    Args:
+        tracker: The dialogue state tracker.
+
+    Returns:
+        List of dictionaries containing agent information for completed agents.
+    """
+    completed_agents = []
+    for event in reversed(tracker.events):
+        if isinstance(event, AgentCompleted):
+            agent_info = get_agent_info(event.agent_id)
+            if agent_info:
+                completed_agents.append(agent_info)
+    return completed_agents
+
+
+def get_active_agent_info(
+    tracker: DialogueStateTracker, flow_id: str
+) -> Optional[Dict[str, str]]:
+    """Get information for the active agent in a specific flow.
+
+    Args:
+        tracker: The dialogue state tracker.
+        flow_id: The flow ID to get the active agent for.
+
+    Returns:
+        Dictionary with agent name and description if an agent is active,
+        None otherwise.
+    """
+    agent_frame = tracker.stack.find_active_agent_stack_frame_for_flow(flow_id)
+    if agent_frame:
+        return get_agent_info(agent_frame.agent_id)
+    return None