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

autobyteus/tools/browser/standalone/webpage_reader.py

@@ -1,101 +0,0 @@
-"""
-File: autobyteus/tools/browser/standalone/webpage_reader.py
-This module provides a WebPageReader tool for reading and cleaning HTML content from webpages.
-"""
-
-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.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
-
-if TYPE_CHECKING:
-    from autobyteus.agent.context import AgentContext 
-
-logger = logging.getLogger(__name__)
-
-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)
-        UIIntegrator.__init__(self) 
-        
-        cleaning_mode_to_use = CleaningMode.THOROUGH
-        if config:
-            cleaning_mode_value = config.get('cleaning_mode') 
-            if cleaning_mode_value:
-                if isinstance(cleaning_mode_value, str):
-                    try:
-                        cleaning_mode_to_use = CleaningMode(cleaning_mode_value.upper())
-                    except ValueError:
-                        logger.warning(f"Invalid cleaning_mode string '{cleaning_mode_value}' in config for WebPageReader. Using THOROUGH.")
-                        cleaning_mode_to_use = CleaningMode.THOROUGH
-                elif isinstance(cleaning_mode_value, CleaningMode):
-                    cleaning_mode_to_use = cleaning_mode_value
-                else:
-                     logger.warning(f"Invalid type for cleaning_mode in config for WebPageReader. Using THOROUGH.")
-        
-        self.cleaning_mode = cleaning_mode_to_use
-        logger.debug(f"WebPageReader initialized with cleaning_mode: {self.cleaning_mode}")
-
-    @classmethod
-    def get_description(cls) -> str:
-        return "Reads and cleans the HTML content from a given webpage URL using Playwright."
-
-    @classmethod
-    def get_argument_schema(cls) -> Optional[ParameterSchema]:
-        """Schema for arguments passed to the execute method."""
-        schema = ParameterSchema()
-        schema.add_parameter(ParameterDefinition(
-            name="url", 
-            param_type=ParameterType.STRING,
-            description="The URL of the webpage to read content from.",
-            required=True
-        ))
-        return schema
-        
-    @classmethod
-    def get_config_schema(cls) -> Optional[ParameterSchema]:
-        """Schema for parameters to configure the WebPageReader instance itself."""
-        schema = ParameterSchema()
-        schema.add_parameter(ParameterDefinition(
-            name="cleaning_mode",
-            param_type=ParameterType.ENUM,
-            description="Level of HTML content cleanup for webpage content. BASIC or THOROUGH.",
-            required=False,
-            default_value="THOROUGH",
-            enum_values=[mode.name for mode in CleaningMode]
-        ))
-        return schema
-
-    async def _execute(self, context: 'AgentContext', url: str) -> str:
-        logger.info(f"WebPageReader executing for agent {context.agent_id} with URL: '{url}'")
-
-        try:
-            await self.initialize()
-            if not self.page:
-                 logger.error("Playwright page not initialized in WebPageReader.")
-                 raise RuntimeError("Playwright page not available for WebPageReader.")
-
-            await self.page.goto(url, timeout=60000, wait_until="domcontentloaded")
-            page_content = await self.page.content()
-            
-            cleaned_content = clean(page_content, mode=self.cleaning_mode)
-            
-            return f'''here is the html of the web page
-<WebPageContentStart>
-{cleaned_content}
-</WebPageContentEnd>
-'''
-        except Exception as e:
-            logger.error(f"Error reading webpage at URL '{url}': {e}", exc_info=True)
-            raise RuntimeError(f"WebPageReader failed for URL '{url}': {str(e)}")
-        finally:
-            await self.close()

autobyteus/tools/browser/standalone/webpage_screenshot_taker.py

