rasa-pro 3.14.0.dev5__py3-none-any.whl → 3.14.0.dev6__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,72 @@
+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/api.py

@@ -20,6 +20,7 @@ if TYPE_CHECKING:
 def run(
     model: Text,
     endpoints: Text,
+    sub_agents: Text,
     connector: Optional[Text] = None,
     credentials: Optional[Text] = None,
     **kwargs: Dict[Text, Any],
@@ -29,6 +30,7 @@ def run(
     Args:
         model: Path to model archive.
         endpoints: Path to endpoints file.
+        sub_agents: Path to sub-agents directory.
         connector: Connector which should be use (overwrites `credentials`
         field).
         credentials: Path to channel credentials file.
@@ -38,11 +40,13 @@ def run(
     """
     import rasa.core.run
     import rasa.shared.utils.common
+    from rasa.core.available_agents import AvailableAgents
     from rasa.core.available_endpoints import AvailableEndpoints
     from rasa.shared.constants import DOCS_BASE_URL
     from rasa.shared.utils.cli import print_warning
 
     _endpoints = AvailableEndpoints.get_instance(endpoints)
+    _sub_agents = AvailableAgents.get_instance(sub_agents)
 
     if not connector and not credentials:
         connector = "rest"
@@ -61,6 +65,7 @@ def run(
         channel=connector,
         credentials=credentials,
         endpoints=_endpoints,
+        sub_agents=_sub_agents,
         **kwargs,
     )
 

rasa/cli/arguments/default_arguments.py

@@ -3,6 +3,7 @@ import logging
 from enum import Enum
 from typing import List, Optional, Text, Union
 
+from rasa.core.constants import DEFAULT_SUB_AGENTS
 from rasa.core.persistor import RemoteStorageType, StorageType, parse_remote_storage
 from rasa.shared.constants import (
     DEFAULT_CONFIG_PATH,
@@ -217,3 +218,14 @@ def add_skip_validation_flag(
         action="append",
         help="Skip YAML validation for selected parts of the training data.",
     )
+
+
+def add_sub_agents_param(
+    parser: Union[argparse.ArgumentParser, argparse._ActionsContainer],
+) -> None:
+    parser.add_argument(
+        "--sub-agents",
+        type=str,
+        default=DEFAULT_SUB_AGENTS,
+        help="Directory that specifies sub-agents to use (default: %(default)s).",
+    )

rasa/cli/arguments/run.py

@@ -7,6 +7,7 @@ from rasa.cli.arguments.default_arguments import (
     add_model_param,
     add_remote_storage_param,
     add_skip_validation_flag,
+    add_sub_agents_param,
 )
 from rasa.core import constants
 from rasa.env import (
@@ -24,6 +25,7 @@ def set_run_arguments(parser: argparse.ArgumentParser) -> None:
     add_server_arguments(parser)
     add_inspect_argument(parser)
     add_skip_validation_flag(parser)
+    add_sub_agents_param(parser)
 
 
 def set_run_action_arguments(parser: argparse.ArgumentParser) -> None:

rasa/cli/dialogue_understanding_test.py

@@ -14,6 +14,7 @@ from rasa.cli.arguments.default_arguments import (
     add_endpoint_param,
     add_model_param,
     add_remote_storage_param,
+    add_sub_agents_param,
 )
 from rasa.core.agent import Agent
 from rasa.core.available_endpoints import AvailableEndpoints
@@ -174,6 +175,8 @@ def add_du_test_arguments(parser: argparse.ArgumentParser) -> None:
         ),
     )
 
+    add_sub_agents_param(du_arguments)
+
 
 def ensure_calm_only_bot(agent: Agent) -> None:
     if agent.domain is None or agent.processor is None:
@@ -218,6 +221,7 @@ def execute_dialogue_understanding_tests(args: argparse.Namespace) -> None:
             model_path=args.model,
             model_server=endpoints.model,
             remote_storage=args.remote_storage,
+            sub_agents_path=args.sub_agents,
         )
     except AgentNotReady as error:
         structlogger.error(

rasa/cli/e2e_test.py

@@ -17,6 +17,7 @@ from rasa.cli.arguments.default_arguments import (
     add_endpoint_param,
     add_model_param,
     add_remote_storage_param,
+    add_sub_agents_param,
 )
 from rasa.core.available_endpoints import AvailableEndpoints
 from rasa.core.exceptions import AgentNotReady
@@ -147,6 +148,8 @@ def add_e2e_test_arguments(parser: argparse.ArgumentParser) -> None:
         help="Directory where to save coverage report to.",
     )
 
+    add_sub_agents_param(parser)
+
 
 def execute_e2e_tests(args: argparse.Namespace) -> None:
     """Run the end-to-end tests.
@@ -192,6 +195,7 @@ def execute_e2e_tests(args: argparse.Namespace) -> None:
             model_server=endpoints.model,
             endpoints=endpoints,
             test_case_path=Path(test_case_path),
+            sub_agents_path=args.sub_agents,
         )
     except AgentNotReady as error:
         structlogger.error(

rasa/cli/inspect.py

@@ -8,6 +8,7 @@ from sanic import Sanic
 from rasa import telemetry
 from rasa.cli import SubParsersAction
 from rasa.cli.arguments import shell as arguments
+from rasa.cli.arguments.default_arguments import add_sub_agents_param
 from rasa.core import constants
 from rasa.core.available_endpoints import AvailableEndpoints
 from rasa.engine.storage.local_model_storage import LocalModelStorage
@@ -44,6 +45,8 @@ def add_subparser(
         "--voice", help="Enable voice", action="store_true", default=False
     )
 
+    add_sub_agents_param(inspect_parser)
+
     # it'd be confusing to expose those arguments to the user,
     # so we remove them
     remove_argument_from_parser(inspect_parser, "--credentials")

rasa/cli/llm_fine_tuning.py

@@ -14,6 +14,7 @@ from rasa.cli.arguments.default_arguments import (
     add_endpoint_param,
     add_model_param,
     add_remote_storage_param,
+    add_sub_agents_param,
 )
 from rasa.cli.e2e_test import (
     RASA_PRO_BETA_FINE_TUNING_RECIPE_ENV_VAR_NAME,
@@ -137,6 +138,8 @@ def add_data_preparation_arguments(parser: argparse.ArgumentParser) -> None:
         default=DEFAULT_INPUT_E2E_TEST_PATH,
     )
 
+    add_sub_agents_param(parser)
+
     add_remote_storage_param(parser)
 
     rephrasing_arguments = parser.add_argument_group("Rephrasing Module")
@@ -376,6 +379,7 @@ def write_params(
             "rephrase_config": rephrase_config,
             "model": args.model,
             "endpoints": args.endpoints,
+            "sub-agents": args.sub_agents,
             "remote-storage": args.remote_storage,
             "train_frac": args.train_frac,
             "output_format": args.output_format,
@@ -420,6 +424,7 @@ def set_up_e2e_test_runner(args: argparse.Namespace) -> E2ETestRunner:
             model_path=args.model,
             model_server=endpoints.model,
             endpoints=endpoints,
+            sub_agents_path=args.sub_agents,
         )
     except AgentNotReady as error:
         structlogger.error(

rasa/cli/project_templates/tutorial/config.yml

@@ -1,6 +1,5 @@
 recipe: default.v1
 language: en
-assistant_id: placeholder_default
 pipeline:
 - name: CompactLLMCommandGenerator
   llm:
@@ -10,4 +9,4 @@ pipeline:
 
 policies:
   - name: FlowPolicy
-#  - name: EnterpriseSearchPolicy
+#  - name: EnterpriseSearchPolicy

rasa/cli/run.py

@@ -109,6 +109,7 @@ def run(args: argparse.Namespace) -> None:
     # configured
 
     import rasa.model
+    from rasa.core.available_agents import AvailableAgents
     from rasa.core.available_endpoints import AvailableEndpoints
 
     # start server if remote storage is configured
@@ -123,6 +124,9 @@ def run(args: argparse.Namespace) -> None:
         rasa_run(**vars(args))
         return
 
+    # load sub-agents
+    AvailableAgents.get_instance(args.sub_agents)
+
     # start server if local model found
     args.model = _validate_model_path(args.model, "model", DEFAULT_MODELS_PATH)
     local_model_set = True

rasa/cli/scaffold.py

@@ -5,9 +5,6 @@ from collections import defaultdict
 from enum import Enum
 from typing import List, Text
 
-import randomname
-import structlog
-
 from rasa import telemetry
 from rasa.api import train
 from rasa.cli import SubParsersAction
@@ -19,38 +16,21 @@ from rasa.shared.constants import (
     DEFAULT_MODELS_PATH,
     DOCS_BASE_URL,
 )
-from rasa.shared.utils import yaml
 from rasa.shared.utils.cli import print_error_and_exit, print_success
 
-structlogger = structlog.get_logger(__name__)
-
 
 class ProjectTemplateName(Enum):
     """Enum of CALM project templates."""
 
     DEFAULT = "default"
     TUTORIAL = "tutorial"
-    BASIC = "basic"
-    FINANCE = "finance"
-    TELCO = "telco"
 
     def __str__(self) -> str:
         return self.value
 
-    @classmethod
-    def get_all_values(cls) -> List[str]:
-        return [name.value for name in cls]
-
-    @classmethod
-    def supported_values(cls) -> str:
-        return ", ".join(cls.get_all_values())
-
 
 template_domain_path = defaultdict(lambda: DEFAULT_DOMAIN_PATH)
 template_domain_path[ProjectTemplateName.DEFAULT] = "domain"
-template_domain_path[ProjectTemplateName.BASIC] = "domain"
-template_domain_path[ProjectTemplateName.FINANCE] = "domain"
-template_domain_path[ProjectTemplateName.TELCO] = "domain"
 
 
 def add_subparser(
@@ -179,33 +159,9 @@ def create_initial_project(
     path: Text, template: ProjectTemplateName = ProjectTemplateName.DEFAULT
 ) -> None:
     """Creates directory structure and templates for initial project."""
-    import distutils.dir_util as dir_util
-
-    # clear the cache of the copy_tree function, this avoids issues if
-    # a project directory existed before and we removed folders in it
-    # with shutil.rmtree. see
-    # https://stackoverflow.com/questions/9160227/dir-util-copy-tree-fails-after-shutil-rmtree
-    if hasattr(dir_util, "_path_created"):
-        dir_util._path_created.clear()
-    else:
-        dir_util.SkipRepeatAbsolutePaths.clear()  # type: ignore[attr-defined]
-    dir_util.copy_tree(scaffold_path(template), path)
+    from distutils.dir_util import copy_tree
 
-    create_random_assistant_id(path)
-
-
-def create_random_assistant_id(path: Text) -> None:
-    """Create a random assistant id."""
-    assistant_id = f"{randomname.get_name()}"
-    config = yaml.read_yaml_file(os.path.join(path, "config.yml"))
-
-    if isinstance(config, dict):
-        config["assistant_id"] = assistant_id
-        yaml.write_yaml(config, os.path.join(path, "config.yml"))
-    else:
-        structlogger.warning(
-            "cli.scaffold.create_random_assistant_id.invalid_config", config=config
-        )
+    copy_tree(scaffold_path(template), path)
 
 
 def scaffold_path(template: ProjectTemplateName) -> Text:

rasa/cli/shell.py

@@ -6,6 +6,7 @@ from typing import List
 from rasa import telemetry
 from rasa.cli import SubParsersAction
 from rasa.cli.arguments import shell as arguments
+from rasa.cli.arguments.default_arguments import add_sub_agents_param
 from rasa.core.available_endpoints import AvailableEndpoints
 from rasa.engine.storage.local_model_storage import LocalModelStorage
 from rasa.exceptions import ModelNotFound
@@ -45,6 +46,8 @@ def add_subparser(
         help="Set the conversation ID.",
     )
 
+    add_sub_agents_param(shell_parser)
+
     run_subparsers = shell_parser.add_subparsers()
 
     shell_nlu_subparser = run_subparsers.add_parser(

rasa/constants.py

@@ -22,8 +22,14 @@ MINIMUM_COMPATIBLE_VERSION = "3.11.0rc1"
 
 GLOBAL_USER_CONFIG_PATH = os.path.expanduser("~/.config/rasa/global.yml")
 
+# Logging level for external libraries (default: ERROR to reduce noise)
 DEFAULT_LOG_LEVEL_LIBRARIES = "ERROR"
 ENV_LOG_LEVEL_LIBRARIES = "LOG_LEVEL_LIBRARIES"
+
+# MCP (Model Context Protocol) logging configuration
+ENV_LOG_LEVEL_MCP = "LOG_LEVEL_MCP"
+ENV_MCP_LOGGING_ENABLED = "MCP_LOGGING_ENABLED"
+
 ENV_LOG_LEVEL_MATPLOTLIB = "LOG_LEVEL_MATPLOTLIB"
 ENV_LOG_LEVEL_RABBITMQ = "LOG_LEVEL_RABBITMQ"
 ENV_LOG_LEVEL_KAFKA = "LOG_LEVEL_KAFKA"