massgen 0.1.0a3__py3-none-any.whl → 0.1.1__py3-none-any.whl

massgen/__init__.py

@@ -68,7 +68,7 @@ from .chat_agent import (
 from .message_templates import MessageTemplates, get_templates
 from .orchestrator import Orchestrator, create_orchestrator
 
-__version__ = "0.1.0a3"
+__version__ = "0.1.1"
 __author__ = "MassGen Contributors"
 
 

massgen/agent_config.py

@@ -58,6 +58,9 @@ class AgentConfig:
         timeout_config: Timeout and resource limit configuration
         coordination_config: Coordination behavior configuration (e.g., planning mode)
         skip_coordination_rounds: Debug/test mode - skip voting rounds and go straight to final presentation (default: False)
+        voting_sensitivity: Controls how critical agents are when voting ("lenient", "balanced", "strict")
+        max_new_answers_per_agent: Maximum number of new answers each agent can provide (None = unlimited)
+        answer_novelty_requirement: How different new answers must be from existing ones ("lenient", "balanced", "strict")
     """
 
     # Core backend configuration (includes tool enablement)
@@ -66,6 +69,11 @@ class AgentConfig:
     # Framework configuration
     message_templates: Optional["MessageTemplates"] = None
 
+    # Voting behavior configuration
+    voting_sensitivity: str = "lenient"
+    max_new_answers_per_agent: Optional[int] = None
+    answer_novelty_requirement: str = "lenient"
+
     # Agent customization
     agent_id: Optional[str] = None
     _custom_system_instruction: Optional[str] = field(default=None, init=False)
@@ -696,6 +704,9 @@ class AgentConfig:
             "backend_params": self.backend_params,
             "agent_id": self.agent_id,
             "custom_system_instruction": self.custom_system_instruction,
+            "voting_sensitivity": self.voting_sensitivity,
+            "max_new_answers_per_agent": self.max_new_answers_per_agent,
+            "answer_novelty_requirement": self.answer_novelty_requirement,
             "timeout_config": {
                 "orchestrator_timeout_seconds": self.timeout_config.orchestrator_timeout_seconds,
             },
@@ -730,6 +741,9 @@ class AgentConfig:
         backend_params = data.get("backend_params", {})
         agent_id = data.get("agent_id")
         custom_system_instruction = data.get("custom_system_instruction")
+        voting_sensitivity = data.get("voting_sensitivity", "lenient")
+        max_new_answers_per_agent = data.get("max_new_answers_per_agent")
+        answer_novelty_requirement = data.get("answer_novelty_requirement", "lenient")
 
         # Handle timeout_config
         timeout_config = TimeoutConfig()
@@ -756,6 +770,9 @@ class AgentConfig:
             message_templates=message_templates,
             agent_id=agent_id,
             custom_system_instruction=custom_system_instruction,
+            voting_sensitivity=voting_sensitivity,
+            max_new_answers_per_agent=max_new_answers_per_agent,
+            answer_novelty_requirement=answer_novelty_requirement,
             timeout_config=timeout_config,
             coordination_config=coordination_config,
         )

massgen/api_params_handler/_api_params_handler_base.py

@@ -21,6 +21,7 @@ class APIParamsHandlerBase(ABC):
         """
         self.backend = backend_instance
         self.formatter = backend_instance.formatter
+        self.custom_tool_manager = backend_instance.custom_tool_manager
 
     @abstractmethod
     async def build_api_params(

massgen/api_params_handler/_chat_completions_api_params_handler.py

@@ -23,6 +23,7 @@ class ChatCompletionsAPIParamsHandler(APIParamsHandlerBase):
                 "enable_code_interpreter",
                 "allowed_tools",
                 "exclude_tools",
+                "custom_tools",  # Custom tools configuration (processed separately)
             },
         )
 
@@ -114,11 +115,17 @@ class ChatCompletionsAPIParamsHandler(APIParamsHandlerBase):
         if provider_tools:
             combined_tools.extend(provider_tools)
 
-        # User-defined tools
+        # Workflow tools
         if tools:
             converted_tools = self.formatter.format_tools(tools)
             combined_tools.extend(converted_tools)
 
