rasa-pro 3.14.0.dev1__py3-none-any.whl → 3.14.0.dev20250818__py3-none-any.whl

rasa/agents/templates/mcp_task_agent_prompt_template.jinja2

@@ -1,13 +0,0 @@
-You are a helpful assistant that should assist the user in the best possible way.
-
-### 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.
-* 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

@@ -1,72 +0,0 @@
-from typing import List, Optional
-
-from rasa.agents.agent_manager import AgentManager
-from rasa.agents.exceptions import AgentNotFoundException
-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()
-
-    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,
-                )

rasa/core/available_agents.py

@@ -1,196 +0,0 @@
-from __future__ import annotations
-
-import os
-from enum import Enum
-from typing import Any, Dict, List, Optional
-
-import structlog
-from pydantic import BaseModel, Field, model_validator
-from ruamel import yaml as yaml
-
-from rasa.utils.singleton import Singleton
-
-DEFAULT_AGENTS_CONFIG_FOLDER = "sub_agents"
-
-structlogger = structlog.get_logger()
-
-
-class ProtocolConfig(str, Enum):
-    """Supported protocols for agents."""
-
-    MCP = "MCP"
-    A2A = "A2A"
-
-
-class AgentInfo(BaseModel):
-    """Configuration for an agent."""
-
-    name: str = Field(..., description="Agent name")
-    protocol: ProtocolConfig = Field(
-        ..., description="Protocol used to communicate with the agent."
-    )
-    description: str = Field(..., description="Agent description")
-
-    @model_validator(mode="before")
-    @classmethod
-    def validate_protocol(cls, values: Any) -> Any:
-        """Validate and normalize protocol values to support lowercase input."""
-        if isinstance(values, dict) and "protocol" in values:
-            protocol_value = values["protocol"]
-            if isinstance(protocol_value, str):
-                # Map lowercase protocol names to uppercase enum values
-                protocol_mapping = {
-                    "mcp": ProtocolConfig.MCP,
-                    "a2a": ProtocolConfig.A2A,
-                    "MCP": ProtocolConfig.MCP,
-                    "A2A": ProtocolConfig.A2A,
-                }
-
-                if protocol_value.lower() in protocol_mapping:
-                    values["protocol"] = protocol_mapping[protocol_value.lower()]
-                else:
-                    # If it's not a recognized protocol, let Pydantic handle the
-                    # validation
-                    # This will raise a proper validation error
-                    pass
-
-        return values
-
-
-class AgentConfiguration(BaseModel):
-    llm: Optional[Dict[str, Any]] = None
-    prompt_template: Optional[str] = None
-    module: Optional[str] = None
-    timeout: Optional[int] = None  # timeout in seconds
-    max_retries: Optional[int] = None
-    agent_card: Optional[str] = None
-
-
-class AgentConnections(BaseModel):
-    mcp_servers: Optional[List[AgentMCPServerConfig]] = None
-
-
-class AgentMCPServerConfig(BaseModel):
-    name: str  # Reference to MCPServerConfig
-    url: Optional[str] = None
-    type: Optional[str] = None
-    include_tools: Optional[List[str]] = None
-    exclude_tools: Optional[List[str]] = None
-
-
-class AgentConfig(BaseModel):
-    agent: AgentInfo
-    configuration: Optional[AgentConfiguration] = None
-    connections: Optional[AgentConnections] = None
-
-    @model_validator(mode="after")
-    def check_agent_config(self) -> AgentConfig:
-        protocol = self.agent.protocol if self.agent else None
-        if protocol == ProtocolConfig.MCP:
-            if self.connections is None or self.connections.mcp_servers is None:
-                raise ValueError(
-                    "For protocol 'MCP', "
-                    "'mcp_servers' in 'connections' must be provided."
-                )
-        if protocol == ProtocolConfig.A2A:
-            if self.configuration is None or self.configuration.agent_card is None:
-                raise ValueError(
-                    "For protocol 'A2A', "
-                    "'agent_card' in 'configuration' must be provided."
-                )
-        return self
-
-
-class AvailableAgents(metaclass=Singleton):
-    """Collection of configured agents."""
-
-    _instance = None
-
-    def __init__(self, agents: Optional[Dict[str, AgentConfig]] = None) -> None:
-        """Create an `AvailableAgents` object."""
-        self.agents = agents or {}
-
-    @classmethod
-    def _read_agent_folder(cls, agent_folder: str) -> AvailableAgents:
-        """Read the different agents from the given folder."""
-        agents: Dict[str, AgentConfig] = {}
-
-        if not os.path.isdir(agent_folder):
-            if agent_folder != DEFAULT_AGENTS_CONFIG_FOLDER:
-                # User explicitly specified a folder, it should exist
-                structlogger.error(
-                    f"The specified agents config folder '{agent_folder}' does not "
-                    f"exist or is not a directory."
-                )
-                raise ValueError(
-                    f"The specified agents config folder '{agent_folder}' does not "
-                    f"exist or is not a directory."
-                )
-            else:
-                # We are using the default folder, it may not be created yet
-                # Init with an empty agents in this case
-                structlogger.warning(
-                    f"Default agents config folder '{agent_folder}' does not exist. "
-                    f"Agent configurations won't be loaded."
-                )
-                return cls(agents)
-
-        for agent_name in os.listdir(agent_folder):
-            config_path = os.path.join(agent_folder, agent_name, "config.yml")
-            if not os.path.isfile(config_path):
-                continue
-            try:
-                agent_config = cls._read_agent_config(config_path)
-                if not isinstance(agent_config, AgentConfig):
-                    raise ValueError(f"Invalid agent config type for {agent_name}")
-                agents[agent_config.agent.name] = agent_config
-            except Exception as e:
-                raise RuntimeError(f"Failed to load agent '{agent_name}': {e}")
-
-        return cls(agents)
-
-    @staticmethod
-    def _read_agent_config(config_path: str) -> AgentConfig:
-        """Read the agent config from a yaml file."""
-        with open(config_path, "r") as f:
-            data = yaml.safe_load(f)
-            agent_config = AgentConfig(
-                agent=AgentInfo(**data.get("agent", {})),
-                configuration=AgentConfiguration(**data.get("configuration", {})),
-                connections=AgentConnections(**data.get("connections", {})),
-            )
-            return agent_config
-
-    @classmethod
-    def get_instance(
-        cls, agent_folder: Optional[str] = DEFAULT_AGENTS_CONFIG_FOLDER
-    ) -> AvailableAgents:
-        """Get the singleton instance of `AvailableAgents`."""
-        if cls._instance is None:
-            cls._instance = cls._read_agent_folder(agent_folder)
-        return cls._instance
-
-    @classmethod
-    def reset_instance(cls) -> None:
-        cls._instance = None
-
-    def as_json_list(self) -> List[Dict[str, Any]]:
-        """Convert the available agents to a JSON-serializable list."""
-        return [
-            {
-                "name": agent_name,
-                "agent": agent_config.agent.model_dump(),
-                "configuration": agent_config.configuration.model_dump()
-                if agent_config.configuration
-                else None,
-                "connections": agent_config.connections.model_dump()
-                if agent_config.connections
-                else None,
-            }
-            for agent_name, agent_config in self.agents.items()
-        ]
-
-    @classmethod
-    def get_agent_config(cls, agent_id: str) -> Optional[AgentConfig]:
-        instance = cls.get_instance()
-        return instance.agents.get(agent_id)

