autobyteus 1.1.3__py3-none-any.whl → 1.1.5__py3-none-any.whl

autobyteus/tools/file/file_writer.py

@@ -3,29 +3,57 @@ import logging
 from typing import TYPE_CHECKING
 
 from autobyteus.tools import tool
+from autobyteus.tools.tool_category import ToolCategory
 
 if TYPE_CHECKING:
     from autobyteus.agent.context import AgentContext
 
 logger = logging.getLogger(__name__)
 
-@tool(name="FileWriter")
+@tool(name="FileWriter", category=ToolCategory.FILE_SYSTEM)
 async def file_writer(context: 'AgentContext', path: str, content: str) -> str:
     """
     Creates or overwrites a file with specified content.
-    'path' is the path where the file will be written.
+    'path' is the path where the file will be written. If relative, it must be resolved against a configured agent workspace.
     'content' is the string content to write.
     Creates parent directories if they don't exist.
+    Raises ValueError if a relative path is given without a valid workspace.
     Raises IOError if file writing fails.
     """
-    logger.debug(f"Functional FileWriter tool for agent {context.agent_id}, path: {path}")
+    logger.debug(f"Functional FileWriter tool for agent {context.agent_id}, initial path: {path}")
+    
+    final_path: str
+    if os.path.isabs(path):
+        final_path = path
+        logger.debug(f"Path '{path}' is absolute. Using it directly.")
+    else:
+        if not context.workspace:
+            error_msg = f"Relative path '{path}' provided, but no workspace is configured for agent '{context.agent_id}'. A workspace is required to resolve relative paths."
+            logger.error(error_msg)
+            raise ValueError(error_msg)
+        
+        base_path = context.workspace.get_base_path()
+        if not base_path or not isinstance(base_path, str):
+            error_msg = f"Agent '{context.agent_id}' has a configured workspace, but it provided an invalid base path ('{base_path}'). Cannot resolve relative path '{path}'."
+            logger.error(error_msg)
+            raise ValueError(error_msg)
+            
+        final_path = os.path.join(base_path, path)
+        logger.debug(f"Path '{path}' is relative. Resolved to '{final_path}' using workspace base path '{base_path}'.")
+
     try:
-        dir_path = os.path.dirname(path)
-        if dir_path: # Only if path includes a directory part
+        # It's good practice to normalize the path to handle things like '..'
+        final_path = os.path.normpath(final_path)
+        
+        dir_path = os.path.dirname(final_path)
+        if dir_path:
             os.makedirs(dir_path, exist_ok=True)
-        with open(path, 'w', encoding='utf-8') as file:
+            
+        with open(final_path, 'w', encoding='utf-8') as file:
             file.write(content)
-        return f"File created/updated at {path}"
+            
+        logger.info(f"File successfully written to '{final_path}' for agent '{context.agent_id}'.")
+        return f"File created/updated at {final_path}"
     except Exception as e:
-        logger.error(f"Error writing file {path} for agent {context.agent_id}: {e}", exc_info=True)
-        raise IOError(f"Could not write file at {path}: {str(e)}")
+        logger.error(f"Error writing file to final path '{final_path}' for agent {context.agent_id}: {e}", exc_info=True)
+        raise IOError(f"Could not write file at '{final_path}': {str(e)}")

autobyteus/tools/functional_tool.py

@@ -8,6 +8,7 @@ from autobyteus.tools.base_tool import BaseTool
 from autobyteus.tools.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType
 from autobyteus.tools.tool_config import ToolConfig
 from autobyteus.tools.registry import default_tool_registry, ToolDefinition
+from autobyteus.tools.tool_origin import ToolOrigin
 from autobyteus.tools.tool_category import ToolCategory
 
 if TYPE_CHECKING:
@@ -200,7 +201,8 @@ def tool(
     name: Optional[str] = None,
     description: Optional[str] = None,
     argument_schema: Optional[ParameterSchema] = None,
-    config_schema: Optional[ParameterSchema] = None
+    config_schema: Optional[ParameterSchema] = None,
+    category: str = ToolCategory.GENERAL
 ):
     def decorator(func: Callable) -> FunctionalTool:
         tool_name = name or func.__name__