+        # Add custom tools
+        custom_tools = self.custom_tool_manager.registered_tools
+        if custom_tools:
+            converted_custom_tools = self.formatter.format_custom_tools(custom_tools)
+            combined_tools.extend(converted_custom_tools)
+
         # MCP tools
         mcp_tools = self.get_mcp_tools()
         if mcp_tools:

massgen/api_params_handler/_claude_api_params_handler.py

@@ -22,6 +22,7 @@ class ClaudeAPIParamsHandler(APIParamsHandlerBase):
                 "enable_code_execution",
                 "allowed_tools",
                 "exclude_tools",
+                "custom_tools",  # Custom tools configuration (processed separately)
                 "_has_files_api_files",
             },
         )
@@ -97,11 +98,17 @@ class ClaudeAPIParamsHandler(APIParamsHandlerBase):
         if provider_tools:
             combined_tools.extend(provider_tools)
 
-        # User-defined tools
+        # Workflow tools
         if tools:
             converted_tools = self.formatter.format_tools(tools)
             combined_tools.extend(converted_tools)
 
+        # Add custom tools
+        custom_tools = self.custom_tool_manager.registered_tools
+        if custom_tools:
+            converted_custom_tools = self.formatter.format_custom_tools(custom_tools)
+            combined_tools.extend(converted_custom_tools)
+
         # MCP tools
         mcp_tools = self.get_mcp_tools()
         if mcp_tools:

massgen/api_params_handler/_gemini_api_params_handler.py

