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

autobyteus/task_management/tools/update_task_status.py

@@ -0,0 +1,135 @@
+import logging
+from typing import TYPE_CHECKING, Optional, List, Dict, Any
+
+from pydantic import ValidationError
+
+from autobyteus.tools.base_tool import BaseTool
+from autobyteus.tools.tool_category import ToolCategory
+from autobyteus.tools.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType
+from autobyteus.task_management.base_task_board import TaskStatus
+from autobyteus.task_management.deliverable import FileDeliverable
+from autobyteus.task_management.schemas import FileDeliverableSchema
+
+if TYPE_CHECKING:
+    from autobyteus.agent.context import AgentContext
+    from autobyteus.agent_team.context import AgentTeamContext
+
+logger = logging.getLogger(__name__)
+
+class UpdateTaskStatus(BaseTool):
+    """A tool for member agents to update their progress and submit file deliverables on the TaskBoard."""
+
+    CATEGORY = ToolCategory.TASK_MANAGEMENT
+
+    @classmethod
+    def get_name(cls) -> str:
+        return "UpdateTaskStatus"
+
+    @classmethod
+    def get_description(cls) -> str:
+        return (
+            "Updates the status of a specific task on the team's shared task board. "
+            "When completing a task, this tool can also be used to formally submit a list of file deliverables."
+        )
+
+    @classmethod
+    def get_argument_schema(cls) -> Optional[ParameterSchema]:
+        schema = ParameterSchema()
+        schema.add_parameter(ParameterDefinition(
+            name="task_name",
+            param_type=ParameterType.STRING,
+            description="The unique name of the task to update (e.g., 'implement_scraper').",
+            required=True
+        ))
+        schema.add_parameter(ParameterDefinition(
+            name="status",
+            param_type=ParameterType.ENUM,
+            description=f"The new status for the task. Must be one of: {', '.join([s.value for s in TaskStatus])}.",
+            required=True,
+            enum_values=[s.value for s in TaskStatus]
+        ))
+        schema.add_parameter(ParameterDefinition(
+            name="deliverables",
+            param_type=ParameterType.ARRAY,
+            description="Optional. A list of file deliverables to submit for this task, typically when status is 'completed'. Each deliverable must include a file_path and a summary.",
+            required=False,
+            array_item_schema=FileDeliverableSchema.model_json_schema()
+        ))
+        return schema
+
+    async def _execute(self, context: 'AgentContext', task_name: str, status: str, deliverables: Optional[List[Dict[str, Any]]] = None) -> str:
+        """
+        Executes the tool to update a task's status and optionally submit deliverables.
+        """
+        agent_name = context.config.name
+        log_msg = f"Agent '{agent_name}' is executing UpdateTaskStatus for task '{task_name}' to status '{status}'"
+        if deliverables:
+            log_msg += f" with {len(deliverables)} deliverable(s)."
+        logger.info(log_msg)
+        
+        team_context: Optional['AgentTeamContext'] = context.custom_data.get("team_context")
+        if not team_context:
+            error_msg = "Error: Team context is not available. Cannot access the task board."
+            logger.error(f"Agent '{agent_name}': {error_msg}")
+            return error_msg
+            
+        task_board = getattr(team_context.state, 'task_board', None)
+        if not task_board:
+            error_msg = "Error: Task board has not been initialized for this team."
+            logger.error(f"Agent '{agent_name}': {error_msg}")
+            return error_msg
+        
+        if not task_board.current_plan:
+            error_msg = "Error: No task plan is currently loaded on the task board."
+            logger.warning(f"Agent '{agent_name}' tried to update task status, but no plan is loaded.")
+            return error_msg
+
+        # Find the task by name
+        target_task = None
+        for task in task_board.current_plan.tasks:
+            if task.task_name == task_name:
+                target_task = task
+                break
+
+        if not target_task:
+            error_msg = f"Failed to update status for task '{task_name}'. The task name does not exist on the current plan."
+            logger.warning(f"Agent '{agent_name}' failed to update status for non-existent task '{task_name}'.")
+            return f"Error: {error_msg}"
+            
+        try:
+            status_enum = TaskStatus(status)
+        except ValueError:
+            error_msg = f"Invalid status '{status}'. Must be one of: {', '.join([s.value for s in TaskStatus])}."
+            logger.warning(f"Agent '{agent_name}' provided invalid status for UpdateTaskStatus: {status}")
+            return f"Error: {error_msg}"
+        
+        # --- Process Deliverables FIRST --- (CORRECTED ORDER)
+        if deliverables:
+            try:
+                for d_data in deliverables:
+                    # Validate and create the internal deliverable object
+                    deliverable_schema = FileDeliverableSchema(**d_data)
+                    full_deliverable = FileDeliverable(
+                        **deliverable_schema.model_dump(),
+                        author_agent_name=agent_name
+                    )
+                    # Append to the task object
+                    target_task.file_deliverables.append(full_deliverable)
+                logger.info(f"Agent '{agent_name}' successfully processed and added {len(deliverables)} deliverables to task '{task_name}'.")
+            except (ValidationError, TypeError) as e:
+                error_msg = f"Failed to process deliverables due to invalid data: {e}. Task status was NOT updated."
+                logger.warning(f"Agent '{agent_name}': {error_msg}")
+                return f"Error: {error_msg}"
+
+        # --- Update Status SECOND --- (CORRECTED ORDER)
+        # This will now emit an event with the deliverables already attached to the task.
+        if not task_board.update_task_status(target_task.task_id, status_enum, agent_name):
+            error_msg = f"Failed to update status for task '{task_name}'. An unexpected error occurred on the task board."
+            logger.error(f"Agent '{agent_name}': {error_msg}")
+            return f"Error: {error_msg}"
+
+        success_msg = f"Successfully updated status of task '{task_name}' to '{status}'."
+        if deliverables:
+            success_msg += f" and submitted {len(deliverables)} deliverable(s)."
+        logger.info(f"Agent '{agent_name}': {success_msg}")
+        return success_msg