@@ -227,8 +229,6 @@ def tool(
                 instantiation_config=inst_config.params if inst_config else None
             )
         
-        # The decorator's responsibility is now just to assemble the raw metadata
-        # and create the definition. It does NOT generate usage strings.
         tool_def = ToolDefinition(
             name=tool_name,
             description=tool_desc,
@@ -236,7 +236,8 @@ def tool(
             config_schema=config_schema,
             custom_factory=factory,
             tool_class=None,
-            category=ToolCategory.LOCAL
+            origin=ToolOrigin.LOCAL,
+            category=category
         )
         default_tool_registry.register_tool(tool_def)
         

autobyteus/tools/image_downloader.py

@@ -7,6 +7,7 @@ from typing import Optional, TYPE_CHECKING, Any
 from autobyteus.tools.base_tool import BaseTool
 from autobyteus.tools.tool_config import ToolConfig 
 from autobyteus.tools.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType 
+from autobyteus.tools.tool_category import ToolCategory
 from PIL import Image
 from io import BytesIO
 from autobyteus.utils.file_utils import get_default_download_folder
@@ -18,6 +19,7 @@ if TYPE_CHECKING:
 logger = logging.getLogger(__name__)
 
 class ImageDownloader(BaseTool):
+    CATEGORY = ToolCategory.WEB
     supported_formats = ['.jpeg', '.jpg', '.gif', '.png', '.webp']
     
     def __init__(self, config: Optional[ToolConfig] = None):

autobyteus/tools/mcp/config_service.py

@@ -118,9 +118,10 @@ class McpConfigService(metaclass=SingletonMeta):
                     f"Total unique configs stored: {len(self._configs)}.")
         return config_object
 
-    def load_config(self, config_dict: Dict[str, Any]) -> BaseMcpConfig:
+    def load_config_from_dict(self, config_dict: Dict[str, Any]) -> BaseMcpConfig:
         """
         Parses a single raw configuration dictionary and adds it to the service.
+        This method handles loading a single configuration.
 
         Args:
             config_dict: A dictionary representing a single server config,
@@ -132,77 +133,81 @@ class McpConfigService(metaclass=SingletonMeta):
         config_object = self.parse_mcp_config_dict(config_dict)
         return self.add_config(config_object)
 
-
-    def load_configs(self, source: Union[str, List[Dict[str, Any]], Dict[str, Any]]) -> List[BaseMcpConfig]:
+    def load_configs_from_dict(self, configs_data: Dict[str, Dict[str, Any]]) -> List[BaseMcpConfig]:
         """
-        Loads multiple MCP configurations from a source, parsing and adding them.
+        Loads multiple MCP configurations from a dictionary where keys are server_ids.
         This will overwrite any existing configurations with the same server_id.
 
         Args:
-            source: The data source. Can be:
-                1. A file path (str) to a JSON file.
-                2. A list of MCP server configuration dictionaries.
-                3. A dictionary of configurations, keyed by server_id.
+            configs_data: A dictionary of configurations, keyed by server_id.
         
         Returns:
             A list of the successfully added McpServerConfig objects.
         """
+        if not isinstance(configs_data, dict):
+             raise TypeError("configs_data must be a dictionary of server configurations keyed by server_id.")
+
         loaded_mcp_configs: List[BaseMcpConfig] = []
+        logger.info(f"McpConfigService loading {len(configs_data)} configs from dictionary.")
         
-        if isinstance(source, str):
-            if not os.path.exists(source):
-                logger.error(f"MCP configuration file not found at path: {source}")
-                raise FileNotFoundError(f"MCP configuration file not found: {source}")
+        for server_id, single_config_data in configs_data.items():
+            if not isinstance(single_config_data, dict):
+                    raise ValueError(f"Configuration for server_id '{server_id}' must be a dictionary.")
             try:
-                with open(source, 'r', encoding='utf-8') as f:
-                    json_data = json.load(f)
-                logger.info(f"Successfully loaded JSON data from file: {source}")
-                return self.load_configs(json_data)
-            except json.JSONDecodeError as e:
-                raise ValueError(f"Invalid JSON in MCP configuration file {source}: {e}") from e
-            except Exception as e:
-                raise ValueError(f"Could not read MCP configuration file {source}: {e}") from e
-
-        elif isinstance(source, list):
-            for i, config_item_dict in enumerate(source):
-                if not isinstance(config_item_dict, dict):
-                    raise ValueError(f"Item at index {i} in source list is not a dictionary.")
-                
-                server_id = config_item_dict.get('server_id')
-                if not server_id:
-                     raise ValueError(f"Item at index {i} in source list is missing 'server_id' field.")
-                
-                try:
-                    # A list item is a single config, but doesn't have the server_id as the key,
-                    # so we wrap it to use the parser.
-                    config_obj = McpConfigService.parse_mcp_config_dict({server_id: config_item_dict})
-                    self.add_config(config_obj)
-                    loaded_mcp_configs.append(config_obj)
-                except ValueError as e:
-                    logger.error(f"Invalid MCP configuration for list item at index {i}: {e}")
-                    raise
+                # The parser expects the server_id to be the key, so we reconstruct that.
+                config_obj = McpConfigService.parse_mcp_config_dict({server_id: single_config_data})
+                self.add_config(config_obj)
+                loaded_mcp_configs.append(config_obj)
+            except ValueError as e:
+                logger.error(f"Invalid MCP configuration for server_id '{server_id}': {e}")
+                raise
         
-        elif isinstance(source, dict):
-            logger.info("Loading MCP server configurations from a dictionary of configs (keyed by server_id).")
-            for server_id, config_data in source.items():
-                if not isinstance(config_data, dict):
-                        raise ValueError(f"Configuration for server_id '{server_id}' must be a dictionary.")
-
-                try:
-                    config_obj = McpConfigService.parse_mcp_config_dict({server_id: config_data})
-                    self.add_config(config_obj)
-                    loaded_mcp_configs.append(config_obj)
-                except ValueError as e:
-                    logger.error(f"Invalid MCP configuration for server_id '{server_id}': {e}")
-                    raise
-        else:
-            raise TypeError(f"Unsupported source type for load_configs: {type(source)}. "
-                            "Expected file path, list of dicts, or dict of dicts.")
-
-        logger.info(f"McpConfigService load_configs completed. {len(loaded_mcp_configs)} new configurations processed. "
-                    f"Total unique configs stored: {len(self._configs)}.")
+        logger.info(f"McpConfigService load_configs_from_dict completed. {len(loaded_mcp_configs)} configurations processed.")
         return loaded_mcp_configs
 
+    def load_configs_from_file(self, filepath: str) -> List[BaseMcpConfig]:
+        """
+        Loads MCP configurations from a JSON file. The file should contain a single
+        JSON object where keys are server_ids.
+
+        Args:
+            filepath: The path to the JSON configuration file.
+        
+        Returns:
+            A list of the successfully added McpServerConfig objects.
+        """
+        if not os.path.exists(filepath):
+            logger.error(f"MCP configuration file not found at path: {filepath}")
+            raise FileNotFoundError(f"MCP configuration file not found: {filepath}")
+        try:
+            with open(filepath, 'r', encoding='utf-8') as f:
+                json_data = json.load(f)
+            logger.info(f"Successfully loaded JSON data from file: {filepath}")
+            
+            if isinstance(json_data, dict):
+                 return self.load_configs_from_dict(json_data)
+            else:
+                # To maintain some flexibility, we can check for the list format.
+                # But the primary documented format should be the dict.
+                logger.warning("Loading MCP configs from a list in a JSON file is supported but deprecated. "
+                               "The recommended format is a dictionary keyed by server_id.")
+                configs_as_dict = {}
+                if isinstance(json_data, list):
+                    for item in json_data:
+                        if isinstance(item, dict) and 'server_id' in item:
+                            server_id = item['server_id']
+                            configs_as_dict[server_id] = item
+                        else:
+                            raise ValueError("When loading from a list, each item must be a dict with a 'server_id'.")
+                    return self.load_configs_from_dict(configs_as_dict)
+
+                raise TypeError(f"Unsupported JSON structure in {filepath}. Expected a dictionary of configurations.")
+
+        except json.JSONDecodeError as e:
+            raise ValueError(f"Invalid JSON in MCP configuration file {filepath}: {e}") from e
+        except Exception as e:
+            raise IOError(f"Could not read or process MCP configuration file {filepath}: {e}") from e
+
     def get_config(self, server_id: str) -> Optional[BaseMcpConfig]:
         """Retrieves an MCP server configuration by its unique server ID."""
         return self._configs.get(server_id)

autobyteus/tools/mcp/server/http_managed_mcp_server.py

@@ -1,5 +1,5 @@
-# file: autobyteus/autobyteus/tools/mcp/server/http_managed_mcp_server.py
 import logging
+import asyncio
 from typing import cast
 
 from mcp import ClientSession
@@ -10,6 +10,8 @@ from ..types import StreamableHttpMcpServerConfig
 
 logger = logging.getLogger(__name__)
 
+INITIALIZE_TIMEOUT = 10  # seconds
+
 class HttpManagedMcpServer(BaseManagedMcpServer):
     """Manages the lifecycle of a streamable_http-based MCP server."""
 
@@ -25,5 +27,15 @@ class HttpManagedMcpServer(BaseManagedMcpServer):
             streamablehttp_client(config.url, headers=config.headers)
         )
         session = await self._exit_stack.enter_async_context(ClientSession(read_stream, write_stream))
-        logger.debug(f"ClientSession established for HTTP server '{self.server_id}'.")
+
+        # --- FIX: Initialize the session after creation with a timeout ---
+        try:
+            logger.debug(f"Initializing ClientSession for HTTP server '{self.server_id}' with a {INITIALIZE_TIMEOUT}s timeout.")
+            await asyncio.wait_for(session.initialize(), timeout=INITIALIZE_TIMEOUT)
+        except asyncio.TimeoutError:
+            logger.error(f"Timeout occurred while initializing session for HTTP server '{self.server_id}'. The server did not respond in time.")
+            # Re-raise as a standard exception to be handled by the BaseManagedMcpServer's connect method.
+            raise ConnectionError(f"Server '{self.server_id}' failed to initialize within the timeout period.")
+
+        logger.debug(f"ClientSession established and initialized for HTTP server '{self.server_id}'.")
         return session

autobyteus/tools/mcp/server/stdio_managed_mcp_server.py

@@ -1,5 +1,5 @@
-# file: autobyteus/autobyteus/tools/mcp/server/stdio_managed_mcp_server.py
 import logging
+import asyncio
 from typing import cast
 
 from mcp import ClientSession, StdioServerParameters
@@ -10,6 +10,8 @@ from ..types import StdioMcpServerConfig
 
 logger = logging.getLogger(__name__)
 
+INITIALIZE_TIMEOUT = 10  # seconds
+
 class StdioManagedMcpServer(BaseManagedMcpServer):
     """Manages the lifecycle of a stdio-based MCP server."""
 
@@ -29,5 +31,15 @@ class StdioManagedMcpServer(BaseManagedMcpServer):
         logger.debug(f"Establishing stdio connection for server '{self.server_id}' with command: {config.command}")
         read_stream, write_stream = await self._exit_stack.enter_async_context(stdio_client(stdio_params))
         session = await self._exit_stack.enter_async_context(ClientSession(read_stream, write_stream))
-        logger.debug(f"ClientSession established for stdio server '{self.server_id}'.")
+        
+        # --- FIX: Initialize the session after creation with a timeout ---
+        try:
+            logger.debug(f"Initializing ClientSession for stdio server '{self.server_id}' with a {INITIALIZE_TIMEOUT}s timeout.")
+            await asyncio.wait_for(session.initialize(), timeout=INITIALIZE_TIMEOUT)
+        except asyncio.TimeoutError:
+            logger.error(f"Timeout occurred while initializing session for server '{self.server_id}'. The server did not respond in time.")
+            # Re-raise as a standard exception to be handled by the BaseManagedMcpServer's connect method.
+            raise ConnectionError(f"Server '{self.server_id}' failed to initialize within the timeout period.")
+        
+        logger.debug(f"ClientSession established and initialized for stdio server '{self.server_id}'.")
         return session

autobyteus/tools/mcp/server_instance_manager.py

@@ -1,12 +1,14 @@
 # file: autobyteus/autobyteus/tools/mcp/server_instance_manager.py
 import logging
+import copy
 from typing import Dict, List, AsyncIterator
 from contextlib import asynccontextmanager
 
 from autobyteus.utils.singleton import SingletonMeta
+from autobyteus.agent.context import AgentContextRegistry
 from .config_service import McpConfigService
 from .server import BaseManagedMcpServer, StdioManagedMcpServer, HttpManagedMcpServer
-from .types import McpTransportType, McpServerInstanceKey, BaseMcpConfig
+from .types import McpTransportType, McpServerInstanceKey, BaseMcpConfig, StdioMcpServerConfig
 
 logger = logging.getLogger(__name__)
 
@@ -17,6 +19,7 @@ class McpServerInstanceManager(metaclass=SingletonMeta):
     """
     def __init__(self):
         self._config_service = McpConfigService()
