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

rasa/agents/schemas/agent_tool_schema.py

@@ -0,0 +1,134 @@
+from typing import Any, Callable, Dict, Optional
+
+from mcp import Tool
+from pydantic import BaseModel
+
+from rasa.agents.constants import (
+    TOOL_ADDITIONAL_PROPERTIES_KEY,
+    TOOL_DESCRIPTION_KEY,
+    TOOL_EXECUTOR_KEY,
+    TOOL_NAME_KEY,
+    TOOL_PARAMETERS_KEY,
+    TOOL_PROPERTIES_KEY,
+    TOOL_PROPERTY_TYPE_KEY,
+    TOOL_REQUIRED_KEY,
+    TOOL_STRICT_KEY,
+    TOOL_TYPE_FUNCTION_KEY,
+    TOOL_TYPE_KEY,
+)
+
+
+class AgentToolSchema(BaseModel):
+    name: str
+    parameters: dict[str, Any]
+    strict: bool
+    description: Optional[str] = None
+    type: str = "function"
+
+    @classmethod
+    def from_mcp_tool(cls, tool: Tool) -> "AgentToolSchema":
+        """Convert MCP Tool to AgentToolSchema."""
+        parameters = tool.inputSchema.copy() if tool.inputSchema else {}
+
+        if parameters:
+            cls._validate_and_fix_parameters(parameters)
+
+        return cls(
+            name=tool.name,
+            description=tool.description,
+            parameters=parameters,
+            strict=False,
+            type=TOOL_TYPE_FUNCTION_KEY,
+        )
+
+    @classmethod
+    def from_openai_json_format(cls, tool: Dict[str, Any]) -> "AgentToolSchema":
+        """Convert OpenAI dict format to AgentToolSchema."""
+        function_data = tool[TOOL_TYPE_FUNCTION_KEY]
+        parameters = function_data.get(TOOL_PARAMETERS_KEY, {})
+
+        if parameters:
+            cls._validate_and_fix_parameters(parameters)
+
+        return cls(
+            name=function_data[TOOL_NAME_KEY],
+            description=function_data[TOOL_DESCRIPTION_KEY],
+            parameters=parameters,
+            strict=function_data.get(TOOL_STRICT_KEY, False),
+            type=tool[TOOL_TYPE_KEY],
+        )
+
+    @staticmethod
+    def _validate_and_fix_parameters(parameters: Dict[str, Any]) -> None:
+        """Validate and fix parameters to ensure they meet OpenAI function calling
+        requirements."""
+        if not parameters:
+            return
+
+        # Ensure additionalProperties is set at the top level
+        if TOOL_ADDITIONAL_PROPERTIES_KEY not in parameters:
+            parameters[TOOL_ADDITIONAL_PROPERTIES_KEY] = False
+
+        # Ensure required is set at the top level
+        if TOOL_REQUIRED_KEY not in parameters:
+            parameters[TOOL_REQUIRED_KEY] = []
+
+        # Ensure all properties have types, required field and additionalProperties
+        if TOOL_PROPERTIES_KEY in parameters:
+            AgentToolSchema._ensure_property_types(parameters)
+
+    @staticmethod
+    def _ensure_property_types(parameters: Dict[str, Any]) -> None:
+        """Ensure all properties in parameters have a type defined and
+        additionalProperties is set."""
+        properties = parameters[TOOL_PROPERTIES_KEY]
+
+        if not properties:
+            return
+
+        for _, prop_schema in properties.items():
+            if not isinstance(prop_schema, dict):
+                continue
+
+            # Ensure the property has a type
+            if TOOL_PROPERTY_TYPE_KEY not in prop_schema:
+                prop_schema[TOOL_PROPERTY_TYPE_KEY] = "string"
+
+            # If it's an object type, ensure additionalProperties and required
+            # fields are set
+            if prop_schema[TOOL_PROPERTY_TYPE_KEY] == "object":
+                if TOOL_ADDITIONAL_PROPERTIES_KEY not in prop_schema:
+                    prop_schema[TOOL_ADDITIONAL_PROPERTIES_KEY] = False
+
+                # Ensure required key exists for object properties
+                if TOOL_REQUIRED_KEY not in prop_schema:
+                    prop_schema[TOOL_REQUIRED_KEY] = []
+
+    def to_openai_json_format(self) -> Dict[str, Any]:
+        """Convert AgentToolSchema to OpenAI format."""
+        # Ensure the schema is valid before conversion
+        return {
+            TOOL_TYPE_KEY: TOOL_TYPE_FUNCTION_KEY,
+            TOOL_TYPE_FUNCTION_KEY: self.model_dump(exclude={TOOL_TYPE_KEY}),
+        }
+
+
+class CustomToolSchema(BaseModel):
+    """A class that represents the schema of a custom agent tool."""
+
+    tool_name: str
+    tool_definition: AgentToolSchema
+    tool_executor: Callable
+
+    @classmethod
+    def from_dict(cls, config: Dict[str, Any]) -> "CustomToolSchema":
+        """Convert a custom tool config to CustomToolSchema."""
+        agent_tool_schema = AgentToolSchema.from_openai_json_format(config)
+        if TOOL_EXECUTOR_KEY not in config:
+            raise ValueError("Custom tool executor is required.")
+
+        return cls(
+            tool_name=agent_tool_schema.name,
+            tool_definition=agent_tool_schema,
+            tool_executor=config[TOOL_EXECUTOR_KEY],
+        )