@@ -0,0 +1,73 @@
+# -*- coding: utf-8 -*-
+"""
+Gemini API parameters handler building SDK config with parameter mapping and exclusions.
+"""
+
+from typing import Any, Dict, List, Set
+
+from ._api_params_handler_base import APIParamsHandlerBase
+
+
+class GeminiAPIParamsHandler(APIParamsHandlerBase):
+    def get_excluded_params(self) -> Set[str]:
+        base = self.get_base_excluded_params()
+        extra = {
+            "enable_web_search",
+            "enable_code_execution",
+            "use_multi_mcp",
+            "mcp_sdk_auto",
+            "allowed_tools",
+            "exclude_tools",
+            "custom_tools",
+        }
+        return set(base) | extra
+
+    def get_provider_tools(self, all_params: Dict[str, Any]) -> List[Dict[str, Any]]:
+        """
+        These are SDK Tool objects (from google.genai.types), not JSON tool declarations.
+        """
+        tools: List[Any] = []
+
+        if all_params.get("enable_web_search", False):
+            try:
+                from google.genai.types import GoogleSearch, Tool
+
+                tools.append(Tool(google_search=GoogleSearch()))
+            except Exception:
+                # Gracefully ignore if SDK not available
+                pass
+
+        if all_params.get("enable_code_execution", False):
+            try:
+                from google.genai.types import Tool, ToolCodeExecution
+
+                tools.append(Tool(code_execution=ToolCodeExecution()))
+            except Exception:
+                # Gracefully ignore if SDK not available
+                pass
+
+        return tools
+
+    async def build_api_params(self, messages: List[Dict[str, Any]], tools: List[Dict[str, Any]], all_params: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Build a config dict for google-genai Client.generate_content_stream.
+        - Map max_tokens -> max_output_tokens
+        - Do not include 'model' here; caller extracts it
+        - Do not add builtin tools; stream logic handles them
+        - Do not handle MCP tools or coordination schema here
+        """
+        excluded = self.get_excluded_params()
+        config: Dict[str, Any] = {}
+
+        for key, value in all_params.items():
+            if key in excluded or value is None:
+                continue
+            if key == "max_tokens":
+                config["max_output_tokens"] = value
+            elif key == "model":
+                # Caller will extract model separately
+                continue
+            else:
+                config[key] = value
+
+        return config

massgen/api_params_handler/_response_api_params_handler.py

@@ -22,6 +22,7 @@ class ResponseAPIParamsHandler(APIParamsHandlerBase):
                 "enable_code_interpreter",
                 "allowed_tools",
                 "exclude_tools",
+                "custom_tools",  # Custom tools configuration (processed separately)
                 "_has_file_search_files",  # Internal flag for file search tracking
             },
         )
@@ -88,11 +89,17 @@ class ResponseAPIParamsHandler(APIParamsHandlerBase):
         if provider_tools:
             combined_tools.extend(provider_tools)
 
-        # Add framework tools
+        # Add workflow tools
         if tools:
             converted_tools = self.formatter.format_tools(tools)
             combined_tools.extend(converted_tools)
 
+        # Add custom tools
+        custom_tools = self.custom_tool_manager.registered_tools
+        if custom_tools:
+            converted_custom_tools = self.formatter.format_custom_tools(custom_tools)
+            combined_tools.extend(converted_custom_tools)
+
         # Add MCP tools (use OpenAI format)
         mcp_tools = self._convert_mcp_tools_to_openai_format()
         if mcp_tools:

massgen/backend/base.py

@@ -59,6 +59,14 @@ class LLMBackend(ABC):
         # Initialize utility classes
         self.token_usage = TokenUsage()
 
+        # # Initialize tool manager
+        # self.custom_tool_manager = ToolManager()
+
+        # # Register custom tools if specified
+        # custom_tools = kwargs.get("custom_tools", [])
+        # if custom_tools:
+        #     self._register_custom_tools(custom_tools)
+
         # Planning mode flag - when True, MCP tools should be blocked during coordination
         self._planning_mode_enabled: bool = False
 
@@ -125,6 +133,29 @@ class LLMBackend(ABC):
         self.api_params_handler = None
         self.coordination_stage = None
 
+    # def _register_custom_tools(self, tool_names: list[str]) -> None:
+    #     """Register custom tool functions.
+
+    #     Args:
+    #         tool_names: List of tool names to register
+    #     """
+    #     import importlib
+
+    #     for tool_name in tool_names:
+    #         try:
+    #             # Try to import from tool module
+    #             module = importlib.import_module("massgen.tool")
+    #             if hasattr(module, tool_name):
+    #                 tool_func = getattr(module, tool_name)
+    #                 self.custom_tool_manager.add_tool_function(tool_func)
+    #                 print(f"Successfully registered custom tool: {tool_name}")
+    #             else:
+    #                 print(f"Warning: Tool '{tool_name}' not found in massgen.tool")
+    #         except ImportError as e:
+    #             print(f"Warning: Could not import tool module: {e}")
+    #         except Exception as e:
+    #             print(f"Error registering tool '{tool_name}': {e}")
+
     def _setup_permission_hooks(self):
         """Setup permission hooks for function-based backends (default behavior)."""
         # Create per-agent hook manager

massgen/backend/{base_with_mcp.py → base_with_custom_tool_and_mcp.py}

@@ -17,6 +17,7 @@ from typing import Any, AsyncGenerator, Dict, List, Optional, Tuple
 import httpx
 
 from ..logger_config import log_backend_activity, logger
+from ..tool import ToolManager
 from .base import LLMBackend, StreamChunk
 
 
@@ -107,13 +108,22 @@ SUPPORTED_AUDIO_MIME_TYPES = {
 }
 
 
-class MCPBackend(LLMBackend):
+class CustomToolAndMCPBackend(LLMBackend):
     """Base backend class with MCP (Model Context Protocol) support."""
 
     def __init__(self, api_key: Optional[str] = None, **kwargs):
         """Initialize backend with MCP support."""
         super().__init__(api_key, **kwargs)
 
+        # Custom tools support - initialize before api_params_handler
+        self.custom_tool_manager = ToolManager()
+        self._custom_tool_names: set[str] = set()
+
+        # Register custom tools if provided
+        custom_tools = kwargs.get("custom_tools", [])
+        if custom_tools:
+            self._register_custom_tools(custom_tools)
+
         # MCP integration (filesystem MCP server may have been injected by base class)
         self.mcp_servers = self.config.get("mcp_servers", [])
         self.allowed_tools = kwargs.pop("allowed_tools", None)
@@ -169,6 +179,261 @@ class MCPBackend(LLMBackend):
     async def _process_stream(self, stream, all_params, agent_id: Optional[str] = None) -> AsyncGenerator[StreamChunk, None]:
         """Process stream."""
 
+    # Custom tools support
+    def _register_custom_tools(self, custom_tools: List[Dict[str, Any]]) -> None:
+        """Register custom tools with the tool manager.
+
+        Supports flexible configuration:
+        - function: str | List[str]
+        - description: str (shared) | List[str] (1-to-1 mapping)
+        - preset_args: dict (shared) | List[dict] (1-to-1 mapping)
+
+        Examples:
+            # Single function
+            function: "my_func"
+            description: "My description"
+
+            # Multiple functions with shared description
+            function: ["func1", "func2"]
+            description: "Shared description"
+
+            # Multiple functions with individual descriptions
+            function: ["func1", "func2"]
+            description: ["Description 1", "Description 2"]
+
+            # Multiple functions with mixed (shared desc, individual args)
+            function: ["func1", "func2"]
+            description: "Shared description"
+            preset_args: [{"arg1": "val1"}, {"arg1": "val2"}]
+
+        Args:
+            custom_tools: List of custom tool configurations
+        """
+        # Collect unique categories and create them if needed
+        categories = set()
+        for tool_config in custom_tools:
+            if isinstance(tool_config, dict):
+                category = tool_config.get("category", "default")
+                if category != "default":
+                    categories.add(category)
+
+        # Create categories that don't exist
+        for category in categories:
+            if category not in self.custom_tool_manager.tool_categories:
+                self.custom_tool_manager.setup_category(
+                    category_name=category,
+                    description=f"Custom {category} tools",
+                    enabled=True,
+                )
+
+        # Register each custom tool
+        for tool_config in custom_tools:
+            try:
+                if isinstance(tool_config, dict):
+                    # Extract base configuration
+                    path = tool_config.get("path")
+                    category = tool_config.get("category", "default")
+
+                    # Normalize function field to list
+                    func_field = tool_config.get("function")
+                    if isinstance(func_field, str):
+                        functions = [func_field]
+                    elif isinstance(func_field, list):
+                        functions = func_field
+                    else:
+                        logger.error(
+                            f"Invalid function field type: {type(func_field)}. " f"Must be str or List[str].",
+                        )
+                        continue
+
+                    if not functions:
+                        logger.error("Empty function list in tool config")
+                        continue
+
+                    num_functions = len(functions)
+
+                    # Process name field (can be str or List[str])
+                    name_field = tool_config.get("name")
+                    names = self._process_field_for_functions(
+                        name_field,
+                        num_functions,
+                        "name",
+                    )
+                    if names is None:
+                        continue  # Validation error, skip this tool
+
+                    # Process description field (can be str or List[str])
+                    desc_field = tool_config.get("description")
+                    descriptions = self._process_field_for_functions(
+                        desc_field,
+                        num_functions,
+                        "description",
+                    )
+                    if descriptions is None:
+                        continue  # Validation error, skip this tool
+
+                    # Process preset_args field (can be dict or List[dict])
+                    preset_field = tool_config.get("preset_args")
+                    preset_args_list = self._process_field_for_functions(
+                        preset_field,
+                        num_functions,
+                        "preset_args",
+                    )
+                    if preset_args_list is None:
+                        continue  # Validation error, skip this tool
+
+                    # Register each function with its corresponding values
+                    for i, func in enumerate(functions):
+                        # Load the function first if custom name is needed
+                        if names[i] and names[i] != func:
+                            # Need to load function and apply custom name
+                            if path:
+                                loaded_func = self.custom_tool_manager._load_function_from_path(path, func)
+                            else:
+                                loaded_func = self.custom_tool_manager._load_builtin_function(func)
+
+                            if loaded_func is None:
+                                logger.error(f"Could not load function '{func}' from path: {path}")
+                                continue
+
+                            # Apply custom name by modifying __name__ attribute
+                            loaded_func.__name__ = names[i]
+
+                            # Register with loaded function (no path needed)
+                            self.custom_tool_manager.add_tool_function(
+                                path=None,
+                                func=loaded_func,
+                                category=category,
+                                preset_args=preset_args_list[i],
+                                description=descriptions[i],
+                            )
+                        else:
+                            # No custom name or same as function name, use normal registration
+                            self.custom_tool_manager.add_tool_function(
+                                path=path,
+                                func=func,
+                                category=category,
+                                preset_args=preset_args_list[i],
+                                description=descriptions[i],
+                            )
+
+                        # Use custom name for logging and tracking if provided
+                        registered_name = names[i] if names[i] else func
+
+                        # Track tool name for categorization
+                        if registered_name.startswith("custom_tool__"):
+                            self._custom_tool_names.add(registered_name)
+                        else:
+                            self._custom_tool_names.add(f"custom_tool__{registered_name}")
+
+                        logger.info(
+                            f"Registered custom tool: {registered_name} from {path} " f"(category: {category}, " f"desc: '{descriptions[i][:50] if descriptions[i] else 'None'}...')",
+                        )
+
+            except Exception as e:
+                func_name = tool_config.get("function", "unknown")
+                logger.error(
+                    f"Failed to register custom tool {func_name}: {e}",
+                    exc_info=True,
+                )
+
+    def _process_field_for_functions(
+        self,
+        field_value: Any,
+        num_functions: int,
+        field_name: str,
+    ) -> Optional[List[Any]]:
+        """Process a config field that can be a single value or list.
+
+        Conversion rules:
+        - None → [None, None, ...] (repeated num_functions times)
+        - Single value (not list) → [value, value, ...] (shared)
+        - List with matching length → use as-is (1-to-1 mapping)
+        - List with wrong length → ERROR (return None)
+
+        Args:
+            field_value: The field value from config
+            num_functions: Number of functions being registered
+            field_name: Name of the field (for error messages)
+
+        Returns:
+            List of values (one per function), or None if validation fails
+
+        Examples:
+            _process_field_for_functions(None, 3, "desc")
+            → [None, None, None]
+
+            _process_field_for_functions("shared", 3, "desc")
+            → ["shared", "shared", "shared"]
+
+            _process_field_for_functions(["a", "b", "c"], 3, "desc")
+            → ["a", "b", "c"]
+
+            _process_field_for_functions(["a", "b"], 3, "desc")
+            → None (error logged)
+        """
+        # Case 1: None or missing field → use None for all functions
+        if field_value is None:
+            return [None] * num_functions
+
+        # Case 2: Single value (not a list) → share across all functions
+        if not isinstance(field_value, list):
+            return [field_value] * num_functions
+
+        # Case 3: List value → must match function count exactly
+        if len(field_value) == num_functions:
+            return field_value
+        else:
+            # Length mismatch → validation error
+            logger.error(
+                f"Configuration error: {field_name} is a list with "
+                f"{len(field_value)} items, but there are {num_functions} functions. "
+                f"Either use a single value (shared) or a list with exactly "
+                f"{num_functions} items (1-to-1 mapping).",
+            )
+            return None
+
+    async def _execute_custom_tool(self, call: Dict[str, Any]) -> str:
+        """Execute a custom tool and return the result.
+
+        Args:
+            call: Function call dictionary with name and arguments
+
+        Returns:
+            The execution result as a string
+        """
+        import json
+
+        tool_request = {
+            "name": call["name"],
+            "input": json.loads(call["arguments"]) if isinstance(call["arguments"], str) else call["arguments"],
+        }
+
+        result_text = ""
+        try:
+            async for result in self.custom_tool_manager.execute_tool(tool_request):
+                # Accumulate results
+                if hasattr(result, "output_blocks"):
+                    for block in result.output_blocks:
+                        if hasattr(block, "data"):
+                            result_text += str(block.data)
+                        elif hasattr(block, "content"):
+                            result_text += str(block.content)
+                elif hasattr(result, "content"):
+                    result_text += str(result.content)
+                else:
+                    result_text += str(result)
+        except Exception as e:
+            logger.error(f"Error in custom tool execution: {e}")
+            result_text = f"Error: {str(e)}"
+
+        return result_text or "Tool executed successfully"
+
+    def _get_custom_tools_schemas(self) -> List[Dict[str, Any]]:
+        """Get OpenAI-formatted schemas for all registered custom tools."""
+        return self.custom_tool_manager.fetch_tool_schemas()
+
+    # MCP support methods
     async def _setup_mcp_tools(self) -> None:
         """Initialize MCP client for mcp_tools-based servers (stdio + streamable-http)."""
         if not self.mcp_servers or self._mcp_initialized:
@@ -783,14 +1048,16 @@ class MCPBackend(LLMBackend):
                     async for chunk in self.yield_mcp_status_chunks(use_mcp):
                         yield chunk
 
-                    if use_mcp:
+                    use_custom_tools = bool(self._custom_tool_names)
+
+                    if use_mcp or use_custom_tools:
                         # MCP MODE: Recursive function call detection and execution
                         logger.info("Using recursive MCP execution mode")
 
                         current_messages = self._trim_message_history(messages.copy())
 
                         # Start recursive MCP streaming
-                        async for chunk in self._stream_with_mcp_tools(current_messages, tools, client, **kwargs):
+                        async for chunk in self._stream_with_custom_and_mcp_tools(current_messages, tools, client, **kwargs):
                             yield chunk
 
                     else:
@@ -798,7 +1065,7 @@ class MCPBackend(LLMBackend):
                         logger.info("Using no-MCP mode")
 
                         # Start non-MCP streaming
-                        async for chunk in self._stream_without_mcp_tools(messages, tools, client, **kwargs):
+                        async for chunk in self._stream_without_custom_and_mcp_tools(messages, tools, client, **kwargs):
                             yield chunk
 
                 except Exception as e:
@@ -808,7 +1075,7 @@ class MCPBackend(LLMBackend):
                         await self._record_mcp_circuit_breaker_failure(e, agent_id)
 
                         # Handle MCP exceptions with fallback
-                        async for chunk in self._stream_handle_mcp_exceptions(e, messages, tools, client, **kwargs):
+                        async for chunk in self._stream_handle_custom_and_mcp_exceptions(e, messages, tools, client, **kwargs):
                             yield chunk
                     else:
                         logger.error(f"Streaming error: {e}")
@@ -824,7 +1091,7 @@ class MCPBackend(LLMBackend):
 
                 if isinstance(e, (MCPConnectionError, MCPTimeoutError, MCPServerError, MCPError)):
                     # Handle MCP exceptions with fallback
-                    async for chunk in self._stream_handle_mcp_exceptions(e, messages, tools, client, **kwargs):
+                    async for chunk in self._stream_handle_custom_and_mcp_exceptions(e, messages, tools, client, **kwargs):
                         yield chunk
                 else:
                     # Generic setup error: still notify if MCP was configured
@@ -837,7 +1104,7 @@ class MCPBackend(LLMBackend):
                         )
 
                     # Proceed with non-MCP streaming