@@ -1,101 +0,0 @@
-from typing import Optional, TYPE_CHECKING, Any
-from autobyteus.tools.base_tool import BaseTool
-from autobyteus.tools.tool_config import ToolConfig
-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 
-import os 
-
-if TYPE_CHECKING:
-    from autobyteus.agent.context import AgentContext 
-
-logger = logging.getLogger(__name__) 
-
-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) 
-        
-        self.full_page: bool = True  
-        self.image_format: str = "png"  
-        
-        if config:
-            self.full_page = config.get('full_page', True)
-            self.image_format = str(config.get('image_format', 'png')).lower()
-            if self.image_format not in ["png", "jpeg"]:
-                logger.warning(f"Invalid image_format '{self.image_format}' in config. Defaulting to 'png'.")
-                self.image_format = "png"
-        logger.debug(f"WebPageScreenshotTaker initialized. Full page: {self.full_page}, Format: {self.image_format}")
-
-    @classmethod
-    def get_description(cls) -> str:
-        return "Takes a screenshot of a given webpage URL using Playwright and saves it to the specified file path. Returns the absolute path of the saved screenshot."
-
-    @classmethod
-    def get_argument_schema(cls) -> Optional[ParameterSchema]:
-        schema = ParameterSchema()
-        schema.add_parameter(ParameterDefinition(
-            name="url",
-            param_type=ParameterType.STRING,
-            description="The URL of the webpage to take a screenshot of.",
-            required=True
-        ))
-        schema.add_parameter(ParameterDefinition(
-            name="file_path", 
-            param_type=ParameterType.STRING,
-            description="The local file path (including filename and extension, e.g., 'screenshots/page.png') where the screenshot will be saved.",
-            required=True
-        ))
-        return schema
-        
-    @classmethod
-    def get_config_schema(cls) -> Optional[ParameterSchema]: 
-        schema = ParameterSchema()
-        schema.add_parameter(ParameterDefinition(
-            name="full_page",
-            param_type=ParameterType.BOOLEAN,
-            description="Whether to capture the full scrollable page content or just the visible viewport by default for this instance.",
-            required=False,
-            default_value=True
-        ))
-        schema.add_parameter(ParameterDefinition(
-            name="image_format",
-            param_type=ParameterType.ENUM,
-            description="Default image format for screenshots taken by this instance (png or jpeg).",
-            required=False,
-            default_value="png",
-            enum_values=["png", "jpeg"]
-        ))
-        return schema
-
-    async def _execute(self, context: 'AgentContext', url: str, file_path: str) -> str: 
-        logger.info(f"WebPageScreenshotTaker for agent {context.agent_id} taking screenshot of '{url}', saving to '{file_path}'.")
-        
-        output_dir = os.path.dirname(file_path)
-        if output_dir: 
-            os.makedirs(output_dir, exist_ok=True)
-
-        try:
-            await self.initialize() 
-            if not self.page:
-                 logger.error("Playwright page not initialized in WebPageScreenshotTaker.")
-                 raise RuntimeError("Playwright page not available for WebPageScreenshotTaker.")
-
-            await self.page.goto(url, wait_until="networkidle", timeout=60000) 
-            
-            await self.page.screenshot(path=file_path, full_page=self.full_page, type=self.image_format) # type: ignore 
-            
-            absolute_file_path = os.path.abspath(file_path)
-            logger.info(f"Screenshot saved successfully to {absolute_file_path}")
-            return absolute_file_path
-        except Exception as e:
-            logger.error(f"Error taking screenshot of URL '{url}': {e}", exc_info=True)
-            raise RuntimeError(f"WebPageScreenshotTaker failed for URL '{url}': {str(e)}")
-        finally:
-            await self.close()

autobyteus/tools/file/file_editor.py

