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

rasa/agents/schemas/agent_tool_schema.py

@@ -1,134 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -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,199 +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
-        # Also clear the metaclass singleton instances
-        if hasattr(type(cls), "_instances"):
-            type(cls)._instances.clear()
-
-    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-0cd70adf.js

@@ -1 +0,0 @@
-import{aI as o,aJ as r}from"./index-3e293924.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-a0f9c4ed.js

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

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

@@ -1 +0,0 @@
-import{p as e,f as o}from"./flowDb-956e92f1-fdebec47.js";import{f as t,g as a}from"./styles-c10674c1-897fbfdd.js";import{u as i}from"./index-3e293924.js";import"./graph-ca9e6217.js";import"./layout-d4307784.js";import"./index-3862675e-c5ceb692.js";import"./clone-a0f9c4ed.js";import"./edges-e0da2a9e-b1553799.js";import"./createText-2e5e7dd3-1c669cad.js";import"./line-0567aaa7.js";import"./array-9f3ba611.js";import"./path-53f90ab3.js";import"./channel-0cd70adf.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};