+        self._context_registry = AgentContextRegistry()
         self._active_servers: Dict[McpServerInstanceKey, BaseManagedMcpServer] = {}
         logger.info("McpServerInstanceManager initialized.")
     
@@ -40,11 +43,34 @@ class McpServerInstanceManager(metaclass=SingletonMeta):
             return self._active_servers[instance_key]
 
         logger.info(f"Creating new persistent server instance for {instance_key}.")
-        config = self._config_service.get_config(server_id)
-        if not config:
+        
+        base_config = self._config_service.get_config(server_id)
+        if not base_config:
             raise ValueError(f"No configuration found for server_id '{server_id}'.")
 
-        server_instance = self._create_server_instance(config)
+        final_config = base_config
+        # --- DYNAMIC WORKSPACE ENV VARIABLE INJECTION ---
+        if isinstance(base_config, StdioMcpServerConfig):
+            agent_context = self._context_registry.get_context(agent_id)
+            if agent_context and agent_context.workspace:
+                workspace_path = agent_context.workspace.get_base_path()
+                if workspace_path:
+                    logger.info(f"Agent '{agent_id}' has a workspace. Injecting AUTOBYTEUS_AGENT_WORKSPACE='{workspace_path}' for MCP server '{server_id}'.")
+                    # Create a copy of the config to avoid modifying the global one
+                    config_copy = copy.deepcopy(base_config)
+                    # Ensure env dict exists
+                    if config_copy.env is None:
+                        config_copy.env = {}
+                    # Add our environment variable
+                    config_copy.env['AUTOBYTEUS_AGENT_WORKSPACE'] = workspace_path
+                    final_config = config_copy
+                else:
+                    logger.warning(f"Agent '{agent_id}' workspace for server '{server_id}' did not provide a base path. No workspace environment variable will be set.")
+            else:
+                logger.debug(f"No workspace found for agent '{agent_id}'. No workspace environment variable will be set for MCP server '{server_id}'.")
+        # --- END DYNAMIC WORKSPACE ENV VARIABLE INJECTION ---
+
+        server_instance = self._create_server_instance(final_config)
         self._active_servers[instance_key] = server_instance
         return server_instance
 