autobyteus/tools/bash/bash_executor.py

@@ -1,6 +1,8 @@
 import asyncio
 import subprocess
 import logging
+import shutil
+import tempfile
 from typing import TYPE_CHECKING, Optional
 
 from autobyteus.tools import tool 
@@ -12,27 +14,60 @@ if TYPE_CHECKING:
 logger = logging.getLogger(__name__)
 
 @tool(name="BashExecutor", category=ToolCategory.SYSTEM)
-async def bash_executor(context: Optional['AgentContext'], command: str, cwd: Optional[str] = None) -> str:
+async def bash_executor(context: Optional['AgentContext'], command: str) -> str:
     """
-    Executes bash commands and retrieves their standard output.
+    Executes bash commands using the '/bin/bash' interpreter.
+    On success, it returns a formatted string containing the command's standard output (stdout) and/or diagnostic logs.
+    On failure, it raises an exception.
+    - If a command has only stdout, its content is returned directly.
+    - If a command has diagnostic output (from stderr), it will be included and labeled as 'LOGS' in the output.
     'command' is the bash command string to be executed.
-    'cwd' is the optional directory to run the command in.
-    Errors during command execution are raised as exceptions.
+    The command is executed in the agent's workspace directory if available.
     """
+    if not shutil.which("bash"):
+        error_msg = "'bash' executable not found in system PATH. The BashExecutor tool cannot be used."
+        logger.error(error_msg)
+        raise FileNotFoundError(error_msg)
+        
     agent_id_str = context.agent_id if context else "Non-Agent"
-    logger.debug(f"Functional BashExecutor tool executing for '{agent_id_str}': {command} in cwd: {cwd or 'default'}")
+    
+    effective_cwd = None
+    log_cwd_source = ""
+
+    if context and hasattr(context, 'workspace') and context.workspace:
+        try:
+            base_path = context.workspace.get_base_path()
+            if base_path and isinstance(base_path, str):
+                effective_cwd = base_path
+                log_cwd_source = f"agent workspace: {effective_cwd}"
+            else:
+                logger.warning(f"Agent '{agent_id_str}' has a workspace, but it provided an invalid base path ('{base_path}'). "
+                               f"Falling back to system temporary directory.")
+        except Exception as e:
+            logger.warning(f"Could not retrieve workspace for agent '{agent_id_str}': {e}. "
+                           f"Falling back to system temporary directory.")
+
+    if not effective_cwd:
+        effective_cwd = tempfile.gettempdir()
+        log_cwd_source = f"system temporary directory: {effective_cwd}"
+
+    logger.debug(f"Functional BashExecutor tool executing for '{agent_id_str}': {command} in cwd from {log_cwd_source}")
 
     try:
-        process = await asyncio.create_subprocess_shell(
-            command,
+        # Explicitly use 'bash -c' for reliable execution
+        process = await asyncio.create_subprocess_exec(
+            'bash', '-c', command,
             stdout=asyncio.subprocess.PIPE,
             stderr=asyncio.subprocess.PIPE,
-            cwd=cwd
+            cwd=effective_cwd
         )
         stdout, stderr = await process.communicate()
+        
+        stdout_output = stdout.decode().strip() if stdout else ""
+        stderr_output = stderr.decode().strip() if stderr else ""
 
         if process.returncode != 0:
-            error_message = stderr.decode().strip() if stderr else "Unknown error"
+            error_message = stderr_output if stderr_output else "Unknown error"
             if not error_message and process.returncode != 0:
                 error_message = f"Command failed with exit code {process.returncode} and no stderr output."
             
@@ -40,16 +75,26 @@ async def bash_executor(context: Optional['AgentContext'], command: str, cwd: Op
             raise subprocess.CalledProcessError(
                 returncode=process.returncode,
                 cmd=command,
-                output=stdout.decode().strip() if stdout else "",
+                output=stdout_output,
                 stderr=error_message
             )
-
-        output = stdout.decode().strip() if stdout else ""
-        logger.debug(f"Command '{command}' output: {output}")
-        return output
+        
+        # Adaptive return for successful commands to provide maximum context to the agent.
+        if stdout_output and stderr_output:
+            return f"STDOUT:\n{stdout_output}\n\nLOGS:\n{stderr_output}"
+        elif stdout_output:
+            return stdout_output  # Keep it simple for commands with only stdout
+        elif stderr_output:
+            return f"LOGS:\n{stderr_output}"
+        else:
+            return "Command executed successfully with no output."
 
     except subprocess.CalledProcessError:
         raise
+    except FileNotFoundError:
+        # This can be raised by create_subprocess_exec if 'bash' is not found, despite the initial check.
+        logger.error("'bash' executable not found when attempting to execute command. Please ensure it is installed and in the PATH.")
+        raise
     except Exception as e: 
         logger.exception(f"An error occurred while preparing or executing command '{command}': {str(e)}")
         raise RuntimeError(f"Failed to execute command '{command}': {str(e)}")

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