autobyteus 1.1.8__py3-none-any.whl → 1.2.0__py3-none-any.whl

autobyteus/task_management/tools/publish_tasks.py

@@ -0,0 +1,74 @@
+# file: autobyteus/autobyteus/task_management/tools/publish_tasks.py
+import logging
+from typing import TYPE_CHECKING, Optional, Dict, Any
+
+from pydantic import ValidationError
+
+from autobyteus.tools.base_tool import BaseTool
+from autobyteus.tools.tool_category import ToolCategory
+from autobyteus.utils.parameter_schema import ParameterSchema
+from autobyteus.tools.pydantic_schema_converter import pydantic_to_parameter_schema
+from autobyteus.task_management.schemas import TasksDefinitionSchema
+from autobyteus.task_management.task import Task
+
+if TYPE_CHECKING:
+    from autobyteus.agent.context import AgentContext
+    from autobyteus.agent_team.context import AgentTeamContext
+
+logger = logging.getLogger(__name__)
+
+class PublishTasks(BaseTool):
+    """
+    A tool to publish multiple tasks to the task board. This is an additive-only operation.
+    """
+
+    CATEGORY = ToolCategory.TASK_MANAGEMENT
+
+    @classmethod
+    def get_name(cls) -> str:
+        return "PublishTasks"
+
+    @classmethod
+    def get_description(cls) -> str:
+        return (
+            "Adds a list of new tasks to the team's shared task board. This action is additive and "
+            "does not affect existing tasks or the team's overall goal."
+        )
+
+    @classmethod
+    def get_argument_schema(cls) -> Optional[ParameterSchema]:
+        return pydantic_to_parameter_schema(TasksDefinitionSchema)
+
+    async def _execute(self, context: 'AgentContext', **kwargs: Any) -> str:
+        agent_name = context.config.name
+        logger.info(f"Agent '{agent_name}' is executing PublishTasks.")
+        
+        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
+            
+        try:
+            tasks_def_schema = TasksDefinitionSchema(**kwargs)
+            final_tasks = [Task(**task_def.model_dump()) for task_def in tasks_def_schema.tasks]
+        except (ValidationError, ValueError) as e:
+            error_msg = f"Invalid task definitions provided: {e}"
+            logger.warning(f"Agent '{agent_name}' provided an invalid definition for PublishTasks: {error_msg}")
+            return f"Error: {error_msg}"
+
+        if task_board.add_tasks(tasks=final_tasks):
+            success_msg = f"Successfully published {len(final_tasks)} new task(s) to the task board."
+            logger.info(f"Agent '{agent_name}': {success_msg}")
+            return success_msg
+        else:
+            # This path is less likely now but kept for robustness.
+            error_msg = "Failed to publish tasks to the board for an unknown reason."
+            logger.error(f"Agent '{agent_name}': {error_msg}")
+            return f"Error: {error_msg}"

autobyteus/task_management/tools/update_task_status.py

@@ -5,7 +5,7 @@ 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.utils.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType
 from autobyteus.tools.pydantic_schema_converter import pydantic_to_parameter_schema
 from autobyteus.task_management.base_task_board import TaskStatus
 from autobyteus.task_management.deliverable import FileDeliverable
@@ -77,12 +77,12 @@ class UpdateTaskStatus(BaseTool):
             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.")
+        if not task_board.tasks:
+            error_msg = "Error: No tasks are currently loaded on the task board."
+            logger.warning(f"Agent '{agent_name}' tried to update task status, but the board is empty.")
             return error_msg
 
-        target_task = next((t for t in task_board.current_plan.tasks if t.task_name == task_name), None)
+        target_task = next((t for t in task_board.tasks if t.task_name == task_name), None)
 
         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."

autobyteus/tools/__init__.py