@@ -1,200 +0,0 @@
-import os
-import re
-import logging
-from typing import TYPE_CHECKING, List
-
-from autobyteus.tools.functional_tool import tool
-from autobyteus.tools.tool_category import ToolCategory
-
-if TYPE_CHECKING:
-    from autobyteus.agent.context import AgentContext
-
-logger = logging.getLogger(__name__)
-
-_HUNK_HEADER_RE = re.compile(r"^@@ -(?P<old_start>\d+)(?:,(?P<old_count>\d+))? \+(?P<new_start>\d+)(?:,(?P<new_count>\d+))? @@")
-
-class PatchApplicationError(ValueError):
-    """Raised when a unified diff patch cannot be applied to the target file."""
-
-
-def _resolve_file_path(context: 'AgentContext', path: str) -> str:
-    """Resolves an absolute path for the given input, using the agent workspace when needed."""
-    if os.path.isabs(path):
-        final_path = path
-        logger.debug("FileEdit: provided path '%s' is absolute.", path)
-    else:
-        if not context.workspace:
-            error_msg = ("Relative path '%s' provided, but no workspace is configured for agent '%s'. "
-                         "A workspace is required to resolve relative paths.")
-            logger.error(error_msg, path, context.agent_id)
-            raise ValueError(error_msg % (path, context.agent_id))
-        base_path = context.workspace.get_base_path()
-        if not base_path or not isinstance(base_path, str):
-            error_msg = ("Agent '%s' has a configured workspace, but it provided an invalid base path ('%s'). "
-                         "Cannot resolve relative path '%s'.")
-            logger.error(error_msg, context.agent_id, base_path, path)
-            raise ValueError(error_msg % (context.agent_id, base_path, path))
-        final_path = os.path.join(base_path, path)
-        logger.debug("FileEdit: resolved relative path '%s' against workspace base '%s' to '%s'.", path, base_path, final_path)
-
-    normalized_path = os.path.normpath(final_path)
-    logger.debug("FileEdit: normalized path to '%s'.", normalized_path)
-    return normalized_path
-
-
-def _apply_unified_diff(original_lines: List[str], patch: str) -> List[str]:
-    """Applies a unified diff patch to the provided original lines and returns the patched lines."""
-    if not patch or not patch.strip():
-        raise PatchApplicationError("Patch content is empty; nothing to apply.")
-
-    patched_lines: List[str] = []
-    orig_idx = 0
-    patch_lines = patch.splitlines(keepends=True)
-    line_idx = 0
-
-    while line_idx < len(patch_lines):
-        line = patch_lines[line_idx]
-
-        if line.startswith('---') or line.startswith('+++'):
-            logger.debug("FileEdit: skipping diff header line '%s'.", line.strip())
-            line_idx += 1
-            continue
-
-        if not line.startswith('@@'):
-            stripped = line.strip()
-            if stripped == '':
-                line_idx += 1
-                continue
-            raise PatchApplicationError(f"Unexpected content outside of hunk header: '{stripped}'.")
-
-        match = _HUNK_HEADER_RE.match(line)
-        if not match:
-            raise PatchApplicationError(f"Malformed hunk header: '{line.strip()}'.")
-
-        old_start = int(match.group('old_start'))
-        old_count = int(match.group('old_count') or '1')
-        new_start = int(match.group('new_start'))
-        new_count = int(match.group('new_count') or '1')
-        logger.debug("FileEdit: processing hunk old_start=%s old_count=%s new_start=%s new_count=%s.",
-                     old_start, old_count, new_start, new_count)
-
-        target_idx = old_start - 1 if old_start > 0 else 0
-        if target_idx > len(original_lines):
-            raise PatchApplicationError("Patch hunk starts beyond end of file.")
-        if target_idx < orig_idx:
-            raise PatchApplicationError("Patch hunks overlap or are out of order.")
-
-        patched_lines.extend(original_lines[orig_idx:target_idx])
-        orig_idx = target_idx
-
-        line_idx += 1
-        hunk_consumed = 0
-        removed = 0
-        added = 0
-
-        while line_idx < len(patch_lines):
-            hunk_line = patch_lines[line_idx]
-            if hunk_line.startswith('@@'):
-                break
-
-            if hunk_line.startswith('-'):
-                if orig_idx >= len(original_lines):
-                    raise PatchApplicationError("Patch attempts to remove lines beyond file length.")
-                if original_lines[orig_idx] != hunk_line[1:]:
-                    raise PatchApplicationError("Patch removal does not match file content.")
-                orig_idx += 1
-                hunk_consumed += 1
-                removed += 1
-            elif hunk_line.startswith('+'):
-                patched_lines.append(hunk_line[1:])
-                added += 1
-            elif hunk_line.startswith(' '):
-                if orig_idx >= len(original_lines):
-                    raise PatchApplicationError("Patch context exceeds file length.")
-                if original_lines[orig_idx] != hunk_line[1:]:
-                    raise PatchApplicationError("Patch context does not match file content.")
-                patched_lines.append(original_lines[orig_idx])
-                orig_idx += 1
-                hunk_consumed += 1
-            elif hunk_line.startswith('\\'):
-                if hunk_line.strip() == '\':
-                    if patched_lines:
-                        patched_lines[-1] = patched_lines[-1].rstrip('\n')
-                else:
-                    raise PatchApplicationError(f"Unsupported patch directive: '{hunk_line.strip()}'.")
-            elif hunk_line.strip() == '':
-                patched_lines.append(hunk_line)
-            else:
-                raise PatchApplicationError(f"Unsupported patch line: '{hunk_line.strip()}'.")
-
-            line_idx += 1
-
-        consumed_total = hunk_consumed
-        if old_count == 0:
-            if consumed_total != 0:
-                raise PatchApplicationError("Patch expects zero original lines but consumed some context.")
-        else:
-            if consumed_total != old_count:
-                raise PatchApplicationError(
-                    f"Patch expected to consume {old_count} original lines but consumed {consumed_total}.")
-
-        context_lines = consumed_total - removed
-        expected_new_lines = context_lines + added
-        if new_count == 0:
-            if expected_new_lines != 0:
-                raise PatchApplicationError("Patch declares zero new lines but produced changes.")
-        else:
-            if expected_new_lines != new_count:
-                raise PatchApplicationError(
-                    f"Patch expected to produce {new_count} new lines but produced {expected_new_lines}.")
-
-    patched_lines.extend(original_lines[orig_idx:])
-    return patched_lines
-
-
-@tool(name="FileEdit", category=ToolCategory.FILE_SYSTEM)
-async def file_edit(context: 'AgentContext', path: str, patch: str, create_if_missing: bool = False) -> str:
-    """Applies a unified diff patch to update a text file without overwriting unrelated content.
-
-    Args:
-        path: Path to the target file. Relative paths are resolved against the agent workspace when available.
-        patch: Unified diff patch describing the edits to apply.
-        create_if_missing: When True, allows applying a patch that introduces content to a non-existent file.
-
-    Raises:
-        FileNotFoundError: If the file does not exist and create_if_missing is False.
-        PatchApplicationError: If the patch content cannot be applied cleanly.
-        IOError: If file reading or writing fails.
-    """
-    logger.debug("FileEdit: requested edit for agent '%s' on path '%s'.", context.agent_id, path)
-    final_path = _resolve_file_path(context, path)
-
-    dir_path = os.path.dirname(final_path)
-    if dir_path and not os.path.exists(dir_path) and create_if_missing:
-        os.makedirs(dir_path, exist_ok=True)
-
-    file_exists = os.path.exists(final_path)
-    if not file_exists and not create_if_missing:
-        raise FileNotFoundError(f"The file at resolved path {final_path} does not exist.")
-
-    try:
-        original_lines: List[str]
-        if file_exists:
-            with open(final_path, 'r', encoding='utf-8') as source:
-                original_lines = source.read().splitlines(keepends=True)
-        else:
-            original_lines = []
-
-        patched_lines = _apply_unified_diff(original_lines, patch)
-
-        with open(final_path, 'w', encoding='utf-8') as destination:
-            destination.writelines(patched_lines)
-
-        logger.info("FileEdit: successfully applied patch to '%s'.", final_path)
-        return f"File edited successfully at {final_path}"
-    except PatchApplicationError as patch_err:
-        logger.error("FileEdit: failed to apply patch to '%s': %s", final_path, patch_err, exc_info=True)
-        raise patch_err
-    except Exception as exc:  # pragma: no cover - general safeguard
-        logger.error("FileEdit: unexpected error while editing '%s': %s", final_path, exc, exc_info=True)
-        raise IOError(f"Could not edit file at '{final_path}': {exc}")