autobyteus/tools/mcp/tool_registrar.py

@@ -11,6 +11,7 @@ from .types import BaseMcpConfig
 from .server import BaseManagedMcpServer
 
 from autobyteus.tools.registry import ToolRegistry, ToolDefinition
+from autobyteus.tools.tool_origin import ToolOrigin
 from autobyteus.tools.tool_category import ToolCategory
 from autobyteus.utils.singleton import SingletonMeta
 from mcp import types as mcp_types
@@ -70,74 +71,128 @@ class McpToolRegistrar(metaclass=SingletonMeta):
             name=registered_name,
             description=actual_desc,
             argument_schema=actual_arg_schema,
-            category=ToolCategory.MCP,
+            origin=ToolOrigin.MCP,
+            category=server_config.server_id, # Use server_id as the category
             metadata={"mcp_server_id": server_config.server_id}, # Store origin in generic metadata
             custom_factory=tool_factory.create_tool,
             config_schema=None,
             tool_class=None
         )
 
-    async def discover_and_register_tools(self, mcp_config: Optional[Union[BaseMcpConfig, Dict[str, Any]]] = None) -> List[ToolDefinition]:
+    async def _discover_and_register_from_config(self, server_config: BaseMcpConfig, schema_mapper: McpSchemaMapper) -> List[ToolDefinition]:
         """
-        Discovers tools from MCP servers and registers them.
+        Performs the core discovery and registration logic for a single server configuration.
+        This method does NOT handle un-registration of existing tools.
         """
-        configs_to_process: List[BaseMcpConfig]
+        registered_tool_definitions: List[ToolDefinition] = []
+        if not server_config.enabled:
+            logger.info(f"MCP server '{server_config.server_id}' is disabled. Skipping.")
+            return registered_tool_definitions
+
+        logger.info(f"Discovering tools from MCP server: '{server_config.server_id}'")
         
-        if mcp_config:
-            validated_config: BaseMcpConfig
-            if isinstance(mcp_config, dict):
+        try:
+            remote_tools = await self._fetch_tools_from_server(server_config)
+            logger.info(f"Discovered {len(remote_tools)} tools from server '{server_config.server_id}'.")
+
+            for remote_tool in remote_tools:
                 try:
-                    validated_config = self._config_service.load_config(mcp_config)
-                except ValueError as e:
-                    logger.error(f"Failed to parse provided MCP config dictionary: {e}")
-                    raise
-            elif isinstance(mcp_config, BaseMcpConfig):
-                validated_config = self._config_service.add_config(mcp_config)
-            else:
-                raise TypeError(f"mcp_config must be a BaseMcpConfig object or a dictionary, not {type(mcp_config)}.")
-            
-            logger.info(f"Starting targeted MCP tool discovery for server: {validated_config.server_id}")
-            self.unregister_tools_from_server(validated_config.server_id)
-            configs_to_process = [validated_config]
-        else:
-            logger.info("Starting full MCP tool discovery. Unregistering all existing MCP tools first.")
-            all_server_ids = list(self._registered_tools_by_server.keys())
-            for server_id in all_server_ids:
-                self.unregister_tools_from_server(server_id)
-            self._registered_tools_by_server.clear()
-            configs_to_process = self._config_service.get_all_configs()
+                    tool_def = self._create_tool_definition_from_remote(remote_tool, server_config, schema_mapper)
+                    self._tool_registry.register_tool(tool_def)
+                    self._registered_tools_by_server.setdefault(server_config.server_id, []).append(tool_def)
+                    registered_tool_definitions.append(tool_def)
+                except Exception as e_tool:
+                    logger.error(f"Failed to process or register remote tool '{remote_tool.name}': {e_tool}", exc_info=True)
+        
+        except Exception as e_server:
+            logger.error(f"Failed to discover tools from MCP server '{server_config.server_id}': {e_server}", exc_info=True)
+            # Re-raise to signal failure to the caller
+            raise
+        
+        return registered_tool_definitions
+
+    async def register_server(self, config_object: BaseMcpConfig) -> List[ToolDefinition]:
+        """
+        Discovers and registers tools from a single MCP server using a validated
+        config object. This will overwrite any existing tools from that server.
+
+        Args:
+            config_object: A pre-instantiated and validated BaseMcpConfig object.
+
+        Returns:
+            A list of the successfully registered ToolDefinition objects from this server.
+        """
+        if not isinstance(config_object, BaseMcpConfig):
+            raise TypeError(f"config_object must be a BaseMcpConfig object, not {type(config_object)}.")
+
+        # Add/update the config in the service
+        self._config_service.add_config(config_object)
+
+        logger.info(f"Starting targeted MCP tool registration for server: {config_object.server_id}")
+        
+        # Unregister existing tools for this specific server before re-registering
+        self.unregister_tools_from_server(config_object.server_id)
+        
+        schema_mapper = McpSchemaMapper()
+        
+        return await self._discover_and_register_from_config(config_object, schema_mapper)
+
+    async def load_and_register_server(self, config_dict: Dict[str, Any]) -> List[ToolDefinition]:
+        """
+        Loads a server configuration from a dictionary, then discovers and registers its tools.
+        This is a convenience method that wraps the parsing and registration process.
+
+        Args:
+            config_dict: The raw dictionary configuration for a single MCP server.
+
+        Returns:
+            A list of the successfully registered ToolDefinition objects from this server.
+        """
+        logger.debug(f"Attempting to load and register server from dictionary: {config_dict.get(next(iter(config_dict), 'unknown'))}")
+        try:
+            validated_config = self._config_service.load_config_from_dict(config_dict)
+        except ValueError as e:
+            logger.error(f"Failed to parse provided MCP config dictionary: {e}")
+            raise
+        
+        return await self.register_server(validated_config)
+
+    async def reload_all_mcp_tools(self) -> List[ToolDefinition]:
+        """
+        Performs a full refresh of tools from ALL MCP servers currently configured
+        in the McpConfigService. This first unregisters all previously registered
+        MCP tools, then re-discovers and re-registers them. This process is resilient
+        to failures from individual servers.
 
+        Returns:
+            A list of all successfully registered ToolDefinition objects.
+        """
+        logger.info("Reloading all MCP tools. Unregistering existing MCP tools first.")
+        
+        # Unregister all previously known MCP tools
+        all_server_ids = list(self._registered_tools_by_server.keys())
+        for server_id in all_server_ids:
+            self.unregister_tools_from_server(server_id)
+        
+        configs_to_process = self._config_service.get_all_configs()
         if not configs_to_process:
-            logger.info("No MCP server configurations to process. Skipping discovery.")
+            logger.info("No MCP server configurations to process. Skipping reload.")
             return []
 
         schema_mapper = McpSchemaMapper()
-        registered_tool_definitions: List[ToolDefinition] = []
+        all_registered_definitions: List[ToolDefinition] = []
+        
         for server_config in configs_to_process:
-            if not server_config.enabled:
-                logger.info(f"MCP server '{server_config.server_id}' is disabled. Skipping.")
-                continue
-
-            logger.info(f"Discovering tools from MCP server: '{server_config.server_id}'")
-            
             try:
-                remote_tools = await self._fetch_tools_from_server(server_config)
-                logger.info(f"Discovered {len(remote_tools)} tools from server '{server_config.server_id}'.")
-
-                for remote_tool in remote_tools:
-                    try:
-                        tool_def = self._create_tool_definition_from_remote(remote_tool, server_config, schema_mapper)
-                        self._tool_registry.register_tool(tool_def)
-                        self._registered_tools_by_server.setdefault(server_config.server_id, []).append(tool_def)
-                        registered_tool_definitions.append(tool_def)
-                    except Exception as e_tool:
-                        logger.error(f"Failed to process or register remote tool '{remote_tool.name}': {e_tool}", exc_info=True)
-            
-            except Exception as e_server:
-                logger.error(f"Failed to discover tools from MCP server '{server_config.server_id}': {e_server}", exc_info=True)
-        
-        logger.info(f"MCP tool discovery and registration process completed. Total tools registered: {len(registered_tool_definitions)}.")
-        return registered_tool_definitions
+                newly_registered = await self._discover_and_register_from_config(server_config, schema_mapper)
+                all_registered_definitions.extend(newly_registered)
+            except Exception as e:
+                # Log the error but continue to the next server. This makes the process resilient.
+                # exc_info is False because the inner method already logged the full stack trace.
+                logger.error(f"Failed to complete discovery for server '{server_config.server_id}', it will be skipped. Error: {e}", exc_info=False)
+
+        logger.info(f"Finished reloading all MCP tools. Total tools registered: {len(all_registered_definitions)}.")
+        return all_registered_definitions
 
     async def list_remote_tools(self, mcp_config: Union[BaseMcpConfig, Dict[str, Any]]) -> List[ToolDefinition]:
         validated_config: BaseMcpConfig