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

autobyteus/task_management/tools/publish_task_plan.py

@@ -0,0 +1,113 @@
+# file: autobyteus/autobyteus/task_management/tools/publish_task_plan.py
+import json
+import logging
+from typing import TYPE_CHECKING, Optional, Dict, Any
+
+from pydantic import ValidationError
+# No longer need GenerateJsonSchema from pydantic.json_schema
+# from pydantic.json_schema import GenerateJsonSchema
+
+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.schemas import TaskPlanDefinitionSchema
+from autobyteus.task_management.converters import TaskPlanConverter, TaskBoardConverter
+
+if TYPE_CHECKING:
+    from autobyteus.agent.context import AgentContext
+    from autobyteus.agent_team.context import AgentTeamContext
+
+logger = logging.getLogger(__name__)
+
+class PublishTaskPlan(BaseTool):
+    """A tool for the coordinator to parse and load a generated plan into the TaskBoard."""
+
+    CATEGORY = ToolCategory.TASK_MANAGEMENT
+
+    # The failing custom InlineSchemaGenerator has been removed.
+
+    @classmethod
+    def get_name(cls) -> str:
+        return "PublishTaskPlan"
+
+    @classmethod
+    def get_description(cls) -> str:
+        return (
+            "Parses a structured object representing a complete task plan, converts it into a "
+            "system-ready format, and loads it onto the team's shared task board. "
+            "This action resets the task board with the new plan. Upon success, it returns "
+            "the initial status of the newly loaded task board. "
+            "This tool should typically only be used by the team coordinator."
+        )
+
+    @classmethod
+    def get_argument_schema(cls) -> Optional[ParameterSchema]:
+        schema = ParameterSchema()
+        
+        # CORRECTED IMPLEMENTATION:
+        # A direct, standard call to model_json_schema(). This generates a valid
+        # JSON schema with $refs, which the framework handles correctly.
+        # This completely avoids the TypeError caused by the unsupported 'ref_strategy' argument.
+        object_json_schema = TaskPlanDefinitionSchema.model_json_schema()
+        
+        schema.add_parameter(ParameterDefinition(
+            name="plan",
+            param_type=ParameterType.OBJECT,
+            description=(
+                "A structured object representing a complete task plan. This object defines the overall goal "
+                "and a list of tasks with their assignees, descriptions, and dependencies. "
+                "Each task must have a unique name within the plan."
+            ),
+            required=True,
+            object_schema=object_json_schema
+        ))
+        return schema
+
+    async def _execute(self, context: 'AgentContext', plan: Dict[str, Any]) -> str:
+        """
+        Executes the tool by validating the plan object, using a converter to create a TaskPlan,
+        and loading it onto the task board.
+        """
+        logger.info(f"Agent '{context.agent_id}' is executing PublishTaskPlan.")
+        
+        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 '{context.agent_id}': {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 '{context.agent_id}': {error_msg}")
+            return error_msg
+            
+        try:
+            # Step 1: The input is now a dictionary, so we can directly validate it.
+            plan_definition_schema = TaskPlanDefinitionSchema(**plan)
+
+            # Step 2: Use the dedicated converter to create the internal TaskPlan object.
+            final_plan = TaskPlanConverter.from_schema(plan_definition_schema)
+
+        except (ValidationError, ValueError) as e:
+            error_msg = f"Invalid or inconsistent task plan provided: {e}"
+            logger.warning(f"Agent '{context.agent_id}' provided an invalid plan for PublishTaskPlan: {error_msg}")
+            return f"Error: {error_msg}"
+        except Exception as e:
+            error_msg = f"An unexpected error occurred during plan parsing or conversion: {e}"
+            logger.error(f"Agent '{context.agent_id}': {error_msg}", exc_info=True)
+            return f"Error: {error_msg}"
+
+        if task_board.load_task_plan(final_plan):
+            logger.info(f"Agent '{context.agent_id}': Task plan published successfully. Returning new board status.")
+            # Convert the new state of the board back to an LLM-friendly schema and return it.
+            status_report_schema = TaskBoardConverter.to_schema(task_board)
+            if status_report_schema:
+                return status_report_schema.model_dump_json(indent=2)
+            else:
+                # This is a fallback case, shouldn't happen right after a successful load.
+                return "Task plan published successfully, but could not generate status report."
+        else:
+            error_msg = "Failed to load task plan onto the board. This can happen if the board implementation rejects the plan."
+            logger.error(f"Agent '{context.agent_id}': {error_msg}")
+            return f"Error: {error_msg}"

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/__init__.py

@@ -10,6 +10,7 @@ from .base_tool import BaseTool
 from .functional_tool import tool # The @tool decorator
 from .parameter_schema import ParameterSchema, ParameterDefinition, ParameterType
 from .tool_config import ToolConfig # Configuration data object, primarily for class-based tools
+from .tool_origin import ToolOrigin
 from .tool_category import ToolCategory
 
 # --- Re-export specific tools for easier access ---
@@ -48,6 +49,7 @@ __all__ = [
     "ParameterDefinition",
     "ParameterType",
     "ToolConfig",
+    "ToolOrigin",
     "ToolCategory",
 
     # Re-exported functional tool instances

autobyteus/tools/ask_user_input.py

@@ -3,13 +3,14 @@ import logging
 from typing import TYPE_CHECKING
 
 from autobyteus.tools import tool # Main @tool decorator
+from autobyteus.tools.tool_category import ToolCategory
 
 if TYPE_CHECKING:
     from autobyteus.agent.context import AgentContext
 
 logger = logging.getLogger(__name__)
 
-@tool(name="AskUserInput") # Explicit name matching the old class name
+@tool(name="AskUserInput", category=ToolCategory.USER_INTERACTION)
 async def ask_user_input(context: 'AgentContext', request: str) -> str: # Function name can be ask_user_input
     """
     Requests input from the user based on a given prompt and returns the user's textual response.

autobyteus/tools/bash/bash_executor.py

@@ -1,37 +1,73 @@
 import asyncio
 import subprocess
 import logging
+import shutil
+import tempfile
 from typing import TYPE_CHECKING, Optional
 
 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="BashExecutor")
-async def bash_executor(context: Optional['AgentContext'], command: str, cwd: Optional[str] = None) -> str:
+@tool(name="BashExecutor", category=ToolCategory.SYSTEM)
+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."
             
@@ -39,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/browser/session_aware/browser_session_aware_navigate_to.py

@@ -1,6 +1,7 @@
 from autobyteus.tools.browser.session_aware.browser_session_aware_tool import BrowserSessionAwareTool
 from autobyteus.tools.browser.session_aware.shared_browser_session import SharedBrowserSession
 from autobyteus.tools.tool_config import ToolConfig
+from autobyteus.tools.tool_category import ToolCategory
 from urllib.parse import urlparse
 from typing import Optional, TYPE_CHECKING, Any
 import logging
@@ -16,6 +17,7 @@ class BrowserSessionAwareNavigateTo(BrowserSessionAwareTool):
     """
     A session-aware tool for navigating to a specified website using a shared browser session.
     """
+    CATEGORY = ToolCategory.WEB
 
     def __init__(self, config: Optional[ToolConfig] = None):
         super().__init__(config=config)

autobyteus/tools/browser/session_aware/browser_session_aware_web_element_trigger.py

@@ -9,6 +9,7 @@ from autobyteus.tools.browser.session_aware.shared_browser_session import Shared
 from autobyteus.tools.browser.session_aware.web_element_action import WebElementAction
 from autobyteus.tools.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType
 from autobyteus.tools.tool_config import ToolConfig
+from autobyteus.tools.tool_category import ToolCategory
 
 if TYPE_CHECKING:
     pass
@@ -19,6 +20,8 @@ class BrowserSessionAwareWebElementTrigger(BrowserSessionAwareTool):
     """
     A session-aware tool to trigger actions on web elements identified by a CSS selector.
     """
+    CATEGORY = ToolCategory.WEB
+    
     def __init__(self, config: Optional[ToolConfig] = None):
         super().__init__(config=config)
         logger.debug("BrowserSessionAwareWebElementTrigger tool initialized.")

autobyteus/tools/browser/session_aware/browser_session_aware_webpage_reader.py

@@ -6,6 +6,7 @@ from autobyteus.tools.browser.session_aware.browser_session_aware_tool import Br
 from autobyteus.tools.browser.session_aware.shared_browser_session import SharedBrowserSession
 from autobyteus.tools.tool_config import ToolConfig 
 from autobyteus.tools.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType 
+from autobyteus.tools.tool_category import ToolCategory
 from autobyteus.utils.html_cleaner import clean, CleaningMode
 
 if TYPE_CHECKING:
@@ -18,6 +19,8 @@ class BrowserSessionAwareWebPageReader(BrowserSessionAwareTool):
     A session-aware tool to read and clean HTML content from the current page
     in a shared browser session.
     """
+    CATEGORY = ToolCategory.WEB
+    
     def __init__(self, config: Optional[ToolConfig] = None): 
         super().__init__(config=config)
         

autobyteus/tools/browser/session_aware/browser_session_aware_webpage_screenshot_taker.py

@@ -7,6 +7,7 @@ from autobyteus.tools.browser.session_aware.browser_session_aware_tool import Br
 from autobyteus.tools.browser.session_aware.shared_browser_session import SharedBrowserSession
 from autobyteus.tools.tool_config import ToolConfig 
 from autobyteus.tools.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType 
+from autobyteus.tools.tool_category import ToolCategory
 
 if TYPE_CHECKING:
     from autobyteus.agent.context import AgentContext 
@@ -17,6 +18,8 @@ class BrowserSessionAwareWebPageScreenshotTaker(BrowserSessionAwareTool):
     """
     A session-aware tool to take a screenshot of the current page in a shared browser session.
     """
+    CATEGORY = ToolCategory.WEB
+    
     def __init__(self, config: Optional[ToolConfig] = None): 
         super().__init__(config=config)
         

autobyteus/tools/browser/standalone/google_search_ui.py

@@ -9,6 +9,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 brui_core.ui_integrator import UIIntegrator 
 from autobyteus.utils.html_cleaner import clean, CleaningMode
 
@@ -22,6 +23,7 @@ class GoogleSearch(BaseTool, UIIntegrator): # Multiple inheritance
     A tool that allows for performing a Google search using Playwright and retrieving the search results.
     Inherits from BaseTool for tool framework compatibility and UIIntegrator for Playwright integration.
     """
+    CATEGORY = ToolCategory.WEB
 
     def __init__(self, config: Optional[ToolConfig] = None):
         BaseTool.__init__(self, config=config)

autobyteus/tools/browser/standalone/navigate_to.py

@@ -1,5 +1,6 @@
 from autobyteus.tools.base_tool import BaseTool
 from autobyteus.tools.tool_config import ToolConfig
+from autobyteus.tools.tool_category import ToolCategory
 from brui_core.ui_integrator import UIIntegrator
 from urllib.parse import urlparse
 from typing import Optional, TYPE_CHECKING, Any
@@ -17,6 +18,7 @@ class NavigateTo(BaseTool, UIIntegrator):
     A standalone tool for navigating to a specified website using Playwright.
     It initializes and closes its own browser instance for each navigation.
     """
+    CATEGORY = ToolCategory.WEB
 
     def __init__(self, config: Optional[ToolConfig] = None):
         BaseTool.__init__(self, config=config)

autobyteus/tools/browser/standalone/web_page_pdf_generator.py

@@ -1,5 +1,6 @@
 from autobyteus.tools.base_tool import BaseTool
 from autobyteus.tools.tool_config import ToolConfig
+from autobyteus.tools.tool_category import ToolCategory
 from brui_core.ui_integrator import UIIntegrator
 import os
 import logging
@@ -18,6 +19,8 @@ class WebPagePDFGenerator(BaseTool, UIIntegrator):
     A class that generates a PDF of a given webpage URL using Playwright.
     Saves the PDF to a specified directory. This is a standalone browser tool.
     """
+    CATEGORY = ToolCategory.WEB
+    
     def __init__(self, config: Optional[ToolConfig] = None): 
         BaseTool.__init__(self, config=config)
         UIIntegrator.__init__(self)

autobyteus/tools/browser/standalone/webpage_image_downloader.py

@@ -1,5 +1,6 @@
 from autobyteus.tools.base_tool import BaseTool
 from autobyteus.tools.tool_config import ToolConfig
+from autobyteus.tools.tool_category import ToolCategory
 from brui_core.ui_integrator import UIIntegrator
 import os
 import logging 
@@ -18,6 +19,8 @@ class WebPageImageDownloader(BaseTool, UIIntegrator):
     A class that downloads images (excluding SVGs and data URIs) from a given webpage URL using Playwright.
     Saves images to a specified directory.
     """
+    CATEGORY = ToolCategory.WEB
+    
     def __init__(self, config: Optional[ToolConfig] = None): 
         BaseTool.__init__(self, config=config)
         UIIntegrator.__init__(self)

autobyteus/tools/browser/standalone/webpage_reader.py

@@ -8,6 +8,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 brui_core.ui_integrator import UIIntegrator 
 from autobyteus.utils.html_cleaner import clean, CleaningMode
 
@@ -20,6 +21,7 @@ class WebPageReader(BaseTool, UIIntegrator):
     """
     A class that reads and cleans the HTML content from a given webpage using Playwright.
     """
+    CATEGORY = ToolCategory.WEB
 
     def __init__(self, config: Optional[ToolConfig] = None):
         BaseTool.__init__(self, config=config)

autobyteus/tools/browser/standalone/webpage_screenshot_taker.py

@@ -2,6 +2,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 brui_core.ui_integrator import UIIntegrator 
 import logging 
 import os 
@@ -15,6 +16,8 @@ class WebPageScreenshotTaker(BaseTool, UIIntegrator):
     """
     A class that takes a screenshot of a given webpage using Playwright and saves it.
     """
+    CATEGORY = ToolCategory.WEB
+    
     def __init__(self, config: Optional[ToolConfig] = None):
         BaseTool.__init__(self, config=config)
         UIIntegrator.__init__(self) 

autobyteus/tools/file/file_reader.py

@@ -3,27 +3,54 @@ 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="FileReader") # Keep registered name "FileReader"
-async def file_reader(context: 'AgentContext', path: str) -> str: # function name can be same
+@tool(name="FileReader", category=ToolCategory.FILE_SYSTEM)
+async def file_reader(context: 'AgentContext', path: str) -> str:
     """
     Reads content from a specified file.
-    'path' is the absolute or relative path to the file.
+    'path' is the path to the file. If relative, it must be resolved against a configured agent workspace.
+    Raises ValueError if a relative path is given without a valid workspace.
     Raises FileNotFoundError if the file does not exist.
     Raises IOError if file reading fails for other reasons.
     """
-    logger.debug(f"Functional FileReader tool for agent {context.agent_id}, path: {path}")
-    if not os.path.exists(path):
-        raise FileNotFoundError(f"The file at {path} does not exist.")
+    logger.debug(f"Functional FileReader 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}'.")
+
+    # It's good practice to normalize the path to handle things like '..'
+    final_path = os.path.normpath(final_path)
+
+    if not os.path.exists(final_path):
+        raise FileNotFoundError(f"The file at resolved path {final_path} does not exist.")
+        
     try:
-        with open(path, 'r', encoding='utf-8') as file:
+        with open(final_path, 'r', encoding='utf-8') as file:
             content = file.read()
+        logger.info(f"File successfully read from '{final_path}' for agent '{context.agent_id}'.")
         return content
     except Exception as e:
-        logger.error(f"Error reading file {path} for agent {context.agent_id}: {e}", exc_info=True)
-        raise IOError(f"Could not read file at {path}: {str(e)}")
+        logger.error(f"Error reading file from final path '{final_path}' for agent {context.agent_id}: {e}", exc_info=True)
+        raise IOError(f"Could not read file at {final_path}: {str(e)}")