-                    async for chunk in self._stream_without_mcp_tools(messages, tools, client, **kwargs):
+                    async for chunk in self._stream_without_custom_and_mcp_tools(messages, tools, client, **kwargs):
                         yield chunk
             except Exception as inner_e:
                 logger.error(f"Streaming error during MCP setup fallback: {inner_e}")
@@ -845,7 +1112,7 @@ class MCPBackend(LLMBackend):
             finally:
                 await self._cleanup_client(client)
 
-    async def _stream_without_mcp_tools(
+    async def _stream_without_custom_and_mcp_tools(
         self,
         messages: List[Dict[str, Any]],
         tools: List[Dict[str, Any]],
@@ -885,7 +1152,7 @@ class MCPBackend(LLMBackend):
         async for chunk in self._process_stream(stream, all_params, agent_id):
             yield chunk
 
-    async def _stream_handle_mcp_exceptions(
+    async def _stream_handle_custom_and_mcp_exceptions(
         self,
         error: Exception,
         messages: List[Dict[str, Any]],
@@ -921,7 +1188,7 @@ class MCPBackend(LLMBackend):
             content=f"\n⚠️  {user_message} ({error}); continuing without MCP tools\n",
         )
 
-        async for chunk in self._stream_without_mcp_tools(messages, tools, client, **kwargs):
+        async for chunk in self._stream_without_custom_and_mcp_tools(messages, tools, client, **kwargs):
             yield chunk
 
     def _track_mcp_function_names(self, tools: List[Dict[str, Any]]) -> None:
@@ -1012,7 +1279,7 @@ class MCPBackend(LLMBackend):
             self._mcp_functions.clear()
             self._mcp_function_names.clear()
 
-    async def __aenter__(self) -> "MCPBackend":
+    async def __aenter__(self) -> "CustomToolAndMCPBackend":
         """Async context manager entry."""
         # Initialize MCP tools if configured
         if MCPResourceManager:
@@ -1087,6 +1354,10 @@ class MCPBackend(LLMBackend):
         """Check if a tool call is an MCP function."""
         return tool_name in self._mcp_functions
 
+    def is_custom_tool_call(self, tool_name: str) -> bool:
+        """Check if a tool call is a custom tool function."""
+        return tool_name in self._custom_tool_names
+
     def get_mcp_tools_formatted(self) -> List[Dict[str, Any]]:
         """Get MCP tools formatted for specific API format."""
         if not self._mcp_functions: