File size: 6,208 Bytes
22087d0 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 | from typing import Dict, Any, List, Callable, Awaitable
from core.agentpress.tool import ToolResult, ToolSchema, SchemaType
from core.utils.logger import logger
_GMAIL_ATTACHMENT_TOOLS = {
"GMAIL_SEND_EMAIL",
"GMAIL_CREATE_EMAIL_DRAFT",
"GMAIL_REPLY_TO_THREAD",
}
_GMAIL_ATTACHMENT_HINT = (
"\n\nTo attach files: first use composio_upload to upload the file to Composio storage. "
"The response includes attachment data (s3key, mimetype, name). "
"Pass these to the attachment parameter as: "
'{"s3key": "<s3key>", "mimetype": "<mimetype>", "name": "<name>"}. '
"IMPORTANT: When attaching presentations to emails, you MUST always export and attach the .pptx file (not .pdf), unless the user explicitly requests a different format."
)
class DynamicToolBuilder:
def __init__(self):
self.dynamic_tools: Dict[str, Dict[str, Any]] = {}
self.schemas: Dict[str, List[ToolSchema]] = {}
def create_dynamic_methods(self, tools_info: List[Dict[str, Any]], custom_tools: Dict[str, Dict[str, Any]], execute_callback: Callable[[str, Dict[str, Any]], Awaitable[ToolResult]]) -> Dict[str, Callable]:
methods = {}
for tool_info in tools_info:
tool_name = tool_info.get('name', '')
if tool_name:
method = self._create_dynamic_method(tool_name, tool_info, execute_callback)
if method:
methods[method['method_name']] = method['method']
for tool_name, tool_info in custom_tools.items():
openapi_tool_info = {
"name": tool_name,
"description": tool_info['description'],
"parameters": tool_info['parameters']
}
method = self._create_dynamic_method(tool_name, openapi_tool_info, execute_callback)
if method:
methods[method['method_name']] = method['method']
logger.debug(f"Created {len(methods)} dynamic MCP tool methods")
return methods
def _create_dynamic_method(self, tool_name: str, tool_info: Dict[str, Any], execute_callback: Callable[[str, Dict[str, Any]], Awaitable[ToolResult]]) -> Dict[str, Any]:
method_name, clean_tool_name, server_name = self._parse_tool_name(tool_name)
# logger.debug(f"Creating dynamic method for tool '{tool_name}': clean_tool_name='{clean_tool_name}', method_name='{method_name}', server='{server_name}'")
async def dynamic_tool_method(**kwargs) -> ToolResult:
return await execute_callback(tool_name, kwargs)
dynamic_tool_method.__name__ = method_name
dynamic_tool_method.__qualname__ = f"MCPToolWrapper.{method_name}"
description = self._build_description(tool_info, server_name, clean_tool_name)
schema = self._create_tool_schema(method_name, description, tool_info)
dynamic_tool_method.tool_schemas = [schema]
tool_data = {
'method': dynamic_tool_method,
'method_name': method_name,
'original_tool_name': tool_name,
'clean_tool_name': clean_tool_name,
'server_name': server_name,
'info': tool_info,
'schema': schema
}
self.dynamic_tools[tool_name] = tool_data
self.schemas[method_name] = [schema]
# logger.debug(f"Created dynamic method '{method_name}' for MCP tool '{tool_name}' from server '{server_name}'")
return tool_data
def _parse_tool_name(self, tool_name: str) -> tuple[str, str, str]:
"""Parse tool name to extract stripped name and server info.
Returns:
tuple: (method_name, clean_tool_name, server_name)
"""
if tool_name.startswith("custom_"):
parts = tool_name.split("_")
if len(parts) >= 3:
clean_tool_name = "_".join(parts[2:])
server_name = parts[1] if len(parts) > 1 else "unknown"
else:
clean_tool_name = tool_name
server_name = "unknown"
else:
parts = tool_name.split("_", 2)
clean_tool_name = parts[2] if len(parts) > 2 else tool_name
server_name = parts[1] if len(parts) > 1 else "unknown"
method_name = clean_tool_name.replace('-', '_')
return method_name, clean_tool_name, server_name
def _build_description(self, tool_info: Dict[str, Any], server_name: str, clean_tool_name: str = "") -> str:
base_description = tool_info.get("description", f"MCP tool from {server_name}")
description = f"{base_description} (MCP Server: {server_name})"
if clean_tool_name.upper() in _GMAIL_ATTACHMENT_TOOLS:
description += _GMAIL_ATTACHMENT_HINT
return description
def _create_tool_schema(self, method_name: str, description: str, tool_info: Dict[str, Any]) -> ToolSchema:
openapi_function_schema = {
"type": "function",
"function": {
"name": method_name,
"description": description,
"parameters": tool_info.get("parameters", {
"type": "object",
"properties": {},
"required": []
})
}
}
return ToolSchema(
schema_type=SchemaType.OPENAPI,
schema=openapi_function_schema
)
def get_dynamic_tools(self) -> Dict[str, Dict[str, Any]]:
return self.dynamic_tools
def get_schemas(self) -> Dict[str, List[ToolSchema]]:
return self.schemas
def find_method_by_name(self, name: str) -> Callable:
for tool_data in self.dynamic_tools.values():
if tool_data['method_name'] == name:
return tool_data['method']
name_with_hyphens = name.replace('_', '-')
for tool_name, tool_data in self.dynamic_tools.items():
if tool_data['method_name'] == name or tool_name == name_with_hyphens:
return tool_data['method']
return None |