@@ -5,40 +5,77 @@ for creating tools within the AutoByteUs framework.
 It also contains implementations of various standard tools.
 """
 
+import logging
+
 # Core components for defining tools
 from .base_tool import BaseTool
 from .functional_tool import tool # The @tool decorator
-from .parameter_schema import ParameterSchema, ParameterDefinition, ParameterType
+from autobyteus.utils.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
 
+logger = logging.getLogger(__name__)
+
 # --- Re-export specific tools for easier access ---
 
 # Functional tools (decorated functions are now instances)
-from .pdf_downloader import pdf_downloader
 from .bash.bash_executor import bash_executor
 from .file.file_reader import file_reader
 from .file.file_writer import file_writer
+from .file.file_editor import file_edit
 
 # General Class-based tools
-from .google_search import GoogleSearch 
-from .image_downloader import ImageDownloader
+try:
+    from .google_search import GoogleSearch
+except ModuleNotFoundError as import_err:
+    logger.warning("GoogleSearch tool not available: %s", import_err)
+    GoogleSearch = None
 from .timer import Timer
-from .multimedia.image_tools import GenerateImageTool, EditImageTool
+try:
+    from .multimedia.image_tools import GenerateImageTool, EditImageTool
+except ModuleNotFoundError as import_err:
+    logger.warning("Image tools not available: %s", import_err)
+    GenerateImageTool = None
+    EditImageTool = None
+try:
+    from .multimedia.media_reader_tool import ReadMediaFile
+except ModuleNotFoundError as import_err:
+    logger.warning("Media reader tool not available: %s", import_err)
+    ReadMediaFile = None
+try:
+    from .download_media_tool import DownloadMediaTool
+except ModuleNotFoundError as import_err:
+    logger.warning("Download media tool not available: %s", import_err)
+    DownloadMediaTool = None
 
 # Standalone Browser tools
-from .browser.standalone.navigate_to import NavigateTo as StandaloneNavigateTo # Alias to avoid name clash
-from .browser.standalone.webpage_reader import WebPageReader as StandaloneWebPageReader # Alias
-from .browser.standalone.webpage_screenshot_taker import WebPageScreenshotTaker as StandaloneWebPageScreenshotTaker # Alias
-from .browser.standalone.webpage_image_downloader import WebPageImageDownloader
-from .browser.standalone.web_page_pdf_generator import WebPagePDFGenerator
+try:
+    from .browser.standalone.navigate_to import NavigateTo as StandaloneNavigateTo # Alias to avoid name clash
+    from .browser.standalone.webpage_reader import WebPageReader as StandaloneWebPageReader # Alias
+    from .browser.standalone.webpage_screenshot_taker import WebPageScreenshotTaker as StandaloneWebPageScreenshotTaker # Alias
+    from .browser.standalone.webpage_image_downloader import WebPageImageDownloader
+    from .browser.standalone.web_page_pdf_generator import WebPagePDFGenerator
+except ModuleNotFoundError as import_err:
+    logger.warning('Standalone browser tools not available: %s', import_err)
+    StandaloneNavigateTo = None
+    StandaloneWebPageReader = None
+    StandaloneWebPageScreenshotTaker = None
+    WebPageImageDownloader = None
+    WebPagePDFGenerator = None
 
 # Session-Aware Browser tools
-from .browser.session_aware.browser_session_aware_navigate_to import BrowserSessionAwareNavigateTo
-from .browser.session_aware.browser_session_aware_web_element_trigger import BrowserSessionAwareWebElementTrigger
-from .browser.session_aware.browser_session_aware_webpage_reader import BrowserSessionAwareWebPageReader
-from .browser.session_aware.browser_session_aware_webpage_screenshot_taker import BrowserSessionAwareWebPageScreenshotTaker
+try:
+    from .browser.session_aware.browser_session_aware_navigate_to import BrowserSessionAwareNavigateTo
+    from .browser.session_aware.browser_session_aware_web_element_trigger import BrowserSessionAwareWebElementTrigger
+    from .browser.session_aware.browser_session_aware_webpage_reader import BrowserSessionAwareWebPageReader
+    from .browser.session_aware.browser_session_aware_webpage_screenshot_taker import BrowserSessionAwareWebPageScreenshotTaker
+except ModuleNotFoundError as import_err:
+    logger.warning('Session-aware browser tools not available: %s', import_err)
+    BrowserSessionAwareNavigateTo = None
+    BrowserSessionAwareWebElementTrigger = None
+    BrowserSessionAwareWebPageReader = None
+    BrowserSessionAwareWebPageScreenshotTaker = None
 
 
 __all__ = [
@@ -53,17 +90,18 @@ __all__ = [
     "ToolCategory",
 
     # Re-exported functional tool instances
-    "pdf_downloader",
     "bash_executor",
     "file_reader",
     "file_writer",
+    "file_edit",
 
     # Re-exported general class-based tools
     "GoogleSearch",
-    "ImageDownloader",
     "Timer",
     "GenerateImageTool",
     "EditImageTool",
+    "ReadMediaFile",
+    "DownloadMediaTool",
 
     # Re-exported Standalone Browser tools
     "StandaloneNavigateTo",

autobyteus/tools/base_tool.py

@@ -5,14 +5,14 @@ from abc import ABC, abstractmethod
 from typing import Optional, Any, TYPE_CHECKING, List as TypingList, Dict, Union
 
 from autobyteus.events.event_emitter import EventEmitter
-from autobyteus.tools.parameter_schema import ParameterType
+from autobyteus.utils.parameter_schema import ParameterType
 
 from .tool_meta import ToolMeta
 from .tool_state import ToolState
 
 if TYPE_CHECKING:
     from autobyteus.agent.context import AgentContext
-    from autobyteus.tools.parameter_schema import ParameterSchema, ParameterDefinition
+    from autobyteus.utils.parameter_schema import ParameterSchema, ParameterDefinition
     from autobyteus.tools.tool_config import ToolConfig
     from .tool_state import ToolState
     from autobyteus.tools.registry import ToolDefinition
@@ -90,8 +90,8 @@ class BaseTool(ABC, EventEmitter, metaclass=ToolMeta):
             if item_schema_dict and isinstance(item_schema_dict, dict) and item_schema_dict.get("type") == "object":
                 # Create a temporary ParameterSchema for the item type to enable recursion.
                 # This is a simplified conversion for coercion purposes only.
-                from .parameter_schema import ParameterSchema as TempSchema
-                from .parameter_schema import ParameterDefinition as TempDef
+                from autobyteus.utils.parameter_schema import ParameterSchema as TempSchema
+                from autobyteus.utils.parameter_schema import ParameterDefinition as TempDef
 
                 item_param_schema = TempSchema()
                 props = item_schema_dict.get("properties", {})

autobyteus/tools/browser/session_aware/browser_session_aware_navigate_to.py

@@ -6,7 +6,7 @@ from urllib.parse import urlparse
 from typing import Optional, TYPE_CHECKING, Any
 import logging
 
-from autobyteus.tools.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType
+from autobyteus.utils.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType
 
 if TYPE_CHECKING:
     from autobyteus.agent.context import AgentContext

autobyteus/tools/browser/session_aware/browser_session_aware_web_element_trigger.py

@@ -7,7 +7,7 @@ import logging
 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.browser.session_aware.web_element_action import WebElementAction
-from autobyteus.tools.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType
+from autobyteus.utils.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType
 from autobyteus.tools.tool_config import ToolConfig
 from autobyteus.tools.tool_category import ToolCategory
 

autobyteus/tools/browser/session_aware/browser_session_aware_webpage_reader.py

@@ -5,7 +5,7 @@ from typing import Optional, TYPE_CHECKING, Any
 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.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType 
+from autobyteus.utils.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType 
 from autobyteus.tools.tool_category import ToolCategory
 from autobyteus.utils.html_cleaner import clean, CleaningMode
 

autobyteus/tools/browser/session_aware/browser_session_aware_webpage_screenshot_taker.py

@@ -6,7 +6,7 @@ from typing import Optional, TYPE_CHECKING, Any
 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.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType 
+from autobyteus.utils.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType 
 from autobyteus.tools.tool_category import ToolCategory
 
 if TYPE_CHECKING:

autobyteus/tools/browser/standalone/navigate_to.py

@@ -6,7 +6,7 @@ from urllib.parse import urlparse
 from typing import Optional, TYPE_CHECKING, Any
 import logging
 
-from autobyteus.tools.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType
+from autobyteus.utils.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType
 
 if TYPE_CHECKING:
     from autobyteus.agent.context import AgentContext

autobyteus/tools/browser/standalone/web_page_pdf_generator.py

@@ -7,7 +7,7 @@ import logging
 from typing import Optional, TYPE_CHECKING, Any 
 from urllib.parse import urlparse 
 
-from autobyteus.tools.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType
+from autobyteus.utils.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType
 
 if TYPE_CHECKING:
     from autobyteus.agent.context import AgentContext

autobyteus/tools/browser/standalone/webpage_image_downloader.py

@@ -7,7 +7,7 @@ import logging
 from urllib.parse import urljoin, urlparse 
 from typing import Optional, TYPE_CHECKING, Any, List 
 
-from autobyteus.tools.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType
+from autobyteus.utils.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType
 
 if TYPE_CHECKING:
     from autobyteus.agent.context import AgentContext

autobyteus/tools/browser/standalone/webpage_reader.py

@@ -7,7 +7,7 @@ import logging
 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.utils.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

autobyteus/tools/browser/standalone/webpage_screenshot_taker.py

@@ -1,7 +1,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.utils.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType 
 from autobyteus.tools.tool_category import ToolCategory
 from brui_core.ui_integrator import UIIntegrator 
 import logging 

autobyteus/tools/download_media_tool.py

@@ -0,0 +1,136 @@
+import os
+import logging
+import mimetypes
+import aiohttp
+from typing import Optional, TYPE_CHECKING
+from urllib.parse import urlparse
+
+from autobyteus.tools.base_tool import BaseTool
+from autobyteus.tools.tool_category import ToolCategory
+from autobyteus.utils.file_utils import get_default_download_folder
+from autobyteus.utils.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType
+
+if TYPE_CHECKING:
+    from autobyteus.agent.context import AgentContext
+
+logger = logging.getLogger(__name__)
+
+class DownloadMediaTool(BaseTool):
+    """
+    A unified tool to download any media file (e.g., image, PDF, audio) from a URL.
+    """
+    CATEGORY = ToolCategory.WEB
+
+    @classmethod
+    def get_name(cls) -> str:
+        return "DownloadMedia"
+
+    @classmethod
+    def get_description(cls) -> str:
+        return (
+            "Downloads various media files (e.g., images like PNG/JPG, documents like PDF, audio like MP3/WAV) "
+            "from a direct URL and saves them locally. It intelligently determines the correct file extension "
+            "based on the content type. Returns the absolute path to the downloaded file."
+        )
+
+    @classmethod
+    def get_argument_schema(cls) -> ParameterSchema:
+        schema = ParameterSchema()
+        schema.add_parameter(ParameterDefinition(
+            name="url",
+            param_type=ParameterType.STRING,
+            description="The direct URL of the media file to download.",
+            required=True
+        ))
+        schema.add_parameter(ParameterDefinition(
+            name="filename",
+            param_type=ParameterType.STRING,
+            description="The desired base name for the downloaded file (e.g., 'vacation_photo', 'annual_report'). The tool will automatically add the correct file extension.",
+            required=True
+        ))
+        schema.add_parameter(ParameterDefinition(
+            name="folder",
+            param_type=ParameterType.STRING,
+            description="Optional. A custom directory path to save the file. If not provided, the system's default download folder will be used.",
+            required=False
+        ))
+        return schema
+
+    async def _execute(self, context: 'AgentContext', url: str, filename: str, folder: Optional[str] = None) -> str:
+        # 1. Determine download directory
+        try:
+            if folder:
+                # Security: prevent path traversal attacks.
+                if ".." in folder:
+                     raise ValueError("Security error: 'folder' path cannot contain '..'.")
+                destination_dir = os.path.abspath(folder)
+            else:
+                destination_dir = get_default_download_folder()
+            
+            os.makedirs(destination_dir, exist_ok=True)
+        except Exception as e:
+            logger.error(f"Error preparing download directory '{folder or 'default'}': {e}", exc_info=True)
+            raise IOError(f"Failed to create or access download directory: {e}")
+
+        # 2. Sanitize filename provided by the LLM
+        if not filename or ".." in filename or os.path.isabs(filename) or "/" in filename or "\\" in filename:
+            raise ValueError("Invalid filename. It must be a simple name without any path characters ('..', '/', '\\').")
+
+        logger.info(f"Attempting to download from {url} to save as '{filename}' in '{destination_dir}'.")
+
+        # 3. Download and process file asynchronously
+        try:
+            async with aiohttp.ClientSession() as session:
+                async with session.get(url, timeout=60) as response:
+                    response.raise_for_status()
+
+                    # 4. Intelligently determine file extension from Content-Type header
+                    content_type = response.headers.get('Content-Type')
+                    correct_ext = ''
+                    if content_type:
+                        mime_type = content_type.split(';')[0].strip()
+                        guess = mimetypes.guess_extension(mime_type)
+                        if guess:
+                            correct_ext = guess
+                            logger.debug(f"Determined extension '{correct_ext}' from Content-Type: '{mime_type}'")
+
+                    # Fallback to URL extension if Content-Type is generic or missing
+                    if not correct_ext or correct_ext == '.bin':
+                        url_path = urlparse(url).path
+                        _, ext_from_url = os.path.splitext(os.path.basename(url_path))
+                        if ext_from_url and len(ext_from_url) > 1: # Ensure it's not just a dot
+                            logger.debug(f"Using fallback extension '{ext_from_url}' from URL.")
+                            correct_ext = ext_from_url
+                    
+                    if not correct_ext:
+                        logger.warning("Could not determine a file extension. The file will be saved without one.")
+                    
+                    # 5. Construct final filename and path
+                    base_filename, _ = os.path.splitext(filename)
+                    final_filename = f"{base_filename}{correct_ext}"
+                    save_path = os.path.join(destination_dir, final_filename)
+                    
+                    # Ensure filename is unique to avoid overwriting
+                    counter = 1
+                    while os.path.exists(save_path):
+                        final_filename = f"{base_filename}_{counter}{correct_ext}"
+                        save_path = os.path.join(destination_dir, final_filename)
+                        counter += 1
+                    
+                    # 6. Stream file content to disk
+                    with open(save_path, 'wb') as f:
+                        async for chunk in response.content.iter_chunked(8192):
+                            f.write(chunk)
+
+                    logger.info(f"Successfully downloaded and saved file to: {save_path}")
+                    return f"Successfully downloaded file to: {save_path}"
+
+        except aiohttp.ClientError as e:
+            logger.error(f"Network error while downloading from {url}: {e}", exc_info=True)
+            raise ConnectionError(f"Failed to download from {url}: {e}")
+        except IOError as e:
+            logger.error(f"Failed to write downloaded file to {destination_dir}: {e}", exc_info=True)
+            raise
+        except Exception as e:
+            logger.error(f"An unexpected error occurred during download from {url}: {e}", exc_info=True)
+            raise RuntimeError(f"An unexpected error occurred: {e}")