autobyteus/tools/google_search.py

@@ -1,149 +0,0 @@
-import os
-import json
-import logging
-import aiohttp
-from typing import Optional, TYPE_CHECKING, Any, Dict, List
-
-from autobyteus.tools.base_tool import BaseTool
-from autobyteus.tools.tool_config import ToolConfig
-from autobyteus.utils.parameter_schema import ParameterSchema, ParameterDefinition, ParameterType
-from autobyteus.tools.tool_category import ToolCategory
-
-if TYPE_CHECKING:
-    from autobyteus.agent.context import AgentContext
-
-logger = logging.getLogger(__name__)
-
-class GoogleSearch(BaseTool):
-    """
-    Performs a Google search using the Serper.dev API and returns a structured summary of the results.
-    This tool requires a Serper API key, which should be set in the SERPER_API_KEY environment variable.
-    """
-    CATEGORY = ToolCategory.WEB
-    API_URL = "https://google.serper.dev/search"
-
-    def __init__(self, config: Optional[ToolConfig] = None):
-        super().__init__(config=config)
-        self.api_key: Optional[str] = None
-        
-        if config:
-            self.api_key = config.get('api_key')
-        
-        if not self.api_key:
-            self.api_key = os.getenv("SERPER_API_KEY")
-
-        if not self.api_key:
-            raise ValueError(
-                "GoogleSearch tool requires a Serper API key. "
-                "Please provide it via the 'api_key' config parameter or set the 'SERPER_API_KEY' environment variable."
-            )
-        logger.debug("GoogleSearch (API-based) tool initialized.")
-    
-    @classmethod
-    def get_name(cls) -> str:
-        return "GoogleSearch"
-
-    @classmethod
-    def get_description(cls) -> str:
-        return (
-            "Searches Google for a given query using the Serper API. "
-            "Returns a concise, structured summary of search results, including direct answers and top organic links."
-        )
-
-    @classmethod
-    def get_argument_schema(cls) -> Optional[ParameterSchema]:
-        schema = ParameterSchema()
-        schema.add_parameter(ParameterDefinition(
-            name="query",
-            param_type=ParameterType.STRING,
-            description="The search query string.",
-            required=True
-        ))
-        schema.add_parameter(ParameterDefinition(
-            name="num_results",
-            param_type=ParameterType.INTEGER,
-            description="The number of organic search results to return.",
-            required=False,
-            default_value=5,
-            min_value=1,
-            max_value=10
-        ))
-        return schema
-
-    @classmethod
-    def get_config_schema(cls) -> Optional[ParameterSchema]:
-        schema = ParameterSchema()
-        schema.add_parameter(ParameterDefinition(
-            name="api_key",
-            param_type=ParameterType.STRING,
-            description="The API key for the Serper.dev service. Overrides the SERPER_API_KEY environment variable.",
-            required=False
-        ))
-        return schema
-
-    def _format_results(self, data: Dict[str, Any]) -> str:
-        """Formats the JSON response from Serper into a clean string for an LLM."""
-        summary_parts = []
-        
-        # 1. Answer Box (most important for direct questions)
-        if "answerBox" in data:
-            answer_box = data["answerBox"]
-            title = answer_box.get("title", "")
-            snippet = answer_box.get("snippet") or answer_box.get("answer")
-            summary_parts.append(f"Direct Answer for '{title}':\n{snippet}")
-
-        # 2. Knowledge Graph (for entity information)
-        if "knowledgeGraph" in data:
-            kg = data["knowledgeGraph"]
-            title = kg.get("title", "")
-            description = kg.get("description")
-            summary_parts.append(f"Summary for '{title}':\n{description}")
-
-        # 3. Organic Results (the main search links)
-        if "organic" in data and data["organic"]:
-            organic_results = data["organic"]
-            results_str = "\n".join(
-                f"{i+1}. {result.get('title', 'No Title')}\n"
-                f"   Link: {result.get('link', 'No Link')}\n"
-                f"   Snippet: {result.get('snippet', 'No Snippet')}"
-                for i, result in enumerate(organic_results)
-            )
-            summary_parts.append(f"Search Results:\n{results_str}")
-        
-        if not summary_parts:
-            return "No relevant information found for the query."
-
-        return "\n\n---\n\n".join(summary_parts)
-
-
-    async def _execute(self, context: 'AgentContext', query: str, num_results: int = 5) -> str:
-        logger.info(f"Executing GoogleSearch (API) for agent {context.agent_id} with query: '{query}'")
-        
-        headers = {
-            'X-API-KEY': self.api_key,
-            'Content-Type': 'application/json'
-        }
-        payload = json.dumps({
-            "q": query,
-            "num": num_results
-        })
-
-        try:
-            async with aiohttp.ClientSession() as session:
-                async with session.post(self.API_URL, headers=headers, data=payload) as response:
-                    if response.status == 200:
-                        data = await response.json()
-                        return self._format_results(data)
-                    else:
-                        error_text = await response.text()
-                        logger.error(
-                            f"Serper API returned a non-200 status code: {response.status}. "
-                            f"Response: {error_text}"
-                        )
-                        raise RuntimeError(f"API request failed with status {response.status}: {error_text}")
-        except aiohttp.ClientError as e:
-            logger.error(f"Network error during GoogleSearch API call: {e}", exc_info=True)
-            raise RuntimeError(f"A network error occurred: {e}")
-        except Exception as e:
-            logger.error(f"An unexpected error occurred in GoogleSearch tool: {e}", exc_info=True)
-            raise