rasa/core/channels/inspector/dist/assets/channel-c436ca7c.js

@@ -1 +0,0 @@
-import{aI as o,aJ as r}from"./index-1bd9135e.js";const s=(a,n)=>o.lang.round(r.parse(a)[n]),e=s;export{e as c};

rasa/core/channels/inspector/dist/assets/clone-50dd656b.js

@@ -1 +0,0 @@
-import{c as r}from"./graph-3e19170f.js";var e=4;function a(o){return r(o,e)}export{a as c};

rasa/core/channels/inspector/dist/assets/flowDiagram-v2-96b9c2cf-2b2aeaf8.js

@@ -1 +0,0 @@
-import{p as e,f as o}from"./flowDb-956e92f1-e576fc02.js";import{f as t,g as a}from"./styles-c10674c1-d600174d.js";import{u as i}from"./index-1bd9135e.js";import"./graph-3e19170f.js";import"./layout-08436411.js";import"./index-3862675e-eb9c86de.js";import"./clone-50dd656b.js";import"./edges-e0da2a9e-b5256940.js";import"./createText-2e5e7dd3-a2a564ca.js";import"./line-683c4f3b.js";import"./array-9f3ba611.js";import"./path-53f90ab3.js";import"./channel-c436ca7c.js";const M={parser:e,db:o,renderer:t,styles:a,init:r=>{r.flowchart||(r.flowchart={}),r.flowchart.arrowMarkerAbsolute=r.arrowMarkerAbsolute,i({flowchart:{arrowMarkerAbsolute:r.arrowMarkerAbsolute}}),t.setConf(r.flowchart),o.clear(),o.setGen("gen-2")}};export{M as diagram};