rasa/agents/templates/mcp_open_agent_prompt_template.jinja2

@@ -0,0 +1,15 @@
+You are a helpful assistant that should assist the user in the best possible way.
+
+### Primary Task
+{{ description }}
+
+### Instructions
+* Always make sure to output responses to the user in a clear, helpful format.
+* Always avoid asking multiple questions at once. Ask questions sequentially one at a time and wait for the user's response before proceeding to next question.
+* Always avoid making assumptions about what values to pass into tools. Ask for clarification if a user's request is ambiguous.
+* Once your primary task, described above, is completed, you must call the `task_completed` tool to signal that you have finished assisting the user. Do not end the conversation or indicate completion without the `task_completed` tool call.
+* Do NOT call the `task_completed` tool unless you're absolutely certain that your primary task (NOT the slot corrections, updates, etc), described above, is fully completed. Focus on the task given in the task description above.
+* Strictly avoid making up information or ability to take some action which is not available in `tool` provided.
+
+### Conversation history
+{{ conversation_history }}

rasa/agents/templates/mcp_task_agent_prompt_template.jinja2

@@ -0,0 +1,17 @@
+You are a helpful assistant that should assist the user in the best possible way.
+
+### Description of your capabilities
+{{ description }}
+
+### Task
+* Use the tools available to gather the required information to set the following slots: {{ slot_names }}.
+* In order to set the slot values, use the `set_slot_<slot_name>` tool.
+
+### Instructions
+* Always make sure to output responses to the user in a clear, helpful format.
+* Always avoid asking multiple questions at once. Ask questions sequentially one at a time and wait for the user's response before proceeding to next question.
+* Always avoid making assumptions about what values to pass into tools. Ask for clarification if a user's request is ambiguous.
+* Strictly avoid making up information or ability to take some action which is not available in `tool` provided.
+
+### Conversation history
+{{ conversation_history }}

rasa/agents/utils.py

@@ -0,0 +1,77 @@
+from typing import 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,
+    AvailableAgents,
+)
+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.flows import FlowsList
+from rasa.shared.core.flows.steps import CallFlowStep
+
+
+def resolve_agent_config(
+    agent_config: AgentConfig,
+    available_endpoints: AvailableEndpoints,
+) -> Optional[AgentConfig]:
+    if agent_config is None:
+        return None
+
+    connections = agent_config.connections
+    mcp_connections: List[AgentMCPServerConfig] = (
+        connections.mcp_servers
+        if connections and connections.mcp_servers is not None
+        else []
+    )
+
+    for mcp_server in mcp_connections:
+        for mcp_server_endpoint in available_endpoints.mcp_servers or []:
+            if mcp_server_endpoint.name == mcp_server.name:
+                mcp_server.url = mcp_server_endpoint.url
+                mcp_server.type = mcp_server_endpoint.type
+
+    return agent_config
+
+
+async def initialize_agents(
+    flows: FlowsList,
+    domain: Domain,
+    sub_agents: AvailableAgents,
+) -> None:
+    """Iterate over flows and create/connect the referenced 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):
+                if flows.flow_by_id(step.call) is not None:
+                    continue
+
+                if step.is_calling_mcp_tool():
+                    # The call step is calling an MCP tool, so we don't need to
+                    # initialize any agent.
+                    continue
+
+                if not step.is_calling_agent():
+                    raise AgentNotFoundException(step.call)
+
+                agent_name = step.call
+                agent_config = sub_agents.get_agent_config(agent_name)
+                resolved_agent_config = resolve_agent_config(agent_config, endpoints)
+                protocol_type = get_protocol_type(step, agent_config)
+
+                await agent_manager.connect_agent(
+                    agent_name,
+                    protocol_type,
+                    resolved_agent_config,
+                )